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