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                 [Test]
 326                 public void RepeatLayout_Lists ()
 327                 {
 328                         TestDataList dl = new TestDataList ();
 329
 330                         AssertExtensions.Throws<ArgumentOutOfRangeException> (() => {
 331                                 dl.RepeatLayout = RepeatLayout.OrderedList;
 332                         }, "#A1");
 333
 334                         AssertExtensions.Throws<ArgumentOutOfRangeException> (() => {
 335                                 dl.RepeatLayout = RepeatLayout.UnorderedList;
 336                         }, "#A2");
 337                 }
 338                 [Test]
 339                 public void CleanProperties ()
 340                 {
 341                         TestDataList dl = new TestDataList ();
 342                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 343                         Assert.AreEqual (0, dl.Attributes.Count, "Attributes.Count-1");
 344                         Assert.AreEqual (0, dl.StateBag.Count, "ViewState.Count-1");
 345
 346                         dl.CellPadding = 0;
 347                         Assert.AreEqual (0, dl.CellPadding, "CellPadding");
 348                         dl.CellSpacing = 1;
 349                         Assert.AreEqual (1, dl.CellSpacing, "CellSpacing");
 350                         dl.GridLines = GridLines.Vertical;
 351                         Assert.AreEqual (GridLines.Vertical, dl.GridLines, "GridLines");
 352                         dl.HorizontalAlign = HorizontalAlign.Center;
 353                         Assert.AreEqual (HorizontalAlign.Center, dl.HorizontalAlign, "HorizontalAlign");
 354                         int sc = 0;
 355                         // so the TableStyle isn't kept directly in the ViewState
 356                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2");
 357
 358                         // now for the DataList properties
 359                         // touching all styles
 360                         dl.AlternatingItemStyle.BackColor = Color.AliceBlue;
 361                         Assert.IsFalse (dl.AlternatingItemStyle.BackColor.IsEmpty, "AlternatingItemStyle");
 362                         dl.EditItemStyle.BackColor = Color.AntiqueWhite;
 363                         Assert.IsFalse (dl.EditItemStyle.BackColor.IsEmpty, "EditItemStyle");
 364                         dl.FooterStyle.BackColor = Color.Aqua;
 365                         Assert.IsFalse (dl.FooterStyle.BackColor.IsEmpty, "FooterStyle");
 366                         dl.HeaderStyle.BackColor = Color.Aquamarine;
 367                         Assert.IsFalse (dl.HeaderStyle.BackColor.IsEmpty, "HeaderStyle");
 368                         dl.ItemStyle.BackColor = Color.Azure;
 369                         Assert.IsFalse (dl.ItemStyle.BackColor.IsEmpty, "ItemStyle");
 370                         dl.SelectedItemStyle.BackColor = Color.Beige;
 371                         Assert.IsFalse (dl.SelectedItemStyle.BackColor.IsEmpty, "SelectedItemStyle");
 372                         dl.SeparatorStyle.BackColor = Color.Bisque;
 373                         Assert.IsFalse (dl.SeparatorStyle.BackColor.IsEmpty, "SeparatorStyle");
 374                         dl.AlternatingItemTemplate = new TestTemplate ();
 375                         Assert.IsNotNull (dl.AlternatingItemTemplate, "AlternatingItemTemplate");
 376                         dl.EditItemTemplate = new TestTemplate ();
 377                         Assert.IsNotNull (dl.EditItemTemplate, "EditItemTemplate");
 378                         dl.FooterTemplate = new TestTemplate ();
 379                         Assert.IsTrue (riu.HasFooter, "HasFooter");
 380                         Assert.IsNotNull (dl.FooterTemplate, "FooterTemplate");
 381                         dl.HeaderTemplate = new TestTemplate ();
 382                         Assert.IsTrue (riu.HasHeader, "HasHeader");
 383                         Assert.IsNotNull (dl.HeaderTemplate, "HeaderTemplate");
 384                         dl.ItemTemplate = new TestTemplate ();
 385                         Assert.IsNotNull (dl.ItemTemplate, "ItemTemplate");
 386                         dl.SelectedItemTemplate = new TestTemplate ();
 387                         Assert.IsNotNull (dl.SelectedItemTemplate, "SelectedItemTemplate");
 388                         dl.SeparatorTemplate = new TestTemplate ();
 389                         Assert.IsTrue (riu.HasSeparators, "HasSeparators");
 390                         Assert.IsNotNull (dl.SeparatorTemplate, "SeparatorTemplate");
 391                         dl.EditItemIndex = 0;
 392                         Assert.AreEqual (0, dl.EditItemIndex, "EditItemIndex");
 393                         dl.EditItemIndex = -1;
 394                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2b");
 395                         dl.SelectedIndex = 0;
 396                         Assert.AreEqual (0, dl.SelectedIndex, "SelectedIndex");
 397                         dl.SelectedIndex = -1;
 398                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-2c");
 399                         dl.ExtractTemplateRows = true;
 400                         Assert.IsTrue (dl.ExtractTemplateRows, "ExtractTemplateRows");
 401                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-3");
 402                         dl.RepeatColumns = 1;
 403                         Assert.AreEqual (1, dl.RepeatColumns, "RepeatColumns");
 404                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-4");
 405                         dl.RepeatDirection = RepeatDirection.Horizontal;
 406                         Assert.AreEqual (RepeatDirection.Horizontal, dl.RepeatDirection, "RepeatDirection");
 407                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-5");
 408                         dl.RepeatLayout = RepeatLayout.Flow;
 409                         Assert.AreEqual (RepeatLayout.Flow, dl.RepeatLayout, "RepeatLayout");
 410                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-6");
 411                         dl.ShowFooter = false;
 412                         Assert.IsFalse (riu.HasFooter, "HasFooter(lost)");
 413                         Assert.IsFalse (dl.ShowFooter, "ShowFooter");
 414                         Assert.AreEqual (sc++, dl.StateBag.Count, "ViewState.Count-7");
 415                         dl.ShowHeader = false;
 416                         Assert.IsFalse (riu.HasHeader, "HasHeader(lost)");
 417                         Assert.IsFalse (dl.ShowHeader, "ShowHeader");
 418                         Assert.AreEqual (sc, dl.StateBag.Count, "ViewState.Count-8");
 419
 420                         // reverting back changes to default...
 421
 422                         dl.CellPadding = -1;
 423                         Assert.AreEqual (-1, dl.CellPadding, "-CellPadding");
 424                         dl.CellSpacing = 0;
 425                         Assert.AreEqual (0, dl.CellSpacing, "-CellSpacing");
 426                         dl.GridLines = GridLines.None;
 427                         Assert.AreEqual (GridLines.None, dl.GridLines, "-GridLines");
 428                         dl.HorizontalAlign = HorizontalAlign.NotSet;
 429                         Assert.AreEqual (HorizontalAlign.NotSet, dl.HorizontalAlign, "-HorizontalAlign");
 430                         Assert.AreEqual (sc, dl.StateBag.Count, "ViewState.Count-9");
 431                         dl.AlternatingItemStyle.Reset ();
 432                         Assert.IsTrue (dl.AlternatingItemStyle.BackColor.IsEmpty, "-AlternatingItemStyle");
 433                         dl.EditItemStyle.Reset ();
 434                         Assert.IsTrue (dl.EditItemStyle.BackColor.IsEmpty, "-EditItemStyle");
 435                         dl.FooterStyle.Reset ();
 436                         Assert.IsTrue (dl.FooterStyle.BackColor.IsEmpty, "-FooterStyle");
 437                         dl.HeaderStyle.Reset ();
 438                         Assert.IsTrue (dl.HeaderStyle.BackColor.IsEmpty, "-HeaderStyle");
 439                         dl.ItemStyle.Reset ();
 440                         Assert.IsTrue (dl.ItemStyle.BackColor.IsEmpty, "-ItemStyle");
 441                         dl.SelectedItemStyle.Reset ();
 442                         Assert.IsTrue (dl.SelectedItemStyle.BackColor.IsEmpty, "-SelectedItemStyle");
 443                         dl.SeparatorStyle.Reset ();
 444                         Assert.IsTrue (dl.SeparatorStyle.BackColor.IsEmpty, "-SeparatorStyle");
 445                         dl.AlternatingItemTemplate = null;
 446                         Assert.IsNull (dl.AlternatingItemTemplate, "-AlternatingItemTemplate");
 447                         dl.EditItemTemplate = null;
 448                         Assert.IsNull (dl.EditItemTemplate, "-EditItemTemplate");
 449                         dl.FooterTemplate = null;
 450                         Assert.IsNull (dl.FooterTemplate, "-FooterTemplate");
 451                         dl.HeaderTemplate = null;
 452                         Assert.IsNull (dl.HeaderTemplate, "-HeaderTemplate");
 453                         dl.ItemTemplate = null;
 454                         Assert.IsNull (dl.ItemTemplate, "-ItemTemplate");
 455                         dl.SelectedItemTemplate = null;
 456                         Assert.IsNull (dl.SelectedItemTemplate, "-SelectedItemTemplate");
 457                         dl.SeparatorTemplate = null;
 458                         Assert.IsNull (dl.SeparatorTemplate, "-SeparatorTemplate");
 459                         dl.EditItemIndex = -1;
 460                         Assert.AreEqual (-1, dl.EditItemIndex, "-EditItemIndex");
 461                         dl.SelectedIndex = -1;
 462                         Assert.AreEqual (-1, dl.SelectedIndex, "-SelectedIndex");
 463                         dl.ExtractTemplateRows = false;
 464                         Assert.IsFalse (dl.ExtractTemplateRows, "-ExtractTemplateRows");
 465                         dl.RepeatColumns = 0;
 466                         Assert.AreEqual (0, dl.RepeatColumns, "-RepeatColumns");
 467                         dl.RepeatDirection = RepeatDirection.Vertical;
 468                         Assert.AreEqual (RepeatDirection.Vertical, dl.RepeatDirection, "-RepeatDirection");
 469                         dl.RepeatLayout = RepeatLayout.Table;
 470                         Assert.AreEqual (RepeatLayout.Table, dl.RepeatLayout, "-RepeatLayout");
 471                         dl.ShowFooter = true;
 472                         Assert.IsTrue (dl.ShowFooter, "-ShowFooter");
 473                         dl.ShowHeader = true;
 474                         Assert.IsTrue (dl.ShowHeader, "-ShowHeader");
 475                         Assert.AreEqual (sc, dl.StateBag.Count, "ViewState.Count-10");
 476
 477                         // and all this didn't affect IRepeatInfoUser
 478                         CheckIRepeatInfoUser (dl);
 479
 480                         Assert.AreEqual (0, dl.Attributes.Count, "Attributes.Count-2");
 481                 }
 482
 483                 [Test]
 484                 public void RepeatedItemCount ()
 485                 {
 486                         TestDataList dl = new TestDataList ();
 487                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 488                         dl.DataSource = GetData (10);
 489                         Assert.AreEqual (0, riu.RepeatedItemCount, "before Bind");
 490                         dl.DataBind ();
 491                         Assert.AreEqual (10, riu.RepeatedItemCount, "after Bind");
 492                 }
 493
 494                 [Test]
 495                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 496                 public void GetItemStyle_Header_Empty ()
 497                 {
 498                         TestDataList dl = new TestDataList ();
 499                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 500                         // empty list/controls
 501                         riu.GetItemStyle (ListItemType.Header, 0);
 502                 }
 503
 504                 [Test]
 505                 public void GetItemStyle_Header ()
 506                 {
 507                         TestDataList dl = new TestDataList ();
 508                         dl.DataSource = GetData (6);
 509                         dl.DataBind ();
 510                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 511                         Assert.IsNull (riu.GetItemStyle (ListItemType.Header, 0));
 512                 }
 513
 514                 [Test]
 515                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 516                 public void GetItemStyle_Separator_Empty ()
 517                 {
 518                         TestDataList dl = new TestDataList ();
 519                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 520                         // empty list/controls
 521                         riu.GetItemStyle (ListItemType.Separator, 0);
 522                 }
 523
 524                 [Test]
 525                 public void GetItemStyle_Separator ()
 526                 {
 527                         TestDataList dl = new TestDataList ();
 528                         dl.DataSource = GetData (6);
 529                         dl.DataBind ();
 530                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 531                         Assert.IsNull (riu.GetItemStyle (ListItemType.Separator, 0));
 532                 }
 533
 534                 [Test]
 535                 public void GetItemStyle_Pager_Empty ()
 536                 {
 537                         TestDataList dl = new TestDataList ();
 538                         IRepeatInfoUser riu = (dl as IRepeatInfoUser);
 539                         // Pager isn't supported in DataList
 540                         Assert.IsNull (riu.GetItemStyle (ListItemType.Pager, 0), "Pager-0");
 541                 }
 542
 543                 [Test]
 544                 public void Controls ()
 545                 {
 546                         TestDataList dl = new TestDataList ();
 547                         Assert.AreEqual (0, dl.Controls.Count, "Controls-1");
 548                         Assert.AreEqual (0, dl.Items.Count, "Items-1");
 549                         dl.DataSource = GetDataSource (3);
 550                         Assert.AreEqual (0, dl.Controls.Count, "Controls-2");
 551                         Assert.AreEqual (0, dl.Items.Count, "Items-2");
 552                         dl.DataBind ();
 553                         Assert.AreEqual (0, dl.Controls.Count, "Controls-3");
 554                         Assert.AreEqual (0, dl.Items.Count, "Items-3");
 555                 }
 556
 557                 [Test]
 558                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 559                 public void EditItemIndexTooLow ()
 560                 {
 561                         TestDataList dl = new TestDataList ();
 562                         dl.EditItemIndex = -2;
 563                 }
 564
 565                 [Test]
 566                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 567                 public void SelectedIndexTooLow ()
 568                 {
 569                         TestDataList dl = new TestDataList ();
 570                         dl.SelectedIndex = -2;
 571                 }
 572
 573                 [Test]
 574                 public void SelectIndexOutOfRange ()
 575                 {
 576                         TestDataList dl = new TestDataList ();
 577                         // No exception is thrown
 578                         dl.SelectedIndex = 25;
 579                 }
 580
 581                 [Test]
 582                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 583                 public void SelectItemOutOfRange ()
 584                 {
 585                         TestDataList dl = new TestDataList ();
 586                         dl.SelectedIndex = 25;
 587                         DataListItem dli = dl.SelectedItem;
 588                 }
 589
 590                 [Test]
 591                 public void SaveViewState ()
 592                 {
 593                         TestDataList dl = new TestDataList ();
 594                         dl.TrackState ();
 595
 596                         object[] vs = (object[]) dl.SaveState ();
 597                         Assert.AreEqual (9, vs.Length, "Size");
 598                         // By default the viewstate is all null
 599                         int i = 0;
 600                         for (; i < vs.Length; i++)
 601                                 Assert.IsNull (vs [i], "Empty-" + i);
 602
 603                         i = 0;
 604                         i++;
 605                         dl.ItemStyle.HorizontalAlign = HorizontalAlign.Center;
 606                         vs = (object []) dl.SaveState ();
 607                         Assert.IsNotNull (vs[i++], "ItemStyle");
 608
 609                         dl.SelectedItemStyle.HorizontalAlign = HorizontalAlign.Center;
 610                         vs = (object []) dl.SaveState ();
 611                         Assert.IsNotNull (vs[i++], "SelectedItemStyle");
 612
 613                         dl.AlternatingItemStyle.HorizontalAlign = HorizontalAlign.Center;
 614                         vs = (object []) dl.SaveState ();
 615                         Assert.IsNotNull (vs[i++], "AlternatingItemStyle");
 616
 617                         dl.EditItemStyle.HorizontalAlign = HorizontalAlign.Center;
 618                         vs = (object []) dl.SaveState ();
 619                         Assert.IsNotNull (vs[i++], "EditItemStyle");
 620
 621                         dl.SeparatorStyle.HorizontalAlign = HorizontalAlign.Center;
 622                         vs = (object []) dl.SaveState ();
 623                         Assert.IsNotNull (vs[i++], "SeparatorStyle");
 624
 625                         dl.HeaderStyle.HorizontalAlign = HorizontalAlign.Center;
 626                         vs = (object []) dl.SaveState ();
 627                         Assert.IsNotNull (vs[i++], "HeaderStyle");
 628
 629                         dl.FooterStyle.HorizontalAlign = HorizontalAlign.Center;
 630                         vs = (object []) dl.SaveState ();
 631                         Assert.IsNotNull (vs[i++], "FooterStyle");
 632                         // GridLines was moved last
 633                         dl.GridLines = GridLines.Vertical;
 634                         vs = (object []) dl.SaveState ();
 635                         Assert.IsNotNull (vs[i++], "GridLines");
 636                 }
 637
 638                 [Test]
 639                 public void SelectedValue_SelectedIndex ()
 640                 {
 641                         // Test for bug https://bugzilla.novell.com/show_bug.cgi?id=376519
 642                         DataTable table = new DataTable();
 643                         table.Columns.Add("id");
 644                         table.Columns.Add("text");
 645
 646                         table.Rows.Add(new object[] {"id1", "Item N1"});
 647                         table.Rows.Add(new object[] {"id2", "Item N2"});
 648                         table.Rows.Add(new object[] {"id3", "Item N3"});
 649
 650                         TestDataList dl = new TestDataList ();
 651                         dl.DataKeyField = "id";
 652                         dl.DataSource = table;
 653                         dl.DataBind ();
 654
 655                         Assert.AreEqual (null, dl.SelectedValue, "A1");
 656                         dl.SelectedIndex = 0;
 657                         Assert.AreEqual ("id1", dl.SelectedValue.ToString (), "A2");
 658                 }
 659
 660                 [Test]
 661                 [ExpectedException (typeof (InvalidOperationException))]
 662                 public void SelectedValue_WithoutDataKeyField ()
 663                 {
 664                         TestDataList dl = new TestDataList ();
 665                         Assert.IsNull (dl.SelectedValue, "SelectedValue");
 666                 }
 667
 668                 [Test]
 669                 public void SelectedValue_WithUnexistingDataKeyField ()
 670                 {
 671                         TestDataList dl = new TestDataList ();
 672                         dl.DataKeyField = "mono";
 673                         Assert.IsNull (dl.SelectedValue, "SelectedValue");
 674                 }
 675                 private bool cancelCommandEvent;
 676                 private bool deleteCommandEvent;
 677                 private bool editCommandEvent;
 678                 private bool itemCommandEvent;
 679                 private bool itemCreatedEvent;
 680                 private bool itemDataBoundEvent;
 681                 private bool updateCommandEvent;
 682                 private bool selectedIndexChangedEvent;
 683
 684                 private void ResetEvents ()
 685                 {
 686                         cancelCommandEvent = false;
 687                         deleteCommandEvent = false;
 688                         editCommandEvent = false;
 689                         itemCommandEvent = false;
 690                         itemCreatedEvent = false;
 691                         itemDataBoundEvent = false;
 692                         updateCommandEvent = false;
 693                         selectedIndexChangedEvent = false;
 694                 }
 695
 696                 private void CancelCommandHandler (object sender, DataListCommandEventArgs e)
 697                 {
 698                         cancelCommandEvent = true;
 699                 }
 700
 701                 private void DeleteCommandHandler (object sender, DataListCommandEventArgs e)
 702                 {
 703                         deleteCommandEvent = true;
 704                 }
 705
 706                 private void EditCommandHandler (object sender, DataListCommandEventArgs e)
 707                 {
 708                         editCommandEvent = true;
 709                 }
 710
 711                 private void ItemCommandHandler (object sender, DataListCommandEventArgs e)
 712                 {
 713                         itemCommandEvent = true;
 714                 }
 715
 716                 private void ItemCreatedHandler (object sender, DataListItemEventArgs e)
 717                 {
 718                         itemCreatedEvent = true;
 719                 }
 720
 721                 private void ItemDataBoundHandler (object sender, DataListItemEventArgs e)
 722                 {
 723                         itemDataBoundEvent = true;
 724                 }
 725
 726                 private void SelectedIndexChangedHandler (object sender, EventArgs e)
 727                 {
 728                         selectedIndexChangedEvent = true;
 729                 }
 730
 731                 private void UpdateCommandHandler (object sender, DataListCommandEventArgs e)
 732                 {
 733                         updateCommandEvent = true;
 734                 }
 735
 736                 [Test]
 737                 public void Events ()
 738                 {
 739                         TestDataList dl = new TestDataList ();
 740                         DataListCommandEventArgs command_args = new DataListCommandEventArgs (null,
 741                                         null, new CommandEventArgs (String.Empty, String.Empty));
 742                         DataListItemEventArgs item_args = new DataListItemEventArgs (null);
 743
 744                         ResetEvents ();
 745                         dl.CancelCommand += new DataListCommandEventHandler (CancelCommandHandler);
 746                         dl.DoCancelCommand (command_args);
 747                         Assert.IsTrue (cancelCommandEvent, "cancelCommandEvent");
 748
 749                         ResetEvents ();
 750                         dl.DeleteCommand += new DataListCommandEventHandler (DeleteCommandHandler);
 751                         dl.DoDeleteCommand (command_args);
 752                         Assert.IsTrue (deleteCommandEvent, "deleteCommandEvent");
 753
 754                         ResetEvents ();
 755                         dl.EditCommand += new DataListCommandEventHandler (EditCommandHandler);
 756                         dl.DoEditCommand (command_args);
 757                         Assert.IsTrue (editCommandEvent, "editCommandEvent");
 758
 759                         ResetEvents ();
 760                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 761                         dl.DoItemCommand (command_args);
 762                         Assert.IsTrue (itemCommandEvent, "itemCommandEvent");
 763
 764                         ResetEvents ();
 765                         dl.ItemCreated += new DataListItemEventHandler (ItemCreatedHandler);
 766                         dl.DoItemCreated (item_args);
 767                         Assert.IsTrue (itemCreatedEvent, "itemCreatedEvent");
 768
 769                         ResetEvents ();
 770                         dl.ItemDataBound += new DataListItemEventHandler (ItemDataBoundHandler);
 771                         dl.DoItemDataBound (item_args);
 772                         Assert.IsTrue (itemDataBoundEvent, "itemDataBoundEvent");
 773
 774                         ResetEvents ();
 775                         dl.UpdateCommand += new DataListCommandEventHandler (UpdateCommandHandler);
 776                         dl.DoUpdateCommand (command_args);
 777                         Assert.IsTrue (updateCommandEvent, "updateCommandEvent");
 778
 779                         ResetEvents ();
 780                         dl.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 781                         dl.DoSelectedIndexChanged (new EventArgs ());
 782                         Assert.IsTrue (selectedIndexChangedEvent, "selectedIndexChangedEvent");
 783                 }
 784
 785                 [Test]
 786                 public void BubbleEvent ()
 787                 {
 788                         TestDataList dl = new TestDataList ();
 789                         DataListCommandEventArgs command_args;
 790
 791                         //
 792                         // Cancel
 793                         //
 794                         ResetEvents ();
 795                         command_args = new DataListCommandEventArgs (null,
 796                                         null, new CommandEventArgs ("Cancel", String.Empty));
 797                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 798                         dl.CancelCommand += new DataListCommandEventHandler (CancelCommandHandler);
 799                         dl.DoBubbleEvent (this, command_args);
 800                         Assert.IsTrue (cancelCommandEvent, "cancelCommandEvent-1");
 801                         Assert.IsTrue (itemCommandEvent, "#00");
 802
 803                         ResetEvents ();
 804                         command_args = new DataListCommandEventArgs (null,
 805                                         null, new CommandEventArgs ("cancel", String.Empty));
 806                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 807                         dl.CancelCommand += new DataListCommandEventHandler (CancelCommandHandler);
 808                         dl.DoBubbleEvent (this, command_args);
 809                         Assert.IsTrue (cancelCommandEvent, "cancelCommandEvent-2");
 810                         Assert.IsTrue (itemCommandEvent, "#00");
 811
 812                         ResetEvents ();
 813                         command_args = new DataListCommandEventArgs (null,
 814                                         null, new CommandEventArgs ("CANCEL", String.Empty));
 815                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 816                         dl.CancelCommand += new DataListCommandEventHandler (CancelCommandHandler);
 817                         dl.DoBubbleEvent (this, command_args);
 818                         Assert.IsTrue (cancelCommandEvent, "cancelCommandEvent-3");
 819                         Assert.IsTrue (itemCommandEvent, "#00");
 820
 821                         //
 822                         // Delete
 823                         //
 824                         ResetEvents ();
 825                         command_args = new DataListCommandEventArgs (null,
 826                                         null, new CommandEventArgs ("Delete", String.Empty));
 827                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 828                         dl.DeleteCommand += new DataListCommandEventHandler (DeleteCommandHandler);
 829                         dl.DoBubbleEvent (this, command_args);
 830                         Assert.IsTrue (deleteCommandEvent, "deleteCommandEvent-1");
 831                         Assert.IsTrue (itemCommandEvent, "#00");
 832
 833                         ResetEvents ();
 834                         command_args = new DataListCommandEventArgs (null,
 835                                         null, new CommandEventArgs ("delete", String.Empty));
 836                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 837                         dl.DeleteCommand += new DataListCommandEventHandler (DeleteCommandHandler);
 838                         dl.DoBubbleEvent (this, command_args);
 839                         Assert.IsTrue (deleteCommandEvent, "deleteCommandEvent-2");
 840                         Assert.IsTrue (itemCommandEvent, "#00");
 841
 842                         ResetEvents ();
 843                         command_args = new DataListCommandEventArgs (null,
 844                                         null, new CommandEventArgs ("DELETE", String.Empty));
 845                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 846                         dl.DeleteCommand += new DataListCommandEventHandler (DeleteCommandHandler);
 847                         dl.DoBubbleEvent (this, command_args);
 848                         Assert.IsTrue (deleteCommandEvent, "deleteCommandEvent-3");
 849                         Assert.IsTrue (itemCommandEvent, "#00");
 850
 851                         //
 852                         // Edit
 853                         //
 854                         ResetEvents ();
 855                         command_args = new DataListCommandEventArgs (null,
 856                                         null, new CommandEventArgs ("Edit", String.Empty));
 857                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 858                         dl.EditCommand += new DataListCommandEventHandler (EditCommandHandler);
 859                         dl.DoBubbleEvent (this, command_args);
 860                         Assert.IsTrue (editCommandEvent, "editCommandEvent-1");
 861                         Assert.IsTrue (itemCommandEvent, "#00");
 862
 863                         ResetEvents ();
 864                         command_args = new DataListCommandEventArgs (null,
 865                                         null, new CommandEventArgs ("edit", String.Empty));
 866                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 867                         dl.EditCommand += new DataListCommandEventHandler (EditCommandHandler);
 868                         dl.DoBubbleEvent (this, command_args);
 869                         Assert.IsTrue (editCommandEvent, "editCommandEvent-2");
 870                         Assert.IsTrue (itemCommandEvent, "#00");
 871
 872                         ResetEvents ();
 873                         command_args = new DataListCommandEventArgs (null,
 874                                         null, new CommandEventArgs ("EDIT", String.Empty));
 875                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 876                         dl.EditCommand += new DataListCommandEventHandler (EditCommandHandler);
 877                         dl.DoBubbleEvent (this, command_args);
 878                         Assert.IsTrue (editCommandEvent, "editCommandEvent-3");
 879                         Assert.IsTrue (itemCommandEvent, "#00");
 880
 881                         //
 882                         // Item
 883                         //
 884                         ResetEvents ();
 885                         command_args = new DataListCommandEventArgs (null,
 886                                         null, new CommandEventArgs ("Item", String.Empty));
 887                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 888                         dl.DoBubbleEvent (this, command_args);
 889                         Assert.IsTrue (itemCommandEvent, "itemCommandEvent-1");
 890
 891                         ResetEvents ();
 892                         command_args = new DataListCommandEventArgs (null,
 893                                         null, new CommandEventArgs ("item", String.Empty));
 894                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 895                         dl.DoBubbleEvent (this, command_args);
 896                         Assert.IsTrue (itemCommandEvent, "itemCommandEvent-2");
 897
 898                         ResetEvents ();
 899                         command_args = new DataListCommandEventArgs (null,
 900                                         null, new CommandEventArgs ("ITEM", String.Empty));
 901                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 902                         dl.DoBubbleEvent (this, command_args);
 903                         Assert.IsTrue (itemCommandEvent, "itemCommandEvent-3");
 904
 905                         //
 906                         // Update
 907                         //
 908                         ResetEvents ();
 909                         command_args = new DataListCommandEventArgs (null,
 910                                         null, new CommandEventArgs ("Update", String.Empty));
 911                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 912                         dl.UpdateCommand += new DataListCommandEventHandler (UpdateCommandHandler);
 913                         dl.DoBubbleEvent (this, command_args);
 914                         Assert.IsTrue (updateCommandEvent, "updateCommandEvent-1");
 915                         Assert.IsTrue (itemCommandEvent, "#00");
 916
 917                         ResetEvents ();
 918                         command_args = new DataListCommandEventArgs (null,
 919                                         null, new CommandEventArgs ("update", String.Empty));
 920                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 921                         dl.UpdateCommand += new DataListCommandEventHandler (UpdateCommandHandler);
 922                         dl.DoBubbleEvent (this, command_args);
 923                         Assert.IsTrue (updateCommandEvent, "updateCommandEvent-2");
 924                         Assert.IsTrue (itemCommandEvent, "#00");
 925
 926                         ResetEvents ();
 927                         command_args = new DataListCommandEventArgs (null,
 928                                         null, new CommandEventArgs ("UPDATE", String.Empty));
 929                         dl.UpdateCommand += new DataListCommandEventHandler (UpdateCommandHandler);
 930                         dl.DoBubbleEvent (this, command_args);
 931                         Assert.IsTrue (updateCommandEvent, "updateCommandEvent-3");
 932                         Assert.IsTrue (itemCommandEvent, "#00");
 933
 934                         //
 935                         // Select
 936                         //
 937                         DataListItem item = new DataListItem (0, ListItemType.Item);
 938
 939                         ResetEvents ();
 940                         command_args = new DataListCommandEventArgs (item, null,
 941                                         new CommandEventArgs ("Select", String.Empty));
 942                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 943                         dl.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 944                         dl.DoBubbleEvent (this, command_args);
 945                         Assert.IsTrue (selectedIndexChangedEvent, "selectedIndexChangedEvent-1");
 946                         Assert.IsTrue (itemCommandEvent, "#00");
 947
 948                         ResetEvents ();
 949                         command_args = new DataListCommandEventArgs (item, null,
 950                                         new CommandEventArgs ("select", String.Empty));
 951                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 952                         dl.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 953                         dl.DoBubbleEvent (this, command_args);
 954                         Assert.IsTrue (selectedIndexChangedEvent, "selectedIndexChangedEvent-2");
 955                         Assert.IsTrue (itemCommandEvent, "#00");
 956
 957                         ResetEvents ();
 958                         command_args = new DataListCommandEventArgs (item, null,
 959                                         new CommandEventArgs ("SELECT", String.Empty));
 960                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 961                         dl.SelectedIndexChanged += new EventHandler (SelectedIndexChangedHandler);
 962                         dl.DoBubbleEvent (this, command_args);
 963                         Assert.IsTrue (selectedIndexChangedEvent, "selectedIndexChangedEvent-3");
 964                         Assert.IsTrue (itemCommandEvent, "#00");
 965
 966                         //
 967                         // any comand
 968                         //
 969                         ResetEvents ();
 970                         command_args = new DataListCommandEventArgs (item, null,
 971                                         new CommandEventArgs ("AnyComand", String.Empty));
 972                         dl.ItemCommand += new DataListCommandEventHandler (ItemCommandHandler);
 973                         bool res = dl.DoBubbleEvent (this, command_args);
 974                         Assert.IsTrue (res, "any comand#00");
 975                         Assert.IsTrue (itemCommandEvent, "any comand#01");
 976                 }
 977
 978                 [Test]
 979                 public void NControls1 ()
 980                 {
 981                         TestDataList dl = new TestDataList ();
 982                         dl.DataSource = GetData (5);
 983                         dl.CreateCH ();
 984                         Assert.AreEqual (5, dl.Controls.Count, "#01");
 985                 }
 986
 987                 [Test]
 988                 public void NControls2 ()
 989                 {
 990                         TestDataList dl = new TestDataList ();
 991                         dl.ShowHeader = true;
 992                         dl.ShowFooter = true;
 993                         dl.DataSource = GetData (5);
 994                         dl.CreateCH ();
 995                         Assert.AreEqual (5, dl.Controls.Count, "#01");
 996                 }
 997
 998                 class Templ : ITemplate {
 999                         public void InstantiateIn (Control ctrl)
1000                         {
1001                                 ctrl.Controls.Add (new LiteralControl ("Lalalaa"));
1002                         }
1003                 }
1004
1005                 //Some real templates for testing if proper Template was used
1006                 class ItemTemplate : ITemplate {
1007                         public void InstantiateIn (Control container)
1008                         {
1009                                 Label lbl = new Label();
1010                                 lbl.ID = "itemtmpl";
1011                                 container.Controls.Add(lbl);
1012                         }
1013                 }
1014
1015                 class EditItemTemplate : ITemplate {
1016                         public void InstantiateIn (Control container)
1017                         {
1018                                 TextBox tb = new TextBox();
1019                                 tb.ID = "eitemtmpl";
1020                                 container.Controls.Add(tb);
1021                         }
1022                 }
1023
1024                 [Test]
1025                 public void ProperTemplateSelectedIndexEqualsEditIndex ()
1026                 {
1027                         TestDataList dl = new TestDataList();
1028                         dl.ItemTemplate = new ItemTemplate();
1029                         dl.AlternatingItemTemplate = new ItemTemplate();
1030                         dl.SelectedItemTemplate = new ItemTemplate();
1031                         dl.EditItemTemplate = new EditItemTemplate();
1032                         dl.DataSource = GetData(5);
1033                         dl.SelectedIndex = 0;
1034                         dl.EditItemIndex = 0;
1035                         dl.DataBind();
1036                         object canIGetMyEditItem = dl.Items[dl.EditItemIndex].FindControl("eitemtmpl");
1037                         Assert.IsTrue(canIGetMyEditItem != null, "ProperTemplateSelectedIndexEqualsEditIndex");
1038                 }
1039
1040                 [Test]
1041                 public void NControls3 ()
1042                 {
1043                         TestDataList dl = new TestDataList ();
1044                         dl.ShowHeader = true;
1045                         dl.HeaderTemplate = new Templ ();
1046                         dl.ShowFooter = true;
1047                         dl.FooterTemplate = new Templ ();
1048                         dl.DataSource = GetData (5);
1049                         dl.CreateCH ();
1050                         Assert.AreEqual (7, dl.Controls.Count, "#01");
1051                 }
1052
1053                 [Test]
1054                 public void NControls4 ()
1055                 {
1056                         TestDataList dl = new TestDataList ();
1057                         dl.SeparatorTemplate = new Templ ();
1058                         dl.DataSource = GetData (5);
1059                         dl.CreateCH ();
1060                         Assert.AreEqual (10, dl.Controls.Count, "#01");
1061                 }
1062
1063                 [Test]
1064                 public void NControls5 ()
1065                 {
1066                         TestDataList dl = new TestDataList ();
1067                         dl.ShowHeader = true;
1068                         dl.HeaderTemplate = new Templ ();
1069                         dl.SeparatorTemplate = new Templ ();
1070                         dl.DataSource = GetData (5);
1071                         dl.CreateCH ();
1072                         Assert.AreEqual (11, dl.Controls.Count, "#01");
1073                 }
1074
1075                 [Test]
1076                 public void DataSourceID ()
1077                 {
1078                         Page p = new Page();
1079                         ObjectDataSource ds = new ObjectDataSource();
1080                         ds.ID = "ObjectDataSource1";
1081                         ds.TypeName = "System.Guid";
1082                         ds.SelectMethod = "ToByteArray";
1083                         TestDataList dl = new TestDataList ();
1084                         dl.Page = p;
1085                         ds.Page = p;
1086                         p.Controls.Add(dl);
1087                         p.Controls.Add(ds);
1088                         dl.DataSourceID = "ObjectDataSource1";
1089                         dl.CreateCH ();
1090                         Assert.AreEqual (16, dl.Controls.Count, "#01");
1091                 }
1092
1093                 [Test]
1094                 public void NControls6 ()
1095                 {
1096                         TestDataList dl = new TestDataList ();
1097                         dl.ShowHeader = true;
1098                         dl.HeaderTemplate = new Templ ();
1099                         dl.ShowFooter = true;
1100                         dl.FooterTemplate = new Templ ();
1101                         dl.SeparatorTemplate = new Templ ();
1102                         dl.DataSource = GetData (6);
1103                         dl.CreateCH ();
1104                         Assert.AreEqual (14, dl.Controls.Count, "#01");
1105
1106                         Assert.AreEqual (ListItemType.Header, ((DataListItem) dl.Controls [0]).ItemType, "#02");
1107                         for (int i = 0; i < 3; i++) {
1108                                 int b = (i * 4) + 1;
1109                                 DataListItem one = (DataListItem) dl.Controls [b];
1110                                 DataListItem two = (DataListItem) dl.Controls [b + 1];
1111                                 DataListItem three = (DataListItem) dl.Controls [b + 2];
1112                                 DataListItem four = (DataListItem) dl.Controls [b + 3];
1113                                 Assert.AreEqual (ListItemType.Item, one.ItemType, String.Format ("#02-{0}", b));
1114                                 Assert.AreEqual (ListItemType.Separator, two.ItemType, String.Format ("#02-{0}", b + 1));
1115                                 Assert.AreEqual (ListItemType.AlternatingItem, three.ItemType, String.Format ("#02-{0}", b + 2));
1116                                 Assert.AreEqual (ListItemType.Separator, four.ItemType, String.Format ("#02-{0}", b + 3));
1117
1118                         }
1119                         Assert.AreEqual (ListItemType.Footer, ((DataListItem) dl.Controls [13]).ItemType, "#03");
1120                 }
1121
1122                 [Test]
1123                 public void RepeatInfo1 ()
1124                 {
1125                         TestDataList dl = new TestDataList ();
1126                         dl.ShowHeader = true;
1127                         dl.HeaderTemplate = new Templ ();
1128                         dl.ShowFooter = true;
1129                         dl.FooterTemplate = new Templ ();
1130                         dl.SeparatorTemplate = new Templ ();
1131                         dl.DataSource = GetData (6);
1132                         dl.CreateCH ();
1133                         IRepeatInfoUser repeater = (IRepeatInfoUser) dl;
1134                         Assert.AreEqual (true, repeater.HasHeader, "#01");
1135                         Assert.AreEqual (true, repeater.HasFooter, "#02");
1136                         Assert.AreEqual (true, repeater.HasSeparators, "#03");
1137                         Assert.AreEqual (6, repeater.RepeatedItemCount, "#04");
1138                 }
1139
1140                 [Test]
1141                 public void RepeatInfo2 ()
1142                 {
1143                         TestDataList dl = new TestDataList ();
1144                         dl.ShowHeader = true;
1145                         dl.HeaderTemplate = new Templ ();
1146                         dl.ShowFooter = true;
1147                         dl.FooterTemplate = new Templ ();
1148                         dl.SeparatorTemplate = new Templ ();
1149                         dl.DataSource = GetData (6);
1150                         dl.CreateCH ();
1151                         IRepeatInfoUser repeater = (IRepeatInfoUser) dl;
1152                         Style style = repeater.GetItemStyle (ListItemType.Pager, -1);
1153                         Assert.IsNull (style, "#01");
1154                         style = repeater.GetItemStyle (ListItemType.Pager, 0);
1155                         Assert.IsNull (style, "#02");
1156                         style = repeater.GetItemStyle (ListItemType.Pager, 15);
1157                         Assert.IsNull (style, "#03");
1158                 }
1159
1160                 [Test]
1161                 public void RepeatInfo3 ()
1162                 {
1163                         TestDataList dl = new TestDataList ();
1164                         dl.ShowHeader = true;
1165                         dl.HeaderTemplate = new Templ ();
1166                         dl.ShowFooter = true;
1167                         dl.FooterTemplate = new Templ ();
1168                         dl.SeparatorTemplate = new Templ ();
1169                         dl.DataSource = GetData (6);
1170                         dl.CreateCH ();
1171                         IRepeatInfoUser repeater = (IRepeatInfoUser) dl;
1172                         Style style = repeater.GetItemStyle (ListItemType.Header, -1);
1173                         DataListItem header = (DataListItem) dl.Controls [0];
1174                         Assert.IsNull (style, "#01");
1175
1176                         style = repeater.GetItemStyle (ListItemType.Footer, -1);
1177                         DataListItem footer = (DataListItem) dl.Controls [13];
1178                         Assert.IsNull (style, "#02");
1179                         for (int i = 0; i < 6; i++) {
1180                                 style = repeater.GetItemStyle (ListItemType.Item, i);
1181                                 Assert.IsNull (style, String.Format ("#02-{0}", i));
1182                         }
1183                 }
1184
1185                 [Test]
1186                 public void RepeatInfo4 ()
1187                 {
1188                         TestDataList dl = new TestDataList ();
1189                         dl.DataSource = GetData (6);
1190                         dl.ItemStyle.ForeColor = Color.Blue;
1191                         dl.CreateCH ();
1192                         dl.PrepareCH (); // removing this causes all the GetItemStyle calls to return null
1193                         IRepeatInfoUser repeater = (IRepeatInfoUser) dl;
1194                         for (int i = 0; i < 6; i++) {
1195                                 Style style = repeater.GetItemStyle (ListItemType.Item, i);
1196                                 DataListItem item = (DataListItem) dl.Controls [i];
1197                                 Assert.AreEqual (style, item.ControlStyle, String.Format ("#01-{0}", i));
1198                         }
1199                 }
1200
1201                 [Test]
1202                 public void DataBindTwice () {
1203                         DataList dl = new DataList ();
1204
1205                         dl.DataSource = new object [] { "1", "2", "3" };
1206                         dl.DataBind ();
1207
1208                         Assert.AreEqual (3, dl.Items.Count, "first binding");
1209
1210                         dl.DataSource = new object [] { "a", "b", "c" };
1211                         dl.DataBind ();
1212
1213                         Assert.AreEqual (3, dl.Items.Count, "second binding");
1214                 }
1215         }
1216 }
1217