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                 [Test]
  14                 public void Remove ()
  15                 {
  16                         TreeView tv = new TreeView ();
  17                         TreeNode nodeA = tv.Nodes.Add ("A");
  18                         TreeNode nodeB = tv.Nodes.Add ("B");
  19                         TreeNode nodeC = tv.Nodes.Add ("C");
  20                         Assert.AreEqual (3, tv.Nodes.Count, "#A1");
  21                         Assert.AreSame (nodeA, tv.Nodes [0], "#A2");
  22                         Assert.AreSame (nodeB, tv.Nodes [1], "#A3");
  23                         Assert.AreSame (nodeC, tv.Nodes [2], "#A3");
  24                         tv.Nodes.Remove (nodeB);
  25                         Assert.AreEqual (2, tv.Nodes.Count, "#B1");
  26                         Assert.AreSame (nodeA, tv.Nodes [0], "#B2");
  27                         Assert.AreSame (nodeC, tv.Nodes [1], "#B3");
  28                         tv.Nodes.Remove (nodeA);
  29                         Assert.AreEqual (1, tv.Nodes.Count, "#C1");
  30                         Assert.AreSame (nodeC, tv.Nodes [0], "#C2");
  31                         tv.Nodes.Remove (nodeC);
  32                         Assert.AreEqual (0, tv.Nodes.Count, "#D1");
  33                 }
  34
  35                 [Test]
  36 #if ONLY_1_1
  37                 [ExpectedException (typeof (NullReferenceException))]
  38 #endif
  39                 public void Remove_NotInCollection ()
  40                 {
  41                         TreeView tv = new TreeView ();
  42                         TreeNode nodeA = tv.Nodes.Add ("A");
  43                         tv.Nodes.Remove (nodeA);
  44                         tv.Nodes.Remove (nodeA);
  45                 }
  46
  47                 [Test]
  48                 [ExpectedException (typeof (NullReferenceException))]
  49                 public void Remove_Null ()
  50                 {
  51                         TreeView tv = new TreeView ();
  52                         tv.Nodes.Remove (null);
  53                 }
  54
  55                 [Test]
  56                 public void Enumerator_Reset ()
  57                 {
  58                         TreeView tv = new TreeView ();
  59                         TreeNode nodeA = tv.Nodes.Add ("A");
  60                         IEnumerator enumerator = tv.Nodes.GetEnumerator ();
  61                         Assert.IsNull (enumerator.Current, "#A1");
  62                         Assert.IsTrue (enumerator.MoveNext (), "#A2");
  63                         Assert.IsNotNull (enumerator.Current, "#A3");
  64                         Assert.AreSame (nodeA, enumerator.Current, "#A4");
  65                         Assert.IsFalse (enumerator.MoveNext (), "#A5");
  66                         enumerator.Reset ();
  67                         Assert.IsNull (enumerator.Current, "#B1");
  68                         Assert.IsTrue (enumerator.MoveNext (), "#B2");
  69                         Assert.IsNotNull (enumerator.Current, "#B3");
  70                         Assert.AreSame (nodeA, enumerator.Current, "#B4");
  71                         Assert.IsFalse (enumerator.MoveNext (), "#B5");
  72                 }
  73
  74                 [Test]
  75                 public void Enumerator_MoveNext ()
  76                 {
  77                         TreeView tv = new TreeView ();
  78                         TreeNode nodeA = tv.Nodes.Add ("A");
  79                         IEnumerator enumerator = tv.Nodes.GetEnumerator ();
  80                         Assert.IsTrue (enumerator.MoveNext (), "#A1");
  81                         Assert.IsFalse (enumerator.MoveNext (), "#A2");
  82                         Assert.IsFalse (enumerator.MoveNext (), "#A3");
  83
  84                         tv = new TreeView ();
  85                         enumerator = tv.Nodes.GetEnumerator ();
  86                         Assert.IsFalse (enumerator.MoveNext (), "#B1");
  87                         Assert.IsFalse (enumerator.MoveNext (), "#B2");
  88                 }
  89
  90                 [Test]
  91                 public void Enumerator_Current ()
  92                 {
  93                         TreeView tv = new TreeView ();
  94                         TreeNode nodeA = tv.Nodes.Add ("A");
  95                         TreeNode nodeB = tv.Nodes.Add ("B");
  96                         IEnumerator enumerator = tv.Nodes.GetEnumerator ();
  97                         Assert.IsNull (enumerator.Current, "#A1");
  98                         enumerator.MoveNext ();
  99                         Assert.IsNotNull (enumerator.Current, "#A2");
 100                         Assert.AreSame (nodeA, enumerator.Current, "#A3");
 101                         enumerator.MoveNext ();
 102                         Assert.IsNotNull (enumerator.Current, "#A4");
 103                         Assert.AreSame (nodeB, enumerator.Current, "#A5");
 104                         enumerator.MoveNext ();
 105                         Assert.IsNotNull (enumerator.Current, "#A6");
 106                         Assert.AreSame (nodeB, enumerator.Current, "#A7");
 107
 108                         tv = new TreeView ();
 109                         enumerator = tv.Nodes.GetEnumerator ();
 110                         Assert.IsNull (enumerator.Current, "#B1");
 111                         enumerator.MoveNext ();
 112                         Assert.IsNull (enumerator.Current, "#B2");
 113                 }
 114
 115                 [Test]
 116                 public void IList_Indexer_Get ()
 117                 {
 118                         TreeView tv = new TreeView ();
 119                         TreeNode nodeA = tv.Nodes.Add ("A");
 120                         TreeNode nodeB = tv.Nodes.Add ("B");
 121                         TreeNode nodeC = tv.Nodes.Add ("C");
 122
 123                         IList list = (IList) tv.Nodes;
 124
 125                         Assert.AreSame (nodeA, list [0], "#A1");
 126                         Assert.AreSame (nodeB, list [1], "#A2");
 127                         Assert.AreSame (nodeC, list [2], "#A3");
 128
 129                         try {
 130                                 object item = list [3];
 131                                 Assert.Fail ("#B1: " + item);
 132                         } catch (ArgumentOutOfRangeException ex) {
 133                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 134                                 Assert.IsNull (ex.ActualValue, "#B3");
 135                                 Assert.IsNull (ex.InnerException, "#B4");
 136                                 Assert.AreEqual ("index", ex.ParamName, "#B5");
 137                         }
 138
 139                         try {
 140                                 object item = list [-1];
 141                                 Assert.Fail ("#C1: " + item);
 142                         } catch (ArgumentOutOfRangeException ex) {
 143                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 144                                 Assert.IsNull (ex.ActualValue, "#C3");
 145                                 Assert.IsNull (ex.InnerException, "#C4");
 146                                 Assert.AreEqual ("index", ex.ParamName, "#C5");
 147                         }
 148                 }
 149
 150                 [Test]
 151                 public void IList_Indexer_Set ()
 152                 {
 153                         TreeView tv = new TreeView ();
 154                         TreeNode nodeA = tv.Nodes.Add ("A");
 155
 156                         IList list = (IList) tv.Nodes;
 157                         TreeNode nodeB = new TreeNode ("B");
 158                         list [0] = nodeB;
 159                         Assert.AreSame (nodeB, list [0], "#A1");
 160
 161                         try {
 162                                 list [1] = nodeA;
 163                                 Assert.Fail ("#B1");
 164                         } catch (ArgumentOutOfRangeException ex) {
 165                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 166                                 Assert.IsNull (ex.ActualValue, "#B3");
 167                                 Assert.IsNull (ex.InnerException, "#B4");
 168 #if NET_2_0
 169                                 Assert.AreEqual ("index", ex.ParamName, "#B5");
 170 #endif
 171                         }
 172
 173                         try {
 174                                 list [-1] = nodeA;
 175                                 Assert.Fail ("#C1");
 176                         } catch (ArgumentOutOfRangeException ex) {
 177                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 178                                 Assert.IsNull (ex.ActualValue, "#C3");
 179                                 Assert.IsNull (ex.InnerException, "#C4");
 180 #if NET_2_0
 181                                 Assert.AreEqual ("index", ex.ParamName, "#C5");
 182 #endif
 183                         }
 184
 185                         try {
 186                                 list [0] = "whatever";
 187                                 Assert.Fail ("#D1");
 188                         } catch (ArgumentException ex) {
 189                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 190                                 Assert.IsNull (ex.InnerException, "#D3");
 191                                 Assert.IsNull (ex.ParamName, "#D4");
 192                         }
 193                 }
 194         }
 195 }