mcs/class/Managed.Windows.Forms/Test/System.Windows.Forms/TreeNodeCollectionTest.cs

   1 using System;
   2 using System.Collections;
   3 using System.Drawing;
   4 using System.Windows.Forms;
   5
   6 using NUnit.Framework;
   7
   8 namespace MonoTests.System.Windows.Forms
   9 {
  10         [TestFixture]
  11         public class TreeNodeCollectionTest
  12         {
  13
  14         [Test]
  15         public void Add()
  16         {
  17             ImageList imglist = null;
  18
  19             TestHelper.RemoveWarning (imglist);
  20
  21             TreeView tv = new TreeView();
  22             tv.Nodes.Add("text");
  23             Assert.AreEqual(1, tv.Nodes.Count, "#A1");
  24             Assert.AreEqual("text", tv.Nodes[0].Text, "#A2");
  25 #if NET_2_0
  26             Assert.AreEqual("", tv.Nodes[0].Name, "#A3");
  27 #endif
  28             tv.Nodes.Clear();
  29
  30             tv.Nodes.Add(new TreeNode());
  31             Assert.AreEqual("", tv.Nodes[0].Text, "#B1");
  32 #if NET_2_0
  33             Assert.AreEqual("", tv.Nodes[0].Name, "#B2");
  34 #endif
  35
  36 #if NET_2_0
  37             tv.Nodes.Clear();
  38
  39             tv.Nodes.Add("key", "text");
  40             Assert.AreEqual("text", tv.Nodes[0].Text, "#C1");
  41             Assert.AreEqual("key", tv.Nodes[0].Name, "#C2");
  42 #endif
  43
  44 #if NET_2_0
  45             tv.Nodes.Clear();
  46             imglist = new ImageList();
  47             imglist.Images.Add("image key", new Bitmap(16, 16));
  48
  49             tv.Nodes.Add("key", "text", 0);
  50             Assert.AreEqual("text", tv.Nodes[0].Text, "#D1");
  51             Assert.AreEqual("key", tv.Nodes[0].Name, "#D2");
  52             Assert.AreEqual(0, tv.Nodes[0].ImageIndex, "#D3");
  53             Assert.AreEqual("", tv.Nodes[0].ImageKey, "#D4");
  54 #endif
  55
  56 #if NET_2_0
  57             tv.Nodes.Clear();
  58             imglist = new ImageList();
  59             imglist.Images.Add("image key", new Bitmap(16, 16));
  60
  61             tv.Nodes.Add("key", "text", "image key");
  62             Assert.AreEqual("text", tv.Nodes[0].Text, "#E1");
  63             Assert.AreEqual("key", tv.Nodes[0].Name, "#E2");
  64             Assert.AreEqual(-1, tv.Nodes[0].ImageIndex, "#E3");
  65             Assert.AreEqual("image key", tv.Nodes[0].ImageKey, "#E4");
  66 #endif
  67
  68 #if NET_2_0
  69             tv.Nodes.Clear();
  70             imglist = new ImageList();
  71             imglist.Images.Add("image key", new Bitmap(16, 16));
  72             imglist.Images.Add("selected image key", new Bitmap(16, 16));
  73
  74             tv.Nodes.Add("key", "text", 0, 1);
  75             Assert.AreEqual("text", tv.Nodes[0].Text, "#F1");
  76             Assert.AreEqual("key", tv.Nodes[0].Name, "#F2");
  77             Assert.AreEqual(0, tv.Nodes[0].ImageIndex, "#F3");
  78             Assert.AreEqual("", tv.Nodes[0].ImageKey, "#F4");
  79             Assert.AreEqual(1, tv.Nodes[0].SelectedImageIndex, "#F5");
  80             Assert.AreEqual("", tv.Nodes[0].SelectedImageKey, "#F6");
  81 #endif
  82
  83 #if NET_2_0
  84             tv.Nodes.Clear();
  85             imglist = new ImageList();
  86             imglist.Images.Add("image key", new Bitmap(16, 16));
  87             imglist.Images.Add("selected image key", new Bitmap(16, 16));
  88
  89             tv.Nodes.Add("key", "text", "image key", "selected image key");
  90             Assert.AreEqual("text", tv.Nodes[0].Text, "#G1");
  91             Assert.AreEqual("key", tv.Nodes[0].Name, "#G2");
  92             Assert.AreEqual(-1, tv.Nodes[0].ImageIndex, "#G3");
  93             Assert.AreEqual("image key", tv.Nodes[0].ImageKey, "#G4");
  94             Assert.AreEqual(-1, tv.Nodes[0].SelectedImageIndex, "#G5");
  95             Assert.AreEqual("selected image key", tv.Nodes[0].SelectedImageKey, "#G6");
  96 #endif
  97
  98 #if NET_2_0
  99             tv.Nodes.Clear();
 100             tv.Nodes.Add("key", "text");
 101             tv.Nodes.Add("key", "text 2");
 102             Assert.AreEqual(2, tv.Nodes.Count, "#H1");
 103             Assert.AreEqual("text", tv.Nodes[0].Text, "#H1");
 104             Assert.AreEqual("key", tv.Nodes[0].Name, "#H2");
 105             Assert.AreEqual("text 2", tv.Nodes[1].Text, "#H1");
 106             Assert.AreEqual("key", tv.Nodes[1].Name, "#H2");
 107
 108             Assert.IsTrue(tv.Nodes.ContainsKey("key"), "#I1");
 109             Assert.AreEqual(0, tv.Nodes.IndexOfKey("key"), "#I2");
 110 #endif
 111         }
 112
 113                 [Test]
 114                 public void Remove ()
 115                 {
 116                         TreeView tv = new TreeView ();
 117                         TreeNode nodeA = tv.Nodes.Add ("A");
 118                         TreeNode nodeB = tv.Nodes.Add ("B");
 119                         TreeNode nodeC = tv.Nodes.Add ("C");
 120                         Assert.AreEqual (3, tv.Nodes.Count, "#A1");
 121                         Assert.AreSame (nodeA, tv.Nodes [0], "#A2");
 122                         Assert.AreSame (nodeB, tv.Nodes [1], "#A3");
 123                         Assert.AreSame (nodeC, tv.Nodes [2], "#A3");
 124                         tv.Nodes.Remove (nodeB);
 125                         Assert.AreEqual (2, tv.Nodes.Count, "#B1");
 126                         Assert.AreSame (nodeA, tv.Nodes [0], "#B2");
 127                         Assert.AreSame (nodeC, tv.Nodes [1], "#B3");
 128                         tv.Nodes.Remove (nodeA);
 129                         Assert.AreEqual (1, tv.Nodes.Count, "#C1");
 130                         Assert.AreSame (nodeC, tv.Nodes [0], "#C2");
 131                         tv.Nodes.Remove (nodeC);
 132                         Assert.AreEqual (0, tv.Nodes.Count, "#D1");
 133                 }
 134
 135                 [Test]
 136 #if ONLY_1_1
 137                 [ExpectedException (typeof (NullReferenceException))]
 138 #endif
 139                 public void Remove_NotInCollection ()
 140                 {
 141                         TreeView tv = new TreeView ();
 142                         TreeNode nodeA = tv.Nodes.Add ("A");
 143                         tv.Nodes.Remove (nodeA);
 144                         tv.Nodes.Remove (nodeA);
 145                 }
 146
 147                 [Test]
 148                 [ExpectedException (typeof (NullReferenceException))]
 149                 public void Remove_Null ()
 150                 {
 151                         TreeView tv = new TreeView ();
 152                         tv.Nodes.Remove (null);
 153                 }
 154
 155                 [Test]
 156                 public void Enumerator_Reset ()
 157                 {
 158                         TreeView tv = new TreeView ();
 159                         TreeNode nodeA = tv.Nodes.Add ("A");
 160                         IEnumerator enumerator = tv.Nodes.GetEnumerator ();
 161                         Assert.IsNull (enumerator.Current, "#A1");
 162                         Assert.IsTrue (enumerator.MoveNext (), "#A2");
 163                         Assert.IsNotNull (enumerator.Current, "#A3");
 164                         Assert.AreSame (nodeA, enumerator.Current, "#A4");
 165                         Assert.IsFalse (enumerator.MoveNext (), "#A5");
 166                         enumerator.Reset ();
 167                         Assert.IsNull (enumerator.Current, "#B1");
 168                         Assert.IsTrue (enumerator.MoveNext (), "#B2");
 169                         Assert.IsNotNull (enumerator.Current, "#B3");
 170                         Assert.AreSame (nodeA, enumerator.Current, "#B4");
 171                         Assert.IsFalse (enumerator.MoveNext (), "#B5");
 172                 }
 173
 174                 [Test]
 175                 public void Enumerator_MoveNext ()
 176                 {
 177                         TreeView tv = new TreeView ();
 178                         TreeNode nodeA = tv.Nodes.Add ("A");
 179
 180                         TestHelper.RemoveWarning (nodeA);
 181
 182                         IEnumerator enumerator = tv.Nodes.GetEnumerator ();
 183                         Assert.IsTrue (enumerator.MoveNext (), "#A1");
 184                         Assert.IsFalse (enumerator.MoveNext (), "#A2");
 185                         Assert.IsFalse (enumerator.MoveNext (), "#A3");
 186
 187                         tv = new TreeView ();
 188                         enumerator = tv.Nodes.GetEnumerator ();
 189                         Assert.IsFalse (enumerator.MoveNext (), "#B1");
 190                         Assert.IsFalse (enumerator.MoveNext (), "#B2");
 191                 }
 192
 193                 [Test]
 194                 public void Enumerator_Current ()
 195                 {
 196                         TreeView tv = new TreeView ();
 197                         TreeNode nodeA = tv.Nodes.Add ("A");
 198                         TreeNode nodeB = tv.Nodes.Add ("B");
 199                         IEnumerator enumerator = tv.Nodes.GetEnumerator ();
 200                         Assert.IsNull (enumerator.Current, "#A1");
 201                         enumerator.MoveNext ();
 202                         Assert.IsNotNull (enumerator.Current, "#A2");
 203                         Assert.AreSame (nodeA, enumerator.Current, "#A3");
 204                         enumerator.MoveNext ();
 205                         Assert.IsNotNull (enumerator.Current, "#A4");
 206                         Assert.AreSame (nodeB, enumerator.Current, "#A5");
 207                         enumerator.MoveNext ();
 208                         Assert.IsNotNull (enumerator.Current, "#A6");
 209                         Assert.AreSame (nodeB, enumerator.Current, "#A7");
 210
 211                         tv = new TreeView ();
 212                         enumerator = tv.Nodes.GetEnumerator ();
 213                         Assert.IsNull (enumerator.Current, "#B1");
 214                         enumerator.MoveNext ();
 215                         Assert.IsNull (enumerator.Current, "#B2");
 216                 }
 217
 218                 [Test]
 219                 public void IList_Indexer_Get ()
 220                 {
 221                         TreeView tv = new TreeView ();
 222                         TreeNode nodeA = tv.Nodes.Add ("A");
 223                         TreeNode nodeB = tv.Nodes.Add ("B");
 224                         TreeNode nodeC = tv.Nodes.Add ("C");
 225
 226                         IList list = (IList) tv.Nodes;
 227
 228                         Assert.AreSame (nodeA, list [0], "#A1");
 229                         Assert.AreSame (nodeB, list [1], "#A2");
 230                         Assert.AreSame (nodeC, list [2], "#A3");
 231
 232                         try {
 233                                 object item = list [3];
 234                                 Assert.Fail ("#B1: " + item);
 235                         } catch (ArgumentOutOfRangeException ex) {
 236                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 237                                 Assert.IsNull (ex.ActualValue, "#B3");
 238                                 Assert.IsNull (ex.InnerException, "#B4");
 239                                 Assert.AreEqual ("index", ex.ParamName, "#B5");
 240                         }
 241
 242                         try {
 243                                 object item = list [-1];
 244                                 Assert.Fail ("#C1: " + item);
 245                         } catch (ArgumentOutOfRangeException ex) {
 246                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 247                                 Assert.IsNull (ex.ActualValue, "#C3");
 248                                 Assert.IsNull (ex.InnerException, "#C4");
 249                                 Assert.AreEqual ("index", ex.ParamName, "#C5");
 250                         }
 251                 }
 252
 253                 [Test]
 254                 public void IList_Indexer_Set ()
 255                 {
 256                         TreeView tv = new TreeView ();
 257                         TreeNode nodeA = tv.Nodes.Add ("A");
 258
 259                         IList list = (IList) tv.Nodes;
 260                         TreeNode nodeB = new TreeNode ("B");
 261                         list [0] = nodeB;
 262                         Assert.AreSame (nodeB, list [0], "#A1");
 263
 264                         try {
 265                                 list [1] = nodeA;
 266                                 Assert.Fail ("#B1");
 267                         } catch (ArgumentOutOfRangeException ex) {
 268                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 269                                 Assert.IsNull (ex.ActualValue, "#B3");
 270                                 Assert.IsNull (ex.InnerException, "#B4");
 271 #if NET_2_0
 272                                 Assert.AreEqual ("index", ex.ParamName, "#B5");
 273 #endif
 274                         }
 275
 276                         try {
 277                                 list [-1] = nodeA;
 278                                 Assert.Fail ("#C1");
 279                         } catch (ArgumentOutOfRangeException ex) {
 280                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 281                                 Assert.IsNull (ex.ActualValue, "#C3");
 282                                 Assert.IsNull (ex.InnerException, "#C4");
 283 #if NET_2_0
 284                                 Assert.AreEqual ("index", ex.ParamName, "#C5");
 285 #endif
 286                         }
 287
 288                         try {
 289                                 list [0] = "whatever";
 290                                 Assert.Fail ("#D1");
 291                         } catch (ArgumentException ex) {
 292                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 293                                 Assert.IsNull (ex.InnerException, "#D3");
 294                                 Assert.IsNull (ex.ParamName, "#D4");
 295                         }
 296                 }
 297
 298 #if NET_2_0
 299                 [Test]
 300                 public void ContainsKey ()
 301                 {
 302                         TreeView tv = new TreeView ();
 303
 304                         for (int i = 0; i < 10; i++) {
 305                                 TreeNode node = new TreeNode ();
 306                                 node.Name = i.ToString ();
 307                                 tv.Nodes.Add (node);
 308                         }
 309
 310                         for (int i = 0; i < 10; i++)
 311                                 Assert.IsTrue (tv.Nodes.ContainsKey (i.ToString ()), "#CK1");
 312
 313                         Assert.AreEqual (false, tv.Nodes.ContainsKey ("42"), "#CK2");
 314                 }
 315
 316                 [Test]
 317                 public void IndexOfKey ()
 318                 {
 319                         TreeView tv = new TreeView ();
 320
 321                         for (int i = 0; i < 10; i++) {
 322                                 TreeNode node = new TreeNode ();
 323                                 node.Name = i.ToString ();
 324                                 tv.Nodes.Add (node);
 325                         }
 326
 327                         for (int i = 0; i < 10; i++)
 328                                 Assert.AreEqual (tv.Nodes.IndexOfKey (i.ToString ()), i, "#KI1");
 329
 330                         Assert.AreEqual (-1, tv.Nodes.IndexOfKey ("42"), "#KI2");
 331                 }
 332 #endif
 333         }
 334 }