mcs/class/System.Web/Test/System.Web.UI.WebControls/GridViewTest.cs

   1 //
   2 // Tests for System.Web.UI.WebControls.GridView.cs
   3 //
   4 // Author:
   5 //      Tal Klahr (talk@mainsoft.com)
   6 //      Yoni Klain (yonik@mainsoft.com)
   7 //
   8 // (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 // NOT TESTED :
  29 // ondatasourceviewchanged(),onpagepreload(),RaiseCallbackEvent(),RaisePostbackEvent
  30
  31
  32 #if NET_2_0
  33
  34
  35 using NUnit.Framework;
  36 using System;
  37 using System.IO;
  38 using System.Globalization;
  39 using System.Web;
  40 using System.Web.UI;
  41 using System.Web.UI.WebControls;
  42 using System.Collections;
  43 using MonoTests.SystemWeb.Framework;
  44 using MonoTests.stand_alone.WebHarness;
  45 using MyWebControl = System.Web.UI.WebControls;
  46 using System.Data;
  47 using System.Drawing;
  48 using System.Threading;
  49 using System.Collections.Generic;
  50
  51 namespace MonoTests.System.Web.UI.WebControls
  52 {
  53
  54         class PokerGridView : GridView
  55         {
  56                 public bool ifPagerInitilized;
  57                 public bool dataPropertyChanged;
  58                 public bool pagePreLoad;
  59                 public bool controlHierarchy;
  60
  61                 public PokerGridView ()
  62                 {
  63                         TrackViewState ();
  64                 }
  65
  66                 public object SaveState ()
  67                 {
  68                         return SaveViewState ();
  69                 }
  70
  71                 public void LoadState (object o)
  72                 {
  73                         LoadViewState (o);
  74                 }
  75
  76                 public StateBag StateBag
  77                 {
  78                         get { return base.ViewState; }
  79                 }
  80
  81                 public HtmlTextWriterTag PTagKey
  82                 {
  83                         get { return base.TagKey;}
  84                 }
  85
  86                 public string Render ()
  87                 {
  88                         StringWriter sw = new StringWriter ();
  89                         HtmlTextWriter tw = new HtmlTextWriter (sw);
  90                         Render (tw);
  91                         return sw.ToString ();
  92                 }
  93
  94                 public AutoGeneratedField DoCreateAutoGeneratedColumn (AutoGeneratedFieldProperties fieldProperties)
  95                 {
  96                         return base.CreateAutoGeneratedColumn (fieldProperties);
  97                 }
  98
  99                 public int DoCreateChildControls (IEnumerable dataSource, bool dataBinding)
 100                 {
 101                         return base.CreateChildControls (dataSource, dataBinding);
 102                 }
 103
 104                 public Table DoCreateChildTable ()
 105                 {
 106                         return base.CreateChildTable ();
 107                 }
 108
 109                 public ICollection DoCreateColumns (PagedDataSource dataSource, bool useDataSource)
 110                 {
 111                         return base.CreateColumns (dataSource, useDataSource);
 112                 }
 113
 114                 public Style DoCreateControlStyle ()
 115                 {
 116                         return base.CreateControlStyle ();
 117                 }
 118
 119                 public DataSourceSelectArguments DoCreateDataSourceSelectArguments ()
 120                 {
 121                         return CreateDataSourceSelectArguments();
 122                 }
 123
 124                 public DataSourceView DoGetData () {
 125                         return GetData ();
 126                 }
 127
 128                 public GridViewRow doCreateRow (int rowIndex, int dataSourceIndex, DataControlRowType rowType, DataControlRowState rowState)
 129                 {
 130                         return base.CreateRow (rowIndex, dataSourceIndex, rowType, rowState);
 131                 }
 132
 133                 public string doGetCallbackResult ()
 134                 {
 135                         return base.GetCallbackResult ();
 136                 }
 137
 138                 public string doGetCallbackScript (IButtonControl buttonControl, string argument)
 139                 {
 140                         return base.GetCallbackScript (buttonControl, argument);
 141                 }
 142
 143                 protected override void InitializePager (GridViewRow row, int columnSpan, PagedDataSource pagedDataSource)
 144                 {
 145                         base.InitializePager (row, columnSpan, pagedDataSource);
 146                         ifPagerInitilized = true;
 147                 }
 148
 149                 protected override void InitializeRow (GridViewRow row, DataControlField[] fields)
 150                 {
 151                         base.InitializeRow (row, fields);
 152                 }
 153
 154                 public bool DoOnBubbleEvent (object source, EventArgs e)
 155                 {
 156                         return base.OnBubbleEvent (source, e);
 157                 }
 158
 159                 public void DoOnDataBinding (EventArgs e)
 160                 {
 161                         base.OnDataBinding (e);
 162                 }
 163
 164                 public void DoOnDataBound (EventArgs e)
 165                 {
 166                         base.OnDataBound (e);
 167                 }
 168
 169                 protected override void OnDataPropertyChanged ()
 170                 {
 171                         base.OnDataPropertyChanged ();
 172                         dataPropertyChanged = true;
 173                 }
 174
 175                 public void DoOnDataSourceViewChanged (object sender, EventArgs e)
 176                 {
 177                         base.OnDataSourceViewChanged (sender, e);
 178                 }
 179
 180                 public void DoOnInit (EventArgs e)
 181                 {
 182                         base.OnInit (e);
 183                 }
 184
 185                 public void DoOnLoad (EventArgs e)
 186                 {
 187                         base.OnLoad (e);
 188                 }
 189
 190                 public void DoOnPageIndexChanged (EventArgs e)
 191                 {
 192                         base.OnPageIndexChanged (e);
 193                 }
 194
 195                 public void DoOnPageIndexChanging (GridViewPageEventArgs e)
 196                 {
 197                         base.OnPageIndexChanging (e);
 198                 }
 199
 200                 protected override void OnPagePreLoad (object sender, EventArgs e)
 201                 {
 202                         base.OnPagePreLoad (sender, e);
 203                         pagePreLoad = true;
 204                 }
 205
 206                 public void DoOnPreRender (EventArgs e)
 207                 {
 208                         base.OnPreRender (e);
 209                 }
 210
 211                 public void DoOnRowCancelingEdit (GridViewCancelEditEventArgs e)
 212                 {
 213                         base.OnRowCancelingEdit (e);
 214                 }
 215
 216                 public void DoOnRowCommand (GridViewCommandEventArgs e)
 217                 {
 218                         base.OnRowCommand (e);
 219                 }
 220
 221                 public void DoOnRowCreated (GridViewRowEventArgs e)
 222                 {
 223                         base.OnRowCreated (e);
 224                 }
 225
 226                 public void DoOnRowDataBound (GridViewRowEventArgs e)
 227                 {
 228                         base.OnRowDataBound (e);
 229                 }
 230
 231                 public void DoOnRowDeleted (GridViewDeletedEventArgs e)
 232                 {
 233                         base.OnRowDeleted (e);
 234                 }
 235
 236                 public void DoOnRowDeleting (GridViewDeleteEventArgs e)
 237                 {
 238                         base.OnRowDeleting (e);
 239                 }
 240
 241                 public void DoOnRowEditing (GridViewEditEventArgs e)
 242                 {
 243                         base.OnRowEditing (e);
 244                 }
 245
 246                 public void DoOnRowUpdated (GridViewUpdatedEventArgs e)
 247                 {
 248                         base.OnRowUpdated (e);
 249                 }
 250
 251                 public void DoOnRowUpdating (GridViewUpdateEventArgs e)
 252                 {
 253                         base.OnRowUpdating (e);
 254                 }
 255
 256                 public void DoOnSelectedIndexChanged (EventArgs e)
 257                 {
 258                         base.OnSelectedIndexChanged (e);
 259                 }
 260
 261                 public void DoOnSelectedIndexChanging (GridViewSelectEventArgs e)
 262                 {
 263                         base.OnSelectedIndexChanging (e);
 264                 }
 265
 266                 public void DoOnSorted (EventArgs e)
 267                 {
 268                         base.OnSorted (e);
 269                 }
 270
 271                 public void DoOnSorting (GridViewSortEventArgs e)
 272                 {
 273                         base.OnSorting (e);
 274                 }
 275
 276                 public void DoOnUnload (EventArgs e)
 277                 {
 278                         base.OnUnload (e);
 279                 }
 280
 281                 public void DoPerformDataBinding (IEnumerable data)
 282                 {
 283                         base.PerformDataBinding (data);
 284                 }
 285
 286                 protected override void PrepareControlHierarchy ()
 287                 {
 288                         base.PrepareControlHierarchy ();
 289                         controlHierarchy = true;
 290                 }
 291
 292                 public object DoSaveControlState ()
 293                 {
 294                         return base.SaveControlState ();
 295                 }
 296
 297                 public void DoLoadControlState (object savedState)
 298                 {
 299                         base.LoadControlState (savedState);
 300                 }
 301
 302                 public void SetRequiresDataBinding (bool value)
 303                 {
 304                         RequiresDataBinding = value;
 305                 }
 306         }
 307
 308         [Serializable]
 309         [TestFixture]
 310         public class GridViewTest
 311         {
 312                 public class DataSourceObject
 313                 {
 314                         public static List<string> GetList (string sortExpression, int startRowIndex, int maximumRows) {
 315                                 return GetList ();
 316                         }
 317
 318                         public static List<string> GetList (int startRowIndex, int maximumRows) {
 319                                 return GetList ();
 320                         }
 321
 322                         public static List<string> GetList (string sortExpression) {
 323                                 return GetList ();
 324                         }
 325
 326                         public static List<string> GetList () {
 327                                 List<string> list = new List<string> ();
 328                                 list.Add ("Norway");
 329                                 list.Add ("Sweden");
 330                                 list.Add ("France");
 331                                 list.Add ("Italy");
 332                                 list.Add ("Israel");
 333                                 list.Add ("Russia");
 334                                 return list;
 335                         }
 336
 337                         public static int GetCount () {
 338                                 return GetList ().Count;
 339                         }
 340                 }
 341
 342                 public class data
 343                 {
 344                         private static ArrayList _data = new ArrayList ();
 345
 346                         static data () {
 347                                 _data.Add (new DataItem (1, "heh1"));
 348                                 _data.Add (new DataItem (2, "heh2"));
 349                         }
 350
 351                         public data () {
 352                         }
 353
 354                         public ArrayList GetAllItems () {
 355                                 return _data;
 356                         }
 357
 358                         public void UpdateItem (int id, string name) {
 359                                 foreach (DataItem i in _data) {
 360                                         if (i.ID == id) {
 361                                                 i.Name = name;
 362                                                 return;
 363                                         }
 364                                 }
 365                         }
 366                 }
 367
 368                 public class DataItem
 369                 {
 370                         int _id = 0;
 371                         string _name = "";
 372
 373                         public DataItem (int id, string name) {
 374                                 _id = id;
 375                                 _name = name;
 376                         }
 377
 378                         public int ID {
 379                                 get { return _id; }
 380                         }
 381
 382                         public string Name {
 383                                 get { return _name; }
 384                                 set { _name = value; }
 385                         }
 386                 }
 387
 388                 public const string BOOLFIELD = "bool";
 389                 public const string STRINGFIELD = "str";
 390                 ArrayList myds = new ArrayList ();
 391                 public bool InitilizePager;
 392
 393                 [TestFixtureSetUp]
 394                 public void GridViewInit ()
 395                 {
 396                         myds.Add ("Norway");
 397                         myds.Add ("Sweden");
 398                         myds.Add ("France");
 399                         myds.Add ("Italy");
 400                         myds.Add ("Israel");
 401                         myds.Add ("Russia");
 402 #if VISUAL_STUDIO
 403                         WebTest.CopyResource (GetType (), "MonoTests.System.Web.UI.WebControls.Resources.GridViewUpdate.aspx", "GridViewUpdate.aspx");
 404 #else
 405                         WebTest.CopyResource (GetType (), "GridViewUpdate.aspx", "GridViewUpdate.aspx");
 406 #endif
 407                 }
 408
 409                 [Test]
 410                 public void GridView_DefaultProperties ()
 411                 {
 412                         PokerGridView g = new PokerGridView ();
 413                         Assert.AreEqual (0, g.StateBag.Count, "ViewState.Count");
 414                         Assert.AreEqual (false, g.AllowPaging, "AllowPaging");
 415                         Assert.AreEqual (false, g.AllowSorting, "AllowSorting");
 416                         // The AlternatingRowStyle property is tested by the TableItemStyle test (already exists)
 417                         Assert.AreEqual (true, g.AutoGenerateColumns, "AutoGenerateColumns");
 418                         Assert.AreEqual (false, g.AutoGenerateDeleteButton, "AutoGenerateDeleteButton");
 419                         Assert.AreEqual (false, g.AutoGenerateEditButton, "AutoGenerateEditButton");
 420                         Assert.AreEqual (false, g.AutoGenerateSelectButton, "AutoGenerateSelectButton");
 421                         Assert.AreEqual ("", g.BackImageUrl, "BackImageUrl");
 422                         Assert.AreEqual (null, g.BottomPagerRow, "BottomPagerRow");
 423                         Assert.AreEqual ("", g.Caption, "Caption");
 424                         Assert.AreEqual (TableCaptionAlign.NotSet, g.CaptionAlign, "CaptionAlign");
 425                         Assert.AreEqual (-1, g.CellPadding, "CellPadding");
 426                         Assert.AreEqual (0, g.CellSpacing, "CellSpacing");
 427                         // ToDo: The Columns property default value is tested by the DataControlFieldCollection and DataControlField tests
 428                         Assert.AreEqual (0, g.DataKeyNames.Length, "DataKeyNames");
 429                         // ToDo: The DataKeys property default value is tested by the DataKeyArray and DataKey tests
 430                         Assert.AreEqual (-1, g.EditIndex, "EditIndex");
 431                         // The EditRowStyle property is tested by the TableItemStyle test (already exists)
 432                         // The EmptyDataRowStyle property is tested by the TableItemStyle test (already exists)
 433                         Assert.AreEqual (null, g.EmptyDataTemplate, "EmptyDataTemplate");
 434                         Assert.AreEqual ("", g.EmptyDataText, "EmptyDataText");
 435                         Assert.AreEqual (false, g.EnableSortingAndPagingCallbacks, "EnableSortingAndPagingCallbacks");
 436
 437                         // The FooterStyle property is tested by the TableItemStyle test (already exists)
 438                         Assert.AreEqual (GridLines.Both, g.GridLines, "GridLines");
 439                         // The HeaderStyle property is tested by the TableItemStyle test (already exists)
 440                         Assert.AreEqual (HorizontalAlign.NotSet, g.HorizontalAlign, "HorizontalAlign");
 441
 442                         Assert.AreEqual (0, g.PageIndex, "PageIndex");
 443                         // ToDo: The PagerSettings property is tested by the PagerSettings test
 444                         // The PagerStyle property is tested by the TableItemStyle test (already exists)
 445                         Assert.AreEqual (null, g.PagerTemplate, "PagerTemplate");
 446                         Assert.AreEqual (10, g.PageSize, "PageSize");
 447                         Assert.AreEqual ("", g.RowHeaderColumn, "RowHeaderColumn");
 448                         // ToDo: The Rows property is tested by the GridViewRowCollection and GridViewRow test
 449                         // The RowStyle property is tested by the TableItemStyle test (already exists)
 450                         Assert.AreEqual (false, g.ShowFooter, "ShowFooter");
 451                         Assert.AreEqual (true, g.ShowHeader, "ShowHeader");
 452                         Assert.AreEqual (SortDirection.Ascending, g.SortDirection, "SortDirection");
 453                         Assert.AreEqual (null, g.TopPagerRow, "TopPagerRow");
 454                         Assert.AreEqual (true, g.UseAccessibleHeader, "UseAccessibleHeader");
 455                 }
 456
 457
 458                 [Test]
 459                 public void GridView_DefaultPropertiesNotWorking ()
 460                 {
 461                         PokerGridView g = new PokerGridView ();
 462                         Assert.AreEqual (null, g.FooterRow, "FooterRow");
 463                         Assert.AreEqual (null, g.HeaderRow, "HeaderRow");
 464                         Assert.AreEqual (true, g.Visible, "ViewVisible");
 465                         Assert.AreEqual (0, g.PageCount, "PageCount");
 466                         Assert.AreEqual ("", g.SortExpression, "SortExpression");
 467                 }
 468
 469
 470                 [Test]
 471                 public void GridView_AssignedProperties ()
 472                 {
 473                         PokerGridView g = new PokerGridView ();
 474                         Assert.AreEqual (0, g.StateBag.Count, "ViewState.Count");
 475                         g.AllowPaging = true;
 476                         Assert.AreEqual (true, g.AllowPaging, "AllowPaging");
 477                         g.AllowSorting = true;
 478                         Assert.AreEqual (true, g.AllowSorting, "AllowSorting");
 479                         g.AutoGenerateColumns = false;
 480                         Assert.AreEqual (false, g.AutoGenerateColumns, "AutoGenerateColumns");
 481                         g.AutoGenerateDeleteButton = true;
 482                         Assert.AreEqual (true, g.AutoGenerateDeleteButton, "AutoGenerateDeleteButton");
 483                         g.AutoGenerateEditButton = true;
 484                         Assert.AreEqual (true, g.AutoGenerateEditButton, "AutoGenerateEditButton");
 485                         g.AutoGenerateSelectButton = true;
 486                         Assert.AreEqual (true, g.AutoGenerateSelectButton, "AutoGenerateSelectButton");
 487                         g.BackImageUrl = "test";
 488                         Assert.AreEqual ("test", g.BackImageUrl, "BackImageUrl");
 489                         g.Caption = "test";
 490                         Assert.AreEqual ("test", g.Caption, "Caption");
 491                         g.CaptionAlign = TableCaptionAlign.Left;
 492                         Assert.AreEqual (TableCaptionAlign.Left, g.CaptionAlign, "CaptionAlign");
 493                         g.CellPadding = 0;
 494                         Assert.AreEqual (0, g.CellPadding, "CellPadding");
 495                         g.CellSpacing = 1;
 496                         Assert.AreEqual (1, g.CellSpacing, "CellSpacing");
 497                         // ToDo: The Columns property default value is tested by the DataControlFieldCollection and DataControlField tests
 498                         string[] str = new String[1];
 499                         str[0] = "test";
 500                         g.DataKeyNames = str;
 501                         Assert.AreEqual ("test", g.DataKeyNames[0], "DataKeyNames");
 502
 503                         // ToDo: The DataKeys property default value is tested by the DataKeyArray and DataKey tests
 504                         g.EditIndex = 0;
 505                         Assert.AreEqual (0, g.EditIndex, "EditIndex");
 506                         // The EditRowStyle property default value is tested by the TableItemStyle test (already exists)
 507                         // The EmptyDataRowStyle property default value is tested by the TableItemStyle test (already exists)
 508
 509                         MyWebControl.Image myImage = new MyWebControl.Image ();
 510                         myImage.ImageUrl = "myimage.jpg";
 511                         ImageTemplate template = new ImageTemplate ();
 512                         template.MyImage = myImage;
 513                         // end create template image
 514
 515                         g.EmptyDataTemplate = template;
 516                         Assert.IsNotNull (g.EmptyDataTemplate, "EmptyDataTemplate");
 517                         g.EmptyDataText = "test";
 518                         Assert.AreEqual ("test", g.EmptyDataText, "EmptyDataText");
 519
 520                         g.EnableSortingAndPagingCallbacks = true;
 521                         Assert.AreEqual (true, g.EnableSortingAndPagingCallbacks, "EnableSortingAndPagingCallbacks");
 522
 523                         // The FooterStyle property default value is tested by the TableItemStyle test (already exists)
 524                         g.GridLines = GridLines.Horizontal;
 525                         Assert.AreEqual (GridLines.Horizontal, g.GridLines, "GridLines");
 526
 527                         g.HorizontalAlign = HorizontalAlign.Justify;
 528                         Assert.AreEqual (HorizontalAlign.Justify, g.HorizontalAlign, "HorizontalAlign");
 529
 530                         g.PageIndex = 1;
 531                         Assert.AreEqual (1, g.PageIndex, "PageIndex");
 532                         // ToDo: The PagerSettings property default value is tested by the PagerSettings test
 533                         // The PagerStyle property default value is tested by the TableItemStyle test (already exists)
 534                         g.PagerTemplate = template;
 535                         Assert.IsNotNull (g.PagerTemplate, "PagerTemplate");
 536                         g.PageSize = 5;
 537                         Assert.AreEqual (5, g.PageSize, "PageSize");
 538                         g.RowHeaderColumn = "test";
 539                         Assert.AreEqual ("test", g.RowHeaderColumn, "RowHeaderColumn");
 540                         // ToDo: The Rows property default value is tested by the GridViewRowCollection and GridViewRow test
 541                         // The RowStyle property default value is tested by the TableItemStyle test (already exists)
 542                         g.ShowFooter = true;
 543                         Assert.AreEqual (true, g.ShowFooter, "ShowFooter");
 544                         g.ShowHeader = false;
 545                         Assert.AreEqual (false, g.ShowHeader, "ShowHeader");
 546                         g.UseAccessibleHeader = false;
 547                         Assert.AreEqual (false, g.UseAccessibleHeader, "UseAccessibleHeader");
 548                 }
 549
 550                 [Test]
 551                 public void GridView_DefaultProtectedProperties ()
 552                 {
 553                         PokerGridView g = new PokerGridView ();
 554                         Assert.AreEqual (HtmlTextWriterTag.Table, g.PTagKey, "TagKey");
 555                 }
 556
 557                 [Test]
 558                 public void GridView_Sort_and_DataSourceSelectArguments () {
 559                         DataSourceView view;
 560                         DataSourceSelectArguments arg;
 561                         Page p = new Page ();
 562
 563                         PokerGridView g = new PokerGridView ();
 564                         g.Columns.Add (new BoundField ());
 565                         g.AllowSorting = true;
 566                         p.Controls.Add (g);
 567
 568                         ObjectDataSource data = new ObjectDataSource ();
 569                         data.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
 570                         data.SelectMethod = "GetList";
 571                         data.SortParameterName = "sortExpression";
 572                         data.ID = "Data";
 573                         p.Controls.Add (data);
 574
 575                         g.DataSourceID = "Data";
 576                         g.EditIndex = 2;
 577                         g.PageIndex = 1;
 578                         g.DataBind ();
 579
 580                         g.Sort ("sort", SortDirection.Descending);
 581
 582                         Assert.AreEqual (-1, g.EditIndex, "EditIndex after Sort, Bound by DataSourceID");
 583                         Assert.AreEqual (0, g.PageIndex, "PageIndex after Sort, Bound by DataSourceID");
 584
 585                         arg = g.DoCreateDataSourceSelectArguments();
 586                         view = g.DoGetData ();
 587                         Assert.IsTrue (view.CanSort);
 588                         Assert.AreEqual ("sort", g.SortExpression, "SortExpression, Bound by DataSourceID");
 589                         Assert.AreEqual (SortDirection.Descending, g.SortDirection, "SortDirection, Bound by DataSourceID");
 590                         Assert.AreEqual ("sort DESC", arg.SortExpression, "AllowSorting = true, Bound by DataSourceID");
 591
 592                         g.AllowSorting = false;
 593                         arg = g.DoCreateDataSourceSelectArguments ();
 594                         Assert.AreEqual ("sort DESC", arg.SortExpression, "AllowSorting = false, Bound by DataSourceID");
 595
 596                 }
 597
 598                 [Test]
 599                 public void GridView_PageCount ()
 600                 {
 601                         Page p = new Page ();
 602
 603                         PokerGridView gv = new PokerGridView ();
 604                         gv.PageSize = 3;
 605                         gv.AllowPaging = true;
 606                         p.Controls.Add (gv);
 607
 608                         ObjectDataSource data = new ObjectDataSource ();
 609                         data.ID = "ObjectDataSource1";
 610                         data.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
 611                         data.SelectMethod = "GetList";
 612                         p.Controls.Add (data);
 613
 614                         gv.DataSourceID = "ObjectDataSource1";
 615                         gv.SetRequiresDataBinding (true);
 616
 617                         Assert.AreEqual (0, gv.PageCount, "PageCount before binding");
 618
 619                         gv.DataBind ();
 620
 621                         Assert.AreEqual (2, gv.PageCount, "PageCount after binding");
 622
 623                         PokerGridView copy = new PokerGridView ();
 624                         copy.LoadState (gv.SaveState ());
 625
 626                         Assert.AreEqual (2, copy.PageCount, "PageCount from ViewState");
 627                 }
 628
 629                 [Test]
 630                 public void GridView_DataKeys () {
 631                         Page p = new Page ();
 632
 633                         PokerGridView gv = new PokerGridView ();
 634                         p.Controls.Add (gv);
 635
 636                         ObjectDataSource data = new ObjectDataSource ();
 637                         data.TypeName = typeof (DataObject).AssemblyQualifiedName;
 638                         data.SelectMethod = "Select";
 639                         p.Controls.Add (data);
 640
 641                         gv.DataSource = data;
 642                         gv.DataKeyNames = new string [] { "ID", "FName" };
 643
 644                         DataKeyArray keys1 = gv.DataKeys;
 645
 646                         Assert.AreEqual (0, keys1.Count, "DataKeys count before binding");
 647
 648                         gv.DataBind ();
 649
 650                         DataKeyArray keys2 = gv.DataKeys;
 651                         DataKeyArray keys3 = gv.DataKeys;
 652
 653                         Assert.IsFalse (Object.ReferenceEquals (keys1, keys2), "DataKey returns the same instans");
 654                         Assert.IsTrue (Object.ReferenceEquals (keys2, keys3), "DataKey returns the same instans");
 655
 656                         Assert.AreEqual (1, keys1.Count, "DataKeys count after binding");
 657                         Assert.AreEqual (1001, keys1 [0].Value, "DataKey.Value after binding");
 658                         Assert.AreEqual (2, keys1 [0].Values.Count, "DataKey.Values count after binding");
 659                         Assert.AreEqual (1001, keys1 [0].Values [0], "DataKey.Values[0] after binding");
 660                         Assert.AreEqual ("Mahesh", keys1 [0].Values [1], "DataKey.Values[1] after binding");
 661
 662                         PokerGridView copy = new PokerGridView ();
 663                         object state = gv.DoSaveControlState ();
 664                         copy.DoLoadControlState (state);
 665
 666                         DataKeyArray keys4 = copy.DataKeys;
 667
 668                         Assert.AreEqual (1, keys4.Count, "DataKeys count from ControlState");
 669                         Assert.AreEqual (1001, keys4 [0].Value, "DataKey.Value from ControlState");
 670                         Assert.AreEqual (2, keys4 [0].Values.Count, "DataKey.Values count from ControlState");
 671                         Assert.AreEqual (1001, keys4 [0].Values [0], "DataKey.Values[0] from ControlState");
 672                         Assert.AreEqual ("Mahesh", keys4 [0].Values [1], "DataKey.Values[1] from ControlState");
 673                 }
 674
 675                 // MSDN: The CreateDataSourceSelectArguments method is a helper method called by
 676                 // the GridView control to create the DataSourceSelectArguments object that
 677                 // contains the arguments passed to the data source. In this implementation,
 678                 // the DataSourceSelectArguments object contains the arguments for paging operations.
 679                 [Test]
 680                 public void GridView_CreateDataSourceSelectArguments () {
 681                         DataSourceView view;
 682                         Page p = new Page ();
 683
 684                         PokerGridView g = new PokerGridView ();
 685                         g.Sorting += new GridViewSortEventHandler (g_Sorting);
 686                         p.Controls.Add (g);
 687
 688                         ObjectDataSource data = new ObjectDataSource ();
 689                         data.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
 690                         data.SelectMethod = "GetList";
 691                         data.SortParameterName = "sortExpression";
 692                         DataSourceSelectArguments arg;
 693                         p.Controls.Add (data);
 694
 695                         g.DataSource = data;
 696                         g.DataBind ();
 697
 698                         arg = g.DoCreateDataSourceSelectArguments ();
 699                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "Default");
 700
 701                         g.AllowPaging = true;
 702                         g.PageIndex = 2;
 703                         g.PageSize = 3;
 704                         arg = g.DoCreateDataSourceSelectArguments ();
 705                         view = g.DoGetData ();
 706                         Assert.IsFalse (view.CanPage);
 707                         Assert.IsTrue (view.CanRetrieveTotalRowCount);
 708                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = true, CanPage = false, CanRetrieveTotalRowCount = true");
 709
 710                         // make DataSourceView.CanPage = true
 711                         data.EnablePaging = true;
 712
 713                         arg = g.DoCreateDataSourceSelectArguments ();
 714                         view = g.DoGetData ();
 715                         Assert.IsTrue (view.CanPage);
 716                         Assert.IsFalse (view.CanRetrieveTotalRowCount);
 717                         Assert.IsTrue (arg.Equals (new DataSourceSelectArguments (6, -1)), "AllowPaging = true, CanPage = true, CanRetrieveTotalRowCount = false");
 718
 719                         g.AllowPaging = false;
 720                         arg = g.DoCreateDataSourceSelectArguments ();
 721                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = false, CanPage = true, CanRetrieveTotalRowCount = false");
 722
 723                         // make DataSourceView.CanRetrieveTotalRowCount = true
 724                         data.SelectCountMethod = "GetCount";
 725
 726                         arg = g.DoCreateDataSourceSelectArguments ();
 727                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = false, CanPage = true, CanRetrieveTotalRowCount = true");
 728
 729                         g.AllowPaging = true;
 730                         arg = g.DoCreateDataSourceSelectArguments ();
 731                         DataSourceSelectArguments arg1 = new DataSourceSelectArguments (6, 3);
 732                         arg1.RetrieveTotalRowCount = true;
 733                         view = g.DoGetData ();
 734                         Assert.IsTrue (view.CanPage);
 735                         Assert.IsTrue (view.CanRetrieveTotalRowCount);
 736                         Assert.IsTrue (arg.Equals (arg1), "AllowPaging = true, CanPage = true, CanRetrieveTotalRowCount = true");
 737
 738                         g.AllowPaging = false;
 739                         g.AllowSorting = true;
 740                         g.EditIndex = 2;
 741                         g.PageIndex = 1;
 742                         g.Sort ("sort", SortDirection.Descending);
 743
 744                         Assert.AreEqual (2, g.EditIndex, "EditIndex after Sort, Bound by DataSource");
 745                         Assert.AreEqual (1, g.PageIndex, "PageIndex after Sort, Bound by DataSource");
 746
 747                         arg = g.DoCreateDataSourceSelectArguments ();
 748                         view = g.DoGetData ();
 749                         Assert.IsTrue (view.CanSort);
 750                         Assert.AreEqual (String.Empty, g.SortExpression, "SortExpression, Bound by DataSource");
 751                         Assert.AreEqual (SortDirection.Ascending, g.SortDirection, "SortDirection, Bound by DataSource");
 752                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowSorting = true, Bound by DataSource");
 753
 754                 }
 755
 756                 static void g_Sorting (object sender, GridViewSortEventArgs e) {
 757                         Assert.AreEqual ("sort", e.SortExpression, "GridViewSortEventArgs.SortExpression");
 758                         Assert.AreEqual (SortDirection.Descending, e.SortDirection, "GridViewSortEventArgs.SortDirection");
 759                 }
 760
 761                 [Test]
 762                 public void GridView_DataBind()
 763                 {
 764                         PokerGridView g = new PokerGridView ();
 765                         g.DataSource = myds;
 766                         g.DataBind ();
 767                         Assert.AreEqual (6, g.Rows.Count, "DataBind");
 768
 769                         g.DataSource = null;
 770                         g.DataBind ();
 771                         Assert.AreEqual (0, g.Rows.Count, "DataBind");
 772                 }
 773
 774                 [Test]
 775                 public void GridView_DataBind_NoDataSource () {
 776                         PokerGridView g = new PokerGridView ();
 777                         g.DataBind ();
 778                         Assert.AreEqual (0, g.Rows.Count, "GridView_DataBind_NoDataSource");
 779                 }
 780
 781                 bool rowcreatedchecker;
 782                 bool deleteitemchecker;
 783                 bool sortingaction;
 784
 785
 786                 [Test]
 787                 public void GridView_DeleteItem ()
 788                 {
 789                         PokerGridView g = new PokerGridView ();
 790                         ArrayList myds = new ArrayList ();
 791                         myds.Add ("Norway");
 792                         myds.Add ("Sweden");
 793                         myds.Add ("France");
 794                         myds.Add ("Italy");
 795
 796                         g.DataSource = myds;
 797                         g.DataBind ();
 798                         Assert.AreEqual (false, deleteitemchecker, "DeleteItem#1");
 799                         g.RowDeleting += new GridViewDeleteEventHandler (RowDeletingHandler);
 800                         g.DeleteRow (0);
 801                         Assert.AreEqual (true, deleteitemchecker, "DeleteItem#2");
 802                 }
 803
 804                 protected void RowDeletingHandler (object sender, GridViewDeleteEventArgs e)
 805                 {
 806                         deleteitemchecker = true;
 807                 }
 808
 809                 [Test]
 810                 public void GridView_RowCreated ()
 811                 {
 812                         GridView g = new GridView ();
 813                         ButtonField field = new ButtonField ();
 814                         field.ButtonType = ButtonType.Link;
 815                         field.Text = "Click";
 816                         field.CommandName = "CMD";
 817                         g.Columns.Add (field);
 818                         g.RowCreated += new GridViewRowEventHandler (RowCreatedHandler);
 819
 820                         Assert.AreEqual (false, rowcreatedchecker, "RowCreated#1");
 821
 822                         ArrayList myds = new ArrayList ();
 823                         myds.Add ("Norway");
 824                         myds.Add ("Sweden");
 825                         myds.Add ("France");
 826                         myds.Add ("Italy");
 827
 828                         g.DataSource = myds;
 829                         g.DataBind ();
 830                         Assert.AreEqual (true, rowcreatedchecker, "RowCreated#2");
 831                 }
 832
 833                 protected void RowCreatedHandler (object sender, GridViewRowEventArgs e)
 834                 {
 835                         if (e.Row.Cells.Count > 0)
 836                                 rowcreatedchecker = true;
 837
 838                         // Example from MSDN: GridView.RowCreated Event
 839
 840                         // The GridViewCommandEventArgs class does not contain a
 841                         // property that indicates which row's command button was
 842                         // clicked. To identify which row's button was clicked, use
 843                         // the button's CommandArgument property by setting it to the
 844                         // row's index.
 845                         if (e.Row.RowType == DataControlRowType.DataRow) {
 846                                 // Retrieve the LinkButton control from the first column.
 847                                 IButtonControl addButton = (IButtonControl) e.Row.Cells [0].Controls [0];
 848
 849                                 // Set the LinkButton's CommandArgument property with the
 850                                 // row's index.
 851                                 addButton.CommandArgument = e.Row.RowIndex.ToString ();
 852                         }
 853                 }
 854
 855                 [Test]
 856                 public void GridView_Sort ()
 857                 {
 858                         PokerGridView g = new PokerGridView ();
 859                         Assert.AreEqual (false, sortingaction, "BeforeSorting");
 860                         g.Sorting += new GridViewSortEventHandler (Gridview_sorting);
 861                         g.Sort("Item",SortDirection.Descending);
 862                         Assert.AreEqual (true, sortingaction, "AfterSorting");
 863                 }
 864
 865                 protected void Gridview_sorting (object sender, GridViewSortEventArgs e)
 866                 {
 867                         sortingaction = true;
 868                 }\r
 869 \r
 870                 [Test]\r
 871                 public void GridView_IsBindableType ()\r
 872                 {\r
 873                         Type [] types = new Type [] {\r
 874                                 typeof(Boolean), \r
 875                                 typeof(Byte),\r
 876                                 typeof(Char),\r
 877                                 typeof(DateTime),\r
 878                                 typeof(Decimal),\r
 879                                 typeof(Double),\r
 880                                 typeof(Guid),\r
 881                                 typeof(Int16),\r
 882                                 typeof(Int32),\r
 883                                 typeof(Int64),\r
 884                                 typeof(SByte),\r
 885                                 typeof(Single),\r
 886                                 typeof(String),\r
 887                                 typeof(UInt16),\r
 888                                 typeof(UInt32),\r
 889                                 typeof(UInt64)\r
 890                                  };\r
 891 \r
 892                         GridView g = new GridView ();\r
 893                         foreach (Type type in types)\r
 894                                 Assert.AreEqual (true, g.IsBindableType (type), type.ToString ());\r
 895 \r
 896                         Assert.AreEqual (false, g.IsBindableType (typeof (Enum)), "test");\r
 897                         Assert.AreEqual (false, g.IsBindableType (typeof (Object)), "test");\r
 898                 }\r
 899
 900                 [Test]
 901                 public void GridView_CreateAutoGeneratedColumn ()
 902                 {
 903                         PokerGridView g = new PokerGridView ();
 904                         AutoGeneratedFieldProperties fp = new AutoGeneratedFieldProperties();
 905                         fp.Name = "testfield";
 906                         fp.Type = typeof (string);
 907                         AutoGeneratedField gf = g.DoCreateAutoGeneratedColumn (fp);
 908                         Assert.AreEqual (typeof (string), gf.DataType , "AutoGeneratedColumn#1");
 909                         Assert.AreEqual ("testfield", gf.HeaderText, "AutoGeneratedColumn#2");
 910                         Assert.AreEqual ("System.Web.UI.WebControls.AutoGeneratedField", gf.GetType ().ToString (), "AutoGeneratedColumn#3");
 911                 }
 912
 913                 [Test]
 914                 public void GridView_CreateChildControls ()
 915                 {
 916                         PokerGridView g = new PokerGridView ();
 917                         g.Page = new Page ();
 918                         g.DataSource = myds;
 919                         g.DataBind ();
 920                         Assert.AreEqual(6,g.DoCreateChildControls(myds,true),"CreateChildControls#1");
 921
 922                         g.AllowPaging = true;
 923                         g.PageSize = 3;
 924                         g.DataBind ();
 925                         Assert.AreEqual (6, g.DoCreateChildControls (myds, true), "CreateChildControls#1");
 926                 }
 927
 928                 class MyEnumSource : IEnumerable
 929                 {
 930                         int _count;
 931
 932                         public MyEnumSource (int count)
 933                         {
 934                                 _count = count;
 935                         }
 936
 937                         #region IEnumerable Members
 938
 939                         public IEnumerator GetEnumerator () {
 940
 941                                 for (int i = 0; i < _count; i++)
 942                                         yield return i;
 943                         }
 944
 945                         #endregion
 946                 }
 947
 948                 [Test]
 949                 public void GridView_CreateChildControls_2 () {
 950                         PokerGridView g = new PokerGridView ();
 951                         g.AutoGenerateColumns = false;
 952                         g.AutoGenerateSelectButton = true;
 953                         g.EmptyDataText = "empty";
 954                         g.Page = new Page ();
 955                         g.DataSource = new MyEnumSource (20);
 956                         //g.DataBind ();
 957                         //Assert.AreEqual (20, g.DoCreateChildControls (new MyEnumSource (20), true), "CreateChildControls#1");
 958                         Assert.AreEqual (0, g.DoCreateChildControls (new MyEnumSource (0), true), "CreateChildControls#2");
 959                 }
 960
 961                 [Test]
 962                 public void GridView_CreateChildControls_1 ()
 963                 {
 964                         PokerGridView g = new PokerGridView ();
 965                         g.AutoGenerateSelectButton = true;
 966                         g.EmptyDataText = "empty";
 967                         Assert.AreEqual (0, g.DoCreateChildControls (new object [0], false), "CreateChildControls#2");
 968                         Assert.AreEqual (-1, g.DoCreateChildControls (new object [5], false), "CreateChildControls#3");
 969                 }
 970
 971                 [Test]
 972                 public void GridView_NullDS ()
 973                 {
 974                         PokerGridView g = new PokerGridView ();
 975                         g.DataSource = null;
 976                         g.DataBind ();
 977                         Assert.AreEqual (0, g.Rows.Count, "NullDS");
 978                 }
 979
 980                 [Test]
 981                 public void GridView_CreateChildTable () {
 982                         PokerGridView g = new PokerGridView ();
 983                         g.ID = "PokerGridView";
 984                         g.Caption = "Caption";
 985                         g.CaptionAlign = TableCaptionAlign.Right;
 986                         g.CellPadding = 2;
 987                         g.CellSpacing = 2;
 988                         Table t = g.DoCreateChildTable ();
 989                         Assert.IsNotNull (t, "CreateChildTable#1");
 990                         Assert.AreEqual (false, t.ControlStyleCreated, "CreateChildTable#2");
 991                 }
 992
 993                 [Test]
 994                 public void GridView_CreateControlStyle ()
 995                 {
 996                         PokerGridView g = new PokerGridView ();
 997                         g.BorderColor = Color.Red;
 998                         g.BorderStyle = BorderStyle.Dashed;
 999                         Style s = g.DoCreateControlStyle ();
1000                         Assert.AreEqual (typeof(TableStyle), s.GetType(), "CreateControlStyle#1");
1001                         Assert.AreEqual (((TableStyle) s).GridLines, GridLines.Both, "CreateControlStyle#2");
1002                         Assert.AreEqual (((TableStyle) s).CellSpacing, 0, "CreateControlStyle#3");
1003                 }
1004
1005                 [Test]
1006                 public void GridView_CreateRow ()
1007                 {
1008                         PokerGridView g = new PokerGridView ();
1009                         GridViewRow gr = g.doCreateRow(0, 0, DataControlRowType.Pager, DataControlRowState.Normal);
1010                         Assert.AreEqual (0, gr.RowIndex, "CreateRow#1");
1011                         Assert.AreEqual (0, gr.DataItemIndex, "CreateRow#2");
1012                         Assert.AreEqual (DataControlRowType.Pager, gr.RowType, "CreateRow#3");
1013                         Assert.AreEqual (DataControlRowState.Normal, gr.RowState, "CreateRow#4");
1014                 }
1015
1016                 [Test]
1017                 public void GridView_GetCallbackResult()
1018                 {
1019                         Page page = new Page ();
1020                         PokerGridView g = new PokerGridView ();
1021                         page.Controls.Add (g);
1022                         string s = g.doGetCallbackResult ();
1023                         if (s == null || s == string.Empty) {
1024                                 Assert.Fail ("GetCallbackResult");
1025                         }
1026                 }
1027
1028                 [Test]
1029                 public void GridView_InitializePager ()
1030                 {
1031                         PokerGridView gv = new PokerGridView ();
1032                         Page page = new Page ();
1033                         page.Controls.Add (gv);
1034                         gv.AllowPaging = true;
1035                         gv.PageSize = 2;
1036                         gv.DataSource = myds;
1037                         Assert.AreEqual (false, gv.ifPagerInitilized, "BeforeInitializePagerRunned");
1038                         Assert.AreEqual (0, gv.PageCount, "BeforeInitializePagerPageCount");
1039                         gv.DataBind ();
1040                         Assert.AreEqual (true, gv.ifPagerInitilized, "AfterInitializePagerRunned");
1041                         Assert.AreEqual (3, gv.PageCount, "AfterInitializePagerPageCount");
1042                 }
1043
1044                 [Test]
1045                 public void GridView_InitializeRow ()
1046                 {
1047                         // not implemented yet
1048                 }
1049
1050                 [Test]
1051                 public void GridView_ViewState ()
1052                 {
1053                         PokerGridView gv = new PokerGridView ();
1054                         PokerGridView copy = new PokerGridView ();
1055                         gv.AllowPaging = true;
1056                         gv.AllowSorting = true;
1057                         gv.BackColor = Color.Red;
1058                         object state = gv.SaveState ();
1059                         copy.LoadState (state);
1060                         Assert.AreEqual (true, copy.AllowPaging, "ViewStateAllowPaging");
1061                         Assert.AreEqual (true, copy.AllowSorting, "ViewStateAllowSorting");
1062                         Assert.AreEqual (Color.Red, copy.BackColor, "ViewStateBackColor");
1063                 }
1064
1065                 // Private variables for bubble events
1066                 private bool bubbledeleterow;
1067                 private bool bubbleupdaterow;
1068                 private bool bubbleeditingrow;
1069                 private bool bubblesortint;
1070                 private bool bubblecanceling;
1071                 private bool bubbleselect;
1072                 private bool bubblepage;
1073                 private int newPageIndex;
1074
1075                 [Test]
1076                 public void GridView_BubbleEvent ()
1077                 {
1078                         PokerGridView gv = new PokerGridView ();
1079                         Page page = new Page ();
1080                         LinkButton lb = new LinkButton ();
1081                         gv.AllowPaging = true;
1082                         page.Controls.Add (gv);
1083                         gv.DataSource = myds;
1084                         gv.DataBind ();
1085                         gv.EditIndex = 0;
1086                         //
1087                         gv.RowDeleting += new GridViewDeleteEventHandler (gv_RowDeleting);
1088                         gv.RowUpdating += new GridViewUpdateEventHandler (gv_RowUpdating);
1089                         gv.RowEditing += new GridViewEditEventHandler (gv_RowEditing);
1090                         gv.Sorting += new GridViewSortEventHandler (gv_Sorting);
1091                         gv.RowCancelingEdit += new GridViewCancelEditEventHandler (gv_RowCancelingEdit);
1092                         gv.SelectedIndexChanging+=new GridViewSelectEventHandler(gv_SelectedIndexChanging);
1093                         gv.PageIndexChanging+=new GridViewPageEventHandler(gv_PageIndexChanging);
1094                         // Delete
1095                         GridViewCommandEventArgs com1 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Delete", "0"));
1096                         Assert.AreEqual (false, bubbledeleterow, "BeforeBubbleEventDeleteRow");
1097                         gv.DoOnBubbleEvent (gv, com1);
1098                         Assert.AreEqual (true, bubbledeleterow, "AfterBubbleEventDeleteRow");
1099                         // Update
1100                         GridViewCommandEventArgs com2 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Update", "0"));
1101                         Assert.AreEqual (false, bubbleupdaterow, "BeforeBubbleEventUpdateRow");
1102                         gv.DoOnBubbleEvent (gv, com2);
1103                         Assert.AreEqual (true, bubbleupdaterow, "AfterBubbleEventUpdateRow");
1104                         // Edit
1105                         GridViewCommandEventArgs com3 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Edit", "0"));
1106                         Assert.AreEqual (false, bubbleeditingrow, "BeforeBubbleEventEditingRow");
1107                         gv.DoOnBubbleEvent (gv, com3);
1108                         Assert.AreEqual (true, bubbleeditingrow, "AfterBubbleEventEditingRow");
1109                         // Sort
1110                         gv.AllowSorting = true;
1111                         GridViewCommandEventArgs com4 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Sort", null));
1112                         Assert.AreEqual (false, bubblesortint, "BeforeBubbleEventSortingRow");
1113                         gv.DoOnBubbleEvent (gv, com4);
1114                         Assert.AreEqual (true, bubblesortint, "AfterBubbleEventSortingRow");
1115                         // Canceling Edit
1116                         GridViewCommandEventArgs com5 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Cancel", null));
1117                         Assert.AreEqual (false, bubblecanceling, "BeforeBubbleEventcancelingEdit");
1118                         gv.DoOnBubbleEvent (gv, com5);
1119                         Assert.AreEqual (true, bubblecanceling, "AfterBubbleEventcancelingEdit");
1120                         // Select
1121                         GridViewCommandEventArgs com6 = new GridViewCommandEventArgs (gv.SelectedRow, lb, new CommandEventArgs ("Select", "2"));
1122                         Assert.AreEqual (false, bubbleselect, "BeforeBubbleEventSelect");
1123                         gv.DoOnBubbleEvent (gv, com6);
1124                         Assert.AreEqual (true, bubbleselect, "AfterBubbleEventSelect");
1125                         //Next Page
1126                         GridViewCommandEventArgs com7 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Page", "Next"));
1127                         Assert.AreEqual (false, bubblepage, "BeforeBubbleEventNextPage");
1128                         gv.DoOnBubbleEvent (gv, com7);
1129                         Assert.AreEqual (true, bubblepage, "AfterBubbleEventNextPage");
1130                         Assert.AreEqual (1, newPageIndex, "NextPage");
1131                         // Prev Page
1132                         ResetEvents ();
1133                         GridViewCommandEventArgs com8 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Page", "Prev"));
1134                         Assert.AreEqual (false, bubblepage, "BeforeBubbleEventPrevPage");
1135                         gv.DoOnBubbleEvent (gv, com8);
1136                         Assert.AreEqual (true, bubblepage, "AfterBubbleEventPrevPage");
1137                         Assert.AreEqual (-1, newPageIndex, "PrevPage");
1138                         ResetEvents ();
1139                         GridViewCommandEventArgs com9 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Page", "Last"));
1140                         Assert.AreEqual (false, bubblepage, "BeforeBubbleEventLastPage");
1141                         gv.DoOnBubbleEvent (gv, com9);
1142                         Assert.AreEqual (true, bubblepage, "AfterBubbleEventLastPage");
1143                         ResetEvents ();
1144                         GridViewCommandEventArgs com10 = new GridViewCommandEventArgs (lb, new CommandEventArgs ("Page", "First"));
1145                         Assert.AreEqual (false, bubblepage, "BeforeBubbleEventFirstPage");
1146                         gv.DoOnBubbleEvent (gv, com10);
1147                         Assert.AreEqual (true, bubblepage, "AfterBubbleEventFirstPage");
1148                         Assert.AreEqual (0, newPageIndex, "FirstPage");
1149                 }
1150
1151                 private void gv_RowDeleting (object sender, EventArgs e)
1152                 {
1153                         bubbledeleterow = true;
1154                         rowDeleting = true;
1155                 }
1156
1157                 private void gv_RowUpdating (object sender, EventArgs e)
1158                 {
1159                         bubbleupdaterow = true;
1160                         rowUpdating = true;
1161                 }
1162
1163                 private void gv_RowEditing (object sender, EventArgs e)
1164                 {
1165                         bubbleeditingrow = true;
1166                         rowEditing = true;
1167                 }
1168
1169                 private void gv_Sorting (object sender, EventArgs e)
1170                 {
1171                         bubblesortint = true;
1172                         sorting = true;
1173                 }
1174
1175                 private void gv_RowCancelingEdit (object sender, EventArgs e)
1176                 {
1177                         bubblecanceling = true;
1178                         gridViewCancelEdit = true;
1179                 }
1180
1181                 private void gv_SelectedIndexChanging (object sender, GridViewSelectEventArgs e)
1182                 {
1183                         bubbleselect = true;
1184                         selectIndexChanging = true;
1185                         Assert.AreEqual (2, e.NewSelectedIndex, "SelectedIndexChanging");
1186                 }
1187
1188                 private void gv_PageIndexChanging (object sender, GridViewPageEventArgs e)
1189                 {
1190                         bubblepage = true;
1191                         pageIndexChanging = true;
1192                         newPageIndex = e.NewPageIndex;
1193                         e.NewPageIndex = 0;
1194                 }
1195
1196                 private void ResetEvents ()
1197                 {
1198                         bubblepage = false;
1199                         dataBinding = false;
1200                         pageIndexChanging = false;
1201                         gridViewCancelEdit = false;
1202                         rowDeleting = false;
1203                         rowEditing = false;
1204                         rowUpdating = false;
1205                         selectIndexChanging = false;
1206                         sorting = false;
1207                 }
1208
1209                 // Events variable
1210                 private bool dataBinding;
1211                 private bool dataBound;
1212                 private bool init;
1213                 private bool load;
1214                 private bool pageIndexChanged;
1215                 private bool pageIndexChanging;
1216                 private bool preRender;
1217                 private bool gridViewCancelEdit;
1218                 private bool rowCommand;
1219                 private bool rowCreated;
1220                 private bool rowDataBound;
1221                 private bool rowDeleted;
1222                 private bool rowDeleting;
1223                 private bool rowEditing;
1224                 private bool rowUpdated;
1225                 private bool rowUpdating;
1226                 private bool selectIndexChanged;
1227                 private bool selectIndexChanging;
1228                 private bool sorted;
1229                 private bool sorting;
1230                 private bool unload;
1231
1232                 [Test]
1233                 public void GridView_Events ()
1234                 {
1235                         PokerGridView gv = new PokerGridView ();
1236                         gv.DataSource = myds;
1237
1238                         gv.DataBinding += new EventHandler (gv_DataBinding);
1239                         gv.DataBound += new EventHandler (gv_DataBound);
1240                         gv.PageIndexChanging += new GridViewPageEventHandler (gv_PageIndexChanging);
1241                         gv.PageIndexChanged += new EventHandler (gv_PageIndexChanged);
1242                         gv.PreRender += new EventHandler (gv_PreRender);
1243                         gv.RowCancelingEdit += new GridViewCancelEditEventHandler (gv_RowCancelingEdit);
1244                         gv.RowCommand += new GridViewCommandEventHandler (gv_RowCommand);
1245                         gv.RowCreated += new GridViewRowEventHandler (gv_RowCreated);
1246                         gv.RowDataBound += new GridViewRowEventHandler (gv_RowDataBound);
1247                         gv.RowDeleted += new GridViewDeletedEventHandler(gv_RowDeleted);
1248                         gv.RowDeleting+= new GridViewDeleteEventHandler(gv_RowDeleting);
1249                         gv.RowEditing+=new GridViewEditEventHandler(gv_RowEditing);
1250                         gv.RowUpdated+= new GridViewUpdatedEventHandler(gv_RowUpdated);
1251                         gv.RowUpdating+=new GridViewUpdateEventHandler(gv_RowUpdating);
1252                         gv.SelectedIndexChanged +=new EventHandler(gv_SelectedIndexChanged);
1253                         gv.SelectedIndexChanging+=new GridViewSelectEventHandler(gv_SelectedIndexChanging);
1254                         gv.Sorted +=new EventHandler(gv_Sorted);
1255                         gv.Sorting +=new GridViewSortEventHandler(gv_Sorting);
1256                         gv.Unload+=new EventHandler(gv_Unload);
1257
1258
1259                         Assert.AreEqual (false, dataBinding, "BeforeDataBinding");
1260                         gv.DoOnDataBinding (new EventArgs ());
1261                         Assert.AreEqual (true, dataBinding, "AfterDataBinding");
1262                         Assert.AreEqual (false, dataBound, "BeforeDataBound");
1263                         gv.DoOnDataBound (new EventArgs ());
1264                         Assert.AreEqual (true, dataBound, "AfterDataBound");
1265                         Assert.AreEqual (false, pageIndexChanged, "BeforepageIndexChanged");
1266                         gv.DoOnPageIndexChanged (new EventArgs ());
1267                         Assert.AreEqual (true, pageIndexChanged, "AfterpageIndexChanged");
1268                         ResetEvents ();
1269                         Assert.AreEqual (false, pageIndexChanging, "BeforepageIndexChanging");
1270                         gv.DoOnPageIndexChanging (new GridViewPageEventArgs(1));
1271                         Assert.AreEqual (true, pageIndexChanging, "AfterpageIndexChanging");
1272                         Assert.AreEqual (false, preRender, "BeforePreRender");
1273                         gv.DoOnPreRender (new EventArgs ());
1274                         Assert.AreEqual (true, preRender, "AfterPreRender");
1275                         ResetEvents ();
1276                         Assert.AreEqual (false, gridViewCancelEdit, "BeforeGridViewCancelEdit");
1277                         gv.DoOnRowCancelingEdit (new GridViewCancelEditEventArgs (1));
1278                         Assert.AreEqual (true, gridViewCancelEdit, "AfterGridViewCancelEdit");
1279                         ResetEvents ();
1280                         Assert.AreEqual (false, rowCommand, "BeforeRowCommand");
1281                         LinkButton lb= new LinkButton();
1282                         gv.DoOnRowCommand (new GridViewCommandEventArgs(lb,new CommandEventArgs("",null)));
1283                         Assert.AreEqual (true, rowCommand, "AfterRowCommand");
1284                         Assert.AreEqual (false, rowCreated, "BeforeRowCreated");
1285                         gv.DoOnRowCreated (new GridViewRowEventArgs (gv.SelectedRow));
1286                         Assert.AreEqual (true, rowCommand, "AfterRowCreated");
1287                         Assert.AreEqual (false, rowDataBound, "BeforeRowDataBound");
1288                         gv.DoOnRowDataBound (new GridViewRowEventArgs (gv.SelectedRow));
1289                         Assert.AreEqual (true, rowDataBound, "AfterRowDataBound");
1290                         Assert.AreEqual (false, rowDeleted, "BeforeRowDeleted");
1291                         gv.DoOnRowDeleted(new GridViewDeletedEventArgs(1,new ArgumentException()));
1292                         Assert.AreEqual (true, rowDeleted, "AfterRowDeleted");
1293                         ResetEvents ();
1294                         Assert.AreEqual (false, rowDeleting, "BeforeRowDeleting");
1295                         gv.DoOnRowDeleting (new GridViewDeleteEventArgs (0));
1296                         Assert.AreEqual (true, rowDeleting, "AfterRowDeleting");
1297                         ResetEvents ();
1298                         Assert.AreEqual (false, rowEditing, "BeforeRowEditing");
1299                         gv.DoOnRowEditing (new GridViewEditEventArgs (0));
1300                         Assert.AreEqual (true, rowEditing, "AfterRowEditing");
1301                         Assert.AreEqual (false, rowUpdated, "BeforeRowUpdated");
1302                         gv.DoOnRowUpdated (new GridViewUpdatedEventArgs(1,new Exception()));
1303                         Assert.AreEqual (true, rowUpdated, "AfterRowUpdated");
1304                         ResetEvents ();
1305                         Assert.AreEqual (false, rowUpdating, "BeforeRowUpdating");
1306                         gv.DoOnRowUpdating (new GridViewUpdateEventArgs (0));
1307                         Assert.AreEqual (true, rowUpdating, "AfterRowUpdating");
1308                         Assert.AreEqual (false, selectIndexChanged, "BeforeSelectedIndexChanged");
1309                         gv.DoOnSelectedIndexChanged (new EventArgs ());
1310                         Assert.AreEqual (true, selectIndexChanged, "AfterSelectedIndexChanged");
1311                         ResetEvents ();
1312                         Assert.AreEqual (false, selectIndexChanging, "BeforeSelectedIndexChanging");
1313                         gv.DoOnSelectedIndexChanging (new GridViewSelectEventArgs (2));
1314                         Assert.AreEqual (true, selectIndexChanging, "AfterSelectedIndexChanging");
1315                         Assert.AreEqual (false, sorted, "BeforeSorted");
1316                         gv.DoOnSorted (new EventArgs ());
1317                         Assert.AreEqual (true, sorted, "AfterSorted");
1318                         Assert.AreEqual (false, sorting, "BeforeSorting");
1319                         gv.DoOnSorting(new GridViewSortEventArgs("",SortDirection.Ascending));
1320                         Assert.AreEqual (true, sorting, "AfterSorting");
1321                         Assert.AreEqual (false, unload, "BeforeUnload");
1322                         gv.DoOnUnload (new EventArgs ());
1323                         Assert.AreEqual (true, unload, "AfterUnload");
1324
1325                 }
1326
1327                 private void gv_Unload (object sender, EventArgs e)
1328                 {
1329                         unload = true;
1330                 }
1331
1332                 private void gv_Sorted (object sender, EventArgs e)
1333                 {
1334                         sorted = true;
1335                 }
1336
1337                 private void gv_SelectedIndexChanged (object sender, EventArgs e)
1338                 {
1339                         selectIndexChanged = true;
1340                 }
1341
1342                 private void gv_RowUpdated (object sender, EventArgs e)
1343                 {
1344                         rowUpdated = true;
1345                 }
1346
1347                 private void gv_RowDeleted (object sender, EventArgs e)
1348                 {
1349                         rowDeleted = true;
1350                 }
1351
1352                 private void gv_RowDataBound (object sender, EventArgs e)
1353                 {
1354                         rowDataBound = true;
1355                 }
1356
1357                 private void gv_RowCreated (object sender, EventArgs e)
1358                 {
1359                         rowCreated = true;
1360                 }
1361
1362                 private void gv_RowCommand (object sender, EventArgs e)
1363                 {
1364                         rowCommand = true;
1365                 }
1366
1367                 private void gv_PreRender (object sender, EventArgs e)
1368                 {
1369                         preRender = true;
1370                 }
1371
1372                 private void gv_DataBinding (object sender, EventArgs e)
1373                 {
1374                         dataBinding = true;
1375                 }
1376
1377                 private void gv_DataBound (object sender, EventArgs e)
1378                 {
1379                         dataBound = true;
1380                 }
1381
1382                 private void gv_Init (object sender, EventArgs e)
1383                 {
1384                         init = true;
1385                 }
1386
1387                 private void gv_Load (object sender, EventArgs e)
1388                 {
1389                         load = true;
1390                 }
1391
1392                 private void gv_PageIndexChanged (object sender, EventArgs e)
1393                 {
1394                         pageIndexChanged = true;
1395                 }
1396
1397                 [Test]
1398                 public void GridView_PerformDataBiding ()
1399                 {
1400                         PokerGridView gv = new PokerGridView ();
1401                         gv.DoPerformDataBinding (myds);
1402                         Assert.AreEqual (6, gv.Rows.Count, "PerformDataBiding_Rows");
1403                 }
1404
1405                 [Test]
1406                 public void GridView_PrepareControlHierarchy ()
1407                 {
1408                         PokerGridView gv = new PokerGridView ();
1409                         gv.controlHierarchy = false;
1410                         gv.Render ();
1411                         Assert.AreEqual (0, gv.Controls.Count, "ControlHierarchy_ControlsCount");
1412                         Assert.AreEqual (true, gv.controlHierarchy, "ControlHierarchy_FirstFlow");
1413                         gv.DataSource = myds;
1414                         gv.DataBind ();
1415                         gv.controlHierarchy = false;
1416                         gv.Render ();
1417                         Assert.AreEqual (1, gv.Controls.Count, "ControlHierarchy_ControlsCountSecondaryFlow");
1418                         Assert.AreEqual (true, gv.controlHierarchy, "ControlHierarchy_SecondaryFlow");
1419                 }
1420
1421                 [Test]
1422                 public void GridView_State ()
1423                 {
1424                         PokerGridView g = new PokerGridView ();
1425                         PokerGridView copy = new PokerGridView ();
1426
1427                         string[] test = new String[1];
1428                         test[0] = "test";
1429                         g.DataKeyNames = test;
1430                         g.EditIndex = 0;
1431                         g.PageIndex = 2;
1432
1433                         object state = g.DoSaveControlState ();
1434                         copy.DoLoadControlState (state);
1435
1436                         Assert.AreEqual ("test", copy.DataKeyNames[0], "DataKeyNames");
1437                         Assert.AreEqual (0, copy.EditIndex, "EditIndex");
1438                         Assert.AreEqual (2, copy.PageIndex, "PageIndex");
1439
1440                 }
1441
1442                 [Test]
1443                 public void GridView_DefaultsRender ()
1444                 {
1445                         PokerGridView b = new PokerGridView ();
1446                         string html = b.Render ();
1447                         Assert.AreEqual(-1 ,b.Render().IndexOf("table"), "RenderViewState");
1448                 }
1449
1450                 [Test]
1451                 public void GridView_Render ()
1452                 {
1453                         PokerGridView b = new PokerGridView ();
1454                         b.DataSource = myds;
1455                         b.DataBind ();
1456                         string OriginControlHtml = @"<div>
1457                                                <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1458                                                 <tr>
1459                                                         <th scope=""col"">Item</th>
1460                                                 </tr><tr>
1461                                                         <td>Norway</td>
1462                                                 </tr><tr>
1463                                                         <td>Sweden</td>
1464                                                 </tr><tr>
1465                                                         <td>France</td>
1466                                                 </tr><tr>
1467                                                         <td>Italy</td>
1468                                                 </tr><tr>
1469                                                         <td>Israel</td>
1470                                                 </tr><tr>
1471                                                         <td>Russia</td>
1472                                                 </tr>
1473                                                </table>
1474                                               </div>";
1475                         string RenderedControlHtml = b.Render ();
1476                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "Rendering");
1477                 }
1478
1479                 [Test]
1480                 public void GridView_RenderAllowPaging ()
1481                 {
1482                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderAllowPaging)).Run ();
1483                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1484                         string OriginControlHtml = @"<div>
1485                                                      <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1486                                                      <tr>
1487                                                      <th scope=""col"">Item</th>
1488                                                      </tr><tr>
1489                                                      <td>Norway</td>
1490                                                      </tr><tr>
1491                                                      <td>Sweden</td>
1492                                                      </tr><tr>
1493                                                      <td><table border=""0"">
1494                                                      <tr>
1495                                                      <td><span>1</span></td><td><a href=""javascript:__doPostBack('ctl01','Page$2')"">2</a></td>
1496                                                      </tr>
1497                                                      </table></td>
1498                                                      </tr>
1499                                                      </table>
1500                                                      </div>";
1501                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderDefault");
1502                 }
1503
1504                 public static void RenderAllowPaging (Page p)
1505                 {
1506                         ArrayList myds = new ArrayList ();
1507                         myds.Add ("Norway");
1508                         myds.Add ("Sweden");
1509                         myds.Add ("France");
1510                         myds.Add ("Italy");
1511                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1512                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1513                         PokerGridView b = new PokerGridView ();
1514                         p.Form.Controls.Add (lcb);
1515                         p.Form.Controls.Add (b);
1516                         b.AllowPaging = true;
1517                         b.PageSize = 2;
1518                         b.DataSource = myds;
1519                         b.DataBind ();
1520                         p.Form.Controls.Add (lce);
1521                 }
1522
1523                 [Test]
1524                 [Category("NunitWeb")]
1525                 public void GridView_RenderAllowPaging2 () {
1526                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderAllowPaging2)).Run ();
1527                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1528                         string OriginControlHtml = @"<div>
1529                                                                                 <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1530                                                                                         <tr>
1531                                                                                                 <th scope=""col"">Item</th>
1532                                                                                         </tr><tr>
1533                                                                                                 <td>France</td>
1534                                                                                         </tr><tr>
1535                                                                                                 <td>Italy</td>
1536                                                                                         </tr><tr>
1537                                                                                                 <td><table border=""0"">
1538                                                                                                         <tr>
1539                                                                                                                 <td><a href=""javascript:__doPostBack('ctl01','Page$1')"">1</a></td><td><span>2</span></td><td><a href=""javascript:__doPostBack('ctl01','Page$3')"">3</a></td><td><a href=""javascript:__doPostBack('ctl01','Page$4')"">4</a></td><td><a href=""javascript:__doPostBack('ctl01','Page$5')"">...</a></td><td><a href=""javascript:__doPostBack('ctl01','Page$Last')"">&gt;&gt;</a></td>
1540                                                                                                         </tr>
1541                                                                                                 </table></td>
1542                                                                                         </tr>
1543                                                                                 </table>
1544                                                                         </div>";
1545                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderDefault");
1546                 }
1547
1548                 public static void RenderAllowPaging2 (Page p) {
1549                         ArrayList myds = new ArrayList ();
1550                         myds.Add ("Norway");
1551                         myds.Add ("Sweden");
1552                         myds.Add ("France");
1553                         myds.Add ("Italy");
1554                         myds.Add ("Norway");
1555                         myds.Add ("Sweden");
1556                         myds.Add ("France");
1557                         myds.Add ("Italy");
1558                         myds.Add ("Norway");
1559                         myds.Add ("Sweden");
1560                         myds.Add ("France");
1561                         myds.Add ("Italy");
1562                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1563                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1564                         PokerGridView b = new PokerGridView ();
1565                         p.Form.Controls.Add (lcb);
1566                         p.Form.Controls.Add (b);
1567                         b.AllowPaging = true;
1568                         b.PageSize = 2;
1569                         b.PageIndex = 1;
1570                         b.PagerSettings.PageButtonCount = 4;
1571                         b.PagerSettings.Mode= PagerButtons.NumericFirstLast;
1572                         b.DataSource = myds;
1573                         b.DataBind ();
1574                         p.Form.Controls.Add (lce);
1575                 }
1576
1577                 [Test]
1578                 public void GridView_RenderProperty ()
1579                 {
1580                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderProperty)).Run ();
1581                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1582                         string OriginControlHtml = @"<div id=""__gvctl01__div"">
1583                                                         <table cellspacing=""1"" cellpadding=""0"" align=""Justify"" rules=""rows"" border=""1"" style=""background-image:url(http://test);"">
1584                                                                 <caption align=""Left"">
1585                                                                         test
1586                                                                 </caption><tr>
1587                                                                         <td><a href=""javascript:__doPostBack('ctl01','Edit$0')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','Delete$0')"">Delete</a></td><td>Norway</td>
1588                                                                 </tr><tr>
1589                                                                         <td><a href=""javascript:__doPostBack('ctl01','Edit$1')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','Delete$1')"">Delete</a></td><td>Sweden</td>
1590                                                                 </tr><tr>
1591                                                                         <td><a href=""javascript:__doPostBack('ctl01','Edit$2')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','Delete$2')"">Delete</a></td><td>France</td>
1592                                                                 </tr><tr>
1593                                                                         <td><a href=""javascript:__doPostBack('ctl01','Edit$3')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','Delete$3')"">Delete</a></td><td>Italy</td>
1594                                                                 </tr><tr>
1595                                                                         <td>&nbsp;</td><td>&nbsp;</td>
1596                                                                 </tr>
1597                                                         </table>
1598                                                 </div>";
1599                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderDefault");
1600                 }
1601
1602                 public static void RenderProperty (Page p)
1603                 {
1604                         // Array list for simple datasource
1605                         ArrayList myds = new ArrayList ();
1606                         myds.Add ("Norway");
1607                         myds.Add ("Sweden");
1608                         myds.Add ("France");
1609                         myds.Add ("Italy");
1610
1611                         // Helper controls for searching usefull data from page
1612                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1613                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1614                         PokerGridView g = new PokerGridView ();
1615
1616                         // Changing some property for test
1617                         g.AutoGenerateDeleteButton = true;
1618                         g.AutoGenerateEditButton = true;
1619                         g.BackImageUrl = "http://test";
1620                         g.Caption = "test";
1621                         g.CaptionAlign = TableCaptionAlign.Left;
1622                         g.CellPadding = 0;
1623                         g.CellSpacing = 1;
1624                         g.EnableSortingAndPagingCallbacks = true;
1625                         g.GridLines = GridLines.Horizontal;
1626                         g.HorizontalAlign = HorizontalAlign.Justify;
1627                         g.ShowFooter = true;
1628                         g.ShowHeader = false;
1629                         g.UseAccessibleHeader = false;
1630
1631                         // Add controls for page
1632                         p.Form.Controls.Add (lcb);
1633                         p.Form.Controls.Add (g);
1634
1635                         // Data source and bind
1636                         g.DataSource = myds;
1637                         g.DataBind ();
1638                         p.Form.Controls.Add (lce);
1639                 }
1640
1641                 /// <summary>
1642                 /// From here rendering all possible field types and kinds of
1643                 /// templates
1644                 /// </summary>
1645
1646                 [Test]
1647                 public void GridView_RenderingBoundField ()
1648                 {
1649                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderingBoundField)).Run ();
1650                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1651                         string OriginControlHtml = @"<div>
1652                                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1653                                                                 <tr>
1654                                                                         <th scope=""col"">HeaderText</th>
1655                                                                 </tr><tr>
1656                                                                         <td>1</td>
1657                                                                 </tr><tr>
1658                                                                         <td>2</td>
1659                                                                 </tr><tr>
1660                                                                         <td>FooterText</td>
1661                                                                 </tr>
1662                                                         </table>
1663                                                     </div>";
1664                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderingBoundField");
1665                 }
1666
1667                 [Test]
1668                 public void GridView_RenderingCheckBoxField ()
1669                 {
1670                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderingCheckBoxField)).Run ();
1671                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1672                         string OriginControlHtml = @"<div>
1673                                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1674                                                         <tr>
1675                                                                 <th scope=""col"">HeaderText</th>
1676                                                         </tr><tr>
1677                                                                 <td><span disabled=""disabled""><input id="""" type=""checkbox"" name="""" checked=""checked"" disabled=""disabled"" /></span></td>
1678                                                         </tr><tr>
1679                                                                 <td><span disabled=""disabled""><input id="""" type=""checkbox"" name="""" disabled=""disabled"" /></span></td>
1680                                                         </tr><tr>
1681                                                                 <td>FooterText</td>
1682                                                         </tr>
1683                                                         </table>
1684                                                         </div>";
1685                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderingCheckBoxField");
1686                 }
1687
1688                 [Test]
1689                 public void GridView_RenderingCheckBoxField2 ()
1690                 {
1691                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderingCheckBoxField2)).Run ();
1692                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1693                         string OriginControlHtml = @"<div>
1694                                                                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1695                                                                                                 <tr>
1696                                                                                                         <th scope=""col"">bool</th><th scope=""col"">str</th>
1697                                                                                                 </tr><tr>
1698                                                                                                         <td><span disabled=""disabled"" title=""bool""><input id=""ctl01_ctl02_ctl00"" type=""checkbox"" name=""ctl01$ctl02$ctl00"" checked=""checked"" disabled=""disabled"" /></span></td><td>1</td>
1699                                                                                                 </tr><tr>
1700                                                                                                         <td><span disabled=""disabled"" title=""bool""><input id=""ctl01_ctl03_ctl00"" type=""checkbox"" name=""ctl01$ctl03$ctl00"" disabled=""disabled"" /></span></td><td>2</td>
1701                                                                                                 </tr><tr>
1702                                                                                                         <td>&nbsp;</td><td>&nbsp;</td>
1703                                                                                                 </tr>
1704                                                                                         </table>
1705                                                                                 </div>";
1706                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderingCheckBoxField2");
1707                 }
1708
1709                 [Test]
1710                 public void GridView_RenderingImageField ()
1711                 {
1712                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderingImageField)).Run ();
1713                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1714                         string OriginControlHtml = @"<div>
1715                                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1716                                                                 <tr>
1717                                                                         <th scope=""col"">HeaderText</th>
1718                                                                 </tr><tr>
1719                                                                         <td><img src=""1"" alt=""1"" style=""border-width:0px;"" /></td>
1720                                                                 </tr><tr>
1721                                                                         <td><img src=""2"" alt=""2"" style=""border-width:0px;"" /></td>
1722                                                                 </tr><tr>
1723                                                                         <td>FooterText</td>
1724                                                                 </tr>
1725                                                         </table>
1726                                                 </div>";
1727                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderingImageField");
1728                 }
1729
1730                 [Test]
1731                 public void GridView_RenderingCommandField ()
1732                 {
1733                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderingCommandField)).Run ();
1734                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1735                         string OriginControlHtml = @"<div>
1736                                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1737                                                                 <tr>
1738                                                                         <th scope=""col"">HeaderText</th>
1739                                                                 </tr><tr>
1740                                                                         <td><a href=""javascript:__doPostBack('ctl01','Edit$0')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','Delete$0')"">Delete</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','New$0')"">New</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','Select$0')"">Select</a></td>
1741                                                                 </tr><tr>
1742                                                                         <td><a href=""javascript:__doPostBack('ctl01','Edit$1')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','Delete$1')"">Delete</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','New$1')"">New</a>&nbsp;<a href=""javascript:__doPostBack('ctl01','Select$1')"">Select</a></td>
1743                                                                 </tr><tr>
1744                                                                         <td>FooterText</td>
1745                                                                 </tr>
1746                                                         </table>
1747                                                      </div>";
1748                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderingCommandField");
1749                 }
1750
1751                 [Test]
1752                 public void GridView_RenderingHyperLinkField ()
1753                 {
1754                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderingHyperLinkField)).Run ();
1755                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1756                         string OriginControlHtml = @"<div>
1757                                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1758                                                                 <tr>
1759                                                                         <th scope=""col"">HeaderText</th>
1760                                                                 </tr><tr>
1761                                                                         <td><a href=""1"">1</a></td>
1762                                                                 </tr><tr>
1763                                                                         <td><a href=""2"">2</a></td>
1764                                                                 </tr><tr>
1765                                                                         <td>FooterText</td>
1766                                                                 </tr>
1767                                                         </table>
1768                                                 </div>";
1769                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderingHyperLinkField");
1770                 }
1771
1772                 [Test]
1773                 public void GridView_RenderingButtonField ()
1774                 {
1775                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderingButtonField)).Run ();
1776                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1777                         string OriginControlHtml = @"<div>
1778                                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1779                                                                 <tr>
1780                                                                         <th scope=""col"">HeaderText</th><th scope=""col"">HeaderText</th><th scope=""col"">HeaderText</th>
1781                                                                 </tr><tr>
1782                                                                         <td><input type=""button"" value=""1"" onclick=""javascript:__doPostBack('ctl01','0')"" /></td><td><a href=""javascript:__doPostBack('ctl01','0')"">1</a></td><td><input type=""image"" src="""" alt=""1"" onclick=""javascript:__doPostBack('ctl01','0')"" style=""border-width:0px;"" /></td>
1783                                                                 </tr><tr>
1784                                                                         <td><input type=""button"" value=""2"" onclick=""javascript:__doPostBack('ctl01','1')"" /></td><td><a href=""javascript:__doPostBack('ctl01','1')"">2</a></td><td><input type=""image"" src="""" alt=""2"" onclick=""javascript:__doPostBack('ctl01','1')"" style=""border-width:0px;"" /></td>
1785                                                                 </tr><tr>
1786                                                                         <td>FooterText</td><td>FooterText</td><td>FooterText</td>
1787                                                                 </tr>
1788                                                         </table>
1789                                                 </div>";
1790                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderingButtonField");
1791                 }
1792
1793
1794
1795
1796
1797                 [Test]
1798                 public void GridView_RenderingTemplateField ()
1799                 {
1800
1801                         string RenderedPageHtml = new WebTest (PageInvoker.CreateOnLoad (RenderingTemplateField)).Run ();
1802                         string RenderedControlHtml = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1803                         string OriginControlHtml = @"<div>
1804                                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1805                                                                 <tr>
1806                                                                         <th scope=""col""><input name="""" type=""text"" id="""" /></th>
1807                                                                 </tr><tr>
1808                                                                         <td><input name="""" type=""text"" value=""1"" id="""" /></td>
1809                                                                 </tr><tr>
1810                                                                         <td><input name="""" type=""text"" value=""2"" id="""" /></td>
1811                                                                 </tr><tr>
1812                                                                         <td><input name="""" type=""text"" id="""" /></td>
1813                                                                 </tr>
1814                                                         </table>
1815                                                       </div>";
1816                         HtmlDiff.AssertAreEqual (OriginControlHtml, RenderedControlHtml, "RenderingTemplateField");
1817                 }
1818
1819
1820                 public static void RenderingTemplateField (Page p)
1821                 {
1822                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1823                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1824                         GridView grid = new GridView ();
1825                         grid.ID = "grid";
1826                         grid.AutoGenerateColumns = false;
1827                         grid.ShowFooter = true;
1828                         TemplateField templatefield = new TemplateField ();
1829                         templatefield.InsertVisible = true;
1830                         templatefield.Visible = true;
1831                         templatefield.HeaderText = "HeaderText";
1832                         templatefield.FooterText = "FooterText";
1833                         templatefield.ItemTemplate = new CompiledTemplateBuilder(BuildControl_itemtemplate);
1834                         templatefield.HeaderTemplate = new CompiledTemplateBuilder (BuildControl_itemtemplate);
1835                         templatefield.FooterTemplate= new CompiledTemplateBuilder (BuildControl_itemtemplate);
1836                         grid.DataSource = GridViewTest.CreateDataSource ();
1837                         grid.Columns.Add (templatefield);
1838                         p.Form.Controls.Add (lcb);
1839                         p.Form.Controls.Add (grid);
1840                         p.Form.Controls.Add (lce);
1841                         grid.DataBind ();
1842                 }
1843
1844                 private static void BuildControl_itemtemplate (Control container)
1845                 {
1846                         TextBox ctrl;
1847                         ctrl = new TextBox ();
1848                         ctrl.ID = "TextBox1";
1849                         ctrl.DataBinding += MyDataBinding;
1850                         container.Controls.Add (ctrl);
1851                 }
1852
1853                 private static void MyDataBinding (object sender, EventArgs e)
1854                 {
1855                         TextBox Target;
1856                         IDataItemContainer Container;
1857                         Target = (TextBox) sender;
1858                         Container = (IDataItemContainer) Target.BindingContainer;
1859                         if ((Target.Page.GetDataItem () != null)) {
1860                                 Target.Text = Convert.ToString (DataBinder.Eval (Target.Page.GetDataItem(),"str"));
1861                         }
1862                 }
1863
1864
1865                 public static void RenderingButtonField (Page p)
1866                 {
1867                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1868                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1869                         GridView grid = new GridView ();
1870                         grid.AutoGenerateColumns = false;
1871                         grid.ShowFooter = true;
1872                         p.Form.Controls.Add (lcb);
1873                         p.Form.Controls.Add (grid);
1874                         p.Form.Controls.Add (lce);
1875
1876                         ButtonField buttonfield = new ButtonField ();
1877                         buttonfield.HeaderText = "HeaderText";
1878                         buttonfield.FooterText = "FooterText";
1879                         buttonfield.ButtonType = ButtonType.Button;
1880                         buttonfield.DataTextField = STRINGFIELD;
1881
1882                         ButtonField buttonfieldlink = new ButtonField ();
1883                         buttonfieldlink.HeaderText = "HeaderText";
1884                         buttonfieldlink.FooterText = "FooterText";
1885                         buttonfieldlink.ButtonType = ButtonType.Link;
1886                         buttonfieldlink.DataTextField = STRINGFIELD;
1887                         buttonfieldlink.CommandName = "cmd2";
1888
1889                         ButtonField buttonfieldimage = new ButtonField ();
1890                         buttonfieldimage.HeaderText = "HeaderText";
1891                         buttonfieldimage.FooterText = "FooterText";
1892                         buttonfieldimage.ButtonType = ButtonType.Image;
1893                         buttonfieldimage.DataTextField = STRINGFIELD;
1894                         buttonfieldimage.CommandName = "cmd3";
1895
1896                         grid.DataSource = GridViewTest.CreateDataSource ();
1897                         grid.Columns.Add (buttonfield);
1898                         grid.Columns.Add (buttonfieldlink);
1899                         grid.Columns.Add (buttonfieldimage);
1900                         grid.DataBind ();
1901                 }
1902
1903                 public static void RenderingHyperLinkField (Page p)
1904                 {
1905                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1906                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1907                         GridView grid = new GridView ();
1908                         grid.AutoGenerateColumns = false;
1909                         grid.ShowFooter = true;
1910                         p.Form.Controls.Add (lcb);
1911                         p.Form.Controls.Add (grid);
1912                         p.Form.Controls.Add (lce);
1913                         HyperLinkField hyperlinkfield = new HyperLinkField ();
1914                         hyperlinkfield.DataTextField = STRINGFIELD;
1915                         string[] str = new string[] { STRINGFIELD };
1916                         hyperlinkfield.DataNavigateUrlFields = str;
1917                         hyperlinkfield.HeaderText = "HeaderText";
1918                         hyperlinkfield.FooterText = "FooterText";
1919                         grid.DataSource = GridViewTest.CreateDataSource ();
1920                         grid.Columns.Add (hyperlinkfield);
1921                         grid.DataBind ();
1922                 }
1923
1924                 public static void RenderingCommandField (Page p)
1925                 {
1926                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1927                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1928                         GridView grid = new GridView ();
1929                         grid.AutoGenerateColumns = false;
1930                         grid.ShowFooter = true;
1931                         p.Form.Controls.Add (lcb);
1932                         p.Form.Controls.Add (grid);
1933                         p.Form.Controls.Add (lce);
1934                         CommandField commandfield = new CommandField ();
1935                         commandfield.HeaderText = "HeaderText";
1936                         commandfield.FooterText = "FooterText";
1937                         commandfield.ShowCancelButton = true;
1938                         commandfield.ShowDeleteButton = true;
1939                         commandfield.ShowEditButton = true;
1940                         commandfield.ShowInsertButton = true;
1941                         commandfield.ShowSelectButton = true;
1942                         grid.DataSource = GridViewTest.CreateDataSource ();
1943                         grid.Columns.Add (commandfield);
1944                         grid.DataBind ();
1945                 }
1946
1947                 public static void RenderingImageField (Page p)
1948                 {
1949                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1950                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1951                         GridView grid = new GridView ();
1952                         grid.AutoGenerateColumns = false;
1953                         grid.ShowFooter = true;
1954                         p.Form.Controls.Add (lcb);
1955                         p.Form.Controls.Add (grid);
1956                         p.Form.Controls.Add (lce);
1957                         ImageField imagefield = new ImageField ();
1958                         imagefield.HeaderText = "HeaderText";
1959                         imagefield.FooterText = "FooterText";
1960                         imagefield.DataImageUrlField = STRINGFIELD;
1961                         imagefield.DataAlternateTextField = STRINGFIELD;
1962                         grid.DataSource = GridViewTest.CreateDataSource ();
1963                         grid.Columns.Add (imagefield);
1964                         grid.DataBind ();
1965                 }
1966
1967                 public static void RenderingBoundField (Page p)
1968                 {
1969                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1970                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1971                         GridView grid = new GridView ();
1972                         grid.AutoGenerateColumns = false;
1973                         grid.ShowFooter = true;
1974                         p.Form.Controls.Add (lcb);
1975                         p.Form.Controls.Add (grid);
1976                         p.Form.Controls.Add (lce);
1977                         BoundField boundfield = new BoundField ();
1978                         boundfield.DataField = STRINGFIELD;
1979                         boundfield.HeaderText = "HeaderText";
1980                         boundfield.FooterText = "FooterText";
1981                         grid.DataSource = GridViewTest.CreateDataSource ();
1982                         grid.Columns.Add (boundfield);
1983                         grid.DataBind ();
1984                 }
1985
1986                 public static void RenderingCheckBoxField (Page p)
1987                 {
1988                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
1989                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
1990                         GridView grid = new GridView ();
1991                         grid.AutoGenerateColumns = false;
1992                         grid.ShowFooter = true;
1993                         CheckBoxField checkboxfield = new CheckBoxField ();
1994                         checkboxfield.DataField = BOOLFIELD;
1995                         checkboxfield.HeaderText = "HeaderText";
1996                         checkboxfield.FooterText = "FooterText";
1997                         p.Form.Controls.Add (lcb);
1998                         p.Form.Controls.Add (grid);
1999                         p.Form.Controls.Add (lce);
2000                         grid.DataSource = GridViewTest.CreateDataSource ();
2001                         grid.Columns.Add (checkboxfield);
2002                         grid.DataBind ();
2003                 }
2004
2005                 public static void RenderingCheckBoxField2 (Page p)
2006                 {
2007                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
2008                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
2009                         GridView grid = new GridView ();
2010                         grid.AutoGenerateColumns = true;
2011                         grid.ShowFooter = true;
2012                         p.Form.Controls.Add (lcb);
2013                         p.Form.Controls.Add (grid);
2014                         p.Form.Controls.Add (lce);
2015                         grid.DataSource = GridViewTest.CreateDataSource ();
2016                         grid.DataBind ();
2017                 }
2018                 ///////////////////////////////////////////////////////
2019                 /////              GRIDVIEW   POSTBACK           //////
2020                 ///////////////////////////////////////////////////////
2021
2022                 [Test]
2023                 public void GridView_GetPostBackOptions () {
2024                         GridView gv = new GridView ();
2025                         gv.Page = new Page ();
2026                         IButtonControl btn = new Button ();
2027                         btn.CausesValidation = false;
2028                         Assert.IsFalse (btn.CausesValidation);
2029                         Assert.AreEqual (String.Empty, btn.CommandName);
2030                         Assert.AreEqual (String.Empty, btn.CommandArgument);
2031                         Assert.AreEqual (String.Empty, btn.PostBackUrl);
2032                         Assert.AreEqual (String.Empty, btn.ValidationGroup);
2033                         PostBackOptions options = ((IPostBackContainer) gv).GetPostBackOptions (btn);
2034                         Assert.IsFalse (options.PerformValidation);
2035                         Assert.IsFalse (options.AutoPostBack);
2036                         Assert.IsFalse (options.TrackFocus);
2037                         Assert.IsTrue (options.ClientSubmit);
2038                         Assert.IsTrue (options.RequiresJavaScriptProtocol);
2039                         Assert.AreEqual ("$", options.Argument);
2040                         Assert.AreEqual (null, options.ActionUrl);
2041                         Assert.AreEqual (null, options.ValidationGroup);
2042
2043                         btn.ValidationGroup = "VG";
2044                         btn.CommandName = "CMD";
2045                         btn.CommandArgument = "ARG";
2046                         btn.PostBackUrl = "Page.aspx";
2047                         Assert.IsFalse (btn.CausesValidation);
2048                         Assert.AreEqual ("CMD", btn.CommandName);
2049                         Assert.AreEqual ("ARG", btn.CommandArgument);
2050                         Assert.AreEqual ("Page.aspx", btn.PostBackUrl);
2051                         Assert.AreEqual ("VG", btn.ValidationGroup);
2052                         options = ((IPostBackContainer) gv).GetPostBackOptions (btn);
2053                         Assert.IsFalse (options.PerformValidation);
2054                         Assert.IsFalse (options.AutoPostBack);
2055                         Assert.IsFalse (options.TrackFocus);
2056                         Assert.IsTrue (options.ClientSubmit);
2057                         Assert.IsTrue (options.RequiresJavaScriptProtocol);
2058                         Assert.AreEqual ("CMD$ARG", options.Argument);
2059                         Assert.AreEqual (null, options.ActionUrl);
2060                         Assert.AreEqual (null, options.ValidationGroup);
2061                 }
2062
2063                 [Test]
2064                 [ExpectedException (typeof (InvalidOperationException))]
2065                 public void GridView_GetPostBackOptions_CausesValidation () {
2066                         GridView gv = new GridView ();
2067                         gv.Page = new Page ();
2068                         IButtonControl btn = new Button ();
2069                         Assert.IsTrue (btn.CausesValidation);
2070                         Assert.AreEqual (String.Empty, btn.CommandName);
2071                         Assert.AreEqual (String.Empty, btn.CommandArgument);
2072                         Assert.AreEqual (String.Empty, btn.PostBackUrl);
2073                         Assert.AreEqual (String.Empty, btn.ValidationGroup);
2074                         PostBackOptions options = ((IPostBackContainer) gv).GetPostBackOptions (btn);
2075                 }
2076
2077                 [Test]
2078                 [ExpectedException(typeof(ArgumentNullException))]
2079                 public void GridView_GetPostBackOptions_Null_Argument () {
2080                         GridView gv = new GridView ();
2081                         gv.Page = new Page ();
2082                         PostBackOptions options = ((IPostBackContainer) gv).GetPostBackOptions (null);
2083                 }
2084
2085                 [Test]
2086                 [Category ("NunitWeb")]
2087                 public void GridView_PostBackSotring ()
2088                 {
2089                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (GridView_postback));
2090                         string pageHTML = t.Run ();
2091                         Assert.AreEqual (-1, pageHTML.IndexOf ("SortingSuccess"), "BeforeSorting");
2092                         FormRequest fr = new FormRequest (t.Response, "form1");
2093                         fr.Controls.Add ("__EVENTTARGET");
2094                         fr.Controls.Add ("__EVENTARGUMENT");
2095                         fr.Controls["__EVENTTARGET"].Value = "mygrid";
2096                         fr.Controls["__EVENTARGUMENT"].Value = "Sort$Item";
2097                         t.Request = fr;
2098                         t.Invoker = PageInvoker.CreateOnLoad (GridView_postback);
2099                         pageHTML = t.Run ();
2100                         if (pageHTML.IndexOf ("SortingSuccess") < 0) {
2101                                 Assert.Fail ("SortingFail");
2102                         }
2103                 }
2104
2105                 [Test]
2106                 [Category ("NunitWeb")]
2107                 public void GridView_PostBackPaging ()
2108                 {
2109                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (GridView_postback));
2110                         string pageHTML = t.Run ();
2111                         Assert.AreEqual (-1, pageHTML.IndexOf ("PagingSuccess"), "BeforePaging");
2112                         FormRequest fr = new FormRequest (t.Response, "form1");
2113                         fr.Controls.Add ("__EVENTTARGET");
2114                         fr.Controls.Add ("__EVENTARGUMENT");
2115                         fr.Controls["__EVENTTARGET"].Value = "mygrid";
2116                         fr.Controls["__EVENTARGUMENT"].Value = "Page$2";
2117                         t.Request = fr;
2118                         t.Invoker = PageInvoker.CreateOnLoad (GridView_postback);
2119                         pageHTML = t.Run ();
2120                         if (pageHTML.IndexOf ("PagingSuccess") < 0) {
2121                                 Assert.Fail ("PagingFail");
2122                         }
2123                 }
2124
2125                 [Test]
2126                 [Category ("NunitWeb")]
2127                 public void GridView_PostBackDelete ()
2128                 {
2129                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (GridView_postback));
2130                         string pageHTML = t.Run ();
2131                         Assert.AreEqual (-1, pageHTML.IndexOf ("DeleteSuccess"), "BeforeDelete");
2132                         FormRequest fr = new FormRequest (t.Response, "form1");
2133                         fr.Controls.Add ("__EVENTTARGET");
2134                         fr.Controls.Add ("__EVENTARGUMENT");
2135                         fr.Controls["__EVENTTARGET"].Value = "mygrid";
2136                         fr.Controls["__EVENTARGUMENT"].Value = "Delete$0";
2137                         t.Request = fr;
2138                         t.Invoker = PageInvoker.CreateOnLoad (GridView_postback);
2139                         pageHTML = t.Run ();
2140                         if (pageHTML.IndexOf ("DeleteSuccess") < 0) {
2141                                 Assert.Fail ("DeleteFail");
2142                         }
2143                 }
2144
2145                 [Test]
2146                 [Category ("NunitWeb")]
2147                 public void GridView_PostBackDeleteItem ()
2148                 {
2149                         WebTest t = new WebTest ();
2150                         PageDelegates pd = new PageDelegates ();
2151                         pd.Load = GridView_postbackdeleteitem;
2152                         pd.PreRenderComplete = GridView_checkrows;
2153                         t.Invoker = new PageInvoker (pd);
2154                         string pageHTML = t.Run ();
2155                         if (pageHTML.IndexOf ("Delete") < 0){
2156                                 Assert.Fail ("BeforeDelete");
2157                         }
2158                         Assert.AreEqual (1, t.UserData , "ObjectDataSource before delete from grid");
2159                         FormRequest fr = new FormRequest (t.Response, "form1");
2160                         fr.Controls.Add ("__EVENTTARGET");
2161                         fr.Controls.Add ("__EVENTARGUMENT");
2162                         fr.Controls["__EVENTTARGET"].Value = "Grid";
2163                         fr.Controls["__EVENTARGUMENT"].Value = "Delete$0";
2164                         t.Request = fr;
2165                         pageHTML = t.Run ();
2166                         Assert.AreEqual (0, t.UserData , "ObjectDataSource after delete from grid");
2167                 }
2168
2169                 public static void GridView_checkrows (Page p)
2170                 {
2171                         GridView grid = p.FindControl ("Grid") as GridView;
2172                         if (grid == null)
2173                                 Assert.Fail ("GridView does not created");
2174
2175                         WebTest.CurrentTest.UserData = grid.Rows.Count;
2176                 }
2177
2178                 public static void GridView_postbackdeleteitem (Page p)
2179                 {
2180                         GridView grid = new GridView ();
2181                         ObjectDataSource ds = new ObjectDataSource ();
2182                         ds.ID = "ObjectDataSource2";
2183
2184                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataObject";
2185                         ds.SelectMethod = "Select";
2186                         ds.DeleteMethod = "Delete";
2187                         ds.InsertMethod = "Insert";
2188                         ds.UpdateMethod = "Update";
2189                         Parameter p1 = new Parameter ("ID", TypeCode.String);
2190                         Parameter p2 = new Parameter ("FName", TypeCode.String);
2191                         Parameter p3 = new Parameter ("LName", TypeCode.String);
2192                         ds.DeleteParameters.Add (p1);
2193                         ds.DeleteParameters.Add (p2);
2194                         ds.DeleteParameters.Add (p3);
2195                         grid.ID = "Grid";
2196                         grid.DataKeyNames = new string[] { "ID", "FName", "LName" };
2197                         grid.AutoGenerateDeleteButton = true;
2198                         grid.DataSourceID = "ObjectDataSource2";
2199                         p.Form.Controls.Add (ds);
2200                         p.Form.Controls.Add (grid);
2201                 }
2202
2203
2204                 [Test]
2205                 [Category ("NunitWeb")]
2206                 public void GridView_PostBackUpdateItem ()
2207                 {
2208                         WebTest t = new WebTest ();
2209                         PageDelegates pd = new PageDelegates ();
2210                         pd.Load = GridView_postbackupdateitem;
2211                         pd.PreRenderComplete = GridView_checkrowsupdate;
2212                         t.Invoker = new PageInvoker (pd);
2213                         string pageHTML = t.Run ();
2214                         if (pageHTML.IndexOf ("Edit") < 0) {
2215                                 Assert.Fail ("BeforeEdit");
2216                         }
2217
2218                         string[] merged_data = t.UserData as string[];
2219                         if (merged_data == null) {
2220                                 Assert.Fail ("Grid rows not created#1");
2221                         }
2222
2223                         Assert.AreEqual ("1001", merged_data[1], "Row before update#1");
2224                         Assert.AreEqual ("Mahesh", merged_data[2], "Row before update#2");
2225                         Assert.AreEqual ("Chand", merged_data[3], "Row before update#3");
2226
2227                         FormRequest fr = new FormRequest (t.Response, "form1");
2228                         fr.Controls.Add ("__EVENTTARGET");
2229                         fr.Controls.Add ("__EVENTARGUMENT");
2230                         fr.Controls["__EVENTTARGET"].Value = "Grid";
2231                         fr.Controls["__EVENTARGUMENT"].Value = "Edit$0";
2232
2233                         t.Request = fr;
2234                         pageHTML = t.Run ();
2235
2236                         merged_data = t.UserData as string[];
2237                         if (merged_data == null) {
2238                                 Assert.Fail ("Grid rows not created#2");
2239                         }
2240
2241                         fr = new FormRequest (t.Response, "form1");
2242                         fr.Controls.Add ("__EVENTTARGET");
2243                         fr.Controls.Add ("__EVENTARGUMENT");
2244                         fr.Controls.Add (merged_data[4]);
2245                         fr.Controls.Add (merged_data[5]);
2246                         fr.Controls.Add (merged_data[6]);
2247
2248                         fr.Controls["__EVENTTARGET"].Value = merged_data[0];
2249                         fr.Controls["__EVENTARGUMENT"].Value = "";
2250                         fr.Controls[merged_data[4]].Value = "1001";
2251                         fr.Controls[merged_data[5]].Value = "TestEname";
2252                         fr.Controls[merged_data[6]].Value = "TestLname";
2253                         t.Request = fr;
2254                         pageHTML = t.Run ();
2255
2256                         merged_data = t.UserData as string[];
2257                         if (merged_data == null) {
2258                                 Assert.Fail ("Grid rows not created#3");
2259                         }
2260
2261                         Assert.AreEqual ("1001", merged_data[1], "Row before update#1");
2262                         Assert.AreEqual ("TestEname", merged_data[2], "Row before update#2");
2263                         Assert.AreEqual ("TestLname", merged_data[3], "Row before update#3");
2264                 }
2265
2266                 public static void GridView_postbackupdateitem (Page p)
2267                 {
2268                         if (!p.IsPostBack)
2269                                 DataObject.Reset ();
2270
2271                         GridView grid = new GridView ();
2272                         ObjectDataSource ds = new ObjectDataSource ();
2273
2274                         ds.ID = "ObjectDataSource2";
2275                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataObject";
2276                         ds.SelectMethod = "Select";
2277                         ds.DeleteMethod = "Delete";
2278                         ds.InsertMethod = "Insert";
2279                         ds.UpdateMethod = "Update";
2280
2281                         Parameter p1 = new Parameter ("ID", TypeCode.String);
2282                         Parameter p2 = new Parameter ("FName", TypeCode.String);
2283                         Parameter p3 = new Parameter ("LName", TypeCode.String);
2284
2285                         ds.UpdateParameters.Add (p1);
2286                         ds.UpdateParameters.Add (p2);
2287                         ds.UpdateParameters.Add (p3);
2288
2289                         grid.ID = "Grid";
2290                         grid.AutoGenerateEditButton = true;
2291
2292                         grid.AutoGenerateColumns = false;
2293
2294                         BoundField field = new BoundField ();
2295                         field.DataField = "ID";
2296                         grid.Columns.Add (field);
2297
2298                         field = new BoundField ();
2299                         field.DataField = "FName";
2300                         grid.Columns.Add (field);
2301
2302                         field = new BoundField ();
2303                         field.DataField = "LName";
2304                         grid.Columns.Add (field);
2305
2306                         grid.DataSourceID = "ObjectDataSource2";
2307                         p.Form.Controls.Add (ds);
2308                         p.Form.Controls.Add (grid);
2309                 }
2310
2311                 public static void GridView_checkrowsupdate (Page p)
2312                 {
2313                         GridView grid = p.FindControl ("Grid") as GridView;
2314                         if (grid == null) {
2315                                 Assert.Fail ("Gridview does not been created");
2316                         }
2317                         string[] data = new string[7];
2318                         try {
2319                                 data[0] = grid.Rows[0].Cells[0].Controls[0].UniqueID;
2320                         }
2321                         catch (Exception e) {
2322                                 Assert.Fail ("Update button not been created" + e.Message);
2323                         }
2324
2325                         data[1] = grid.Rows[0].Cells[1].Text;
2326                         data[2] = grid.Rows[0].Cells[2].Text;
2327                         data[3] = grid.Rows[0].Cells[3].Text;
2328
2329
2330
2331                         if (grid.Rows[0].Cells[1].Controls.Count > 0) {
2332                                 data[4] = grid.Rows[0].Cells[1].Controls[0].UniqueID;
2333                                 data[5] = grid.Rows[0].Cells[2].Controls[0].UniqueID;
2334                                 data[6] = grid.Rows[0].Cells[3].Controls[0].UniqueID;
2335                         }
2336
2337                         WebTest.CurrentTest.UserData = data;
2338                 }
2339
2340                 [Test]
2341                 [Category ("NunitWeb")]
2342                 public void GridView_PostBackEdit ()
2343                 {
2344                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (GridView_postback));
2345                         string pageHTML = t.Run ();
2346                         Assert.AreEqual (-1, pageHTML.IndexOf ("EditSuccess"), "BeforeEdit");
2347                         FormRequest fr = new FormRequest (t.Response, "form1");
2348                         fr.Controls.Add ("__EVENTTARGET");
2349                         fr.Controls.Add ("__EVENTARGUMENT");
2350                         fr.Controls["__EVENTTARGET"].Value = "mygrid";
2351                         fr.Controls["__EVENTARGUMENT"].Value = "Edit$0";
2352                         t.Request = fr;
2353                         t.Invoker = PageInvoker.CreateOnLoad (GridView_postback);
2354                         pageHTML = t.Run ();
2355                         if (pageHTML.IndexOf ("EditSuccess") < 0) {
2356                                 Assert.Fail ("EditFail");
2357                         }
2358                 }
2359
2360                 [Test]
2361                 [Category ("NunitWeb")]
2362                 public void GridView_PostBackSelect ()
2363                 {
2364                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (GridView_postback));
2365                         string pageHTML = t.Run ();
2366                         Assert.AreEqual (-1, pageHTML.IndexOf ("SelectSuccess"), "BeforeSelect");
2367                         FormRequest fr = new FormRequest (t.Response, "form1");
2368                         fr.Controls.Add ("__EVENTTARGET");
2369                         fr.Controls.Add ("__EVENTARGUMENT");
2370                         fr.Controls["__EVENTTARGET"].Value = "mygrid";
2371                         fr.Controls["__EVENTARGUMENT"].Value = "Select$0";
2372                         t.Request = fr;
2373                         t.Invoker = PageInvoker.CreateOnLoad (GridView_postback);
2374                         pageHTML = t.Run ();
2375                         if (pageHTML.IndexOf ("SelectSuccess") < 0) {
2376                                 Assert.Fail ("SelectFail");
2377                         }
2378                 }
2379
2380                 public void GridView_postback (Page p)
2381                 {
2382                         PokerGridView b = new PokerGridView ();
2383                         b.ID = "mygrid";
2384                         b.PageIndexChanging += new GridViewPageEventHandler (b_PageIndexChanging);
2385                         b.Sorting += new GridViewSortEventHandler (b_Sorting);
2386                         b.RowDeleting += new GridViewDeleteEventHandler (b_RowDeleting);
2387                         b.RowEditing += new GridViewEditEventHandler (b_RowEditing);
2388                         b.SelectedIndexChanging += new GridViewSelectEventHandler (b_SelectedIndexChanging);
2389                         ArrayList myds = new ArrayList ();
2390                         myds.Add ("Norway");
2391                         myds.Add ("Sweden");
2392                         myds.Add ("France");
2393                         myds.Add ("Italy");
2394
2395                         p.Form.Controls.Add (b);
2396                         b.AllowPaging = true;
2397                         b.PageSize = 2;
2398                         b.AllowSorting = true;
2399
2400                         b.AutoGenerateDeleteButton = true;
2401                         b.AutoGenerateEditButton = true;
2402                         b.AutoGenerateSelectButton = true;
2403
2404                         b.DataSource = myds;
2405                         b.DataBind ();
2406                 }
2407
2408                 public void b_RowEditing (object o, GridViewEditEventArgs e)
2409                 {
2410                         ((GridView) o).Page.Controls.Add (new LiteralControl ("EditSuccess"));
2411                         Assert.AreEqual (false, e.Cancel, "EditCancel");
2412                         Assert.AreEqual (0, e.NewEditIndex, "NewEditIndex");
2413                 }
2414
2415                 public void b_PageIndexChanging (object o, GridViewPageEventArgs e)
2416                 {
2417                         ((GridView) o).Page.Controls.Add (new LiteralControl ("PagingSuccess"));
2418                         Assert.AreEqual(false,e.Cancel,"Cancel");
2419                 }
2420
2421                 public void b_Sorting (object o, GridViewSortEventArgs e)
2422                 {
2423                         ((GridView) o).Page.Controls.Add (new LiteralControl ("SortingSuccess"));
2424                 }
2425
2426                 public void b_RowDeleting (object o, GridViewDeleteEventArgs e)
2427                 {
2428                         ((GridView) o).Page.Controls.Add (new LiteralControl ("DeleteSuccess"));
2429                 }
2430
2431                 public void b_SelectedIndexChanging (object o, GridViewSelectEventArgs e)
2432                 {
2433                         ((GridView) o).Page.Controls.Add (new LiteralControl ("SelectSuccess"));
2434                 }
2435
2436
2437                 /// <summary>
2438                 /// All possible exceptions what can be thrown
2439                 /// </summary>
2440
2441                 [Test]
2442                 [ExpectedException (typeof (InvalidOperationException))]
2443                 public void GridView_GetDefaultSelectedValue ()
2444                 {
2445                         PokerGridView g = new PokerGridView ();
2446                         object o = g.SelectedValue;
2447                 }
2448
2449                 [Test]
2450                 [Category ("NunitWeb")]
2451                 [Category ("NotDotNet")]
2452                 public void GridViewUpdate () {
2453                         WebTest t = new WebTest ("GridViewUpdate.aspx");
2454                         string pageHTML = HtmlDiff.GetControlFromPageHtml (t.Run ());
2455
2456                         FormRequest fr = new FormRequest (t.Response, "form1");
2457                         fr.Controls.Add ("__EVENTTARGET");
2458                         fr.Controls.Add ("__EVENTARGUMENT");
2459                         fr.Controls.Add ("GridView1$ctl02$Name"); // for .NET use "GridView1$ctl02$Name"
2460                         fr.Controls.Add ("GridView1$ctl03$Name");
2461                         fr.Controls ["__EVENTTARGET"].Value = "Button1";
2462                         fr.Controls ["__EVENTARGUMENT"].Value = "";
2463                         fr.Controls ["GridView1$ctl02$Name"].Value = "ABC";
2464                         fr.Controls ["GridView1$ctl03$Name"].Value = "123";
2465                         t.Request = fr;
2466                         t.Invoker = PageInvoker.CreateOnLoad (GridView_postback);
2467                         pageHTML = HtmlDiff.GetControlFromPageHtml (t.Run ());
2468                         #region original
2469                         string original = @"<div>
2470         <table cellspacing=""0"" rules=""all"" border=""1"" id=""GridView1"" style=""border-collapse:collapse;"">
2471                 <tr>
2472                         <th scope=""col"">ID</th><th scope=""col"">&nbsp;</th>
2473                 </tr><tr>
2474                         <td>1</td><td>
2475                         <input name=""GridView1$ctl02$Name"" type=""text"" value=""ABC"" id=""GridView1_ctl02_Name"" />
2476                         <input type=""button"" name=""GridView1$ctl02$b1"" value=""upd"" onclick=""javascript:__doPostBack('GridView1$ctl02$b1','')"" id=""GridView1_ctl02_b1"" />
2477                     </td>
2478                 </tr><tr>
2479                         <td>2</td><td>
2480                         <input name=""GridView1$ctl03$Name"" type=""text"" value=""123"" id=""GridView1_ctl03_Name"" />
2481                         <input type=""button"" name=""GridView1$ctl03$b1"" value=""upd"" onclick=""javascript:__doPostBack('GridView1$ctl03$b1','')"" id=""GridView1_ctl03_b1"" />
2482                     </td>
2483                 </tr>
2484         </table>
2485 </div>";
2486
2487                         #endregion
2488                         HtmlDiff.AssertAreEqual (original, pageHTML, "GridViewUpdate #1");
2489
2490                         fr = new FormRequest (t.Response, "form1");
2491                         fr.Controls.Add ("__EVENTTARGET");
2492                         fr.Controls.Add ("__EVENTARGUMENT");
2493                         fr.Controls.Add ("GridView1$ctl02$Name");
2494                         fr.Controls.Add ("GridView1$ctl03$Name");
2495                         fr.Controls ["__EVENTTARGET"].Value = "GridView1$ctl02$b1";
2496                         fr.Controls ["__EVENTARGUMENT"].Value = "";
2497                         fr.Controls ["GridView1$ctl02$Name"].Value = "ABC";
2498                         fr.Controls ["GridView1$ctl03$Name"].Value = "123";
2499                         t.Request = fr;
2500                         t.Invoker = PageInvoker.CreateOnLoad (GridView_postback);
2501                         pageHTML = HtmlDiff.GetControlFromPageHtml (t.Run ());
2502                         #region original
2503                         original = @"<div>
2504         <table cellspacing=""0"" rules=""all"" border=""1"" id=""GridView1"" style=""border-collapse:collapse;"">
2505                 <tr>
2506                         <th scope=""col"">ID</th><th scope=""col"">&nbsp;</th>
2507                 </tr><tr>
2508                         <td>1</td><td>
2509                         <input name=""GridView1$ctl02$Name"" type=""text"" value=""ABC"" id=""GridView1_ctl02_Name"" />
2510                         <input type=""button"" name=""GridView1$ctl02$b1"" value=""upd"" onclick=""javascript:__doPostBack('GridView1$ctl02$b1','')"" id=""GridView1_ctl02_b1"" />
2511                     </td>
2512                 </tr><tr>
2513                         <td>2</td><td>
2514                         <input name=""GridView1$ctl03$Name"" type=""text"" value=""heh2"" id=""GridView1_ctl03_Name"" />
2515                         <input type=""button"" name=""GridView1$ctl03$b1"" value=""upd"" onclick=""javascript:__doPostBack('GridView1$ctl03$b1','')"" id=""GridView1_ctl03_b1"" />
2516                     </td>
2517                 </tr>
2518         </table>
2519 </div>";
2520
2521                         #endregion
2522                         HtmlDiff.AssertAreEqual (original, pageHTML, "GridViewUpdate #2");
2523
2524                         fr = new FormRequest (t.Response, "form1");
2525                         fr.Controls.Add ("__EVENTTARGET");
2526                         fr.Controls.Add ("__EVENTARGUMENT");
2527                         fr.Controls.Add ("GridView1$ctl02$Name");
2528                         fr.Controls.Add ("GridView1$ctl03$Name");
2529                         fr.Controls ["__EVENTTARGET"].Value = "GridView1$ctl03$b1";
2530                         fr.Controls ["__EVENTARGUMENT"].Value = "";
2531                         fr.Controls ["GridView1$ctl02$Name"].Value = "ABC";
2532                         fr.Controls ["GridView1$ctl03$Name"].Value = "123";
2533                         t.Request = fr;
2534                         t.Invoker = PageInvoker.CreateOnLoad (GridView_postback);
2535                         pageHTML = HtmlDiff.GetControlFromPageHtml (t.Run ());
2536                         #region original
2537                         original = @"<div>
2538         <table cellspacing=""0"" rules=""all"" border=""1"" id=""GridView1"" style=""border-collapse:collapse;"">
2539                 <tr>
2540                         <th scope=""col"">ID</th><th scope=""col"">&nbsp;</th>
2541                 </tr><tr>
2542                         <td>1</td><td>
2543                         <input name=""GridView1$ctl02$Name"" type=""text"" value=""ABC"" id=""GridView1_ctl02_Name"" />
2544                         <input type=""button"" name=""GridView1$ctl02$b1"" value=""upd"" onclick=""javascript:__doPostBack('GridView1$ctl02$b1','')"" id=""GridView1_ctl02_b1"" />
2545                     </td>
2546                 </tr><tr>
2547                         <td>2</td><td>
2548                         <input name=""GridView1$ctl03$Name"" type=""text"" value=""123"" id=""GridView1_ctl03_Name"" />
2549                         <input type=""button"" name=""GridView1$ctl03$b1"" value=""upd"" onclick=""javascript:__doPostBack('GridView1$ctl03$b1','')"" id=""GridView1_ctl03_b1"" />
2550                     </td>
2551                 </tr>
2552         </table>
2553 </div>";
2554
2555                         #endregion
2556                         HtmlDiff.AssertAreEqual (original, pageHTML, "GridViewUpdate #3");
2557                 }
2558
2559         [TestFixtureTearDown]
2560         public void TearDown()
2561         {
2562             WebTest.Unload();
2563         }
2564
2565
2566                 public static DataTable CreateDataSource ()
2567                 {
2568                         DataTable aTable = new DataTable ("A");
2569                         DataColumn dtCol;
2570                         DataRow dtRow;
2571                         // Create ID column and add to the DataTable.
2572                         dtCol = new DataColumn ();
2573                         dtCol.DataType = Type.GetType ("System.Boolean");
2574                         dtCol.ColumnName = BOOLFIELD;
2575                         dtCol.Caption = BOOLFIELD;
2576                         dtCol.ReadOnly = true;
2577
2578                         // Add the column to the DataColumnCollection.
2579                         aTable.Columns.Add (dtCol);
2580
2581                         dtCol = new DataColumn ();
2582                         dtCol.DataType = Type.GetType ("System.String");
2583                         dtCol.ColumnName = STRINGFIELD;
2584                         dtCol.Caption = STRINGFIELD;
2585                         dtCol.ReadOnly = true;
2586
2587                         // Add the column to the DataColumnCollection.
2588                         aTable.Columns.Add (dtCol);
2589
2590                         // Create 2 rows to the table
2591                         dtRow = aTable.NewRow ();
2592                         dtRow[BOOLFIELD] = true;
2593                         dtRow[STRINGFIELD] = "1";
2594                         aTable.Rows.Add (dtRow);
2595
2596                         dtRow = aTable.NewRow ();
2597                         dtRow[BOOLFIELD] = false;
2598                         dtRow[STRINGFIELD] = "2";
2599                         aTable.Rows.Add (dtRow);
2600                         return aTable;
2601                 }
2602
2603                 // A simple Template class to wrap an image.
2604                 public class ImageTemplate : ITemplate
2605                 {
2606                         private MyWebControl.Image myImage;
2607                         public MyWebControl.Image MyImage
2608                         {
2609                                 get
2610                                 {
2611                                         return myImage;
2612                                 }
2613                                 set
2614                                 {
2615                                         myImage = value;
2616                                 }
2617                         }
2618                         public void InstantiateIn (Control container)
2619                         {
2620                                 container.Controls.Add (MyImage);
2621                         }
2622                 }
2623         }
2624
2625         public class DataObject
2626         {
2627                 public static DataTable ds = CreateDataTable ();
2628                 public static DataTable Select ()
2629                 {
2630                         return ds;
2631                 }
2632
2633                 public static void Reset ()
2634                 {
2635                         ds = CreateDataTable ();
2636                 }
2637
2638                 public static DataTable Delete (string ID, string FName, string LName)
2639                 {
2640                         DataRow dr = ds.Rows.Find (ID);
2641                         if (dr != null) {
2642                                 ds.Rows.Remove (dr);
2643                         }
2644                         return ds;
2645                 }
2646
2647                 public static DataTable Insert (string ID, string FName, string LName)
2648                 {
2649                         DataRow dr = ds.NewRow ();
2650                         dr["ID"] = ID;
2651                         dr["FName"] = FName;
2652                         dr["LName"] = LName;
2653                         ds.Rows.Add (dr);
2654                         return ds;
2655                 }
2656
2657                 public static DataTable Update (string ID, string FName, string LName)
2658                 {
2659                         foreach (DataRow row in ds.Rows) {
2660                                 if (row["ID"].ToString () == ID) {
2661                                         row["FName"] = FName;
2662                                         row["LName"] = LName;
2663                                 }
2664                         }
2665                         return ds;
2666                 }
2667
2668                 public static DataTable CreateDataTable ()
2669                 {
2670                         DataTable aTable = new DataTable ("A");
2671                         DataColumn dtCol;
2672                         DataRow dtRow;
2673
2674                         // Create ID column and add to the DataTable.
2675                         dtCol = new DataColumn ();
2676                         dtCol.DataType = Type.GetType ("System.Int32");
2677                         dtCol.ColumnName = "ID";
2678                         dtCol.AutoIncrement = true;
2679                         dtCol.Caption = "ID";
2680                         dtCol.ReadOnly = true;
2681                         dtCol.Unique = true;
2682                         aTable.Columns.Add (dtCol);
2683
2684                         // Create Name column and add to the table
2685                         dtCol = new DataColumn ();
2686                         dtCol.DataType = Type.GetType ("System.String");
2687                         dtCol.ColumnName = "FName";
2688                         dtCol.AutoIncrement = false;
2689                         dtCol.Caption = "First Name";
2690                         dtCol.ReadOnly = false;
2691                         dtCol.Unique = false;
2692                         aTable.Columns.Add (dtCol);
2693
2694                         // Create Last Name column and add to the table.
2695                         dtCol = new DataColumn ();
2696                         dtCol.DataType = Type.GetType ("System.String");
2697                         dtCol.ColumnName = "LName";
2698                         dtCol.AutoIncrement = false;
2699                         dtCol.Caption = "Last Name";
2700                         dtCol.ReadOnly = false;
2701                         dtCol.Unique = false;
2702                         aTable.Columns.Add (dtCol);
2703
2704                         // Create three rows to the table
2705                         dtRow = aTable.NewRow ();
2706                         dtRow["ID"] = 1001;
2707                         dtRow["FName"] = "Mahesh";
2708                         dtRow["LName"] = "Chand";
2709                         aTable.Rows.Add (dtRow);
2710
2711                         aTable.PrimaryKey = new DataColumn[] { aTable.Columns["ID"] };
2712                         return aTable;
2713                 }
2714         }
2715 }
2716
2717 #endif
2718
2719
2720
2721
2722
2723