mcs/class/System.XML/Test/System.Xml/XmlNodeListTests.cs

   1 //
   2 // System.Xml.XmlTextWriterTests
   3 //
   4 // Authors:
   5 //   Kral Ferch <kral_ferch@hotmail.com>
   6 //   Martin Willemoes Hansen <mwh@sysrq.dk>
   7 //
   8 // (C) 2002 Kral Ferch
   9 // (C) 2003 Martin Willemoes Hansen
  10 //
  11
  12 using System;
  13 using System.Xml;
  14 using System.Collections;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.System.Xml
  19 {
  20         [TestFixture]
  21         public class XmlNodeListTests : Assertion
  22         {
  23                 XmlDocument document;
  24                 XmlElement documentElement;
  25                 XmlElement element;
  26                 XmlNode node;
  27                 Object obj;
  28                 IEnumerator enumerator;
  29                 int index;
  30
  31                 [SetUp]
  32                 public void GetReady ()
  33                 {
  34                         document = new XmlDocument ();
  35                 }
  36
  37                 [Test]
  38                 public void NodeTypesThatCantHaveChildren ()
  39                 {
  40                         document.LoadXml ("<foo>bar</foo>");
  41                         documentElement = document.DocumentElement;
  42                         node = documentElement.FirstChild;
  43                         AssertEquals ("Expected a text node.", node.NodeType, XmlNodeType.Text);
  44                         AssertEquals ("Shouldn't have children.", node.HasChildNodes, false);
  45                         AssertEquals ("Should be empty node list.", node.ChildNodes.Count, 0);
  46                         AssertEquals ("Should be empty node list.", node.GetEnumerator().MoveNext(), false);
  47                 }
  48
  49                 [Test]
  50                 public void ZeroChildren ()
  51                 {
  52                         document.LoadXml ("<foo/>");
  53                         documentElement = document.DocumentElement;
  54                         AssertEquals ("Should be empty node list.", documentElement.GetEnumerator().MoveNext(), false);
  55                 }
  56
  57                 [Test]
  58                 public void OneChild ()
  59                 {
  60                         document.LoadXml ("<foo><child1/></foo>");
  61                         documentElement = document.DocumentElement;
  62                         AssertEquals ("Incorrect number of children returned from Count property.", documentElement.ChildNodes.Count, 1);
  63                         index = 1;
  64                         foreach (XmlNode childNode in documentElement.ChildNodes)
  65                         {
  66                                 AssertEquals ("Enumerator didn't return correct node.", "child" + index.ToString(), childNode.LocalName);
  67                                 index++;
  68                         }
  69                         AssertEquals ("foreach didn't loop over all children correctly.", index, 2);
  70                 }
  71
  72                 [Test]
  73                 public void MultipleChildren ()
  74                 {
  75                         document.LoadXml ("<foo><child1/><child2/><child3/></foo>");
  76                         element = document.DocumentElement;
  77                         AssertEquals ("Incorrect number of children returned from Count property.", element.ChildNodes.Count, 3);
  78                         AssertNull ("Index less than zero should have returned null.", element.ChildNodes [-1]);
  79                         AssertNull ("Index greater than or equal to Count should have returned null.", element.ChildNodes [3]);
  80                         AssertEquals ("Didn't return the correct child.", element.FirstChild, element.ChildNodes[0]);
  81                         AssertEquals ("Didn't return the correct child.", "child1", element.ChildNodes[0].LocalName);
  82                         AssertEquals ("Didn't return the correct child.", "child2", element.ChildNodes[1].LocalName);
  83                         AssertEquals ("Didn't return the correct child.", "child3", element.ChildNodes[2].LocalName);
  84
  85                         index = 1;
  86                         foreach (XmlNode childNode in element.ChildNodes)
  87                         {
  88                                 AssertEquals ("Enumerator didn't return correct node.", "child" + index.ToString(), childNode.LocalName);
  89                                 index++;
  90                         }
  91                         AssertEquals ("foreach didn't loop over all children correctly.", index, 4);
  92                 }
  93
  94                 [Test]
  95                 public void AppendChildAffectOnEnumeration ()
  96                 {
  97                         document.LoadXml ("<foo><child1/></foo>");
  98                         element = document.DocumentElement;
  99                         enumerator = element.GetEnumerator();
 100                         AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
 101                         AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
 102                         enumerator.Reset();
 103                         AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
 104                         element.AppendChild(document.CreateElement("child2"));
 105                         AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
 106                         AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
 107                 }
 108
 109                 [Test]
 110                 public void RemoveChildAffectOnEnumeration ()
 111                 {
 112                         document.LoadXml ("<foo><child1/><child2/></foo>");
 113                         element = document.DocumentElement;
 114                         enumerator = element.GetEnumerator();
 115                         element.RemoveChild(element.FirstChild);
 116                         enumerator.MoveNext();
 117                         AssertEquals ("Expected child2 element.", ((XmlElement)enumerator.Current).LocalName, "child2");
 118                 }
 119
 120                 [Test]
 121                 public void RemoveChildAffectOnEnumerationWhenEnumeratorIsOnRemovedChild ()
 122                 {
 123                         document.LoadXml ("<foo><child1/><child2/><child3/></foo>");
 124                         element = document.DocumentElement;
 125                         enumerator = element.GetEnumerator ();
 126                         enumerator.MoveNext ();
 127                         enumerator.MoveNext ();
 128                         AssertEquals ("Expected child2 element.", "child2", ((XmlElement)enumerator.Current).LocalName);
 129                         AssertEquals ("Expected child2 element.", "child2", element.FirstChild.NextSibling.LocalName);
 130                         element.RemoveChild (element.FirstChild.NextSibling);
 131                         enumerator.MoveNext ();
 132
 133                         try {
 134                                 element = (XmlElement) enumerator.Current;
 135                                 Fail ("Expected an InvalidOperationException.");
 136                         } catch (InvalidOperationException) { }
 137                 }
 138
 139                 // TODO:  Take the word save off front of this method when XmlNode.ReplaceChild() is implemented.
 140
 141                 public void saveTestReplaceChildAffectOnEnumeration ()
 142                 {
 143                         document.LoadXml ("<foo><child1/><child2/></foo>");
 144                         element = document.DocumentElement;
 145                         node = document.CreateElement("child3");
 146                         enumerator = element.GetEnumerator();
 147                         AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
 148                         element.ReplaceChild(node, element.LastChild);
 149                         enumerator.MoveNext();
 150                         AssertEquals ("Expected child3 element.", ((XmlElement)enumerator.Current).LocalName, "child3");
 151                         AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
 152                 }
 153
 154                 [Test]
 155                 public void RemoveOnlyChildAffectOnEnumeration ()
 156                 {
 157                         document.LoadXml ("<foo><child1/></foo>");
 158                         element = document.DocumentElement;
 159                         enumerator = element.GetEnumerator();
 160                         element.RemoveChild(element.FirstChild);
 161                         AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
 162                 }
 163
 164                 // TODO:  Take the word save off front of this method when XmlNode.RemoveAll() is fully implemented.
 165
 166                 public void saveTestRemoveAllAffectOnEnumeration ()
 167                 {
 168                         document.LoadXml ("<foo><child1/><child2/><child3/></foo>");
 169                         element = document.DocumentElement;
 170                         enumerator = element.GetEnumerator();
 171                         AssertEquals ("Expected 3 children.", element.ChildNodes.Count, 3);
 172                         AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
 173                         element.RemoveAll();
 174                         AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
 175                 }
 176
 177                 [Test]
 178                 public void CurrentBeforeFirstNode ()
 179                 {
 180                         document.LoadXml ("<foo><child1/></foo>");
 181                         element = document.DocumentElement;
 182                         enumerator = element.GetEnumerator();
 183                         try
 184                         {
 185                                 obj = enumerator.Current;
 186                                 Fail ("Calling Current property before first node in list should have thrown InvalidOperationException.");
 187                         } catch (InvalidOperationException) { }
 188                 }
 189
 190                 [Test]
 191                 public void CurrentAfterLastNode ()
 192                 {
 193                         document.LoadXml ("<foo><child1/></foo>");
 194                         element = document.DocumentElement;
 195                         enumerator = element.GetEnumerator();
 196                         enumerator.MoveNext();
 197                         enumerator.MoveNext();
 198                         try
 199                         {
 200                                 obj = enumerator.Current;
 201                                 Fail ("Calling Current property after last node in list should have thrown InvalidOperationException.");
 202                         }
 203                         catch (InvalidOperationException) { }
 204                 }
 205
 206                 [Test]
 207                 public void CurrentDoesntMove ()
 208                 {
 209                         document.LoadXml ("<foo><child1/></foo>");
 210                         element = document.DocumentElement;
 211                         enumerator = element.GetEnumerator();
 212                         enumerator.MoveNext();
 213                         AssertEquals("Consecutive calls to Current property should yield same reference.", Object.ReferenceEquals(enumerator.Current, enumerator.Current), true);
 214                 }
 215
 216                 [Test]
 217                 public void Reset ()
 218                 {
 219                         document.LoadXml ("<foo><child1/><child2/></foo>");
 220                         element = document.DocumentElement;
 221                         enumerator = element.GetEnumerator();
 222                         enumerator.MoveNext();
 223                         enumerator.MoveNext();
 224                         AssertEquals("Expected child2.", ((XmlElement)enumerator.Current).LocalName, "child2");
 225                         enumerator.Reset();
 226                         enumerator.MoveNext();
 227                         AssertEquals("Expected child1.", ((XmlElement)enumerator.Current).LocalName, "child1");
 228                 }
 229
 230                 [Test]
 231                 public void ReturnNullWhenIndexIsOutOfRange ()
 232                 {
 233                         document.LoadXml ("<root><foo/></root>");
 234                         XmlNodeList nl = document.DocumentElement.GetElementsByTagName ("bar");
 235                         AssertEquals ("empty list. count", 0, nl.Count);
 236                         try {
 237                                 AssertNull ("index 0", nl [0]);
 238                                 AssertNull ("index 1", nl [1]);
 239                                 AssertNull ("index -1", nl [-1]);
 240                         } catch (ArgumentOutOfRangeException) {
 241                                 Fail ("don't throw index out of range.");
 242                         }
 243                 }
 244         }
 245 }