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

   1 //
   2 // DataListTest.cs - Unit tests for System.Web.UI.WebControls.DataList
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //      Gonzalo Paniagua Javier <gonzalo@ximian.com>
   7 //
   8 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Collections;
  32 using System.ComponentModel;
  33 using System.Data;
  34 using System.Drawing;
  35 using System.IO;
  36 using System.Web;
  37 using System.Web.UI;
  38 using System.Web.UI.WebControls;
  39
  40 using NUnit.Framework;
  41 using MonoTests.Common;
  42
  43 namespace MonoTests.System.Web.UI.WebControls {
  44
  45         public class TestDataList : DataList {
  46
  47                 public string Tag {
  48                         get { return base.TagName; }
  49                 }
  50
  51                 public StateBag StateBag {
  52                         get { return base.ViewState; }
  53                 }
  54
  55
  56                 private HtmlTextWriter GetWriter ()
  57                 {
  58                         StringWriter sw = new StringWriter ();
  59                         sw.NewLine = "\n";
  60                         return new HtmlTextWriter (sw);
  61                 }
  62
  63                 public string Render ()
  64                 {
  65                         HtmlTextWriter writer = GetWriter ();
  66                         base.Render (writer);
  67                         return writer.InnerWriter.ToString ();
  68                 }
  69
  70                 public string RenderItem (ListItemType itemType, int repeatIndex, RepeatInfo repeatInfo)
  71                 {
  72                         HtmlTextWriter writer = GetWriter ();
  73                         (this as IRepeatInfoUser).RenderItem (itemType, repeatIndex, repeatInfo, writer);
  74                         return writer.InnerWriter.ToString ();
  75                 }
  76
  77                 public void CreateCH ()
  78                 {
  79                         CreateControlHierarchy (true);
  80                 }
  81
  82                 public void PrepareCH ()
  83                 {
  84                         PrepareControlHierarchy ();
  85                 }
  86
  87                 public void TrackState ()
  88                 {
  89                         TrackViewState ();
  90                 }
  91
  92                 public void LoadState (object state)
  93                 {
  94                         LoadViewState (state);
  95                 }
  96
  97                 public object SaveState ()
  98                 {
  99                         return SaveViewState ();
 100                 }
 101
 102                 public void DoCancelCommand (DataListCommandEventArgs e)
 103                 {
 104                         OnCancelCommand (e);
 105                 }
 106
 107                 public void DoDeleteCommand (DataListCommandEventArgs e)
 108                 {
 109                         OnDeleteCommand (e);
 110                 }
 111
 112                 public void DoEditCommand (DataListCommandEventArgs e)
 113                 {
 114                         OnEditCommand (e);
 115                 }
 116
 117                 public void DoItemCommand (DataListCommandEventArgs e)
 118                 {
 119                         OnItemCommand (e);
 120                 }
 121
 122                 public void DoUpdateCommand (DataListCommandEventArgs e)
 123                 {
 124                         OnUpdateCommand (e);
 125                 }
 126
 127                 public void DoItemCreated (DataListItemEventArgs e)
 128                 {
 129                         OnItemCreated (e);
 130                 }
 131
 132                 public void DoItemDataBound (DataListItemEventArgs e)
 133                 {
 134                         OnItemDataBound (e);
 135                 }
 136
 137                 public void DoSelectedIndexChanged (EventArgs e)
 138                 {
 139                         OnSelectedIndexChanged (e);
 140                 }
 141
 142                 public bool DoBubbleEvent (object source, EventArgs e)
 143                 {
 144                         return OnBubbleEvent (source, e);
 145                 }
 146         }
 147
 148         public class TestTemplate : ITemplate {
 149
 150                 public void InstantiateIn (Control container)
 151                 {
 152                 }
 153         }
 154
 155         [TestFixture]
 156         public class DataListTest {
 157
 158                 private HtmlTextWriter GetWriter ()
 159                 {
 160                         StringWriter sw = new StringWriter ();
 161                         sw.NewLine = "\n";
 162                         return new HtmlTextWriter (sw);
 163                 }
 164
 165                 // IList based
 166                 private ArrayList GetData (int n)
 167                 {
 168                         ArrayList al = new ArrayList ();
 169                         for (int i = 0; i < n; i++) {
 170                                 al.Add (i.ToString ());
 171                         }
 172                         return al;
 173                 }
 174
 175                 // IListSource based
 176                 private TestDataSource GetDataSource (int n)
 177                 {
 178                         return new TestDataSource (GetData (n));
 179                 }
 180
 181                 public void CheckIRepeatInfoUser (IRepeatInfoUser riu)
 182                 {
 183                         Assert.IsFalse (riu.HasFooter, "HasFooter");
 184                         Assert.IsFalse (riu.HasHeader, "HasHeader");
 185                         Assert.IsFalse (riu.HasSeparators, "HasSeparators");
 186                         Assert.AreEqual (0, riu.RepeatedItemCount, "RepeatedItemCount");
 187                 }
 188
 189                 [Test]
 190                 public void ConstantStrings ()
 191                 {
 192                         Assert.AreEqual ("Cancel", DataList.CancelCommandName, "CancelCommandName");
 193                         Assert.AreEqual ("Delete", DataList.DeleteCommandName, "DeleteCommandName");
 194                         Assert.AreEqual ("Edit", DataList.EditCommandName, "EditCommandName");
 195                         Assert.AreEqual ("Select", DataList.SelectCommandName, "SelectCommandName");
 196                         Assert.AreEqual ("Update", DataList.UpdateCommandName, "UpdateCommandName");
 197                 }
 198
 199                 [Test]
 200                 public void DefaultProperties ()
 201                 {
 202                         TestDataList dl = new TestDataList ();
 203                         CheckIRepeatInfoUser (dl);
 204                         Assert.AreEqual ("table", dl.Tag, "TagName");
 205                         Assert.AreEqual (0, dl.Attributes.Count, "Attributes.Count-1");
 206                         Assert.AreEqual (0, dl.StateBag.Count, "ViewState.Count-1");
 207
 208                         // Styles
 209                         Assert.IsNotNull (dl.AlternatingItemStyle, "AlternatingItemStyle");
 210                         Assert.IsNotNull (dl.EditItemStyle, "EditItemStyle");
 211                         Assert.IsNotNull (dl.FooterStyle, "FooterStyle");
 212                         Assert.IsNotNull (dl.HeaderStyle, "HeaderStyle");
 213                         Assert.IsNotNull (dl.ItemStyle, "ItemStyle");
 214                         Assert.IsNotNull (dl.SelectedItemStyle, "SelectedItemStyle");
 215                         Assert.IsNotNull (dl.SeparatorStyle, "SeparatorStyle");
 216
 217                         // Templates
 218                         Assert.IsNull (dl.AlternatingItemTemplate, "AlternatingItemTemplate");
 219                         Assert.IsNull (dl.EditItemTemplate, "EditItemTemplate");
 220                         Assert.IsNull (dl.FooterTemplate, "FooterTemplate");
 221                         Assert.IsNull (dl.HeaderTemplate, "HeaderTemplate");
 222                         Assert.IsNull (dl.ItemTemplate, "ItemTemplate");
 223                         Assert.IsNull (dl.SelectedItemTemplate, "SelectedItemTemplate");
 224                         Assert.IsNull (dl.SeparatorTemplate, "SeparatorTemplate");
 225
 226                         // Indexes
 227                         Assert.AreEqual (-1, dl.EditItemIndex, "EditItemIndex");
 228                         Assert.AreEqual (-1, dl.SelectedIndex, "SelectedIndex");
 229
 230                         // others (from DataList)
 231                         Assert.IsFalse (dl.ExtractTemplateRows, "ExtractTemplateRows");
 232                         Assert.AreEqual (0, dl.Items.Count, "Items.Count");
 233                         Assert.AreEqual (0, dl.RepeatColumns, "RepeatColumns");
 234                         Assert.AreEqual (RepeatDirection.Vertical, dl.RepeatDirection, "RepeatDirection");
 235                         Assert.AreEqual (RepeatLayout.Table, dl.RepeatLayout, "RepeatLayout");
 236                         Assert.IsNull (dl.SelectedItem, "SelectedItem");
 237                         Assert.IsTrue (dl.ShowFooter, "ShowFooter");
 238                         Assert.IsTrue (dl.ShowHeader, "ShowHeader");
 239
 240                         // the CellPadding, CellSpacing, GridLines and HorizontalAlign are defined
 241                         // in BaseDataList but couldn't be totally tested from there
 242                         Assert.AreEqual (-1, dl.CellPadding, "CellPadding");
 243                         Assert.AreEqual (0, dl.CellSpacing, "CellSpacing");
 244                         Assert.AreEqual (GridLines.None, dl.GridLines, "GridLines");
 245                         Assert.AreEqual (HorizontalAlign.NotSet, dl.HorizontalAlign, "HorizontalAlign");
 246
 247                         Assert.AreEqual (0, dl.Attributes.Count, "Attributes.Count-2");
 248                         Assert.AreEqual (0, dl.StateBag.Count, "ViewState.Count-2");
 249                 }
 250
 251                 [Test]
 252                 public void NullProperties ()
 253                 {
 254                         TestDataList dl = new TestDataList ();
 255                         Assert.AreEqual (0, dl.Attributes.Count, "Attributes.Count-1");
 256                         Assert.AreEqual (0, dl.StateBag.Count, "ViewState.Count-1");
 257
 258                         // some properties couldn't be set in BaseDataList without causing a
 259                         // InvalidCastException, so they get test here first...
 260                         dl.CellPadding = -1;
 261                         Assert.AreEqual (-1, dl.CellPadding, "CellPadding");
 262                         dl.CellSpacing = 0;
 263                         Assert.AreEqual (0, dl.CellSpacing, "CellSpacing");
 264                         dl.GridLines = GridLines.None;
 265                         Assert.AreEqual (GridLines.None, dl.GridLines, "GridLines");
 266                         dl.HorizontalAlign = HorizontalAlign.NotSet;
 267                         Assert.AreEqual (HorizontalAlign.NotSet, dl.HorizontalAlign, "HorizontalAlign");
 268                         int sc = 0;
 269                         // so the TableStyle isn't kept directly in the ViewState
 270                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2");
 271
 272                         // now for the DataList properties
 273                         // touching all styles
 274                         Assert.IsTrue (dl.AlternatingItemStyle.BackColor.IsEmpty, "AlternatingItemStyle");
 275                         Assert.IsTrue (dl.EditItemStyle.BackColor.IsEmpty, "EditItemStyle");
 276                         Assert.IsTrue (dl.FooterStyle.BackColor.IsEmpty, "FooterStyle");
 277                         Assert.IsTrue (dl.HeaderStyle.BackColor.IsEmpty, "HeaderStyle");
 278                         Assert.IsTrue (dl.ItemStyle.BackColor.IsEmpty, "ItemStyle");
 279                         Assert.IsTrue (dl.SelectedItemStyle.BackColor.IsEmpty, "SelectedItemStyle");
 280                         Assert.IsTrue (dl.SeparatorStyle.BackColor.IsEmpty, "SeparatorStyle");
 281                         dl.AlternatingItemTemplate = null;
 282                         Assert.IsNull (dl.AlternatingItemTemplate, "AlternatingItemTemplate");
 283                         dl.EditItemTemplate = null;
 284                         Assert.IsNull (dl.EditItemTemplate, "EditItemTemplate");
 285                         dl.FooterTemplate = null;
 286                         Assert.IsNull (dl.FooterTemplate, "FooterTemplate");
 287                         dl.HeaderTemplate = null;
 288                         Assert.IsNull (dl.HeaderTemplate, "HeaderTemplate");
 289                         dl.ItemTemplate = null;
 290                         Assert.IsNull (dl.ItemTemplate, "ItemTemplate");
 291                         dl.SelectedItemTemplate = null;
 292                         Assert.IsNull (dl.SelectedItemTemplate, "SelectedItemTemplate");
 293                         dl.SeparatorTemplate = null;
 294                         Assert.IsNull (dl.SeparatorTemplate, "SeparatorTemplate");
 295                         dl.EditItemIndex = -1;
 296                         Assert.AreEqual (-1, dl.EditItemIndex, "EditItemIndex");
 297                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2b");
 298                         dl.SelectedIndex = -1;
 299                         Assert.AreEqual (-1, dl.SelectedIndex, "SelectedIndex");
 300                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2c");
 301                         dl.ExtractTemplateRows = false;
 302                         Assert.IsFalse (dl.ExtractTemplateRows, "ExtractTemplateRows");
 303                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-3");
 304                         dl.RepeatColumns = 0;
 305                         Assert.AreEqual (0, dl.RepeatColumns, "RepeatColumns");
 306                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-4");
 307                         dl.RepeatDirection = RepeatDirection.Vertical;
 308                         Assert.AreEqual (RepeatDirection.Vertical, dl.RepeatDirection, "RepeatDirection");
 309                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-5");
 310                         dl.RepeatLayout = RepeatLayout.Table;
 311                         Assert.AreEqual (RepeatLayout.Table, dl.RepeatLayout, "RepeatLayout");
 312                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-6");
 313                         dl.ShowFooter = true;
 314                         Assert.IsTrue (dl.ShowFooter, "ShowFooter");
 315                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-7");
 316                         dl.ShowHeader = true;
 317                         Assert.IsTrue (dl.ShowHeader, "ShowHeader");
 318                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-8");
 319
 320                         // and all this didn't affect IRepeatInfoUser
 321                         CheckIRepeatInfoUser (dl);
 322
 323                         Assert.AreEqual (0, dl.Attributes.Count, "Attributes.Count-2");
 324                 }
 325 #if NET_4_0
 326                 [Test]
 327                 public void RepeatLayout_Lists ()
 328                 {
 329                         TestDataList dl = new TestDataList ();
 330
 331                         AssertExtensions.Throws<ArgumentOutOfRangeException> (() => {
 332                                 dl.RepeatLayout = RepeatLayout.OrderedList;
 333                         }, "#A1");
 334
 335                         AssertExtensions.Throws<ArgumentOutOfRangeException> (() => {
 336                                 dl.RepeatLayout = RepeatLayout.UnorderedList;
 337                         }, "#A2");
 338                 }
 339 #endif
 340                 [Test]
 341                 public void CleanProperties ()
 342                 {
 343                         TestDataList dl = new TestDataList ();
 344                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 345                         Assert.AreEqual (0, dl.Attributes.Count, "Attributes.Count-1");
 346                         Assert.AreEqual (0, dl.StateBag.Count, "ViewState.Count-1");
 347
 348                         dl.CellPadding = 0;
 349                         Assert.AreEqual (0, dl.CellPadding, "CellPadding");
 350                         dl.CellSpacing = 1;
 351                         Assert.AreEqual (1, dl.CellSpacing, "CellSpacing");
 352                         dl.GridLines = GridLines.Vertical;
 353                         Assert.AreEqual (GridLines.Vertical, dl.GridLines, "GridLines");
 354                         dl.HorizontalAlign = HorizontalAlign.Center;
 355                         Assert.AreEqual (HorizontalAlign.Center, dl.HorizontalAlign, "HorizontalAlign");
 356                         int sc = 0;
 357                         // so the TableStyle isn't kept directly in the ViewState
 358                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2");
 359
 360                         // now for the DataList properties
 361                         // touching all styles
 362                         dl.AlternatingItemStyle.BackColor = Color.AliceBlue;
 363                         Assert.IsFalse (dl.AlternatingItemStyle.BackColor.IsEmpty, "AlternatingItemStyle");
 364                         dl.EditItemStyle.BackColor = Color.AntiqueWhite;
 365                         Assert.IsFalse (dl.EditItemStyle.BackColor.IsEmpty, "EditItemStyle");
 366                         dl.FooterStyle.BackColor = Color.Aqua;
 367                         Assert.IsFalse (dl.FooterStyle.BackColor.IsEmpty, "FooterStyle");
 368                         dl.HeaderStyle.BackColor = Color.Aquamarine;
 369                         Assert.IsFalse (dl.HeaderStyle.BackColor.IsEmpty, "HeaderStyle");
 370                         dl.ItemStyle.BackColor = Color.Azure;
 371                         Assert.IsFalse (dl.ItemStyle.BackColor.IsEmpty, "ItemStyle");
 372                         dl.SelectedItemStyle.BackColor = Color.Beige;
 373                         Assert.IsFalse (dl.SelectedItemStyle.BackColor.IsEmpty, "SelectedItemStyle");
 374                         dl.SeparatorStyle.BackColor = Color.Bisque;
 375                         Assert.IsFalse (dl.SeparatorStyle.BackColor.IsEmpty, "SeparatorStyle");
 376                         dl.AlternatingItemTemplate = new TestTemplate ();
 377                         Assert.IsNotNull (dl.AlternatingItemTemplate, "AlternatingItemTemplate");
 378                         dl.EditItemTemplate = new TestTemplate ();
 379                         Assert.IsNotNull (dl.EditItemTemplate, "EditItemTemplate");
 380                         dl.FooterTemplate = new TestTemplate ();
 381                         Assert.IsTrue (riu.HasFooter, "HasFooter");
 382                         Assert.IsNotNull (dl.FooterTemplate, "FooterTemplate");
 383                         dl.HeaderTemplate = new TestTemplate ();
 384                         Assert.IsTrue (riu.HasHeader, "HasHeader");
 385                         Assert.IsNotNull (dl.HeaderTemplate, "HeaderTemplate");
 386                         dl.ItemTemplate = new TestTemplate ();
 387                         Assert.IsNotNull (dl.ItemTemplate, "ItemTemplate");
 388                         dl.SelectedItemTemplate = new TestTemplate ();
 389                         Assert.IsNotNull (dl.SelectedItemTemplate, "SelectedItemTemplate");
 390                         dl.SeparatorTemplate = new TestTemplate ();
 391                         Assert.IsTrue (riu.HasSeparators, "HasSeparators");
 392                         Assert.IsNotNull (dl.SeparatorTemplate, "SeparatorTemplate");
 393                         dl.EditItemIndex = 0;
 394                         Assert.AreEqual (0, dl.EditItemIndex, "EditItemIndex");
 395                         dl.EditItemIndex = -1;
 396                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2b");
 397                         dl.SelectedIndex = 0;
 398                         Assert.AreEqual (0, dl.SelectedIndex, "SelectedIndex");
 399                         dl.SelectedIndex = -1;
 400                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2c");
 401                         dl.ExtractTemplateRows = true;
 402                         Assert.IsTrue (dl.ExtractTemplateRows, "ExtractTemplateRows");
 403                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-3");
 404                         dl.RepeatColumns = 1;
 405                         Assert.AreEqual (1, dl.RepeatColumns, "RepeatColumns");
 406                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-4");
 407                         dl.RepeatDirection = RepeatDirection.Horizontal;
 408                         Assert.AreEqual (RepeatDirection.Horizontal, dl.RepeatDirection, "RepeatDirection");
 409                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-5");
 410                         dl.RepeatLayout = RepeatLayout.Flow;
 411                         Assert.AreEqual (RepeatLayout.Flow, dl.RepeatLayout, "RepeatLayout");
 412                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-6");
 413                         dl.ShowFooter = false;
 414                         Assert.IsFalse (riu.HasFooter, "HasFooter(lost)");
 415                         Assert.IsFalse (dl.ShowFooter, "ShowFooter");
 416                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-7");
 417                         dl.ShowHeader = false;
 418                         Assert.IsFalse (riu.HasHeader, "HasHeader(lost)");
 419                         Assert.IsFalse (dl.ShowHeader, "ShowHeader");
 420                         Assert.AreEqual (sc, dl.StateBag.Count, "ViewState.Count-8");
 421
 422                         // reverting back changes to default...
 423
 424                         dl.CellPadding = -1;
 425                         Assert.AreEqual (-1, dl.CellPadding, "-CellPadding");
 426                         dl.CellSpacing = 0;
 427                         Assert.AreEqual (0, dl.CellSpacing, "-CellSpacing");
 428                         dl.GridLines = GridLines.None;
 429                         Assert.AreEqual (GridLines.None, dl.GridLines, "-GridLines");
 430                         dl.HorizontalAlign = HorizontalAlign.NotSet;
 431                         Assert.AreEqual (HorizontalAlign.NotSet, dl.HorizontalAlign, "-HorizontalAlign");
 432                         Assert.AreEqual (sc, dl.StateBag.Count, "ViewState.Count-9");
 433                         dl.AlternatingItemStyle.Reset ();
 434                         Assert.IsTrue (dl.AlternatingItemStyle.BackColor.IsEmpty, "-AlternatingItemStyle");
 435                         dl.EditItemStyle.Reset ();
 436                         Assert.IsTrue (dl.EditItemStyle.BackColor.IsEmpty, "-EditItemStyle");
 437                         dl.FooterStyle.Reset ();
 438                         Assert.IsTrue (dl.FooterStyle.BackColor.IsEmpty, "-FooterStyle");
 439                         dl.HeaderStyle.Reset ();
 440                         Assert.IsTrue (dl.HeaderStyle.BackColor.IsEmpty, "-HeaderStyle");
 441                         dl.ItemStyle.Reset ();
 442                         Assert.IsTrue (dl.ItemStyle.BackColor.IsEmpty, "-ItemStyle");
 443                         dl.SelectedItemStyle.Reset ();
 444                         Assert.IsTrue (dl.SelectedItemStyle.BackColor.IsEmpty, "-SelectedItemStyle");
 445                         dl.SeparatorStyle.Reset ();
 446                         Assert.IsTrue (dl.SeparatorStyle.BackColor.IsEmpty, "-SeparatorStyle");
 447                         dl.AlternatingItemTemplate = null;
 448                         Assert.IsNull (dl.AlternatingItemTemplate, "-AlternatingItemTemplate");
 449                         dl.EditItemTemplate = null;
 450                         Assert.IsNull (dl.EditItemTemplate, "-EditItemTemplate");
 451                         dl.FooterTemplate = null;
 452                         Assert.IsNull (dl.FooterTemplate, "-FooterTemplate");
 453                         dl.HeaderTemplate = null;
 454                         Assert.IsNull (dl.HeaderTemplate, "-HeaderTemplate");
 455                         dl.ItemTemplate = null;
 456                         Assert.IsNull (dl.ItemTemplate, "-ItemTemplate");
 457                         dl.SelectedItemTemplate = null;
 458                         Assert.IsNull (dl.SelectedItemTemplate, "-SelectedItemTemplate");
 459                         dl.SeparatorTemplate = null;
 460                         Assert.IsNull (dl.SeparatorTemplate, "-SeparatorTemplate");
 461                         dl.EditItemIndex = -1;
 462                         Assert.AreEqual (-1, dl.EditItemIndex, "-EditItemIndex");
 463                         dl.SelectedIndex = -1;
 464                         Assert.AreEqual (-1, dl.SelectedIndex, "-SelectedIndex");
 465                         dl.ExtractTemplateRows = false;
 466                         Assert.IsFalse (dl.ExtractTemplateRows, "-ExtractTemplateRows");
 467                         dl.RepeatColumns = 0;
 468                         Assert.AreEqual (0, dl.RepeatColumns, "-RepeatColumns");
 469                         dl.RepeatDirection = RepeatDirection.Vertical;
 470                         Assert.AreEqual (RepeatDirection.Vertical, dl.RepeatDirection, "-RepeatDirection");
 471                         dl.RepeatLayout = RepeatLayout.Table;
 472                         Assert.AreEqual (RepeatLayout.Table, dl.RepeatLayout, "-RepeatLayout");
 473                         dl.ShowFooter = true;
 474                         Assert.IsTrue (dl.ShowFooter, "-ShowFooter");
 475                         dl.ShowHeader = true;
 476                         Assert.IsTrue (dl.ShowHeader, "-ShowHeader");
 477                         Assert.AreEqual (sc, dl.StateBag.Count, "ViewState.Count-10");
 478
 479                         // and all this didn't affect IRepeatInfoUser
 480                         CheckIRepeatInfoUser (dl);
 481
 482                         Assert.AreEqual (0, dl.Attributes.Count, "Attributes.Count-2");
 483                 }
 484
 485                 [Test]
 486                 public void RepeatedItemCount ()
 487                 {
 488                         TestDataList dl = new TestDataList ();
 489                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 490                         dl.DataSource = GetData (10);
 491                         Assert.AreEqual (0, riu.RepeatedItemCount, "before Bind");
 492                         dl.DataBind ();
 493                         Assert.AreEqual (10, riu.RepeatedItemCount, "after Bind");
 494                 }
 495
 496                 [Test]
 497                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 498                 public void GetItemStyle_Header_Empty ()
 499                 {
 500                         TestDataList dl = new TestDataList ();
 501                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 502                         // empty list/controls
 503                         riu.GetItemStyle (ListItemType.Header, 0);
 504                 }
 505
 506                 [Test]
 507                 public void GetItemStyle_Header ()
 508                 {
 509                         TestDataList dl = new TestDataList ();
 510                         dl.DataSource = GetData (6);
 511                         dl.DataBind ();
 512                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 513                         Assert.IsNull (riu.GetItemStyle (ListItemType.Header, 0));
 514                 }
 515
 516                 [Test]
 517                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 518                 public void GetItemStyle_Separator_Empty ()
 519                 {
 520                         TestDataList dl = new TestDataList ();
 521                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 522                         // empty list/controls
 523                         riu.GetItemStyle (ListItemType.Separator, 0);
 524                 }
 525
 526                 [Test]
 527                 public void GetItemStyle_Separator ()
 528                 {
 529                         TestDataList dl = new TestDataList ();
 530                         dl.DataSource = GetData (6);
 531                         dl.DataBind ();
 532                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 533                         Assert.IsNull (riu.GetItemStyle (ListItemType.Separator, 0));
 534                 }
 535
 536                 [Test]
 537                 public void GetItemStyle_Pager_Empty ()
 538                 {
 539                         TestDataList dl = new TestDataList ();
 540                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 541                         // Pager isn't supported in DataList
 542                         Assert.IsNull (riu.GetItemStyle (ListItemType.Pager, 0), "Pager-0");
 543                 }
 544
 545                 [Test]
 546                 public void Controls ()
 547                 {
 548                         TestDataList dl = new TestDataList ();
 549                         Assert.AreEqual (0, dl.Controls.Count, "Controls-1");
 550                         Assert.AreEqual (0, dl.Items.Count, "Items-1");
 551                         dl.DataSource = GetDataSource (3);
 552                         Assert.AreEqual (0, dl.Controls.Count, "Controls-2");
 553                         Assert.AreEqual (0, dl.Items.Count, "Items-2");
 554                         dl.DataBind ();
 555                         Assert.AreEqual (0, dl.Controls.Count, "Controls-3");
 556                         Assert.AreEqual (0, dl.Items.Count, "Items-3");
 557                 }
 558
 559                 [Test]
 560                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 561                 public void EditItemIndexTooLow ()
 562                 {
 563                         TestDataList dl = new TestDataList ();
 564                         dl.EditItemIndex = -2;
 565                 }
 566
 567                 [Test]
 568                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 569                 public void SelectedIndexTooLow ()
 570                 {
 571                         TestDataList dl = new TestDataList ();
 572                         dl.SelectedIndex = -2;
 573                 }
 574
 575                 [Test]
 576                 public void SelectIndexOutOfRange ()
 577                 {
 578                         TestDataList dl = new TestDataList ();
 579                         // No exception is thrown
 580                         dl.SelectedIndex = 25;
 581                 }
 582
 583                 [Test]
 584                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 585                 public void SelectItemOutOfRange ()
 586                 {
 587                         TestDataList dl = new TestDataList ();
 588                         dl.SelectedIndex = 25;
 589                         DataListItem dli = dl.SelectedItem;
 590                 }
 591
 592                 [Test]
 593                 public void SaveViewState ()
 594                 {
 595                         TestDataList dl = new TestDataList ();
 596                         dl.TrackState ();
 597
 598                         object[] vs = (object[]) dl.SaveState ();
 599                         Assert.AreEqual (9, vs.Length, "Size");
 600                         // By default the viewstate is all null
 601                         int i = 0;
 602                         for (; i < vs.Length; i++)
 603                                 Assert.IsNull (vs [i], "Empty-" + i);
 604
 605                         i = 0;
 606                         i++;
 607                         dl.ItemStyle.HorizontalAlign = HorizontalAlign.Center;
 608                         vs = (object []) dl.SaveState ();
 609                         Assert.IsNotNull (vs[i++], "ItemStyle");
 610
 611                         dl.SelectedItemStyle.HorizontalAlign = HorizontalAlign.Center;
 612                         vs = (object []) dl.SaveState ();
 613                         Assert.IsNotNull (vs[i++], "SelectedItemStyle");
 614
 615                         dl.AlternatingItemStyle.HorizontalAlign = HorizontalAlign.Center;
 616                         vs = (object []) dl.SaveState ();
 617                         Assert.IsNotNull (vs[i++], "AlternatingItemStyle");
 618
 619                         dl.EditItemStyle.HorizontalAlign = HorizontalAlign.Center;
 620                         vs = (object []) dl.SaveState ();
 621                         Assert.IsNotNull (vs[i++], "EditItemStyle");
 622
 623                         dl.SeparatorStyle.HorizontalAlign = HorizontalAlign.Center;
 624                         vs = (object []) dl.SaveState ();
 625                         Assert.IsNotNull (vs[i++], "SeparatorStyle");
 626
 627                         dl.HeaderStyle.HorizontalAlign = HorizontalAlign.Center;
 628                         vs = (object []) dl.SaveState ();
 629                         Assert.IsNotNull (vs[i++], "HeaderStyle");
 630
 631                         dl.FooterStyle.HorizontalAlign = HorizontalAlign.Center;
 632                         vs = (object []) dl.SaveState ();
 633                         Assert.IsNotNull (vs[i++], "FooterStyle");
 634                         // GridLines was moved last
 635                         dl.GridLines = GridLines.Vertical;
 636                         vs = (object []) dl.SaveState ();
 637                         Assert.IsNotNull (vs[i++], "GridLines");
 638                 }
 639
 640                 [Test]
 641                 public void SelectedValue_SelectedIndex ()
 642                 {
 643                         // Test for bug https://bugzilla.novell.com/show_bug.cgi?id=376519
 644                         DataTable table = new DataTable();
 645                         table.Columns.Add("id");
 646                         table.Columns.Add("text");
 647
 648                         table.Rows.Add(new object[] {"id1", "Item N1"});
 649                         table.Rows.Add(new object[] {"id2", "Item N2"});
 650                         table.Rows.Add(new object[] {"id3", "Item N3"});
 651
 652                         TestDataList dl = new TestDataList ();
 653                         dl.DataKeyField = "id";
 654                         dl.DataSource = table;
 655                         dl.DataBind ();
 656
 657                         Assert.AreEqual (null, dl.SelectedValue, "A1");
 658                         dl.SelectedIndex = 0;
 659                         Assert.AreEqual ("id1", dl.SelectedValue.ToString (), "A2");
 660                 }
 661
 662                 [Test]
 663                 [ExpectedException (typeof (InvalidOperationException))]
 664                 public void SelectedValue_WithoutDataKeyField ()
 665                 {
 666                         TestDataList dl = new TestDataList ();
 667                         Assert.IsNull (dl.SelectedValue, "SelectedValue");
 668                 }
 669
 670                 [Test]
 671                 public void SelectedValue_WithUnexistingDataKeyField ()
 672                 {
 673                         TestDataList dl = new TestDataList ();
 674                         dl.DataKeyField = "mono";
 675                         Assert.IsNull (dl.SelectedValue, "SelectedValue");
 676                 }
 677                 private bool cancelCommandEvent;
 678                 private bool deleteCommandEvent;
 679                 private bool editCommandEvent;
 680                 private bool itemCommandEvent;
 681                 private bool itemCreatedEvent;
 682                 private bool itemDataBoundEvent;
 683                 private bool updateCommandEvent;
 684                 private bool selectedIndexChangedEvent;
 685
 686                 private void ResetEvents ()
 687                 {
 688                         cancelCommandEvent = false;
 689                         deleteCommandEvent = false;
 690                         editCommandEvent = false;
 691                         itemCommandEvent = false;
 692                         itemCreatedEvent = false;
 693                         itemDataBoundEvent = false;
 694                         updateCommandEvent = false;
 695                         selectedIndexChangedEvent = false;
 696                 }
 697
 698                 private void CancelCommandHandler (object sender, DataListCommandEventArgs e)
 699                 {
 700                         cancelCommandEvent = true;
 701                 }
 702
 703                 private void DeleteCommandHandler (object sender, DataListCommandEventArgs e)
 704                 {
 705                         deleteCommandEvent = true;
 706                 }
 707
 708                 private void EditCommandHandler (object sender, DataListCommandEventArgs e)
 709                 {
 710                         editCommandEvent = true;
 711                 }
 712
 713                 private void ItemCommandHandler (object sender, DataListCommandEventArgs e)
 714                 {
 715                         itemCommandEvent = true;
 716                 }
 717
 718                 private void ItemCreatedHandler (object sender, DataListItemEventArgs e)
 719                 {
 720                         itemCreatedEvent = true;
 721                 }
 722
 723                 private void ItemDataBoundHandler (object sender, DataListItemEventArgs e)
 724                 {
 725                         itemDataBoundEvent = true;
 726                 }
 727
 728                 private void SelectedIndexChangedHandler (object sender, EventArgs e)
 729                 {
 730                         selectedIndexChangedEvent = true;
 731                 }
 732
 733                 private void UpdateCommandHandler (object sender, DataListCommandEventArgs e)
 734                 {
 735                         updateCommandEvent = true;
 736                 }
 737
 738                 [Test]
 739                 public void Events ()
 740                 {
 741                         TestDataList dl = new TestDataList ();
 742                         DataListCommandEventArgs command_args = new DataListCommandEventArgs (null,
 743                                         null, new CommandEventArgs (String.Empty, String.Empty));
 744                         DataListItemEventArgs item_args = new DataListItemEventArgs (null);
 745
 746                         ResetEvents ();
 747                         dl.CancelCommand += new DataListCommandEventHandler (CancelCommandHandler);
 748                         dl.DoCancelCommand (command_args);
 749                         Assert.IsTrue (cancelCommandEvent, "cancelCommandEvent");
 750
 751                         ResetEvents ();
 752                         dl.DeleteCommand += new DataListCommandEventHandler (DeleteCommandHandler);
 753                         dl.DoDeleteCommand (command_args);
 754                         Assert.IsTrue (deleteCommandEvent, "deleteCommandEvent");
 755
 756                         ResetEvents ();
 757                         dl.EditCommand += new DataListCommandEventHandler (EditCommandHandler);
 758                         dl.DoEditCommand (command_args);
 759                         Assert.IsTrue (editCommandEvent, "editCommandEvent");
 760
 761                         ResetEvents ();
 762                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 763                         dl.DoItemCommand (command_args);
 764                         Assert.IsTrue (itemCommandEvent, "itemCommandEvent");
 765
 766                         ResetEvents ();
 767                         dl.ItemCreated += new DataListItemEventHandler (ItemCreatedHandler);
 768                         dl.DoItemCreated (item_args);
 769                         Assert.IsTrue (itemCreatedEvent, "itemCreatedEvent");
 770
 771                         ResetEvents ();
 772                         dl.ItemDataBound += new DataListItemEventHandler (ItemDataBoundHandler);
 773                         dl.DoItemDataBound (item_args);
 774                         Assert.IsTrue (itemDataBoundEvent, "itemDataBoundEvent");
 775
 776                         ResetEvents ();
 777                         dl.UpdateCommand += new DataListCommandEventHandler (UpdateCommandHandler);
 778                         dl.DoUpdateCommand (command_args);
 779                         Assert.IsTrue (updateCommandEvent, "updateCommandEvent");
 780
 781                         ResetEvents ();
 782                         dl.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 783                         dl.DoSelectedIndexChanged (new EventArgs ());
 784                         Assert.IsTrue (selectedIndexChangedEvent, "selectedIndexChangedEvent");
 785                 }
 786
 787                 [Test]
 788                 public void BubbleEvent ()
 789                 {
 790                         TestDataList dl = new TestDataList ();
 791                         DataListCommandEventArgs command_args;
 792
 793                         //
 794                         // Cancel
 795                         //
 796                         ResetEvents ();
 797                         command_args = new DataListCommandEventArgs (null,
 798                                         null, new CommandEventArgs ("Cancel", String.Empty));
 799                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 800                         dl.CancelCommand += new DataListCommandEventHandler (CancelCommandHandler);
 801                         dl.DoBubbleEvent (this, command_args);
 802                         Assert.IsTrue (cancelCommandEvent, "cancelCommandEvent-1");
 803                         Assert.IsTrue (itemCommandEvent, "#00");
 804
 805                         ResetEvents ();
 806                         command_args = new DataListCommandEventArgs (null,
 807                                         null, new CommandEventArgs ("cancel", String.Empty));
 808                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 809                         dl.CancelCommand += new DataListCommandEventHandler (CancelCommandHandler);
 810                         dl.DoBubbleEvent (this, command_args);
 811                         Assert.IsTrue (cancelCommandEvent, "cancelCommandEvent-2");
 812                         Assert.IsTrue (itemCommandEvent, "#00");
 813
 814                         ResetEvents ();
 815                         command_args = new DataListCommandEventArgs (null,
 816                                         null, new CommandEventArgs ("CANCEL", String.Empty));
 817                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 818                         dl.CancelCommand += new DataListCommandEventHandler (CancelCommandHandler);
 819                         dl.DoBubbleEvent (this, command_args);
 820                         Assert.IsTrue (cancelCommandEvent, "cancelCommandEvent-3");
 821                         Assert.IsTrue (itemCommandEvent, "#00");
 822
 823                         //
 824                         // Delete
 825                         //
 826                         ResetEvents ();
 827                         command_args = new DataListCommandEventArgs (null,
 828                                         null, new CommandEventArgs ("Delete", String.Empty));
 829                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 830                         dl.DeleteCommand += new DataListCommandEventHandler (DeleteCommandHandler);
 831                         dl.DoBubbleEvent (this, command_args);
 832                         Assert.IsTrue (deleteCommandEvent, "deleteCommandEvent-1");
 833                         Assert.IsTrue (itemCommandEvent, "#00");
 834
 835                         ResetEvents ();
 836                         command_args = new DataListCommandEventArgs (null,
 837                                         null, new CommandEventArgs ("delete", String.Empty));
 838                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 839                         dl.DeleteCommand += new DataListCommandEventHandler (DeleteCommandHandler);
 840                         dl.DoBubbleEvent (this, command_args);
 841                         Assert.IsTrue (deleteCommandEvent, "deleteCommandEvent-2");
 842                         Assert.IsTrue (itemCommandEvent, "#00");
 843
 844                         ResetEvents ();
 845                         command_args = new DataListCommandEventArgs (null,
 846                                         null, new CommandEventArgs ("DELETE", String.Empty));
 847                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 848                         dl.DeleteCommand += new DataListCommandEventHandler (DeleteCommandHandler);
 849                         dl.DoBubbleEvent (this, command_args);
 850                         Assert.IsTrue (deleteCommandEvent, "deleteCommandEvent-3");
 851                         Assert.IsTrue (itemCommandEvent, "#00");
 852
 853                         //
 854                         // Edit
 855                         //
 856                         ResetEvents ();
 857                         command_args = new DataListCommandEventArgs (null,
 858                                         null, new CommandEventArgs ("Edit", String.Empty));
 859                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 860                         dl.EditCommand += new DataListCommandEventHandler (EditCommandHandler);
 861                         dl.DoBubbleEvent (this, command_args);
 862                         Assert.IsTrue (editCommandEvent, "editCommandEvent-1");
 863                         Assert.IsTrue (itemCommandEvent, "#00");
 864
 865                         ResetEvents ();
 866                         command_args = new DataListCommandEventArgs (null,
 867                                         null, new CommandEventArgs ("edit", String.Empty));
 868                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 869                         dl.EditCommand += new DataListCommandEventHandler (EditCommandHandler);
 870                         dl.DoBubbleEvent (this, command_args);
 871                         Assert.IsTrue (editCommandEvent, "editCommandEvent-2");
 872                         Assert.IsTrue (itemCommandEvent, "#00");
 873
 874                         ResetEvents ();
 875                         command_args = new DataListCommandEventArgs (null,
 876                                         null, new CommandEventArgs ("EDIT", String.Empty));
 877                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 878                         dl.EditCommand += new DataListCommandEventHandler (EditCommandHandler);
 879                         dl.DoBubbleEvent (this, command_args);
 880                         Assert.IsTrue (editCommandEvent, "editCommandEvent-3");
 881                         Assert.IsTrue (itemCommandEvent, "#00");
 882
 883                         //
 884                         // Item
 885                         //
 886                         ResetEvents ();
 887                         command_args = new DataListCommandEventArgs (null,
 888                                         null, new CommandEventArgs ("Item", String.Empty));
 889                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 890                         dl.DoBubbleEvent (this, command_args);
 891                         Assert.IsTrue (itemCommandEvent, "itemCommandEvent-1");
 892
 893                         ResetEvents ();
 894                         command_args = new DataListCommandEventArgs (null,
 895                                         null, new CommandEventArgs ("item", String.Empty));
 896                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 897                         dl.DoBubbleEvent (this, command_args);
 898                         Assert.IsTrue (itemCommandEvent, "itemCommandEvent-2");
 899
 900                         ResetEvents ();
 901                         command_args = new DataListCommandEventArgs (null,
 902                                         null, new CommandEventArgs ("ITEM", String.Empty));
 903                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 904                         dl.DoBubbleEvent (this, command_args);
 905                         Assert.IsTrue (itemCommandEvent, "itemCommandEvent-3");
 906
 907                         //
 908                         // Update
 909                         //
 910                         ResetEvents ();
 911                         command_args = new DataListCommandEventArgs (null,
 912                                         null, new CommandEventArgs ("Update", String.Empty));
 913                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 914                         dl.UpdateCommand += new DataListCommandEventHandler (UpdateCommandHandler);
 915                         dl.DoBubbleEvent (this, command_args);
 916                         Assert.IsTrue (updateCommandEvent, "updateCommandEvent-1");
 917                         Assert.IsTrue (itemCommandEvent, "#00");
 918
 919                         ResetEvents ();
 920                         command_args = new DataListCommandEventArgs (null,
 921                                         null, new CommandEventArgs ("update", String.Empty));
 922                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 923                         dl.UpdateCommand += new DataListCommandEventHandler (UpdateCommandHandler);
 924                         dl.DoBubbleEvent (this, command_args);
 925                         Assert.IsTrue (updateCommandEvent, "updateCommandEvent-2");
 926                         Assert.IsTrue (itemCommandEvent, "#00");
 927
 928                         ResetEvents ();
 929                         command_args = new DataListCommandEventArgs (null,
 930                                         null, new CommandEventArgs ("UPDATE", String.Empty));
 931                         dl.UpdateCommand += new DataListCommandEventHandler (UpdateCommandHandler);
 932                         dl.DoBubbleEvent (this, command_args);
 933                         Assert.IsTrue (updateCommandEvent, "updateCommandEvent-3");
 934                         Assert.IsTrue (itemCommandEvent, "#00");
 935
 936                         //
 937                         // Select
 938                         //
 939                         DataListItem item = new DataListItem (0, ListItemType.Item);
 940
 941                         ResetEvents ();
 942                         command_args = new DataListCommandEventArgs (item, null,
 943                                         new CommandEventArgs ("Select", String.Empty));
 944                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 945                         dl.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 946                         dl.DoBubbleEvent (this, command_args);
 947                         Assert.IsTrue (selectedIndexChangedEvent, "selectedIndexChangedEvent-1");
 948                         Assert.IsTrue (itemCommandEvent, "#00");
 949
 950                         ResetEvents ();
 951                         command_args = new DataListCommandEventArgs (item, null,
 952                                         new CommandEventArgs ("select", String.Empty));
 953                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 954                         dl.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 955                         dl.DoBubbleEvent (this, command_args);
 956                         Assert.IsTrue (selectedIndexChangedEvent, "selectedIndexChangedEvent-2");
 957                         Assert.IsTrue (itemCommandEvent, "#00");
 958
 959                         ResetEvents ();
 960                         command_args = new DataListCommandEventArgs (item, null,
 961                                         new CommandEventArgs ("SELECT", String.Empty));
 962                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 963                         dl.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 964                         dl.DoBubbleEvent (this, command_args);
 965                         Assert.IsTrue (selectedIndexChangedEvent, "selectedIndexChangedEvent-3");
 966                         Assert.IsTrue (itemCommandEvent, "#00");
 967
 968                         //
 969                         // any comand
 970                         //
 971                         ResetEvents ();
 972                         command_args = new DataListCommandEventArgs (item, null,
 973                                         new CommandEventArgs ("AnyComand", String.Empty));
 974                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 975                         bool res = dl.DoBubbleEvent (this, command_args);
 976                         Assert.IsTrue (res, "any comand#00");
 977                         Assert.IsTrue (itemCommandEvent, "any comand#01");
 978                 }
 979
 980                 [Test]
 981                 public void NControls1 ()
 982                 {
 983                         TestDataList dl = new TestDataList ();
 984                         dl.DataSource = GetData (5);
 985                         dl.CreateCH ();
 986                         Assert.AreEqual (5, dl.Controls.Count, "#01");
 987                 }
 988
 989                 [Test]
 990                 public void NControls2 ()
 991                 {
 992                         TestDataList dl = new TestDataList ();
 993                         dl.ShowHeader = true;
 994                         dl.ShowFooter = true;
 995                         dl.DataSource = GetData (5);
 996                         dl.CreateCH ();
 997                         Assert.AreEqual (5, dl.Controls.Count, "#01");
 998                 }
 999
1000                 class Templ : ITemplate {
1001                         public void InstantiateIn (Control ctrl)
1002                         {
1003                                 ctrl.Controls.Add (new LiteralControl ("Lalalaa"));
1004                         }
1005                 }
1006
1007                 //Some real templates for testing if proper Template was used
1008                 class ItemTemplate : ITemplate {
1009                         public void InstantiateIn (Control container)
1010                         {
1011                                 Label lbl = new Label();
1012                                 lbl.ID = "itemtmpl";
1013                                 container.Controls.Add(lbl);
1014                         }
1015                 }
1016
1017                 class EditItemTemplate : ITemplate {
1018                         public void InstantiateIn (Control container)
1019                         {
1020                                 TextBox tb = new TextBox();
1021                                 tb.ID = "eitemtmpl";
1022                                 container.Controls.Add(tb);
1023                         }
1024                 }
1025
1026                 [Test]
1027                 public void ProperTemplateSelectedIndexEqualsEditIndex ()
1028                 {
1029                         TestDataList dl = new TestDataList();
1030                         dl.ItemTemplate = new ItemTemplate();
1031                         dl.AlternatingItemTemplate = new ItemTemplate();
1032                         dl.SelectedItemTemplate = new ItemTemplate();
1033                         dl.EditItemTemplate = new EditItemTemplate();
1034                         dl.DataSource = GetData(5);
1035                         dl.SelectedIndex = 0;
1036                         dl.EditItemIndex = 0;
1037                         dl.DataBind();
1038                         object canIGetMyEditItem = dl.Items[dl.EditItemIndex].FindControl("eitemtmpl");
1039                         Assert.IsTrue(canIGetMyEditItem != null, "ProperTemplateSelectedIndexEqualsEditIndex");
1040                 }
1041
1042                 [Test]
1043                 public void NControls3 ()
1044                 {
1045                         TestDataList dl = new TestDataList ();
1046                         dl.ShowHeader = true;
1047                         dl.HeaderTemplate = new Templ ();
1048                         dl.ShowFooter = true;
1049                         dl.FooterTemplate = new Templ ();
1050                         dl.DataSource = GetData (5);
1051                         dl.CreateCH ();
1052                         Assert.AreEqual (7, dl.Controls.Count, "#01");
1053                 }
1054
1055                 [Test]
1056                 public void NControls4 ()
1057                 {
1058                         TestDataList dl = new TestDataList ();
1059                         dl.SeparatorTemplate = new Templ ();
1060                         dl.DataSource = GetData (5);
1061                         dl.CreateCH ();
1062                         Assert.AreEqual (10, dl.Controls.Count, "#01");
1063                 }
1064
1065                 [Test]
1066                 public void NControls5 ()
1067                 {
1068                         TestDataList dl = new TestDataList ();
1069                         dl.ShowHeader = true;
1070                         dl.HeaderTemplate = new Templ ();
1071                         dl.SeparatorTemplate = new Templ ();
1072                         dl.DataSource = GetData (5);
1073                         dl.CreateCH ();
1074                         Assert.AreEqual (11, dl.Controls.Count, "#01");
1075                 }
1076
1077                 [Test]
1078                 public void DataSourceID ()
1079                 {
1080                         Page p = new Page();
1081                         ObjectDataSource ds = new ObjectDataSource();
1082                         ds.ID = "ObjectDataSource1";
1083                         ds.TypeName = "System.Guid";
1084                         ds.SelectMethod = "ToByteArray";
1085                         TestDataList dl = new TestDataList ();
1086                         dl.Page = p;
1087                         ds.Page = p;
1088                         p.Controls.Add(dl);
1089                         p.Controls.Add(ds);
1090                         dl.DataSourceID = "ObjectDataSource1";
1091                         dl.CreateCH ();
1092                         Assert.AreEqual (16, dl.Controls.Count, "#01");
1093                 }
1094
1095                 [Test]
1096                 public void NControls6 ()
1097                 {
1098                         TestDataList dl = new TestDataList ();
1099                         dl.ShowHeader = true;
1100                         dl.HeaderTemplate = new Templ ();
1101                         dl.ShowFooter = true;
1102                         dl.FooterTemplate = new Templ ();
1103                         dl.SeparatorTemplate = new Templ ();
1104                         dl.DataSource = GetData (6);
1105                         dl.CreateCH ();
1106                         Assert.AreEqual (14, dl.Controls.Count, "#01");
1107
1108                         Assert.AreEqual (ListItemType.Header, ((DataListItem) dl.Controls [0]).ItemType, "#02");
1109                         for (int i = 0; i < 3; i++) {
1110                                 int b = (i * 4) + 1;
1111                                 DataListItem one = (DataListItem) dl.Controls [b];
1112                                 DataListItem two = (DataListItem) dl.Controls [b + 1];
1113                                 DataListItem three = (DataListItem) dl.Controls [b + 2];
1114                                 DataListItem four = (DataListItem) dl.Controls [b + 3];
1115                                 Assert.AreEqual (ListItemType.Item, one.ItemType, String.Format ("#02-{0}", b));
1116                                 Assert.AreEqual (ListItemType.Separator, two.ItemType, String.Format ("#02-{0}", b + 1));
1117                                 Assert.AreEqual (ListItemType.AlternatingItem, three.ItemType, String.Format ("#02-{0}", b + 2));
1118                                 Assert.AreEqual (ListItemType.Separator, four.ItemType, String.Format ("#02-{0}", b + 3));
1119
1120                         }
1121                         Assert.AreEqual (ListItemType.Footer, ((DataListItem) dl.Controls [13]).ItemType, "#03");
1122                 }
1123
1124                 [Test]
1125                 public void RepeatInfo1 ()
1126                 {
1127                         TestDataList dl = new TestDataList ();
1128                         dl.ShowHeader = true;
1129                         dl.HeaderTemplate = new Templ ();
1130                         dl.ShowFooter = true;
1131                         dl.FooterTemplate = new Templ ();
1132                         dl.SeparatorTemplate = new Templ ();
1133                         dl.DataSource = GetData (6);
1134                         dl.CreateCH ();
1135                         IRepeatInfoUser repeater = (IRepeatInfoUser) dl;
1136                         Assert.AreEqual (true, repeater.HasHeader, "#01");
1137                         Assert.AreEqual (true, repeater.HasFooter, "#02");
1138                         Assert.AreEqual (true, repeater.HasSeparators, "#03");
1139                         Assert.AreEqual (6, repeater.RepeatedItemCount, "#04");
1140                 }
1141
1142                 [Test]
1143                 public void RepeatInfo2 ()
1144                 {
1145                         TestDataList dl = new TestDataList ();
1146                         dl.ShowHeader = true;
1147                         dl.HeaderTemplate = new Templ ();
1148                         dl.ShowFooter = true;
1149                         dl.FooterTemplate = new Templ ();
1150                         dl.SeparatorTemplate = new Templ ();
1151                         dl.DataSource = GetData (6);
1152                         dl.CreateCH ();
1153                         IRepeatInfoUser repeater = (IRepeatInfoUser) dl;
1154                         Style style = repeater.GetItemStyle (ListItemType.Pager, -1);
1155                         Assert.IsNull (style, "#01");
1156                         style = repeater.GetItemStyle (ListItemType.Pager, 0);
1157                         Assert.IsNull (style, "#02");
1158                         style = repeater.GetItemStyle (ListItemType.Pager, 15);
1159                         Assert.IsNull (style, "#03");
1160                 }
1161
1162                 [Test]
1163                 public void RepeatInfo3 ()
1164                 {
1165                         TestDataList dl = new TestDataList ();
1166                         dl.ShowHeader = true;
1167                         dl.HeaderTemplate = new Templ ();
1168                         dl.ShowFooter = true;
1169                         dl.FooterTemplate = new Templ ();
1170                         dl.SeparatorTemplate = new Templ ();
1171                         dl.DataSource = GetData (6);
1172                         dl.CreateCH ();
1173                         IRepeatInfoUser repeater = (IRepeatInfoUser) dl;
1174                         Style style = repeater.GetItemStyle (ListItemType.Header, -1);
1175                         DataListItem header = (DataListItem) dl.Controls [0];
1176                         Assert.IsNull (style, "#01");
1177
1178                         style = repeater.GetItemStyle (ListItemType.Footer, -1);
1179                         DataListItem footer = (DataListItem) dl.Controls [13];
1180                         Assert.IsNull (style, "#02");
1181                         for (int i = 0; i < 6; i++) {
1182                                 style = repeater.GetItemStyle (ListItemType.Item, i);
1183                                 Assert.IsNull (style, String.Format ("#02-{0}", i));
1184                         }
1185                 }
1186
1187                 [Test]
1188                 public void RepeatInfo4 ()
1189                 {
1190                         TestDataList dl = new TestDataList ();
1191                         dl.DataSource = GetData (6);
1192                         dl.ItemStyle.ForeColor = Color.Blue;
1193                         dl.CreateCH ();
1194                         dl.PrepareCH (); // removing this causes all the GetItemStyle calls to return null
1195                         IRepeatInfoUser repeater = (IRepeatInfoUser) dl;
1196                         for (int i = 0; i < 6; i++) {
1197                                 Style style = repeater.GetItemStyle (ListItemType.Item, i);
1198                                 DataListItem item = (DataListItem) dl.Controls [i];
1199                                 Assert.AreEqual (style, item.ControlStyle, String.Format ("#01-{0}", i));
1200                         }
1201                 }
1202
1203                 [Test]
1204                 public void DataBindTwice () {
1205                         DataList dl = new DataList ();
1206
1207                         dl.DataSource = new object [] { "1", "2", "3" };
1208                         dl.DataBind ();
1209
1210                         Assert.AreEqual (3, dl.Items.Count, "first binding");
1211
1212                         dl.DataSource = new object [] { "a", "b", "c" };
1213                         dl.DataBind ();
1214
1215                         Assert.AreEqual (3, dl.Items.Count, "second binding");
1216                 }
1217         }
1218 }
1219