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

   1 //
   2 // DataListItemTest.cs
   3 //      - Unit tests for System.Web.UI.WebControls.DataListItem
   4 //
   5 // Author:
   6 //      Sebastien Pouliot  <sebastien@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.IO;
  34 using System.Web;
  35 using System.Web.UI;
  36 using System.Web.UI.WebControls;
  37
  38 using NUnit.Framework;
  39
  40 namespace MonoTests.System.Web.UI.WebControls {
  41
  42         public class TestDataListItem : DataListItem {
  43
  44                 public TestDataListItem (int index, ListItemType type)
  45                         : base (index, type)
  46                 {
  47                 }
  48
  49
  50                 public string Render (bool extractRows, bool tableLayout)
  51                 {
  52                         StringWriter sw = new StringWriter ();
  53                         sw.NewLine = "\n";
  54                         HtmlTextWriter writer = new HtmlTextWriter (sw);
  55                         base.RenderItem (writer, extractRows, tableLayout);
  56                         return writer.InnerWriter.ToString ();
  57                 }
  58
  59                 public void SetType (ListItemType type)
  60                 {
  61                         base.SetItemType (type);
  62                 }
  63         }
  64
  65         [TestFixture]
  66         public class DataListItemTest {
  67
  68                 private void BaseTests (TestDataListItem dli)
  69                 {
  70                         Assert.IsNull (dli.DataItem, "DataItem");
  71                         Assert.AreEqual (String.Empty, dli.Render (true, true), "Render-Empty-T-T");
  72                         Assert.AreEqual (String.Empty, dli.Render (true, false), "Render-Empty-T-F");
  73                         Assert.AreEqual (String.Empty, dli.Render (false, true), "Render-Empty-F-T");
  74                         Assert.AreEqual ("<span></span>", dli.Render (false, false), "Render-Empty-F-F");
  75
  76                         dli.DataItem = (object)Int32.MaxValue;
  77                         Assert.AreEqual (Int32.MaxValue, dli.DataItem, "DataItem-Int32");
  78                         Assert.AreEqual (String.Empty, dli.Render (true, true), "Render-Int32-T-T");
  79                         Assert.AreEqual (String.Empty, dli.Render (true, false), "Render-Int32-T-F");
  80                         Assert.AreEqual (String.Empty, dli.Render (false, true), "Render-Int32-F-T");
  81                         Assert.AreEqual ("<span></span>", dli.Render (false, false), "Render-Int32-F-F");
  82
  83                         dli.DataItem = (object)"mono";
  84                         Assert.AreEqual ("mono", dli.DataItem, "DataItem-String");
  85                         Assert.AreEqual (String.Empty, dli.Render (true, true), "Render-String-T-T");
  86                         Assert.AreEqual (String.Empty, dli.Render (true, false), "Render-String-T-F");
  87                         Assert.AreEqual (String.Empty, dli.Render (false, true), "Render-String-F-T");
  88                         Assert.AreEqual ("<span></span>", dli.Render (false, false), "Render-String-F-F");
  89                 }
  90
  91                 private void DataItemContainer (TestDataListItem dli, int index)
  92                 {
  93                         IDataItemContainer dic = (dli as IDataItemContainer);
  94                         Assert.IsNull (dic.DataItem, "IDataItemContainer-DataItem");
  95                         Assert.AreEqual (index, dic.DataItemIndex, "IDataItemContainer-DataItemIndex");
  96                         Assert.AreEqual (index, dic.DisplayIndex, "IDataItemContainer-DisplayIndex");
  97                 }
  98
  99                 [Test]
 100                 public void AlternatingItem ()
 101                 {
 102                         TestDataListItem dli = new TestDataListItem (0, ListItemType.AlternatingItem);
 103                         Assert.AreEqual (0, dli.ItemIndex, "ItemIndex");
 104                         Assert.AreEqual (ListItemType.AlternatingItem, dli.ItemType, "ItemType");
 105
 106                         DataItemContainer (dli, 0);
 107                         BaseTests (dli);
 108
 109                         dli.SetType (ListItemType.EditItem);
 110                         Assert.AreEqual (ListItemType.EditItem, dli.ItemType, "SetItemType");
 111                 }
 112
 113                 [Test]
 114                 public void EditItem ()
 115                 {
 116                         TestDataListItem dli = new TestDataListItem (Int32.MaxValue, ListItemType.EditItem);
 117                         Assert.AreEqual (Int32.MaxValue, dli.ItemIndex, "ItemIndex");
 118                         Assert.AreEqual (ListItemType.EditItem, dli.ItemType, "ItemType");
 119
 120                         DataItemContainer (dli, Int32.MaxValue);
 121                         BaseTests (dli);
 122
 123                         dli.SetType (ListItemType.Footer);
 124                         Assert.AreEqual (ListItemType.Footer, dli.ItemType, "SetItemType");
 125                 }
 126
 127                 [Test]
 128                 public void Footer ()
 129                 {
 130                         TestDataListItem dli = new TestDataListItem (Int32.MinValue, ListItemType.Footer);
 131                         Assert.AreEqual (Int32.MinValue, dli.ItemIndex, "ItemIndex");
 132                         Assert.AreEqual (ListItemType.Footer, dli.ItemType, "ItemType");
 133
 134                         DataItemContainer (dli, Int32.MinValue);
 135                         BaseTests (dli);
 136
 137                         dli.SetType (ListItemType.Header);
 138                         Assert.AreEqual (ListItemType.Header, dli.ItemType, "SetItemType");
 139                 }
 140
 141                 [Test]
 142                 public void Header ()
 143                 {
 144                         TestDataListItem dli = new TestDataListItem (0, ListItemType.Header);
 145                         Assert.AreEqual (0, dli.ItemIndex, "ItemIndex");
 146                         Assert.AreEqual (ListItemType.Header, dli.ItemType, "ItemType");
 147
 148                         DataItemContainer (dli, 0);
 149                         BaseTests (dli);
 150
 151                         dli.SetType (ListItemType.Item);
 152                         Assert.AreEqual (ListItemType.Item, dli.ItemType, "SetItemType");
 153                 }
 154
 155                 [Test]
 156                 public void Item ()
 157                 {
 158                         TestDataListItem dli = new TestDataListItem (0, ListItemType.Item);
 159                         Assert.AreEqual (0, dli.ItemIndex, "ItemIndex");
 160                         Assert.AreEqual (ListItemType.Item, dli.ItemType, "ItemType");
 161
 162                         DataItemContainer (dli, 0);
 163                         BaseTests (dli);
 164
 165                         dli.SetType (ListItemType.Pager);
 166                         Assert.AreEqual (ListItemType.Pager, dli.ItemType, "SetItemType");
 167                 }
 168
 169                 [Test]
 170                 public void Pager ()
 171                 {
 172                         TestDataListItem dli = new TestDataListItem (0, ListItemType.Pager);
 173                         Assert.AreEqual (0, dli.ItemIndex, "ItemIndex");
 174                         Assert.AreEqual (ListItemType.Pager, dli.ItemType, "ItemType");
 175
 176                         DataItemContainer (dli, 0);
 177                         BaseTests (dli);
 178
 179                         dli.SetType (ListItemType.SelectedItem);
 180                         Assert.AreEqual (ListItemType.SelectedItem, dli.ItemType, "SetItemType");
 181                 }
 182
 183                 [Test]
 184                 public void SelectedItem ()
 185                 {
 186                         TestDataListItem dli = new TestDataListItem (1, ListItemType.SelectedItem);
 187                         Assert.AreEqual (1, dli.ItemIndex, "ItemIndex");
 188                         Assert.AreEqual (ListItemType.SelectedItem, dli.ItemType, "ItemType");
 189
 190                         DataItemContainer (dli, 1);
 191                         BaseTests (dli);
 192
 193                         dli.SetType (ListItemType.Separator);
 194                         Assert.AreEqual (ListItemType.Separator, dli.ItemType, "SetItemType");
 195                 }
 196
 197                 [Test]
 198                 public void Separator ()
 199                 {
 200                         TestDataListItem dli = new TestDataListItem (-1, ListItemType.Separator);
 201                         Assert.AreEqual (-1, dli.ItemIndex, "ItemIndex");
 202                         Assert.AreEqual (ListItemType.Separator, dli.ItemType, "ItemType");
 203
 204                         DataItemContainer (dli, -1);
 205                         BaseTests (dli);
 206
 207                         dli.SetType (ListItemType.AlternatingItem);
 208                         Assert.AreEqual (ListItemType.AlternatingItem, dli.ItemType, "SetItemType");
 209                 }
 210
 211                 [Test]
 212                 public void Bad_ListItemType ()
 213                 {
 214                         TestDataListItem dli = new TestDataListItem (0, (ListItemType)Int32.MinValue);
 215                         Assert.AreEqual (0, dli.ItemIndex, "ItemIndex");
 216                         Assert.AreEqual ((ListItemType)Int32.MinValue, dli.ItemType, "ItemType");
 217
 218                         DataItemContainer (dli, 0);
 219                         BaseTests (dli);
 220                 }
 221
 222                 private Table GetTable (string s)
 223                 {
 224                         LiteralControl lc = new LiteralControl (s);
 225                         TableCell td = new TableCell ();
 226                         td.Controls.Add (lc);
 227                         TableRow tr = new TableRow ();
 228                         tr.Cells.Add (td);
 229                         Table t = new Table ();
 230                         t.Rows.Add (tr);
 231                         return t;
 232                 }
 233
 234                 private string Adjust (string s)
 235                 {
 236                         // right now Mono doesn't generate the exact same indentation/lines as MS implementation
 237                         // and different fx versions have different casing for enums
 238                         return s.Replace ("\n", "").Replace ("\t", "").ToLower ();
 239                 }
 240
 241                 [Test]
 242                 public void Controls_Table ()
 243                 {
 244                         string origHtml1 = "<tr>\n\t<td>mono</td>\n</tr>";
 245                         string origHtml2 = "<tr>\n\t<td>mono</td>\n</tr>";
 246                         string origHtml3 = "<table>\n\t<tr>\n\t\t<td>mono</td>\n\t</tr>\n</table>";
 247                         string origHtml4 = "<span><table>\n\t<tr>\n\t\t<td>mono</td>\n\t</tr>\n</table></span>";
 248                         TestDataListItem dli = new TestDataListItem (0, ListItemType.Item);
 249                         dli.Controls.Add (GetTable ("mono"));
 250
 251                         string renderedHtml = dli.Render (true, true);
 252                         Assert.AreEqual (origHtml1, renderedHtml, "Render-Empty-T-T");
 253
 254                         renderedHtml = dli.Render (true, false);
 255                         Assert.AreEqual (origHtml2, renderedHtml, "Render-Empty-T-F");
 256
 257                         renderedHtml = dli.Render (false, true);
 258                         Assert.AreEqual (Adjust (origHtml3), Adjust (renderedHtml), "Render-Empty-F-T");
 259
 260                         renderedHtml = dli.Render (false, false);
 261                         Assert.AreEqual (Adjust (origHtml4), Adjust (renderedHtml), "Render-Empty-F-F");
 262                 }
 263
 264                 [Test]
 265                 public void Controls_Table_Dual ()
 266                 {
 267                         string origHtml1 = "<tr>\n\t<td>mono</td>\n</tr>";
 268                         string origHtml2 = "<tr>\n\t<td>mono</td>\n</tr>";
 269                         string origHtml3 = "<table>\n\t<tr>\n\t\t<td>mono</td>\n\t</tr>\n</table><table>\n\t<tr>\n\t\t<td>monkey</td>\n\t</tr>\n</table>";
 270                         string origHtml4 = "<span><table>\n\t<tr>\n\t\t<td>mono</td>\n\t</tr>\n</table><table>\n\t<tr>\n\t\t<td>monkey</td>\n\t</tr>\n</table></span>";
 271                         TestDataListItem dli = new TestDataListItem (0, ListItemType.Item);
 272                         dli.Controls.Add (GetTable ("mono"));
 273                         dli.Controls.Add (GetTable ("monkey"));
 274
 275                         // the second table is ignored if extractRows is true
 276                         string renderedHtml = dli.Render (true, true);
 277                         Assert.AreEqual (origHtml1, renderedHtml, "Render-Empty-T-T");
 278
 279                         renderedHtml = dli.Render (true, false);
 280                         Assert.AreEqual (origHtml2, renderedHtml, "Render-Empty-T-F");
 281
 282                         // but not if extractRows is false
 283                         renderedHtml = dli.Render (false, true);
 284                         Assert.AreEqual (Adjust (origHtml3), Adjust (renderedHtml), "Render-Empty-F-T");
 285
 286                         renderedHtml = dli.Render (false, false);
 287                         Assert.AreEqual (Adjust (origHtml4), Adjust (renderedHtml), "Render-Empty-F-F");
 288                 }
 289
 290                 [Test]
 291                 public void Controls_LiteralControl ()
 292                 {
 293                         TestDataListItem dli = new TestDataListItem (0, ListItemType.Item);
 294                         LiteralControl lc = new LiteralControl ("mono");
 295                         dli.Controls.Add (lc);
 296
 297                         // there's no table here (but there are controls), so calling Render with true for
 298                         // extractRows cause a NullReferenceException on MS implementation
 299                         //Assert.AreEqual ("<tr>\n\t<td></td>\n<\tr>", dli.Render (true, true), "Render-Empty-T-T");
 300                         //Assert.AreEqual ("<tr>\n\t<td></td>\n<\tr>", dli.Render (true, false), "Render-Empty-T-F");
 301                         Assert.AreEqual ("mono", dli.Render (false, true), "Render-Empty-F-T");
 302                         Assert.AreEqual ("<span>mono</span>", dli.Render (false, false), "Render-Empty-F-F");
 303                 }
 304                 [Test]
 305                 public void SupportsDisabledAttribute ()
 306                 {
 307                         var ver40 = new Version (4, 0);
 308                         var ver35 = new Version (3, 5);
 309                         var p = new TestDataListItem (0, ListItemType.Item);
 310                         Assert.AreEqual (ver40, p.RenderingCompatibility, "#A1-1");
 311                         Assert.IsFalse (p.SupportsDisabledAttribute, "#A1-2");
 312
 313                         p.RenderingCompatibility = new Version (3, 5);
 314                         Assert.AreEqual (ver35, p.RenderingCompatibility, "#A2-1");
 315                         Assert.IsTrue (p.SupportsDisabledAttribute, "#A2-2");
 316                 }
 317         }
 318 }