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

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