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

   1 //
   2 // Tests for System.Web.UI.WebControls.DataGrid.cs
   3 //
   4 // Author:
   5 //      Jackson Harper (jackson@ximian.com)
   6 //      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   7 //
   8 //
   9 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 using NUnit.Framework;
  32 using AttributeCollection = System.ComponentModel.AttributeCollection;
  33 using System;
  34 using System.Drawing;
  35 using System.IO;
  36 using System.Globalization;
  37 using System.Web;
  38 using System.Web.UI;
  39 using System.Web.UI.WebControls;
  40 using System.Collections;
  41 using System.Data;
  42 using System.ComponentModel;
  43 using System.Diagnostics;
  44 using System.Collections.Generic;
  45 using MonoTests.SystemWeb.Framework;
  46 using MonoTests.stand_alone.WebHarness;
  47
  48 namespace MonoTests.System.Web.UI.WebControls {
  49
  50         public class DataGridPoker : DataGrid {
  51
  52                 public DataGridPoker ()
  53                 {
  54                         TrackViewState ();
  55                 }
  56
  57                 public string GetTagName ()
  58                 {
  59                         return TagName;
  60                 }
  61
  62                 public void PrepareCH ()
  63                 {
  64                         PrepareControlHierarchy ();
  65                 }
  66
  67                 public string Render ()
  68                 {
  69                         StringWriter sw = new StringWriter ();
  70                         HtmlTextWriter tw = new HtmlTextWriter (sw);
  71
  72                         Render (tw);
  73                         return sw.ToString ();
  74                 }
  75
  76                 public StateBag GetViewState ()
  77                 {
  78                         return ViewState;
  79                 }
  80
  81                 public new Style ControlStyle ()
  82                 {
  83                         return CreateControlStyle ();
  84                 }
  85
  86                 public void DoCancelCommand (DataGridCommandEventArgs e)
  87                 {
  88                         OnCancelCommand (e);
  89                 }
  90
  91                 public void DoDeleteCommand (DataGridCommandEventArgs e)
  92                 {
  93                         OnDeleteCommand (e);
  94                 }
  95
  96                 public void DoEditCommand (DataGridCommandEventArgs e)
  97                 {
  98                         OnEditCommand (e);
  99                 }
 100
 101                 public void DoItemCommand (DataGridCommandEventArgs e)
 102                 {
 103                         OnItemCommand (e);
 104                 }
 105
 106                 public void DoUpdateCommand (DataGridCommandEventArgs e)
 107                 {
 108                         OnUpdateCommand (e);
 109                 }
 110
 111                 public void DoItemCreated (DataGridItemEventArgs e)
 112                 {
 113                         OnItemCreated (e);
 114                 }
 115
 116                 public void DoItemDataBound (DataGridItemEventArgs e)
 117                 {
 118                         OnItemDataBound (e);
 119                 }
 120
 121                 public void DoPageIndexChanged (DataGridPageChangedEventArgs e)
 122                 {
 123                         OnPageIndexChanged (e);
 124                 }
 125
 126                 public void DoSortCommand (DataGridSortCommandEventArgs e)
 127                 {
 128                         OnSortCommand (e);
 129                 }
 130
 131                 public void DoBubbleEvent (object source, EventArgs e)
 132                 {
 133                         OnBubbleEvent (source, e);
 134                 }
 135
 136                 public void TrackState ()
 137                 {
 138                         TrackViewState ();
 139                 }
 140
 141                 public object SaveState ()
 142                 {
 143                         return SaveViewState ();
 144                 }
 145
 146                 public ArrayList CreateColumns (PagedDataSource data_source, bool use_data_source)
 147                 {
 148                         return CreateColumnSet (data_source, use_data_source);
 149                 }
 150
 151                 public void CreateControls (bool use_data_source)
 152                 {
 153                         CreateControlHierarchy (use_data_source);
 154                 }
 155
 156                 public void InitPager (DataGridItem item, int columnSpan,
 157                                 PagedDataSource pagedDataSource)
 158                 {
 159                         InitializePager (item, columnSpan, pagedDataSource);
 160                 }
 161         }
 162
 163         public class AmazingEnumerable : IEnumerable {
 164
 165                 private IList list;
 166                 public int CallCount;
 167
 168                 public AmazingEnumerable (IList list)
 169                 {
 170                         this.list = list;
 171                 }
 172
 173                 public IEnumerator GetEnumerator ()
 174                 {
 175                         CallCount++;
 176                         return list.GetEnumerator ();
 177                 }
 178
 179         }
 180
 181         [TestFixture]
 182         public class DataGridTest {
 183
 184                 [TestFixtureSetUp()]
 185                 public void FixtureSetup ()
 186                 {
 187                         WebTest.CopyResource (GetType (), "DataGrid.aspx", "DataGrid.aspx");
 188                 }
 189
 190                 [TestFixtureTearDown()]
 191                 public void FixtureTearDown ()
 192                 {
 193                         WebTest.Unload ();
 194                 }
 195
 196                 [Test]
 197                 public void Defaults ()
 198                 {
 199                         DataGridPoker p = new DataGridPoker ();
 200
 201                         Assert.AreEqual (DataGrid.CancelCommandName, "Cancel", "A1");
 202                         Assert.AreEqual (DataGrid.DeleteCommandName, "Delete", "A2");
 203                         Assert.AreEqual (DataGrid.EditCommandName, "Edit", "A3");
 204                         Assert.AreEqual (DataGrid.NextPageCommandArgument, "Next", "A4");
 205                         Assert.AreEqual (DataGrid.PageCommandName, "Page", "A5");
 206                         Assert.AreEqual (DataGrid.PrevPageCommandArgument, "Prev", "A6");
 207                         Assert.AreEqual (DataGrid.SelectCommandName, "Select", "A7");
 208                         Assert.AreEqual (DataGrid.SortCommandName, "Sort", "A8");
 209                         Assert.AreEqual (DataGrid.UpdateCommandName, "Update", "A9");
 210
 211                         Assert.AreEqual (p.AllowCustomPaging, false, "A10");
 212                         Assert.AreEqual (p.AllowPaging, false, "A11");
 213                         Assert.AreEqual (p.AllowSorting, false, "A12");
 214                         Assert.AreEqual (p.AutoGenerateColumns, true, "A13");
 215                         Assert.AreEqual (p.BackImageUrl, String.Empty, "A14");
 216                         Assert.AreEqual (p.CurrentPageIndex, 0, "A15");
 217                         Assert.AreEqual (p.EditItemIndex, -1, "A16");
 218                         Assert.AreEqual (p.PageCount, 0, "A17");
 219                         Assert.AreEqual (p.PageSize, 10, "A18");
 220                         Assert.AreEqual (p.SelectedIndex, -1, "A19");
 221                         Assert.AreEqual (p.SelectedItem, null, "A20");
 222                         Assert.AreEqual (p.ShowFooter, false, "A21");
 223                         Assert.AreEqual (p.ShowHeader, true, "A22");
 224                         Assert.AreEqual (p.VirtualItemCount, 0, "A23");
 225                 }
 226
 227                 [Test]
 228                 public void TagName ()
 229                 {
 230                         DataGridPoker p = new DataGridPoker ();
 231                         Assert.AreEqual (p.GetTagName (), "table", "A1");
 232                 }
 233
 234                 [Test]
 235                 [ExpectedException (typeof (ArgumentNullException))]
 236                 public void NullBackImage ()
 237                 {
 238                         DataGridPoker p = new DataGridPoker ();
 239
 240                         p.BackImageUrl = null;
 241                         Assert.AreEqual (p.BackImageUrl, String.Empty, "A1");
 242                 }
 243
 244                 [Test]
 245                 public void CleanProperties ()
 246                 {
 247                         DataGridPoker p = new DataGridPoker ();
 248
 249                         p.AllowCustomPaging = true;
 250                         Assert.IsTrue (p.AllowCustomPaging, "A1");
 251                         p.AllowCustomPaging = false;
 252                         Assert.IsFalse (p.AllowCustomPaging, "A2");
 253
 254                         p.AllowPaging = true;
 255                         Assert.IsTrue (p.AllowPaging, "A3");
 256                         p.AllowPaging = false;
 257                         Assert.IsFalse (p.AllowPaging, "A4");
 258
 259                         p.AllowSorting = true;
 260                         Assert.IsTrue (p.AllowSorting, "A5");
 261                         p.AllowSorting = false;
 262                         Assert.IsFalse (p.AllowSorting, "A6");
 263
 264                         p.AutoGenerateColumns = true;
 265                         Assert.IsTrue (p.AutoGenerateColumns, "A7");
 266                         p.AutoGenerateColumns = false;
 267                         Assert.IsFalse (p.AutoGenerateColumns, "A8");
 268
 269                         p.BackImageUrl = "foobar";
 270                         Assert.AreEqual (p.BackImageUrl, "foobar", "A9");
 271
 272                         p.CurrentPageIndex = 0;
 273                         Assert.AreEqual (p.CurrentPageIndex, 0, "A10");
 274                         p.CurrentPageIndex = Int32.MaxValue;
 275                         Assert.AreEqual (p.CurrentPageIndex, Int32.MaxValue, "A11");
 276
 277                         p.EditItemIndex = 0;
 278                         Assert.AreEqual (p.EditItemIndex, 0, "A12");
 279                         p.EditItemIndex = -1;
 280                         Assert.AreEqual (p.EditItemIndex, -1, "A13");
 281                         p.EditItemIndex = Int32.MaxValue;
 282                         Assert.AreEqual (p.EditItemIndex, Int32.MaxValue, "A14");
 283
 284                         p.PageSize = 1;
 285                         Assert.AreEqual (p.PageSize, 1, "A15");
 286                         p.PageSize = Int32.MaxValue;
 287
 288                         p.SelectedIndex = 0;
 289                         Assert.AreEqual (p.SelectedIndex, 0, "A16");
 290                         p.SelectedIndex = -1;
 291                         Assert.AreEqual (p.SelectedIndex, -1, "A17");
 292                         p.SelectedIndex = Int32.MaxValue;
 293                         Assert.AreEqual (p.SelectedIndex, Int32.MaxValue, "A18");
 294
 295                         p.ShowFooter = true;
 296                         Assert.IsTrue (p.ShowFooter, "A19");
 297                         p.ShowFooter = false;
 298                         Assert.IsFalse (p.ShowFooter, "A20");
 299
 300                         p.ShowHeader = true;
 301                         Assert.IsTrue (p.ShowHeader, "A21");
 302                         p.ShowHeader = false;
 303                         Assert.IsFalse (p.ShowHeader, "A22");
 304
 305                         p.VirtualItemCount = 0;
 306                         Assert.AreEqual (p.VirtualItemCount, 0, "A23");
 307                         p.VirtualItemCount = Int32.MaxValue;
 308                         Assert.AreEqual (p.VirtualItemCount, Int32.MaxValue, "A24");
 309                 }
 310
 311                 [Test]
 312                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 313                 public void CurrentPageIndexTooLow ()
 314                 {
 315                         DataGridPoker p = new DataGridPoker ();
 316                         p.CurrentPageIndex = -1;
 317                 }
 318
 319                 [Test]
 320                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 321                 public void EditItemIndexTooLow ()
 322                 {
 323                         DataGridPoker p = new DataGridPoker ();
 324                         p.EditItemIndex = -2;
 325                 }
 326
 327                 [Test]
 328                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 329                 public void PageSizeTooLow ()
 330                 {
 331                         DataGridPoker p = new DataGridPoker ();
 332                         p.PageSize = 0;
 333                 }
 334
 335                 [Test]
 336                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 337                 public void SelectedIndexTooLow ()
 338                 {
 339                         DataGridPoker p = new DataGridPoker ();
 340                         p.SelectedIndex = -2;
 341                 }
 342
 343                 [Test]
 344                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 345                 public void VirtualItemCountTooLow ()
 346                 {
 347                         DataGridPoker p = new DataGridPoker ();
 348                         p.VirtualItemCount = -1;
 349                 }
 350
 351                 [Test]
 352                 public void ViewState ()
 353                 {
 354                         DataGridPoker p = new DataGridPoker ();
 355                         StateBag vs = p.GetViewState ();
 356
 357                         Assert.AreEqual (vs.Count, 0, "A1");
 358
 359                         p.AllowCustomPaging = true;
 360                         Assert.AreEqual (vs.Count, 1, "A2");
 361                         Assert.AreEqual (vs ["AllowCustomPaging"], true, "A3");
 362                         p.AllowCustomPaging = false;
 363                         Assert.AreEqual (vs.Count, 1, "A4");
 364                         Assert.AreEqual (vs ["AllowCustomPaging"], false, "A5");
 365
 366                         p.AllowPaging = true;
 367                         Assert.AreEqual (vs.Count, 2, "A6");
 368                         Assert.AreEqual (vs ["AllowPaging"], true, "A7");
 369                         p.AllowPaging = false;
 370                         Assert.AreEqual (vs.Count, 2, "A8");
 371                         Assert.AreEqual (vs ["AllowPaging"], false, "A9");
 372
 373                         p.AllowSorting = true;
 374                         Assert.AreEqual (vs.Count, 3, "A10");
 375                         Assert.AreEqual (vs ["AllowSorting"], true, "A11");
 376                         p.AllowSorting = false;
 377                         Assert.AreEqual (vs.Count, 3, "A12");
 378                         Assert.AreEqual (vs ["AllowSorting"], false, "A13");
 379
 380                         p.AutoGenerateColumns = true;
 381                         Assert.AreEqual (vs.Count, 4, "A14");
 382                         Assert.AreEqual (vs ["AutoGenerateColumns"], true, "A15");
 383                         p.AutoGenerateColumns = false;
 384                         Assert.AreEqual (vs.Count, 4, "A16");
 385                         Assert.AreEqual (vs ["AutoGenerateColumns"], false, "A17");
 386
 387                         p.CurrentPageIndex = 1;
 388                         Assert.AreEqual (vs.Count, 5, "A18");
 389                         Assert.AreEqual (vs ["CurrentPageIndex"], 1, "A19");
 390
 391                         p.EditItemIndex = 1;
 392                         Assert.AreEqual (vs.Count, 6, "A20");
 393                         Assert.AreEqual (vs ["EditItemIndex"], 1, "A20");
 394
 395                         p.PageSize = 25;
 396                         Assert.AreEqual (vs.Count, 7, "A21");
 397                         Assert.AreEqual (vs ["PageSize"], 25, "A22");
 398
 399                         p.SelectedIndex = 25;
 400                         Assert.AreEqual (vs.Count, 8, "A23");
 401                         Assert.AreEqual (vs ["SelectedIndex"], 25, "A24");
 402
 403                         p.ShowFooter = false;
 404                         Assert.AreEqual (vs.Count, 9, "A25");
 405                         Assert.AreEqual (vs ["ShowFooter"], false, "A26");
 406                         p.ShowFooter = true;
 407                         Assert.AreEqual (vs ["ShowFooter"], true, "A27");
 408
 409                         p.ShowHeader = false;
 410                         Assert.AreEqual (vs.Count, 10, "A28");
 411                         Assert.AreEqual (vs ["ShowHeader"], false, "A29");
 412                         p.ShowHeader = true;
 413                         Assert.AreEqual (vs ["ShowHeader"], true, "A30");
 414
 415                         p.VirtualItemCount = 100;
 416                         Assert.AreEqual (vs.Count, 11, "A31");
 417                         Assert.AreEqual (vs ["VirtualItemCount"], 100, "A32");
 418                 }
 419
 420                 [Test]
 421                 public void SelectIndexOutOfRange ()
 422                 {
 423                         DataGridPoker p = new DataGridPoker ();
 424
 425                         // No exception is thrown
 426                         p.SelectedIndex = 25;
 427                 }
 428
 429                 [Test]
 430                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 431                 public void SelectItemOutOfRange ()
 432                 {
 433                         DataGridPoker p = new DataGridPoker ();
 434                         DataGridItem d;
 435
 436                         p.SelectedIndex = 25;
 437                         d = p.SelectedItem;
 438                 }
 439
 440                 [Test]
 441                 public void ControlStyle ()
 442                 {
 443                         DataGridPoker p = new DataGridPoker ();
 444
 445                         Assert.AreEqual (p.ControlStyle ().GetType (),
 446                                         typeof (TableStyle), "A1");
 447
 448                         TableStyle t = (TableStyle) p.ControlStyle ();
 449                         Assert.AreEqual (t.GridLines, GridLines.Both, "A2");
 450                         Assert.AreEqual (t.CellSpacing, 0, "A3");
 451                 }
 452
 453                 [Test]
 454                 public void Styles ()
 455                 {
 456                         DataGridPoker p = new DataGridPoker ();
 457                         StateBag vs = p.GetViewState ();
 458
 459                         p.BackImageUrl = "foobar url";
 460
 461                         // The styles get stored in the view state
 462                         Assert.AreEqual (vs.Count, 0, "A1");
 463                         Assert.IsNull (vs ["BackImageUrl"], "A2");
 464                         Assert.IsNull (vs ["GridLines"], "A3");
 465                         Assert.IsNull (vs ["CellSpacing"], "A4");
 466                 }
 467
 468                 private bool cancel_command;
 469                 private bool delete_command;
 470                 private bool edit_command;
 471                 private bool item_command;
 472                 private bool update_command;
 473                 private bool item_created;
 474                 private bool item_data_bound;
 475                 private bool page_index_changed;
 476                 private bool sort_command;
 477                 private bool selected_changed;
 478
 479                 private int new_page_index;
 480
 481                 private void ResetEvents ()
 482                 {
 483                         cancel_command =
 484                         delete_command =
 485                         edit_command =
 486                         item_command =
 487                         update_command =
 488                         item_created =
 489                         item_data_bound =
 490                         page_index_changed =
 491                         sort_command =
 492                         selected_changed = false;
 493
 494                         new_page_index = Int32.MinValue;
 495                 }
 496
 497                 private void CancelCommandHandler (object sender, DataGridCommandEventArgs e)
 498                 {
 499                         cancel_command = true;
 500                 }
 501
 502                 private void DeleteCommandHandler (object sender, DataGridCommandEventArgs e)
 503                 {
 504                         delete_command = true;
 505                 }
 506
 507                 private void EditCommandHandler (object sender, DataGridCommandEventArgs e)
 508                 {
 509                         edit_command = true;
 510                 }
 511
 512                 private void ItemCommandHandler (object sender, DataGridCommandEventArgs e)
 513                 {
 514                         item_command = true;
 515                 }
 516
 517                 private void UpdateCommandHandler (object sender, DataGridCommandEventArgs e)
 518                 {
 519                         update_command = true;
 520                 }
 521
 522                 private void ItemCreatedHandler (object sender, DataGridItemEventArgs e)
 523                 {
 524                         item_created = true;
 525                 }
 526
 527                 private void ItemDataBoundHandler (object sender, DataGridItemEventArgs e)
 528                 {
 529                         item_data_bound = true;
 530                 }
 531
 532                 private void PageIndexChangedHandler (object sender, DataGridPageChangedEventArgs e)
 533                 {
 534                         page_index_changed = true;
 535                         new_page_index = e.NewPageIndex;
 536                 }
 537
 538                 private void SortCommandHandler (object sender, DataGridSortCommandEventArgs e)
 539                 {
 540                         sort_command = true;
 541                 }
 542
 543                 private void SelectedIndexChangedHandler (object sender, EventArgs e)
 544                 {
 545                         selected_changed = true;
 546                 }
 547
 548                 [Test]
 549                 public void Events ()
 550                 {
 551                         DataGridPoker p = new DataGridPoker ();
 552                         DataGridCommandEventArgs command_args = new DataGridCommandEventArgs (null,
 553                                         null, new CommandEventArgs (String.Empty, String.Empty));
 554                         DataGridItemEventArgs item_args = new DataGridItemEventArgs (null);
 555                         DataGridPageChangedEventArgs page_args = new DataGridPageChangedEventArgs (null, 0);
 556                         DataGridSortCommandEventArgs sort_args = new DataGridSortCommandEventArgs (null,
 557                                         command_args);
 558
 559                         ResetEvents ();
 560                         p.CancelCommand += new DataGridCommandEventHandler (CancelCommandHandler);
 561                         p.DoCancelCommand (command_args);
 562                         Assert.IsTrue (cancel_command, "A1");
 563
 564                         ResetEvents ();
 565                         p.DeleteCommand += new DataGridCommandEventHandler (DeleteCommandHandler);
 566                         p.DoDeleteCommand (command_args);
 567                         Assert.IsTrue (delete_command, "A2");
 568
 569                         ResetEvents ();
 570                         p.EditCommand += new DataGridCommandEventHandler (EditCommandHandler);
 571                         p.DoEditCommand (command_args);
 572                         Assert.IsTrue (edit_command, "A3");
 573
 574                         ResetEvents ();
 575                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 576                         p.DoItemCommand (command_args);
 577                         Assert.IsTrue (item_command, "A4");
 578
 579                         ResetEvents ();
 580                         p.UpdateCommand += new DataGridCommandEventHandler (UpdateCommandHandler);
 581                         p.DoUpdateCommand (command_args);
 582                         Assert.IsTrue (update_command, "A5");
 583
 584                         ResetEvents ();
 585                         p.ItemCreated += new DataGridItemEventHandler (ItemCreatedHandler);
 586                         p.DoItemCreated (item_args);
 587                         Assert.IsTrue (item_created, "A6");
 588
 589                         ResetEvents ();
 590                         p.ItemDataBound += new DataGridItemEventHandler (ItemDataBoundHandler);
 591                         p.DoItemDataBound (item_args);
 592                         Assert.IsTrue (item_data_bound, "A7");
 593
 594                         ResetEvents ();
 595                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 596                         p.DoPageIndexChanged (page_args);
 597                         Assert.IsTrue (page_index_changed, "A8");
 598
 599                         ResetEvents ();
 600                         p.SortCommand += new DataGridSortCommandEventHandler (SortCommandHandler);
 601                         p.DoSortCommand (sort_args);
 602                         Assert.IsTrue (sort_command, "A9");
 603                 }
 604
 605                 [Test]
 606                 public void BubbleEvent ()
 607                 {
 608                         DataGridPoker p = new DataGridPoker ();
 609                         DataGridCommandEventArgs command_args;
 610
 611                         //
 612                         // Cancel
 613                         //
 614                         ResetEvents ();
 615                         command_args = new DataGridCommandEventArgs (null,
 616                                         null, new CommandEventArgs ("Cancel", String.Empty));
 617                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 618                         p.CancelCommand += new DataGridCommandEventHandler (CancelCommandHandler);
 619                         p.DoBubbleEvent (this, command_args);
 620                         Assert.IsTrue (cancel_command, "A1");
 621                         Assert.IsTrue (item_command, "#01");
 622
 623                         ResetEvents ();
 624                         command_args = new DataGridCommandEventArgs (null,
 625                                         null, new CommandEventArgs ("cancel", String.Empty));
 626                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 627                         p.CancelCommand += new DataGridCommandEventHandler (CancelCommandHandler);
 628                         p.DoBubbleEvent (this, command_args);
 629                         Assert.IsTrue (cancel_command, "A2");
 630                         Assert.IsTrue (item_command, "#02");
 631
 632                         ResetEvents ();
 633                         command_args = new DataGridCommandEventArgs (null,
 634                                         null, new CommandEventArgs ("CANCEL", String.Empty));
 635                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 636                         p.CancelCommand += new DataGridCommandEventHandler (CancelCommandHandler);
 637                         p.DoBubbleEvent (this, command_args);
 638                         Assert.IsTrue (cancel_command, "A3");
 639                         Assert.IsTrue (item_command, "#03");
 640
 641                         //
 642                         // Delete
 643                         //
 644                         ResetEvents ();
 645                         command_args = new DataGridCommandEventArgs (null,
 646                                         null, new CommandEventArgs ("Delete", String.Empty));
 647                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 648                         p.DeleteCommand += new DataGridCommandEventHandler (DeleteCommandHandler);
 649                         p.DoBubbleEvent (this, command_args);
 650                         Assert.IsTrue (delete_command, "A4");
 651                         Assert.IsTrue (item_command, "#04");
 652
 653                         ResetEvents ();
 654                         command_args = new DataGridCommandEventArgs (null,
 655                                         null, new CommandEventArgs ("delete", String.Empty));
 656                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 657                         p.DeleteCommand += new DataGridCommandEventHandler (DeleteCommandHandler);
 658                         p.DoBubbleEvent (this, command_args);
 659                         Assert.IsTrue (delete_command, "A5");
 660                         Assert.IsTrue (item_command, "#05");
 661
 662                         ResetEvents ();
 663                         command_args = new DataGridCommandEventArgs (null,
 664                                         null, new CommandEventArgs ("DELETE", String.Empty));
 665                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 666                         p.DeleteCommand += new DataGridCommandEventHandler (DeleteCommandHandler);
 667                         p.DoBubbleEvent (this, command_args);
 668                         Assert.IsTrue (delete_command, "A6");
 669                         Assert.IsTrue (item_command, "#06");
 670
 671                         //
 672                         // Edit
 673                         //
 674                         ResetEvents ();
 675                         command_args = new DataGridCommandEventArgs (null,
 676                                         null, new CommandEventArgs ("Edit", String.Empty));
 677                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 678                         p.EditCommand += new DataGridCommandEventHandler (EditCommandHandler);
 679                         p.DoBubbleEvent (this, command_args);
 680                         Assert.IsTrue (edit_command, "A7");
 681                         Assert.IsTrue (item_command, "#07");
 682
 683                         ResetEvents ();
 684                         command_args = new DataGridCommandEventArgs (null,
 685                                         null, new CommandEventArgs ("edit", String.Empty));
 686                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 687                         p.EditCommand += new DataGridCommandEventHandler (EditCommandHandler);
 688                         p.DoBubbleEvent (this, command_args);
 689                         Assert.IsTrue (edit_command, "A8");
 690                         Assert.IsTrue (item_command, "#08");
 691
 692                         ResetEvents ();
 693                         command_args = new DataGridCommandEventArgs (null,
 694                                         null, new CommandEventArgs ("EDIT", String.Empty));
 695                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 696                         p.EditCommand += new DataGridCommandEventHandler (EditCommandHandler);
 697                         p.DoBubbleEvent (this, command_args);
 698                         Assert.IsTrue (edit_command, "A9");
 699                         Assert.IsTrue (item_command, "#09");
 700
 701                         //
 702                         // Item
 703                         //
 704                         ResetEvents ();
 705                         command_args = new DataGridCommandEventArgs (null,
 706                                         null, new CommandEventArgs ("Item", String.Empty));
 707                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 708                         p.DoBubbleEvent (this, command_args);
 709                         Assert.IsTrue (item_command, "A10");
 710
 711                         ResetEvents ();
 712                         command_args = new DataGridCommandEventArgs (null,
 713                                         null, new CommandEventArgs ("item", String.Empty));
 714                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 715                         p.DoBubbleEvent (this, command_args);
 716                         Assert.IsTrue (item_command, "A11");
 717
 718                         ResetEvents ();
 719                         command_args = new DataGridCommandEventArgs (null,
 720                                         null, new CommandEventArgs ("ITEM", String.Empty));
 721                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 722                         p.DoBubbleEvent (this, command_args);
 723                         Assert.IsTrue (item_command, "A12");
 724
 725                         //
 726                         // Sort
 727                         //
 728                         ResetEvents ();
 729                         command_args = new DataGridCommandEventArgs (null,
 730                                         null, new CommandEventArgs ("Sort", String.Empty));
 731                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 732                         p.SortCommand += new DataGridSortCommandEventHandler (SortCommandHandler);
 733                         p.DoBubbleEvent (this, command_args);
 734                         Assert.IsTrue (sort_command, "A13");
 735                         Assert.IsTrue (item_command, "#10");
 736
 737                         ResetEvents ();
 738                         command_args = new DataGridCommandEventArgs (null,
 739                                         null, new CommandEventArgs ("sort", String.Empty));
 740                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 741                         p.SortCommand += new DataGridSortCommandEventHandler (SortCommandHandler);
 742                         p.DoBubbleEvent (this, command_args);
 743                         Assert.IsTrue (sort_command, "A14");
 744                         Assert.IsTrue (item_command, "#11");
 745
 746                         ResetEvents ();
 747                         command_args = new DataGridCommandEventArgs (null,
 748                                         null, new CommandEventArgs ("SORT", String.Empty));
 749                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 750                         p.SortCommand += new DataGridSortCommandEventHandler (SortCommandHandler);
 751                         p.DoBubbleEvent (this, command_args);
 752                         Assert.IsTrue (sort_command, "A15");
 753                         Assert.IsTrue (item_command, "#12");
 754
 755                         //
 756                         // Update
 757                         //
 758                         ResetEvents ();
 759                         command_args = new DataGridCommandEventArgs (null,
 760                                         null, new CommandEventArgs ("Update", String.Empty));
 761                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 762                         p.UpdateCommand += new DataGridCommandEventHandler (UpdateCommandHandler);
 763                         p.DoBubbleEvent (this, command_args);
 764                         Assert.IsTrue (update_command, "A16");
 765                         Assert.IsTrue (item_command, "#13");
 766
 767                         ResetEvents ();
 768                         command_args = new DataGridCommandEventArgs (null,
 769                                         null, new CommandEventArgs ("update", String.Empty));
 770                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 771                         p.UpdateCommand += new DataGridCommandEventHandler (UpdateCommandHandler);
 772                         p.DoBubbleEvent (this, command_args);
 773                         Assert.IsTrue (update_command, "A17");
 774                         Assert.IsTrue (item_command, "#14");
 775
 776                         ResetEvents ();
 777                         command_args = new DataGridCommandEventArgs (null,
 778                                         null, new CommandEventArgs ("UPDATE", String.Empty));
 779                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 780                         p.UpdateCommand += new DataGridCommandEventHandler (UpdateCommandHandler);
 781                         p.DoBubbleEvent (this, command_args);
 782                         Assert.IsTrue (update_command, "A18");
 783                         Assert.IsTrue (item_command, "#15");
 784
 785                         //
 786                         // Select
 787                         //
 788                         DataGridItem item = new DataGridItem (0, 0, ListItemType.Item);
 789
 790                         ResetEvents ();
 791                         command_args = new DataGridCommandEventArgs (item, null,
 792                                         new CommandEventArgs ("Select", String.Empty));
 793                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 794                         p.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 795                         p.DoBubbleEvent (this, command_args);
 796                         Assert.IsTrue (selected_changed, "A19");
 797                         Assert.IsTrue (item_command, "#16");
 798
 799                         ResetEvents ();
 800                         command_args = new DataGridCommandEventArgs (item, null,
 801                                         new CommandEventArgs ("select", String.Empty));
 802                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 803                         p.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 804                         p.DoBubbleEvent (this, command_args);
 805                         Assert.IsTrue (selected_changed, "A20");
 806                         Assert.IsTrue (item_command, "#17");
 807
 808                         ResetEvents ();
 809                         command_args = new DataGridCommandEventArgs (item, null,
 810                                         new CommandEventArgs ("SELECT", String.Empty));
 811                         p.ItemCommand += new DataGridCommandEventHandler (ItemCommandHandler);
 812                         p.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 813                         p.DoBubbleEvent (this, command_args);
 814                         Assert.IsTrue (selected_changed, "A21");
 815                         Assert.IsTrue (item_command, "#18");
 816                 }
 817
 818                 [Test]
 819                 public void BubblePageCommand ()
 820                 {
 821                         DataGridPoker p = new DataGridPoker ();
 822                         DataGridItem item = new DataGridItem (0, 0, ListItemType.Item);
 823                         DataGridCommandEventArgs command_args;
 824
 825
 826                         //
 827                         // Prev
 828                         //
 829                         ResetEvents ();
 830                         command_args = new DataGridCommandEventArgs (item, null,
 831                                         new CommandEventArgs ("Page", "Prev"));
 832                         p.CurrentPageIndex = 10;
 833                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 834                         p.DoBubbleEvent (this, command_args);
 835                         Assert.IsTrue (page_index_changed, "A1");
 836                         Assert.AreEqual (new_page_index, 9, "A2");
 837
 838                         ResetEvents ();
 839                         command_args = new DataGridCommandEventArgs (item, null,
 840                                         new CommandEventArgs ("page", "prev"));
 841                         p.CurrentPageIndex = 10;
 842                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 843                         p.DoBubbleEvent (this, command_args);
 844                         Assert.IsTrue (page_index_changed, "A3");
 845                         Assert.AreEqual (new_page_index, 9, "A4");
 846
 847                         ResetEvents ();
 848                         command_args = new DataGridCommandEventArgs (item, null,
 849                                         new CommandEventArgs ("PAGE", "PREV"));
 850                         p.CurrentPageIndex = 10;
 851                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 852                         p.DoBubbleEvent (this, command_args);
 853                         Assert.IsTrue (page_index_changed, "A5");
 854                         Assert.AreEqual (new_page_index, 9, "A6");
 855
 856
 857                         //
 858                         // Next
 859                         //
 860                         ResetEvents ();
 861                         command_args = new DataGridCommandEventArgs (item, null,
 862                                         new CommandEventArgs ("Page", "Next"));
 863                         p.CurrentPageIndex = 10;
 864                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 865                         p.DoBubbleEvent (this, command_args);
 866                         Assert.IsTrue (page_index_changed, "A5");
 867                         Assert.AreEqual (new_page_index, 11, "A6");
 868
 869                         ResetEvents ();
 870                         command_args = new DataGridCommandEventArgs (item, null,
 871                                         new CommandEventArgs ("page", "next"));
 872                         p.CurrentPageIndex = 10;
 873                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 874                         p.DoBubbleEvent (this, command_args);
 875                         Assert.IsTrue (page_index_changed, "A7");
 876                         Assert.AreEqual (new_page_index, 11, "A8");
 877
 878                         ResetEvents ();
 879                         command_args = new DataGridCommandEventArgs (item, null,
 880                                         new CommandEventArgs ("PAGE", "NEXT"));
 881                         p.CurrentPageIndex = 10;
 882                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 883                         p.DoBubbleEvent (this, command_args);
 884                         Assert.IsTrue (page_index_changed, "A9");
 885                         Assert.AreEqual (new_page_index, 11, "A10");
 886
 887
 888                         //
 889                         // Specific
 890                         //
 891                         ResetEvents ();
 892                         command_args = new DataGridCommandEventArgs (item, null,
 893                                         new CommandEventArgs ("Page", "25"));
 894                         p.CurrentPageIndex = 10;
 895                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 896                         p.DoBubbleEvent (this, command_args);
 897                         Assert.IsTrue (page_index_changed, "A11");
 898                         Assert.AreEqual (new_page_index, 24, "A12");
 899
 900                         ResetEvents ();
 901                         command_args = new DataGridCommandEventArgs (item, null,
 902                                         new CommandEventArgs ("Page", "0"));
 903                         p.CurrentPageIndex = 10;
 904                         p.PageIndexChanged += new DataGridPageChangedEventHandler (PageIndexChangedHandler);
 905                         p.DoBubbleEvent (this, command_args);
 906                         Assert.IsTrue (page_index_changed, "A11");
 907                         Assert.AreEqual (new_page_index, -1, "A12");
 908                 }
 909
 910                 [Test]
 911                 [ExpectedException (typeof (FormatException))]
 912                 public void BadBubblePageArg ()
 913                 {
 914                         DataGridPoker p = new DataGridPoker ();
 915                         DataGridItem item = new DataGridItem (0, 0, ListItemType.Item);
 916                         DataGridCommandEventArgs command_args;
 917
 918                         ResetEvents ();
 919                         command_args = new DataGridCommandEventArgs (item, null,
 920                                         new CommandEventArgs ("Page", "i am bad"));
 921
 922                         p.DoBubbleEvent (this, command_args);
 923                 }
 924
 925                 [Test]
 926                 [ExpectedException (typeof (InvalidCastException))]
 927                 public void BadBubblePageArg2 ()
 928                 {
 929                         DataGridPoker p = new DataGridPoker ();
 930                         DataGridItem item = new DataGridItem (0, 0, ListItemType.Item);
 931                         DataGridCommandEventArgs command_args;
 932
 933                         ResetEvents ();
 934                         command_args = new DataGridCommandEventArgs (item, null,
 935                                         new CommandEventArgs ("Page", new object ()));
 936
 937                         p.DoBubbleEvent (this, command_args);
 938                 }
 939
 940                 [Test]
 941                 public void SaveViewState ()
 942                 {
 943                         DataGridPoker p = new DataGridPoker ();
 944
 945                         p.TrackState ();
 946
 947                         object [] vs = (object []) p.SaveState ();
 948                         Assert.AreEqual (vs.Length, 11, "A1");
 949
 950                         // By default the viewstate is all null
 951                         for (int i = 0; i < vs.Length; i++)
 952                                 Assert.IsNull (vs [i], "A2-" + i);
 953
 954                         //
 955                         // TODO: What goes in the [1] and [9] slots?
 956                         //
 957
 958                         p.AllowPaging = true;
 959                         vs = (object []) p.SaveState ();
 960                         Assert.IsNotNull (vs [0], "A3");
 961
 962                         /*
 963                           This test doesn't work right now. It must be an issue
 964                           in the DataGridPagerStyle
 965
 966                         p.PagerStyle.Visible = true;
 967                         vs = (object []) p.SaveState ();
 968                         Assert.IsNotNull (vs [2], "A5");
 969                         */
 970
 971                         p.HeaderStyle.HorizontalAlign = HorizontalAlign.Center;
 972                         vs = (object []) p.SaveState ();
 973                         Assert.IsNotNull (vs [3], "A6");
 974
 975                         p.FooterStyle.HorizontalAlign = HorizontalAlign.Center;
 976                         vs = (object []) p.SaveState ();
 977                         Assert.IsNotNull (vs [4], "A7");
 978
 979                         p.ItemStyle.HorizontalAlign = HorizontalAlign.Center;
 980                         vs = (object []) p.SaveState ();
 981                         Assert.IsNotNull (vs [5], "A8");
 982
 983                         p.AlternatingItemStyle.HorizontalAlign = HorizontalAlign.Center;
 984                         vs = (object []) p.SaveState ();
 985                         Assert.IsNotNull (vs [6], "A9");
 986
 987                         p.SelectedItemStyle.HorizontalAlign = HorizontalAlign.Center;
 988                         vs = (object []) p.SaveState ();
 989                         Assert.IsNotNull (vs [7], "A10");
 990
 991                         p.EditItemStyle.HorizontalAlign = HorizontalAlign.Center;
 992                         vs = (object []) p.SaveState ();
 993                         Assert.IsNotNull (vs [8], "A11");
 994
 995                         PagedDataSource source = new PagedDataSource ();
 996                         DataTable table = new DataTable ();
 997                         ArrayList columns;
 998
 999                         table.Columns.Add (new DataColumn ("one", typeof (string)));
1000                         table.Columns.Add (new DataColumn ("two", typeof (string)));
1001                         table.Columns.Add (new DataColumn ("three", typeof (string)));
1002                         source.DataSource = new DataView (table);
1003                         columns = p.CreateColumns (source, true);
1004
1005                         vs = (object []) p.SaveState ();
1006                         Assert.IsNull (vs [9], "A12");
1007                         p.BackImageUrl = "foobar url";
1008                         vs = (object []) p.SaveState ();
1009                         Assert.IsNotNull (vs [9], "A12");
1010
1011                         Assert.IsNotNull (vs [10], "A12");
1012                         Assert.AreEqual (vs [10].GetType (), typeof (object []), "A12");
1013
1014                         object [] cols = (object []) vs [10];
1015                         Assert.AreEqual (cols.Length, 3, "A13");
1016                 }
1017
1018                 [Test]
1019                 public void CreateColumnSet ()
1020                 {
1021                         DataGridPoker p = new DataGridPoker ();
1022                         PagedDataSource source = new PagedDataSource ();
1023                         DataTable table = new DataTable ();
1024                         ArrayList columns;
1025
1026                         table.Columns.Add (new DataColumn ("one", typeof (string)));
1027                         table.Columns.Add (new DataColumn ("two", typeof (string)));
1028                         table.Columns.Add (new DataColumn ("three", typeof (string)));
1029
1030                         source.DataSource = new DataView (table);
1031
1032                         columns = p.CreateColumns (source, true);
1033                         Assert.AreEqual (columns.Count, 3, "A1");
1034                         Assert.AreEqual (((DataGridColumn) columns [0]).HeaderText, "one", "A2");
1035                         Assert.AreEqual (((DataGridColumn) columns [1]).HeaderText, "two", "A3");
1036                         Assert.AreEqual (((DataGridColumn) columns [2]).HeaderText, "three", "A4");
1037
1038                         // AutoGenerated columns are not added to the ColumnsCollection
1039                         Assert.AreEqual (p.Columns.Count, 0, "A5");
1040
1041                         // Without allowing data dinding,
1042                         columns = p.CreateColumns (source, false);
1043                         Assert.AreEqual (columns.Count, 3, "A6");
1044                         Assert.AreEqual (((DataGridColumn) columns [0]).HeaderText, "one", "A7");
1045                         Assert.AreEqual (((DataGridColumn) columns [1]).HeaderText, "two", "A8");
1046                         Assert.AreEqual (((DataGridColumn) columns [2]).HeaderText, "three", "A9");
1047
1048
1049                         // Mixing with already added columns
1050                         p = new DataGridPoker ();
1051                         DataGridColumn a = new ButtonColumn ();
1052                         DataGridColumn b = new ButtonColumn ();
1053
1054                         a.HeaderText = "A";
1055                         b.HeaderText = "B";
1056                         p.Columns.Add (a);
1057                         p.Columns.Add (b);
1058
1059                         columns = p.CreateColumns (source, true);
1060                         Assert.AreEqual (columns.Count, 5, "A6");
1061                         Assert.AreEqual (((DataGridColumn) columns [0]).HeaderText, "A", "A10");
1062                         Assert.AreEqual (((DataGridColumn) columns [1]).HeaderText, "B", "A11");
1063                         Assert.AreEqual (((DataGridColumn) columns [2]).HeaderText, "one", "A12");
1064                         Assert.AreEqual (((DataGridColumn) columns [3]).HeaderText, "two", "A13");
1065                         Assert.AreEqual (((DataGridColumn) columns [4]).HeaderText, "three", "A14");
1066
1067                         // Assigned properties of the newly created columns
1068                         BoundColumn one = (BoundColumn) columns [2];
1069
1070                         Assert.AreEqual (one.HeaderText, "one", "A15");
1071                         Assert.AreEqual (one.DataField, "one", "A16");
1072                         Assert.AreEqual (one.DataFormatString, String.Empty, "A17");
1073                         Assert.AreEqual (one.SortExpression, "one", "A18");
1074                         Assert.AreEqual (one.HeaderImageUrl, String.Empty, "A19");
1075                         Assert.AreEqual (one.FooterText, String.Empty, "A20");
1076                 }
1077
1078                 [Test]
1079                 public void CreateColumnsBinding ()
1080                 {
1081                         DataGridPoker p = new DataGridPoker ();
1082                         PagedDataSource source = new PagedDataSource ();
1083                         DataTable table = new DataTable ();
1084                         ArrayList columns;
1085
1086                         table.Columns.Add (new DataColumn ("one", typeof (string)));
1087                         table.Columns.Add (new DataColumn ("two", typeof (string)));
1088                         table.Columns.Add (new DataColumn ("three", typeof (string)));
1089
1090                         source.DataSource = new DataView (table);
1091
1092                         columns = p.CreateColumns (source, true);
1093                         Assert.AreEqual (columns.Count, 3, "A1");
1094                         Assert.AreEqual (((DataGridColumn) columns [0]).HeaderText, "one", "A2");
1095                         Assert.AreEqual (((DataGridColumn) columns [1]).HeaderText, "two", "A3");
1096                         Assert.AreEqual (((DataGridColumn) columns [2]).HeaderText, "three", "A4");
1097
1098                         table.Columns.Add (new DataColumn ("four", typeof (string)));
1099                         table.Columns.Add (new DataColumn ("five", typeof (string)));
1100                         table.Columns.Add (new DataColumn ("six", typeof (string)));
1101
1102                         // Just gets the old columns
1103                         columns = p.CreateColumns (source, false);
1104                         Assert.AreEqual (columns.Count, 3, "A5");
1105                         Assert.AreEqual (((DataGridColumn) columns [0]).HeaderText, "one", "A6");
1106                         Assert.AreEqual (((DataGridColumn) columns [1]).HeaderText, "two", "A7");
1107                         Assert.AreEqual (((DataGridColumn) columns [2]).HeaderText, "three", "A8");
1108
1109                         columns = p.CreateColumns (source, true);
1110                         Assert.AreEqual (columns.Count, 6, "A9");
1111                         Assert.AreEqual (((DataGridColumn) columns [0]).HeaderText, "one", "A10");
1112                         Assert.AreEqual (((DataGridColumn) columns [1]).HeaderText, "two", "A11");
1113                         Assert.AreEqual (((DataGridColumn) columns [2]).HeaderText, "three", "A12");
1114                         Assert.AreEqual (((DataGridColumn) columns [3]).HeaderText, "four", "A13");
1115                         Assert.AreEqual (((DataGridColumn) columns [4]).HeaderText, "five", "A14");
1116                         Assert.AreEqual (((DataGridColumn) columns [5]).HeaderText, "six", "A15");
1117
1118                         // Assigned properties of the newly created columns
1119                         BoundColumn one = (BoundColumn) columns [0];
1120
1121                         Assert.AreEqual (one.HeaderText, "one", "A16");
1122                         Assert.AreEqual (one.DataField, "one", "A17");
1123                         Assert.AreEqual (one.DataFormatString, String.Empty, "A18");
1124                         Assert.AreEqual (one.SortExpression, "one", "A19");
1125                         Assert.AreEqual (one.HeaderImageUrl, String.Empty, "A20");
1126                         Assert.AreEqual (one.FooterText, String.Empty, "A21");
1127                 }
1128
1129                 [Test]
1130                 public void CreateSimpleColumns ()
1131                 {
1132                         DataGridPoker p = new DataGridPoker ();
1133                         PagedDataSource source = new PagedDataSource ();
1134                         ArrayList list = new ArrayList ();
1135                         ArrayList columns;
1136
1137                         list.Add ("One");
1138                         list.Add ("Two");
1139                         list.Add ("Three");
1140
1141                         source.DataSource = list;
1142                         columns = p.CreateColumns (source, true);
1143                         Assert.AreEqual (1, columns.Count, "A1");
1144                         Assert.AreEqual ("Item", ((DataGridColumn) columns [0]).HeaderText, "A2");
1145
1146                         AmazingEnumerable amazing = new AmazingEnumerable (list);
1147
1148                         source.DataSource = amazing;
1149                         columns = p.CreateColumns (source, true);
1150                         Assert.AreEqual (1, columns.Count, "A3");
1151
1152                         BoundColumn one = (BoundColumn) columns [0];
1153
1154                         Assert.AreEqual ("Item", one.HeaderText, "A4");
1155
1156                         // I guess this makes it bind to itself ?
1157                         Assert.AreEqual (BoundColumn.thisExpr, one.DataField, "A5");
1158
1159                         Assert.AreEqual (String.Empty, one.DataFormatString, "A6");
1160                         Assert.AreEqual ("Item", one.SortExpression, "A7");
1161                         Assert.AreEqual (String.Empty, one.HeaderImageUrl, "A8");
1162                         Assert.AreEqual (String.Empty, one.FooterText, "A9");
1163                         Assert.AreEqual ("Item", one.HeaderText, "A10");
1164
1165                         source.DataSource = new ArrayList ();
1166                         columns = p.CreateColumns (source, true);
1167                         Assert.AreEqual (0, columns.Count, "A11");
1168                 }
1169
1170                 [Test]
1171                 public void DataBindingEnumerator ()
1172                 {
1173                         DataGridPoker p = new DataGridPoker ();
1174                         PagedDataSource source = new PagedDataSource ();
1175                         ArrayList list = new ArrayList ();
1176                         ArrayList columns;
1177
1178                         list.Add ("One");
1179                         list.Add ("Two");
1180                         list.Add ("Three");
1181
1182                         AmazingEnumerable amazing = new AmazingEnumerable (list);
1183                         source.DataSource = amazing;
1184                         columns = p.CreateColumns (source, true);
1185                         Assert.AreEqual (1, columns.Count, "A1");
1186                         Assert.AreEqual ("Item", ((DataGridColumn) columns [0]).HeaderText, "A2");
1187                         Assert.AreEqual (1, amazing.CallCount, "A3");
1188                         Assert.AreEqual (0, p.DataKeys.Count, "A4");
1189                 }
1190
1191                 class Custom : ICustomTypeDescriptor {
1192                         public AttributeCollection GetAttributes ()
1193                         {
1194                                 throw new Exception ();
1195                         }
1196
1197                         public string GetClassName()
1198                         {
1199                                 throw new Exception ();
1200                         }
1201
1202                         public string GetComponentName()
1203                         {
1204                                 throw new Exception ();
1205                         }
1206
1207                         public TypeConverter GetConverter()
1208                         {
1209                                 throw new Exception ();
1210                         }
1211
1212                         public EventDescriptor GetDefaultEvent()
1213                         {
1214                                 throw new Exception ();
1215                         }
1216
1217                         public PropertyDescriptor GetDefaultProperty()
1218                         {
1219                                 throw new Exception ();
1220                         }
1221
1222                         public object GetEditor (Type editorBaseType)
1223                         {
1224                                 throw new Exception ();
1225                         }
1226
1227                         public EventDescriptorCollection GetEvents ()
1228                         {
1229                                 throw new Exception ();
1230                         }
1231
1232                         public EventDescriptorCollection GetEvents (Attribute[] arr)
1233                         {
1234                                 throw new Exception ();
1235                         }
1236
1237                         public int CallCount;
1238                         public PropertyDescriptorCollection GetProperties()
1239                         {
1240                                 // MS calls this one
1241                                 if (CallCount++ > 0)
1242                                         throw new Exception ("This should not happen");
1243                                 PropertyDescriptorCollection coll = new PropertyDescriptorCollection (null);
1244                                 coll.Add (new MyPropertyDescriptor ());
1245                                 return coll;
1246                         }
1247
1248                         public PropertyDescriptorCollection GetProperties (Attribute[] arr)
1249                         {
1250                                 // We call this one
1251                                 return GetProperties ();
1252                         }
1253
1254                         public object GetPropertyOwner (PropertyDescriptor pd)
1255                         {
1256                                 throw new Exception ();
1257                         }
1258                 }
1259
1260                 class MyPropertyDescriptor : PropertyDescriptor {
1261                         int val;
1262
1263                         public MyPropertyDescriptor () : base ("CustomName", null)
1264                         {
1265                         }
1266
1267                         public override Type ComponentType {
1268                                 get { return typeof (MyPropertyDescriptor); }
1269                         }
1270
1271                         public override bool IsReadOnly {
1272                                 get { return true; }
1273                         }
1274
1275                         public override Type PropertyType {
1276                                 get { return typeof (int); }
1277                         }
1278
1279                         public override object GetValue (object component)
1280                         {
1281                                 return val++;
1282                         }
1283
1284                         public override void SetValue (object component, object value)
1285                         {
1286                         }
1287
1288                         public override void ResetValue (object component)
1289                         {
1290                         }
1291
1292                         public override bool CanResetValue (object component)
1293                         {
1294                                 return false;
1295                         }
1296
1297                         public override bool ShouldSerializeValue (object component)
1298                         {
1299                                 return false;
1300                         }
1301                 }
1302
1303                 class MyEnumerable : IEnumerable {
1304                         public object Item;
1305                         public IEnumerator GetEnumerator ()
1306                         {
1307                                 ArrayList list = new ArrayList ();
1308                                 list.Add (Item);
1309                                 return list.GetEnumerator ();
1310                         }
1311                 }
1312
1313                 [Test]
1314                 public void DataBindingCustomElement ()
1315                 {
1316                         DataGridPoker p = new DataGridPoker ();
1317                         p.DataKeyField = "CustomName";
1318                         PagedDataSource source = new PagedDataSource ();
1319                         MyEnumerable myenum = new MyEnumerable ();
1320                         myenum.Item = new Custom ();
1321                         source.DataSource = myenum;
1322                         ArrayList columns = p.CreateColumns (source, true);
1323                         Assert.AreEqual (1, columns.Count, "A1");
1324                         Assert.AreEqual ("CustomName", ((DataGridColumn) columns [0]).HeaderText, "A2");
1325                         Assert.AreEqual (0, p.DataKeys.Count, "A3");
1326                 }
1327
1328                 public class data
1329                 {
1330                         private static ArrayList _data = new ArrayList ();
1331
1332                         static data () {
1333                                 _data.Add (new DataItem (1, "heh1"));
1334                                 _data.Add (new DataItem (2, "heh2"));
1335                                 _data.Add (new DataItem (3, "heh3"));
1336                                 _data.Add (new DataItem (4, "heh4"));
1337                                 _data.Add (new DataItem (5, "heh5"));
1338                                 _data.Add (new DataItem (6, "heh6"));
1339                                 _data.Add (new DataItem (7, "heh7"));
1340                                 _data.Add (new DataItem (8, "heh8"));
1341                                 _data.Add (new DataItem (9, "heh9"));
1342                                 _data.Add (new DataItem (10, "heh10"));
1343                         }
1344
1345                         public data () {
1346                         }
1347
1348                         public ArrayList GetAllItems () {
1349                                 return _data;
1350                         }
1351
1352                         public ArrayList GetPagedItems (int startIndex, int maxRows)
1353                         {
1354                                 ArrayList list = new ArrayList ();
1355                                 if (startIndex < _data.Count - 1) {
1356                                         int countToReturn = Math.Min (maxRows, _data.Count - startIndex);
1357                                         for (int i = startIndex; i < startIndex + countToReturn; i++) {
1358                                                 list.Add (_data [i]);
1359                                         }
1360                                 }
1361
1362                                 return list;
1363                         }
1364
1365                         public int GetCount ()
1366                         {
1367                                 return _data.Count;
1368                         }
1369
1370                         public void UpdateItem (int id, string name) {
1371                                 foreach (DataItem i in _data) {
1372                                         if (i.ID == id) {
1373                                                 i.Name = name;
1374                                                 return;
1375                                         }
1376                                 }
1377                         }
1378                 }
1379
1380                 public class DataItem
1381                 {
1382                         int _id = 0;
1383                         string _name = "";
1384
1385                         public DataItem (int id, string name) {
1386                                 _id = id;
1387                                 _name = name;
1388                         }
1389
1390                         public int ID {
1391                                 get { return _id; }
1392                         }
1393
1394                         public string Name {
1395                                 get { return _name; }
1396                                 set { _name = value; }
1397                         }
1398                 }
1399
1400                 public class DataSourceObject
1401                 {
1402                         public static List<string> GetList (string sortExpression, int startRowIndex, int maximumRows) {
1403                                 return GetList ();
1404                         }
1405
1406                         public static List<string> GetList (int startRowIndex, int maximumRows) {
1407                                 return GetList ();
1408                         }
1409
1410                         public static List<string> GetList (string sortExpression) {
1411                                 return GetList ();
1412                         }
1413
1414                         public static List<string> GetList () {
1415                                 List<string> list = new List<string> ();
1416                                 list.Add ("Norway");
1417                                 list.Add ("Sweden");
1418                                 list.Add ("France");
1419                                 list.Add ("Italy");
1420                                 list.Add ("Israel");
1421                                 list.Add ("Russia");
1422                                 return list;
1423                         }
1424
1425                         public static int GetCount () {
1426                                 return GetList ().Count;
1427                         }
1428                 }
1429
1430                 [Test]
1431                 [ExpectedException(typeof(InvalidOperationException))]
1432                 public void DataSourceAndDataSourceID ()
1433                 {
1434                         Page page = new Page ();
1435                         DataGridPoker dg = new DataGridPoker ();
1436
1437                         page.Controls.Add (dg);
1438
1439                         DataTable dt = new DataTable ();
1440                         dt.Columns.Add (new DataColumn ("something", typeof (Int32)));
1441                         DataRow dr = dt.NewRow ();
1442                         dt.Rows.Add (new object [] { 1 });
1443                         DataView dv = new DataView (dt);
1444
1445                         dg.DataSource = dv;
1446
1447                         ObjectDataSource ds = new ObjectDataSource ();
1448                         ds.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
1449                         ds.SelectMethod = "GetList";
1450                         ds.SortParameterName = "sortExpression";
1451                         ds.ID = "Data";
1452                         page.Controls.Add (ds);
1453
1454                         dg.DataSourceID = "Data";
1455
1456                         dg.DataBind ();
1457                 }
1458
1459                 [Test]
1460                 public void DataBindingDataSourceID ()
1461                 {
1462                         Page page = new Page ();
1463                         DataGridPoker dg = new DataGridPoker ();
1464                         page.Controls.Add (dg);
1465
1466                         ObjectDataSource ds = new ObjectDataSource ();
1467                         ds.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
1468                         ds.SelectMethod = "GetList";
1469                         ds.SortParameterName = "sortExpression";
1470                         ds.ID = "Data";
1471                         page.Controls.Add (ds);
1472
1473                         dg.DataSourceID = "Data";
1474                         dg.DataBind ();
1475
1476                         Assert.AreEqual (6, dg.Items.Count, "DataBindingDataSourceID");
1477                 }
1478
1479                 [Test]
1480                 [NUnit.Framework.Category ("NunitWeb")]
1481                 public void DataBindingDataSourceIDAutomatic ()
1482                 {
1483                         WebTest t = new WebTest ();
1484                         PageDelegates pd = new PageDelegates();
1485                         pd.Load = DataSourceIDAutomatic_Load;
1486                         pd.PreRender = DataSourceIDAutomatic_PreRender;
1487                         t.Invoker = new PageInvoker (pd);
1488
1489                         t.Run ();
1490                 }
1491
1492                 public static void DataSourceIDAutomatic_Load (Page page)
1493                 {
1494                         DataGridPoker dg = new DataGridPoker ();
1495                         dg.ID = "DataGrid";
1496                         page.Controls.Add (dg);
1497
1498                         ObjectDataSource ds = new ObjectDataSource ();
1499                         ds.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
1500                         ds.SelectMethod = "GetList";
1501                         ds.SortParameterName = "sortExpression";
1502                         ds.ID = "Data";
1503                         page.Controls.Add (ds);
1504
1505                         dg.DataSourceID = "Data";
1506                 }
1507
1508                 public static void DataSourceIDAutomatic_PreRender (Page page)
1509                 {
1510                         DataGrid dg = (DataGrid)page.FindControl ("DataGrid");
1511
1512                         Assert.AreEqual (6, dg.Items.Count, "DataBindingDataSourceID");
1513                 }
1514
1515                 [Test]
1516                 public void DataSourceIDBindingNoColumns ()
1517                 {
1518                         Page page = new Page ();
1519                         DataGridPoker dg = new DataGridPoker ();
1520                         dg.ID = "DataGrid";
1521                         dg.AutoGenerateColumns = false;
1522
1523                         page.Controls.Add (dg);
1524
1525                         ObjectDataSource ds = new ObjectDataSource ();
1526                         ds.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
1527                         ds.SelectMethod = "GetList";
1528                         ds.SortParameterName = "sortExpression";
1529                         ds.ID = "Data";
1530                         page.Controls.Add (ds);
1531
1532                         dg.DataSourceID = "Data";
1533                         dg.DataBind ();
1534
1535                         Assert.AreEqual (0, dg.Columns.Count, "Columns Count");
1536                         Assert.AreEqual (0, dg.Items.Count, "Items Count");
1537                 }
1538
1539                 [Test]
1540                 public void DataSourceIDBindingManualColumns ()
1541                 {
1542                         Page page = new Page ();
1543                         DataGridPoker dg = new DataGridPoker ();
1544                         dg.ID = "DataGrid";
1545                         dg.AutoGenerateColumns = false;
1546                         BoundColumn col = new BoundColumn();
1547                         col.DataField = "something";
1548                         dg.Columns.Add (col);
1549
1550                         page.Controls.Add (dg);
1551
1552                         DataTable dt = new DataTable ();
1553                         dt.Columns.Add (new DataColumn ("something", typeof (Int32)));
1554                         DataRow dr = dt.NewRow ();
1555                         dt.Rows.Add (new object [] { 1 });
1556                         dt.Rows.Add (new object [] { 2 });
1557                         dt.Rows.Add (new object [] { 3 });
1558                         dt.Rows.Add (new object [] { 4 });
1559                         dt.Rows.Add (new object [] { 5 });
1560                         dt.Rows.Add (new object [] { 6 });
1561
1562                         DataView dv = new DataView (dt);
1563
1564                         dg.DataSource = dv;
1565                         dg.DataBind ();
1566
1567                         Assert.AreEqual (1, dg.Columns.Count, "Columns Count");
1568                         Assert.AreEqual (6, dg.Items.Count, "Items Count");
1569                         Assert.AreEqual ("1", dg.Items[0].Cells[0].Text, "Cell content");
1570                 }
1571
1572                 [Test]
1573                 [NUnit.Framework.Category ("NunitWeb")]
1574                 public void Paging ()
1575                 {
1576                         WebTest t = new WebTest ("DataGrid.aspx");
1577                         t.Invoker = PageInvoker.CreateOnInit (DataGrid_OnInit);
1578                         string html = t.Run ();
1579                         string gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1580                         string expectedFirstPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>1</td><td>heh1</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>1</td><td>heh1</td><td>Comment 1</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>2</td><td>heh2</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>2</td><td>heh2</td><td>Comment 2</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>3</td><td>heh3</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>3</td><td>heh3</td><td>Comment 3</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>4</td><td>heh4</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>4</td><td>heh4</td><td>Comment 4</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>5</td><td>heh5</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>5</td><td>heh5</td><td>Comment 5</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><span>Previous</span>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Next</a></td>\r\n\t</tr>\r\n</table>";
1581
1582                         HtmlDiff.AssertAreEqual (expectedFirstPage, gridHtml, "DataGrid initial Render");
1583
1584                         FormRequest fr = new FormRequest (t.Response, "form1");
1585                         fr.Controls.Add ("__EVENTTARGET");
1586                         fr.Controls.Add ("__EVENTARGUMENT");
1587 #if DOT_NET
1588                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl09$ctl01";
1589 #else
1590                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl08$ctl01";
1591 #endif
1592                         fr.Controls ["__EVENTARGUMENT"].Value = "";
1593                         t.Request = fr;
1594
1595                         html = t.Run ();
1596                         gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1597                         string expectedSecondPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>6</td><td>heh6</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>6</td><td>heh6</td><td>Comment 6</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>7</td><td>heh7</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>7</td><td>heh7</td><td>Comment 7</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>8</td><td>heh8</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>8</td><td>heh8</td><td>Comment 8</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>9</td><td>heh9</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>9</td><td>heh9</td><td>Comment 9</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>10</td><td>heh10</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>10</td><td>heh10</td><td>Comment 10</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Previous</a>&nbsp;<span>Next</span></td>\r\n\t</tr>\r\n</table>";
1598                         HtmlDiff.AssertAreEqual (expectedSecondPage, gridHtml, "DataGrid Paging Next");
1599
1600                         fr = new FormRequest (t.Response, "form1");
1601                         fr.Controls.Add ("__EVENTTARGET");
1602                         fr.Controls.Add ("__EVENTARGUMENT");
1603 #if DOT_NET
1604                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl09$ctl00";
1605 #else
1606                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl08$ctl00";
1607 #endif
1608                         fr.Controls ["__EVENTARGUMENT"].Value = "";
1609                         t.Request = fr;
1610
1611                         html = t.Run ();
1612                         gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1613
1614                         HtmlDiff.AssertAreEqual (expectedFirstPage, gridHtml, "DataGrid Paging Previous");
1615                 }
1616
1617                 [Test]
1618                 [NUnit.Framework.Category ("NunitWeb")]
1619                 public void EditUpdateDelete ()
1620                 {
1621                         WebTest t = new WebTest ("DataGrid.aspx");
1622                         t.Invoker = PageInvoker.CreateOnInit (DataGrid_OnInit);
1623                         string html = t.Run ();
1624                         string gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1625                         string expectedFirstPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>1</td><td>heh1</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>1</td><td>heh1</td><td>Comment 1</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>2</td><td>heh2</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>2</td><td>heh2</td><td>Comment 2</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>3</td><td>heh3</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>3</td><td>heh3</td><td>Comment 3</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>4</td><td>heh4</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>4</td><td>heh4</td><td>Comment 4</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>5</td><td>heh5</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>5</td><td>heh5</td><td>Comment 5</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><span>Previous</span>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Next</a></td>\r\n\t</tr>\r\n</table>";
1626
1627                         HtmlDiff.AssertAreEqual (expectedFirstPage, gridHtml, "DataGrid initial Render");
1628
1629                         FormRequest fr = new FormRequest (t.Response, "form1");
1630                         fr.Controls.Add ("__EVENTTARGET");
1631                         fr.Controls.Add ("__EVENTARGUMENT");
1632 #if DOT_NET
1633                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl03$ctl00";
1634 #else
1635                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl02$ctl00";
1636 #endif
1637                         fr.Controls ["__EVENTARGUMENT"].Value = "";
1638                         t.Request = fr;
1639
1640                         html = t.Run ();
1641                         gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1642                         string expectedSecondPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:#333333;background-color:Green;font-weight:normal;font-style:normal;text-decoration:none;\">\r\n\t\t<td>1</td><td><input name=\"DataGrid1$ctl03$ctl00\" type=\"text\" value=\"heh1\" /></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Update</a>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl02&#39;,&#39;&#39;)\" style=\"color:#333333;\">Cancel</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl03&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>1</td><td><input name=\"DataGrid1$ctl03$ctl04\" type=\"text\" value=\"heh1\" /></td><td><input name=\"DataGrid1$ctl03$ctl05\" type=\"text\" value=\"Comment 1\" /></td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>2</td><td>heh2</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>2</td><td>heh2</td><td>Comment 2</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>3</td><td>heh3</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>3</td><td>heh3</td><td>Comment 3</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>4</td><td>heh4</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>4</td><td>heh4</td><td>Comment 4</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>5</td><td>heh5</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>5</td><td>heh5</td><td>Comment 5</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><span>Previous</span>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Next</a></td>\r\n\t</tr>\r\n</table>";
1643                         HtmlDiff.AssertAreEqual (expectedSecondPage, gridHtml, "DataGrid Edit");
1644
1645                         fr = new FormRequest (t.Response, "form1");
1646                         fr.Controls.Add ("__EVENTTARGET");
1647                         fr.Controls.Add ("__EVENTARGUMENT");
1648 #if DOT_NET
1649                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl03$ctl01";
1650 #else
1651                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl02$ctl01";
1652 #endif
1653                         fr.Controls ["__EVENTARGUMENT"].Value = "";
1654 #if DOT_NET
1655                         fr.Controls.Add ("DataGrid1$ctl03$ctl00");
1656                         fr.Controls ["DataGrid1$ctl03$ctl00"].Value = "New Value";
1657 #else
1658                         fr.Controls.Add ("DataGrid1$ctl02$ctl00");
1659                         fr.Controls ["DataGrid1$ctl02$ctl00"].Value = "New Value";
1660 #endif
1661                         t.Request = fr;
1662
1663                         html = t.Run ();
1664                         gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1665                         string expectedThirdPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>1</td><td>New Value</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>1</td><td>New Value</td><td>Comment 1</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>2</td><td>heh2</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>2</td><td>heh2</td><td>Comment 2</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>3</td><td>heh3</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>3</td><td>heh3</td><td>Comment 3</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>4</td><td>heh4</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>4</td><td>heh4</td><td>Comment 4</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>5</td><td>heh5</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>5</td><td>heh5</td><td>Comment 5</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><span>Previous</span>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Next</a></td>\r\n\t</tr>\r\n</table>";
1666
1667                         HtmlDiff.AssertAreEqual (expectedThirdPage, gridHtml, "DataGrid Update");
1668
1669                         fr = new FormRequest (t.Response, "form1");
1670                         fr.Controls.Add ("__EVENTTARGET");
1671                         fr.Controls.Add ("__EVENTARGUMENT");
1672 #if DOT_NET
1673                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl04$ctl01";
1674 #else
1675                         fr.Controls ["__EVENTTARGET"].Value = "DataGrid1$ctl03$ctl01";
1676 #endif
1677                         fr.Controls ["__EVENTARGUMENT"].Value = "";
1678                         t.Request = fr;
1679
1680                         html = t.Run ();
1681                         gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1682                         string expectedFourthPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>1</td><td>New Value</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>1</td><td>New Value</td><td>Comment 1</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>3</td><td>heh3</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>3</td><td>heh3</td><td>Comment 3</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>4</td><td>heh4</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>4</td><td>heh4</td><td>Comment 4</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>5</td><td>heh5</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>5</td><td>heh5</td><td>Comment 5</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>6</td><td>heh6</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>6</td><td>heh6</td><td>Comment 6</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><span>Previous</span>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Next</a></td>\r\n\t</tr>\r\n</table>";
1683
1684                         HtmlDiff.AssertAreEqual (expectedFourthPage, gridHtml, "DataGrid Delete");
1685                 }
1686
1687                 [Test]
1688                 [NUnit.Framework.Category ("NunitWeb")]
1689                 public void SelectedIndex ()
1690                 {
1691                         WebTest t = new WebTest ("DataGrid.aspx");
1692                         t.Invoker = PageInvoker.CreateOnInit (DataGrid_OnInit);
1693                         string html = t.Run ();
1694                         string gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1695                         string expectedFirstPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>1</td><td>heh1</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>1</td><td>heh1</td><td>Comment 1</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>2</td><td>heh2</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>2</td><td>heh2</td><td>Comment 2</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>3</td><td>heh3</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>3</td><td>heh3</td><td>Comment 3</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>4</td><td>heh4</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>4</td><td>heh4</td><td>Comment 4</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>5</td><td>heh5</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>5</td><td>heh5</td><td>Comment 5</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><span>Previous</span>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Next</a></td>\r\n\t</tr>\r\n</table>";
1696
1697                         HtmlDiff.AssertAreEqual (expectedFirstPage, gridHtml, "DataGrid initial Render");
1698
1699                         FormRequest fr = new FormRequest (t.Response, "form1");
1700                         fr.Controls.Add ("__EVENTTARGET");
1701                         fr.Controls.Add ("__EVENTARGUMENT");
1702                         fr.Controls ["__EVENTTARGET"].Value = "Button1";
1703                         fr.Controls ["__EVENTARGUMENT"].Value = "";
1704                         t.Request = fr;
1705
1706                         html = t.Run ();
1707                         gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1708                         string expectedSecondPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:Navy;background-color:#FFCC66;font-weight:bold;\">\r\n\t\t<td>1</td><td>heh1</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl00&#39;,&#39;&#39;)\" style=\"color:Navy;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:Navy;\">Delete</a></td><td>1</td><td>heh1</td><td>Comment 1</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>2</td><td>heh2</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>2</td><td>heh2</td><td>Comment 2</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>3</td><td>heh3</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>3</td><td>heh3</td><td>Comment 3</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>4</td><td>heh4</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>4</td><td>heh4</td><td>Comment 4</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>5</td><td>heh5</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>5</td><td>heh5</td><td>Comment 5</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><span>Previous</span>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Next</a></td>\r\n\t</tr>\r\n</table>";
1709                         HtmlDiff.AssertAreEqual (expectedSecondPage, gridHtml, "DataGrid Selected 1");
1710
1711                         fr = new FormRequest (t.Response, "form1");
1712                         fr.Controls.Add ("__EVENTTARGET");
1713                         fr.Controls.Add ("__EVENTARGUMENT");
1714                         fr.Controls ["__EVENTTARGET"].Value = "Button1";
1715                         fr.Controls ["__EVENTARGUMENT"].Value = "";
1716                         t.Request = fr;
1717
1718                         html = t.Run ();
1719                         gridHtml = HtmlDiff.GetControlFromPageHtml (html);
1720                         string expectedThirdPage = "\n        <table cellspacing=\"0\" cellpadding=\"4\" id=\"DataGrid1\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>ID</td><td>Name</td><td>&nbsp;</td><td>&nbsp;</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl00&#39;,&#39;&#39;)\" style=\"color:White;\">ID</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl01&#39;,&#39;&#39;)\" style=\"color:White;\">Name</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl02$ctl02&#39;,&#39;&#39;)\" style=\"color:White;\">Comment</a></td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>1</td><td>heh1</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl03$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>1</td><td>heh1</td><td>Comment 1</td>\r\n\t</tr><tr style=\"color:Navy;background-color:#FFCC66;font-weight:bold;\">\r\n\t\t<td>2</td><td>heh2</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl00&#39;,&#39;&#39;)\" style=\"color:Navy;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl04$ctl01&#39;,&#39;&#39;)\" style=\"color:Navy;\">Delete</a></td><td>2</td><td>heh2</td><td>Comment 2</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>3</td><td>heh3</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl05$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>3</td><td>heh3</td><td>Comment 3</td>\r\n\t</tr><tr style=\"color:#333333;background-color:White;\">\r\n\t\t<td>4</td><td>heh4</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl06$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>4</td><td>heh4</td><td>Comment 4</td>\r\n\t</tr><tr style=\"color:#333333;background-color:#FFFBD6;\">\r\n\t\t<td>5</td><td>heh5</td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl00&#39;,&#39;&#39;)\" style=\"color:#333333;\">Edit</a></td><td><a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl07$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Delete</a></td><td>5</td><td>heh5</td><td>Comment 5</td>\r\n\t</tr><tr style=\"color:White;background-color:#990000;font-weight:bold;\">\r\n\t\t<td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td><td>&nbsp;</td>\r\n\t</tr><tr align=\"center\" style=\"color:#333333;background-color:#FFCC66;\">\r\n\t\t<td colspan=\"4\"><span>Previous</span>&nbsp;<a href=\"javascript:__doPostBack(&#39;DataGrid1$ctl09$ctl01&#39;,&#39;&#39;)\" style=\"color:#333333;\">Next</a></td>\r\n\t</tr>\r\n</table>";
1721
1722                         HtmlDiff.AssertAreEqual (expectedThirdPage, gridHtml, "DataGrid Selected 2");
1723                 }
1724
1725                 public static void DataGrid_OnInit (Page p)
1726                 {
1727                         if (!p.IsPostBack)
1728                                 MyDataSource.Init ();
1729                         DataGrid DataGrid1 = (DataGrid)p.FindControl ("DataGrid1");
1730                         DataGrid1.PageIndexChanged += new DataGridPageChangedEventHandler (DataGrid1_PageIndexChanged);
1731                         DataGrid1.CancelCommand += new DataGridCommandEventHandler (DataGrid1_CancelCommand);
1732                         DataGrid1.DeleteCommand += new DataGridCommandEventHandler (DataGrid1_DeleteCommand);
1733                         DataGrid1.EditCommand += new DataGridCommandEventHandler (DataGrid1_EditCommand);
1734                         DataGrid1.UpdateCommand += new DataGridCommandEventHandler (DataGrid1_UpdateCommand);
1735                         DataGrid1.ItemCreated += new DataGridItemEventHandler (DataGrid1_ItemCreated);
1736                 }
1737
1738                 public static void DataGrid1_ItemCreated (object sender, DataGridItemEventArgs e)
1739                 {
1740                         if (e.Item.ItemType == ListItemType.Pager) {
1741                                 e.Item.Cells [0].ColumnSpan = 4;
1742                         }
1743                 }
1744
1745                 public static void DataGrid1_PageIndexChanged (object source, DataGridPageChangedEventArgs e)
1746                 {
1747                         DataGrid DataGrid1 = (DataGrid) source;
1748                         DataGrid1.CurrentPageIndex = e.NewPageIndex;
1749                         DataGrid1.DataBind ();
1750                 }
1751
1752                 public static void DataGrid1_EditCommand (object source, DataGridCommandEventArgs e)
1753                 {
1754                         DataGrid DataGrid1 = (DataGrid) source;
1755                         DataGrid1.EditItemIndex = e.Item.ItemIndex;
1756                         DataGrid1.DataBind ();
1757                 }
1758
1759                 public static void DataGrid1_DeleteCommand (object source, DataGridCommandEventArgs e)
1760                 {
1761                         DataGrid DataGrid1 = (DataGrid) source;
1762                         MyDataSource ds = new MyDataSource ();
1763                         ds.DeleteItem (e.Item.DataSetIndex);
1764                         DataGrid1.DataBind ();
1765                 }
1766
1767                 public static void DataGrid1_UpdateCommand (object source, DataGridCommandEventArgs e)
1768                 {
1769                         DataGrid DataGrid1 = (DataGrid) source;
1770                         MyDataSource ds = new MyDataSource ();
1771                         TextBox edittedName = (TextBox) e.Item.Cells [1].Controls [0];
1772                         ds.UpdateItem (e.Item.DataSetIndex, Int32.Parse (e.Item.Cells [0].Text), edittedName.Text);
1773                         DataGrid1.EditItemIndex = -1;
1774                         DataGrid1.DataBind ();
1775                 }
1776
1777                 public static void DataGrid1_CancelCommand (object source, DataGridCommandEventArgs e)
1778                 {
1779                         DataGrid DataGrid1 = (DataGrid) source;
1780                         DataGrid1.EditItemIndex = -1;
1781                         DataGrid1.DataBind ();
1782                 }
1783
1784                 public class MyDataSource
1785                 {
1786                         private static ArrayList _data;
1787
1788                         static MyDataSource ()
1789                         {
1790                                 Init ();
1791                         }
1792
1793                         public static void Init ()
1794                         {
1795                                 _data = new ArrayList ();
1796                                 _data.Add (new MyDataItem (1, "heh1", "Comment 1"));
1797                                 _data.Add (new MyDataItem (2, "heh2", "Comment 2"));
1798                                 _data.Add (new MyDataItem (3, "heh3", "Comment 3"));
1799                                 _data.Add (new MyDataItem (4, "heh4", "Comment 4"));
1800                                 _data.Add (new MyDataItem (5, "heh5", "Comment 5"));
1801                                 _data.Add (new MyDataItem (6, "heh6", "Comment 6"));
1802                                 _data.Add (new MyDataItem (7, "heh7", "Comment 7"));
1803                                 _data.Add (new MyDataItem (8, "heh8", "Comment 8"));
1804                                 _data.Add (new MyDataItem (9, "heh9", "Comment 9"));
1805                                 _data.Add (new MyDataItem (10, "heh10", "Comment 10"));
1806                         }
1807
1808                         public MyDataSource ()
1809                         {
1810                         }
1811
1812                         public ArrayList GetAllItems ()
1813                         {
1814                                 return _data;
1815                         }
1816
1817                         public int GetCount ()
1818                         {
1819                                 return _data.Count;
1820                         }
1821
1822                         public void UpdateItem (int itemIndex, int id, string name)
1823                         {
1824                                 if (itemIndex >= 0 && itemIndex < _data.Count) {
1825                                         MyDataItem item = (MyDataItem) _data [itemIndex];
1826                                         item.Name = name;
1827                                         return;
1828                                 }
1829                         }
1830
1831                         public void DeleteItem (int p)
1832                         {
1833                                 _data.RemoveAt (p);
1834                         }
1835                 }
1836
1837                 public class MyDataItem
1838                 {
1839                         int _id = 0;
1840                         string _name = "";
1841                         string _comment = "";
1842
1843                         public MyDataItem (int id, string name, string comment)
1844                         {
1845                                 _id = id;
1846                                 _name = name;
1847                                 _comment = comment;
1848                         }
1849
1850                         public int ID {
1851                                 get { return _id; }
1852                         }
1853
1854                         public string Name {
1855                                 get { return _name; }
1856                                 set { _name = value; }
1857                         }
1858
1859                         public string Comment {
1860                                 get { return _comment; }
1861                                 set { _comment = value; }
1862                         }
1863                 }
1864
1865
1866                 class MyTemplate : ITemplate {
1867                         string text;
1868                         public MyTemplate (string text)
1869                         {
1870                                 this.text = text;
1871                         }
1872
1873                         public void InstantiateIn (Control control)
1874                         {
1875                                 control.Controls.Add (new LiteralControl (text));
1876                         }
1877                 }
1878
1879                 [Test]
1880                 public void OneTemplateColumn1 ()
1881                 {
1882                         DataGridPoker p = new DataGridPoker ();
1883                         TemplateColumn tc = new TemplateColumn ();
1884                         tc.ItemTemplate = new MyTemplate ("hola");
1885                         p.Columns.Add (tc);
1886                         ControlCollection controls = p.Controls;
1887                         p.CreateControls (true);
1888                         Assert.AreEqual (1, p.Columns.Count, "columns");
1889                         Assert.AreEqual (0, controls.Count, "controls");
1890                         string render = p.Render ();
1891                         // no items, even with a templated column.
1892                         // The table is not added if DataSource == null
1893                         Assert.IsTrue (-1 == render.IndexOf ("hola"), "template");
1894                 }
1895
1896                 [Test]
1897                 public void OneTemplateColumn2 ()
1898                 {
1899                         DataGridPoker p = new DataGridPoker ();
1900                         p.ShowFooter = true;
1901                         p.AutoGenerateColumns = false;
1902                         p.DataSource = new ArrayList ();
1903                         TemplateColumn tc = new TemplateColumn ();
1904                         tc.HeaderText = " ";
1905                         tc.FooterTemplate = new MyTemplate ("hola");
1906                         p.Columns.Add (tc);
1907                         Assert.AreEqual (1, p.Columns.Count, "columns-1");
1908                         Assert.AreEqual (0, p.Controls.Count, "controls-1");
1909                         p.CreateControls (true);
1910                         // This time we have the table there. Thanks to the empty ArrayList
1911                         Assert.AreEqual (1, p.Columns.Count, "columns-2");
1912                         Assert.AreEqual (1, p.Controls.Count, "controls-2");
1913                         p.PrepareCH ();
1914                         Assert.AreEqual (1, p.Columns.Count, "columns-3");
1915                         Assert.AreEqual (1, p.Controls.Count, "controls-3");
1916                 }
1917
1918                 [Test]
1919                 public void OneTemplateColumn3 ()
1920                 {
1921                         DataGridPoker p = new DataGridPoker ();
1922                         p.ShowFooter = true;
1923                         p.AutoGenerateColumns = false;
1924                         p.DataSource = new ArrayList ();
1925                         TemplateColumn tc = new TemplateColumn ();
1926                         tc.FooterTemplate = new MyTemplate ("hola");
1927                         p.Columns.Add (tc);
1928                         p.DataBind ();
1929
1930                         StringWriter sw = new StringWriter ();
1931                         HtmlTextWriter tw = new HtmlTextWriter (sw);
1932                         Assert.AreEqual (1, p.Columns.Count, "columns");
1933                         Assert.AreEqual (1, p.Controls.Count, "controls");
1934
1935                         string render = p.Render ();
1936                         // no items, but we have a footer
1937                         Assert.IsTrue (-1 != render.IndexOf ("hola"), "template");
1938                 }
1939
1940                 // This one throw nullref on MS and works with mono
1941                 /*
1942                 [Test]
1943                 [NUnit.Framework.CategoryAttribute ("NotDotNet")]
1944                 public void OneTemplateColumn4 ()
1945                 {
1946                         DataGridPoker p = new DataGridPoker ();
1947                         TemplateColumn tc = new TemplateColumn ();
1948                         tc.ItemTemplate = new MyTemplate ("hola");
1949                         p.Columns.Add (tc);
1950                         p.DataSource = new ArrayList ();
1951                         p.CreateControls (false);
1952                         Assert.AreEqual (1, p.Columns.Count, "columns");
1953                         // Table added because useDataSource == false...
1954                         Assert.AreEqual (1, p.Controls.Count, "controls");
1955                         string render = p.Render ();
1956                         // ... but no template rendered.
1957                         Assert.IsTrue (-1 == render.IndexOf ("hola"), "template");
1958                 }
1959                 */
1960
1961                 [Test]
1962                 public void CreateControls ()
1963                 {
1964                         DataGridPoker p = new DataGridPoker ();
1965                         DataTable table = new DataTable ();
1966
1967                         table.Columns.Add (new DataColumn ("one", typeof (string)));
1968                         table.Columns.Add (new DataColumn ("two", typeof (string)));
1969                         table.Columns.Add (new DataColumn ("three", typeof (string)));
1970                         table.Rows.Add (new object [] { "1", "2", "3" });
1971
1972                         p.DataSource = new DataView (table);
1973
1974                         p.CreateControls (true);
1975                         Assert.AreEqual (p.Controls.Count, 1, "A1");
1976
1977                         ShowControlsRecursive (p.Controls [0], 1);
1978                 }
1979
1980                 [Test]
1981                 public void CreationEvents ()
1982                 {
1983                         DataGridPoker p = new DataGridPoker ();
1984                         DataTable table = new DataTable ();
1985
1986                         table.Columns.Add (new DataColumn ("one", typeof (string)));
1987                         table.Columns.Add (new DataColumn ("two", typeof (string)));
1988                         table.Columns.Add (new DataColumn ("three", typeof (string)));
1989
1990                         p.DataSource = new DataView (table);
1991
1992                         p.ItemCreated += new DataGridItemEventHandler (ItemCreatedHandler);
1993                         p.ItemDataBound += new DataGridItemEventHandler (ItemDataBoundHandler);
1994
1995                         // No items added yet
1996                         ResetEvents ();
1997                         p.CreateControls (true);
1998                         Assert.IsTrue (item_created, "A1");
1999                         Assert.IsTrue (item_data_bound, "A2");
2000
2001                         table.Rows.Add (new object [] { "1", "2", "3" });
2002
2003                         ResetEvents ();
2004                         p.CreateControls (true);
2005                         Assert.IsTrue (item_created, "A3");
2006                         Assert.IsTrue (item_data_bound, "A4");
2007
2008                         // no databinding
2009                         ResetEvents ();
2010                         p.CreateControls (false);
2011                         Assert.IsTrue (item_created, "A5");
2012                         Assert.IsFalse (item_data_bound, "A6");
2013                 }
2014
2015                 [Test]
2016                 public void InitializePager ()
2017                 {
2018                         DataGridPoker p = new DataGridPoker ();
2019                         PagedDataSource paged = new PagedDataSource ();
2020                         DataTable table = new DataTable ();
2021                         DataGridItem item = new DataGridItem (-1, -1, ListItemType.Pager);
2022                         ArrayList columns;
2023                         LinkButton next;
2024                         LinkButton prev;
2025
2026                         table.Columns.Add (new DataColumn ("one", typeof (string)));
2027                         table.Columns.Add (new DataColumn ("two", typeof (string)));
2028                         table.Columns.Add (new DataColumn ("three", typeof (string)));
2029
2030                         for (int i = 0; i < 25; i++)
2031                                 table.Rows.Add (new object [] { "1", "2", "3" });
2032                         paged.DataSource = new DataView (table);
2033
2034                         columns = p.CreateColumns (paged, true);
2035                         p.InitPager (item, columns.Count, paged);
2036
2037                         //
2038                         // No where to go
2039                         //
2040
2041                         Assert.AreEqual (item.Controls.Count, 1, "A1");
2042                         Assert.AreEqual (item.Controls [0].GetType (), typeof (TableCell), "A2");
2043                         Assert.AreEqual (item.Controls [0].Controls.Count, 3, "A3");
2044                         Assert.AreEqual (item.Controls [0].Controls [0].GetType (), typeof (Label), "A4");
2045                         Assert.AreEqual (item.Controls [0].Controls [1].GetType (),
2046                                         typeof (LiteralControl), "A5");
2047                         Assert.AreEqual (item.Controls [0].Controls [2].GetType (), typeof (Label), "A6");
2048                         Assert.AreEqual (((Label) item.Controls [0].Controls [0]).Text, "&lt;", "A7");
2049                         Assert.AreEqual (((LiteralControl) item.Controls [0].Controls [1]).Text,
2050                                         "&nbsp;", "A7");
2051                         Assert.AreEqual (((Label) item.Controls [0].Controls [2]).Text, "&gt;", "A8");
2052
2053                         //
2054                         // Next
2055                         //
2056
2057                         item = new DataGridItem (-1, -1, ListItemType.Pager);
2058                         paged.PageSize = 5;
2059                         paged.VirtualCount = 25;
2060                         paged.AllowPaging = true;
2061                         p.InitPager (item, columns.Count, paged);
2062
2063                         Assert.AreEqual (item.Controls.Count, 1, "A9");
2064                         Assert.AreEqual (item.Controls [0].GetType (), typeof (TableCell), "A10");
2065                         Assert.AreEqual (item.Controls [0].Controls.Count, 3, "A11");
2066                         Assert.AreEqual (item.Controls [0].Controls [0].GetType (), typeof (Label), "A12");
2067                         Assert.AreEqual (item.Controls [0].Controls [1].GetType (),
2068                                         typeof (LiteralControl), "A13");
2069                         Assert.AreEqual (((Label) item.Controls [0].Controls [0]).Text, "&lt;", "A14");
2070                         Assert.AreEqual (((LiteralControl) item.Controls [0].Controls [1]).Text,
2071                                         "&nbsp;", "A16");
2072
2073                         next = (LinkButton) item.Controls [0].Controls [2];
2074                         Assert.AreEqual (next.Text, "&gt;", "A17");
2075                         Assert.AreEqual (next.CommandName, "Page", "A18");
2076                         Assert.AreEqual (next.CommandArgument, "Next", "A19");
2077
2078
2079                         //
2080                         // Both
2081                         //
2082
2083                         item = new DataGridItem (-1, -1, ListItemType.Pager);
2084                         paged.PageSize = 5;
2085                         paged.VirtualCount = 25;
2086                         paged.AllowPaging = true;
2087                         paged.CurrentPageIndex = 2;
2088                         p.InitPager (item, columns.Count, paged);
2089
2090                         Assert.AreEqual (item.Controls.Count, 1, "A20");
2091                         Assert.AreEqual (item.Controls [0].GetType (), typeof (TableCell), "A21");
2092                         Assert.AreEqual (item.Controls [0].Controls.Count, 3, "A22");
2093                         Assert.AreEqual (item.Controls [0].Controls [1].GetType (),
2094                                         typeof (LiteralControl), "A23");
2095                         Assert.AreEqual (((LiteralControl) item.Controls [0].Controls [1]).Text,
2096                                         "&nbsp;", "A24");
2097
2098                         // This is failing with an invalidcast right now. It's something related to
2099                         // the pager thinking that it's on the last page and rendering a label instead
2100                         next = (LinkButton) item.Controls [0].Controls [2];
2101                         Assert.AreEqual (next.Text, "&gt;", "A25");
2102                         Assert.AreEqual (next.CommandName, "Page", "A26");
2103                         Assert.AreEqual (next.CommandArgument, "Next", "A27");
2104
2105                         prev = (LinkButton) item.Controls [0].Controls [0];
2106                         Assert.AreEqual (prev.Text, "&lt;", "A28");
2107                         Assert.AreEqual (prev.CommandName, "Page", "A29");
2108                         Assert.AreEqual (prev.CommandArgument, "Prev", "A30");
2109
2110                         //
2111                         // Back only
2112                         //
2113
2114                         item = new DataGridItem (-1, -1, ListItemType.Pager);
2115                         paged.PageSize = 5;
2116                         paged.VirtualCount = 25;
2117                         paged.AllowPaging = true;
2118                         paged.CurrentPageIndex = 4;
2119                         p.InitPager (item, columns.Count, paged);
2120
2121                         Assert.AreEqual (item.Controls.Count, 1, "A31");
2122                         Assert.AreEqual (item.Controls [0].GetType (), typeof (TableCell), "A32");
2123                         Assert.AreEqual (item.Controls [0].Controls.Count, 3, "A33");
2124                         Assert.AreEqual (item.Controls [0].Controls [1].GetType (),
2125                                         typeof (LiteralControl), "A34");
2126                         Assert.AreEqual (item.Controls [0].Controls [2].GetType (), typeof (Label), "A35");
2127                         Assert.AreEqual (((LiteralControl) item.Controls [0].Controls [1]).Text,
2128                                         "&nbsp;", "A36");
2129                         Assert.AreEqual (((Label) item.Controls [0].Controls [2]).Text, "&gt;", "A37");
2130
2131                         prev = (LinkButton) item.Controls [0].Controls [0];
2132                         Assert.AreEqual (prev.Text, "&lt;", "A38");
2133                         Assert.AreEqual (prev.CommandName, "Page", "A39");
2134                         Assert.AreEqual (prev.CommandArgument, "Prev", "A40");
2135
2136                 }
2137
2138                 [Conditional ("VERBOSE_DATAGRID")]
2139                 private void ShowControlsRecursive (Control c, int depth)
2140                 {
2141                         for (int i = 0; i < depth; i++)
2142                                 Console.Write ("-");
2143
2144                         // StringWriter sw = new StringWriter ();
2145                         // HtmlTextWriter tw = new HtmlTextWriter (sw);
2146
2147                         // c.RenderControl (tw);
2148                         // Console.WriteLine (sw.ToString ());
2149
2150                         Console.WriteLine (c);
2151
2152                         foreach (Control child in c.Controls)
2153                                 ShowControlsRecursive (child, depth + 5);
2154                 }
2155
2156                 [Test]
2157                 public void Render ()
2158                 {
2159                         DataGridPoker p = new DataGridPoker ();
2160
2161                         Assert.AreEqual (p.Render (), String.Empty, "A1");
2162                 }
2163
2164                 Control FindByType (Control parent, Type type)
2165                 {
2166                         if (!parent.HasControls ())
2167                                 return null;
2168
2169                         foreach (Control c in parent.Controls) {
2170                                 if (type.IsAssignableFrom (c.GetType ()))
2171                                         return c;
2172
2173                                 Control ret = FindByType (c, type);
2174                                 if (ret != null)
2175                                         return ret;
2176                         }
2177                         return null;
2178                 }
2179
2180                 // Header link
2181                 [Test]
2182                 public void SpecialLinkButton1 ()
2183                 {
2184                         DataTable dt = new DataTable();
2185                         dt.Columns.Add (new DataColumn("something", typeof(Int32)));
2186                         DataRow dr = dt.NewRow ();
2187                         dt.Rows.Add (new object [] { 1 });
2188                         DataView dv = new DataView (dt);
2189                         DataGridPoker dg = new DataGridPoker ();
2190                         dg.AllowSorting = true;
2191                         dg.HeaderStyle.Font.Bold = true;
2192                         dg.HeaderStyle.ForeColor = Color.FromArgb (255,255,255,255);
2193                         dg.HeaderStyle.BackColor = Color.FromArgb (33,33,33,33);
2194                         dg.DataSource = dv;
2195                         dg.DataBind ();
2196                         LinkButton lb = (LinkButton) FindByType (dg.Controls [0], typeof (LinkButton));
2197                         Assert.IsNotNull (lb, "lb");
2198                         StringWriter sr = new StringWriter ();
2199                         HtmlTextWriter output = new HtmlTextWriter (sr);
2200                         // Nothing here...
2201                         Assert.AreEqual (Color.Empty, lb.ControlStyle.ForeColor, "fore");
2202                         lb.RenderControl (output);
2203                         // Nothing here...
2204                         Assert.AreEqual (Color.Empty, lb.ControlStyle.ForeColor, "fore2");
2205                         dg.Render ();
2206                         // Surprise! after rendering the datagrid, the linkbutton has the ForeColor from the datagrid
2207                         Assert.AreEqual (Color.FromArgb (255,255,255,255), lb.ControlStyle.ForeColor, "fore3");
2208
2209                         // Extra. Items != empty
2210                         Assert.AreEqual (1, dg.Items.Count, "itemCount");
2211                 }
2212
2213                 // value link in buttoncolumn
2214                 [Test]
2215                 public void SpecialLinkButton2 ()
2216                 {
2217                         DataTable dt = new DataTable();
2218                         dt.Columns.Add (new DataColumn("string_col", typeof(string)));
2219                         DataRow dr = dt.NewRow ();
2220                         dt.Rows.Add (new object [] { "Item 1" });
2221                         DataView dv = new DataView (dt);
2222
2223                         DataGridPoker dg = new DataGridPoker ();
2224                         dg.DataSource = dv;
2225                         dg.AutoGenerateColumns = false;
2226                         dg.HeaderStyle.ForeColor = Color.FromArgb (255,255,255,255);
2227                         dg.HeaderStyle.BackColor = Color.FromArgb (33,33,33,33);
2228
2229                         ButtonColumn bc = new ButtonColumn ();
2230                         bc.HeaderText = "Some header";
2231                         bc.DataTextField = "string_col";
2232                         bc.CommandName = "lalala";
2233                         dg.Columns.Add (bc);
2234
2235                         BoundColumn bound = new BoundColumn ();
2236                         bound.HeaderText = "The other column";
2237                         bound.DataField = "string_col";
2238                         dg.Columns.Add (bound);
2239
2240                         dg.DataBind ();
2241
2242                         LinkButton lb = (LinkButton) FindByType (dg.Controls [0], typeof (LinkButton));
2243                         Assert.IsNotNull (lb, "lb");
2244                         StringWriter sr = new StringWriter ();
2245                         HtmlTextWriter output = new HtmlTextWriter (sr);
2246                         Assert.AreEqual (Color.Empty, lb.ControlStyle.ForeColor, "fore");
2247                         lb.RenderControl (output);
2248                         Assert.AreEqual (Color.Empty, lb.ControlStyle.ForeColor, "fore2");
2249                         string str = dg.Render ();
2250                         Assert.IsTrue (-1 != str.IndexOf ("<a>Item 1</a>"), "item1");
2251                         Assert.IsTrue (-1 != str.IndexOf ("<td>Item 1</td>"), "item1-2");
2252                 }
2253         }
2254 }
2255