mcs/class/System.XML/Test/System.Xml.XPath/XPathNavigatorTests.cs

   1 //
   2 // MonoTests.System.Xml.XPathNavigatorTests
   3 //
   4 // Authors:
   5 //   Jason Diamond <jason@injektilo.org>
   6 //   Martin Willemoes Hansen <mwh@sysrq.dk>
   7 //
   8 // (C) 2002 Jason Diamond
   9 // (C) 2003 Martin Willemoes Hansen
  10 //
  11
  12 using System;
  13 using System.IO;
  14 using System.Xml;
  15 using System.Xml.XPath;
  16
  17 using NUnit.Framework;
  18
  19 namespace MonoTests.System.Xml
  20 {
  21         [TestFixture]
  22         public class XPathNavigatorTests : Assertion
  23         {
  24                 XmlDocument document;
  25                 XPathNavigator navigator;
  26
  27                 [SetUp]
  28                 public void GetReady ()
  29                 {
  30                         document = new XmlDocument ();
  31                 }
  32
  33                 [Test]
  34                 public void CreateNavigator ()
  35                 {
  36                         document.LoadXml ("<foo />");
  37                         navigator = document.CreateNavigator ();
  38                         AssertNotNull (navigator);
  39                 }
  40
  41                 [Test]
  42                 public void PropertiesOnDocument ()
  43                 {
  44                         document.LoadXml ("<foo:bar xmlns:foo='#foo' />");
  45                         navigator = document.CreateNavigator ();
  46
  47                         AssertEquals (XPathNodeType.Root, navigator.NodeType);
  48                         AssertEquals (String.Empty, navigator.Name);
  49                         AssertEquals (String.Empty, navigator.LocalName);
  50                         AssertEquals (String.Empty, navigator.NamespaceURI);
  51                         AssertEquals (String.Empty, navigator.Prefix);
  52                         Assert (!navigator.HasAttributes);
  53                         Assert (navigator.HasChildren);
  54                         Assert (!navigator.IsEmptyElement);
  55                 }
  56
  57                 [Test]
  58                 public void PropertiesOnElement ()
  59                 {
  60                         document.LoadXml ("<foo:bar xmlns:foo='#foo' />");
  61                         navigator = document.DocumentElement.CreateNavigator ();
  62
  63                         AssertEquals (XPathNodeType.Element, navigator.NodeType);
  64                         AssertEquals ("foo:bar", navigator.Name);
  65                         AssertEquals ("bar", navigator.LocalName);
  66                         AssertEquals ("#foo", navigator.NamespaceURI);
  67                         AssertEquals ("foo", navigator.Prefix);
  68                         Assert (!navigator.HasAttributes);
  69                         Assert (!navigator.HasChildren);
  70                         Assert (navigator.IsEmptyElement);
  71                 }
  72
  73                 [Test]
  74                 public void PropertiesOnAttribute ()
  75                 {
  76                         document.LoadXml ("<foo bar:baz='quux' xmlns:bar='#bar' />");
  77                         navigator = document.DocumentElement.GetAttributeNode("baz", "#bar").CreateNavigator ();
  78
  79                         AssertEquals (XPathNodeType.Attribute, navigator.NodeType);
  80                         AssertEquals ("bar:baz", navigator.Name);
  81                         AssertEquals ("baz", navigator.LocalName);
  82                         AssertEquals ("#bar", navigator.NamespaceURI);
  83                         AssertEquals ("bar", navigator.Prefix);
  84                         Assert (!navigator.HasAttributes);
  85                         Assert (!navigator.HasChildren);
  86                         Assert (!navigator.IsEmptyElement);
  87                 }
  88
  89                 [Test]
  90                 public void PropertiesOnNamespace ()
  91                 {
  92                         document.LoadXml ("<root xmlns='urn:foo' />");\r
  93                         navigator = document.DocumentElement.Attributes [0].CreateNavigator ();\r
  94                         AssertEquals (XPathNodeType.Namespace, navigator.NodeType);
  95                 }
  96
  97                 [Test]
  98                 public void Navigation ()
  99                 {
 100                         document.LoadXml ("<foo><bar /><baz /></foo>");
 101                         navigator = document.DocumentElement.CreateNavigator ();
 102
 103                         AssertEquals ("foo", navigator.Name);
 104                         Assert (navigator.MoveToFirstChild ());
 105                         AssertEquals ("bar", navigator.Name);
 106                         Assert (navigator.MoveToNext ());
 107                         AssertEquals ("baz", navigator.Name);
 108                         Assert (!navigator.MoveToNext ());
 109                         AssertEquals ("baz", navigator.Name);
 110                         Assert (navigator.MoveToPrevious ());
 111                         AssertEquals ("bar", navigator.Name);
 112                         Assert (!navigator.MoveToPrevious ());
 113                         Assert (navigator.MoveToParent ());
 114                         AssertEquals ("foo", navigator.Name);
 115                         navigator.MoveToRoot ();
 116                         AssertEquals (XPathNodeType.Root, navigator.NodeType);
 117                         Assert (!navigator.MoveToParent ());
 118                         AssertEquals (XPathNodeType.Root, navigator.NodeType);
 119                         Assert (navigator.MoveToFirstChild ());
 120                         AssertEquals ("foo", navigator.Name);
 121                         Assert (navigator.MoveToFirst ());
 122                         AssertEquals ("foo", navigator.Name);
 123                         Assert (navigator.MoveToFirstChild ());
 124                         AssertEquals ("bar", navigator.Name);
 125                         Assert (navigator.MoveToNext ());
 126                         AssertEquals ("baz", navigator.Name);
 127                         Assert (navigator.MoveToFirst ());
 128                         AssertEquals ("bar", navigator.Name);
 129                 }
 130
 131                 [Test]
 132                 public void MoveToAndIsSamePosition ()
 133                 {
 134                         XmlDocument document1 = new XmlDocument ();
 135                         document1.LoadXml ("<foo><bar /></foo>");
 136                         XPathNavigator navigator1a = document1.DocumentElement.CreateNavigator ();
 137                         XPathNavigator navigator1b = document1.DocumentElement.CreateNavigator ();
 138
 139                         XmlDocument document2 = new XmlDocument ();
 140                         document2.LoadXml ("<foo><bar /></foo>");
 141                         XPathNavigator navigator2 = document2.DocumentElement.CreateNavigator ();
 142
 143                         AssertEquals ("foo", navigator1a.Name);
 144                         Assert (navigator1a.MoveToFirstChild ());
 145                         AssertEquals ("bar", navigator1a.Name);
 146
 147                         Assert (!navigator1b.IsSamePosition (navigator1a));
 148                         AssertEquals ("foo", navigator1b.Name);
 149                         Assert (navigator1b.MoveTo (navigator1a));
 150                         Assert (navigator1b.IsSamePosition (navigator1a));
 151                         AssertEquals ("bar", navigator1b.Name);
 152
 153                         Assert (!navigator2.IsSamePosition (navigator1a));
 154                         AssertEquals ("foo", navigator2.Name);
 155                         Assert (!navigator2.MoveTo (navigator1a));
 156                         AssertEquals ("foo", navigator2.Name);
 157                 }
 158
 159                 [Test]
 160                 public void AttributeNavigation ()
 161                 {
 162                         document.LoadXml ("<foo bar='baz' quux='quuux' />");
 163                         navigator = document.DocumentElement.CreateNavigator ();
 164
 165                         AssertEquals (XPathNodeType.Element, navigator.NodeType);
 166                         AssertEquals ("foo", navigator.Name);
 167                         Assert (navigator.MoveToFirstAttribute ());
 168                         AssertEquals (XPathNodeType.Attribute, navigator.NodeType);
 169                         AssertEquals ("bar", navigator.Name);
 170                         AssertEquals ("baz", navigator.Value);
 171                         Assert (navigator.MoveToNextAttribute ());
 172                         AssertEquals (XPathNodeType.Attribute, navigator.NodeType);
 173                         AssertEquals ("quux", navigator.Name);
 174                         AssertEquals ("quuux", navigator.Value);
 175                 }
 176
 177                 [Test]
 178                 public void ElementAndRootValues()
 179                 {
 180                         document.LoadXml ("<foo><bar>baz</bar><quux>quuux</quux></foo>");
 181                         navigator = document.DocumentElement.CreateNavigator ();
 182
 183                         AssertEquals (XPathNodeType.Element, navigator.NodeType);
 184                         AssertEquals ("foo", navigator.Name);
 185                         //AssertEquals ("bazquuux", navigator.Value);
 186
 187                         navigator.MoveToRoot ();
 188                         //AssertEquals ("bazquuux", navigator.Value);
 189                 }
 190
 191                 [Test]
 192                 public void DocumentWithXmlDeclaration ()
 193                 {
 194                         document.LoadXml ("<?xml version=\"1.0\" standalone=\"yes\"?><Root><foo>bar</foo></Root>");
 195                         navigator = document.CreateNavigator ();
 196
 197                         navigator.MoveToRoot ();
 198                         navigator.MoveToFirstChild ();
 199                         AssertEquals (XPathNodeType.Element, navigator.NodeType);
 200                         AssertEquals ("Root", navigator.Name);
 201                 }
 202
 203                 [Test]
 204                 public void DocumentWithProcessingInstruction ()
 205                 {
 206                         document.LoadXml ("<?xml-stylesheet href='foo.xsl' type='text/xsl' ?><foo />");
 207                         navigator = document.CreateNavigator ();
 208
 209                         Assert (navigator.MoveToFirstChild ());
 210                         AssertEquals (XPathNodeType.ProcessingInstruction, navigator.NodeType);
 211                         AssertEquals ("xml-stylesheet", navigator.Name);
 212
 213                         XPathNodeIterator iter = navigator.SelectChildren (XPathNodeType.Element);
 214                         AssertEquals (0, iter.Count);
 215                 }
 216
 217                 [Test]
 218                 public void SelectFromOrphan ()
 219                 {
 220                         // SelectSingleNode () from node without parent.
 221                         XmlDocument doc = new XmlDocument ();
 222                         doc.LoadXml ("<foo><include id='original' /></foo>");
 223
 224                         XmlNode node = doc.CreateElement ("child");
 225                         node.InnerXml = "<include id='new' />";
 226
 227                         XmlNode new_include = node.SelectSingleNode ("//include");
 228                         AssertEquals ("<include id=\"new\" />", new_include.OuterXml);
 229
 230                         // In this case 'node2' has parent 'node'
 231                         doc = new XmlDocument ();
 232                         doc.LoadXml ("<foo><include id='original' /></foo>");
 233
 234                         node = doc.CreateElement ("child");
 235                         XmlNode node2 = doc.CreateElement ("grandchild");
 236                         node.AppendChild (node2);
 237                         node2.InnerXml = "<include id='new' />";
 238
 239                         new_include = node2.SelectSingleNode ("/");
 240                         AssertEquals ("<child><grandchild><include id=\"new\" /></grandchild></child>",
 241                                 new_include.OuterXml);
 242                 }
 243
 244                 [Test]
 245                 public void XPathDocumentMoveToId ()
 246                 {
 247                         string dtd = "<!DOCTYPE root [<!ELEMENT root EMPTY><!ATTLIST root id ID #REQUIRED>]>";\r
 248                         string xml = dtd + "<root id='aaa'/>";\r
 249                         StringReader sr = new StringReader (xml);\r
 250                         XPathNavigator nav = new XPathDocument (sr).CreateNavigator ();\r
 251                         Assert ("ctor() from TextReader", nav.MoveToId ("aaa"));\r
 252
 253                         XmlValidatingReader xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 254                         nav = new XPathDocument (xvr).CreateNavigator ();\r
 255                         Assert ("ctor() from XmlValidatingReader", nav.MoveToId ("aaa"));\r
 256
 257                         // FIXME: it seems to result in different in .NET 2.0.
 258 #if NET_2_0
 259 #else
 260                         // When it is XmlTextReader, XPathDocument fails.
 261                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);\r
 262                         nav = new XPathDocument (xtr).CreateNavigator ();\r
 263                         Assert ("ctor() from XmlTextReader", !nav.MoveToId ("aaa"));\r
 264                         xtr.Close ();\r
 265 #endif
 266                 }
 267
 268                 [Test]
 269                 public void SignificantWhitespaceConstruction ()
 270                 {
 271                         string xml = @"<root>
 272         <child xml:space='preserve'>    <!-- -->   </child>
 273         <child xml:space='preserve'>    </child>
 274 </root>";
 275                         XPathNavigator nav = new XPathDocument (
 276                                 new XmlTextReader (xml, XmlNodeType.Document, null),
 277                                 XmlSpace.Preserve).CreateNavigator ();
 278                         nav.MoveToFirstChild ();
 279                         nav.MoveToFirstChild ();
 280                         AssertEquals ("#1", XPathNodeType.Whitespace, nav.NodeType);
 281                         nav.MoveToNext ();
 282                         nav.MoveToFirstChild ();
 283                         AssertEquals ("#2", XPathNodeType.SignificantWhitespace,
 284                                 nav.NodeType);
 285                 }
 286
 287 #if NET_2_0
 288                 [Test]
 289                 public void ValueAsBoolean ()
 290                 {
 291                         string xml = "<root>1</root>";
 292                         XmlDocument doc = new XmlDocument ();
 293                         doc.LoadXml (xml);
 294                         XPathNavigator nav = doc.CreateNavigator ();
 295                         nav.MoveToFirstChild ();
 296                         AssertEquals ("#1", true, nav.ValueAsBoolean);
 297                         nav.MoveToFirstChild ();
 298                         AssertEquals ("#2", true, nav.ValueAsBoolean);
 299                 }
 300
 301                 [Test]
 302                 [ExpectedException (typeof (FormatException))]
 303                 public void ValueAsBooleanFail ()
 304                 {
 305                         string xml = "<root>1.0</root>";
 306                         XmlDocument doc = new XmlDocument ();
 307                         doc.LoadXml (xml);
 308                         XPathNavigator nav = doc.CreateNavigator ();
 309                         nav.MoveToFirstChild ();
 310                         bool i = nav.ValueAsBoolean;
 311                 }
 312
 313                 [Test]
 314                 public void ValueAsDateTime ()
 315                 {
 316                         DateTime time = new DateTime (2005, 12, 13);
 317                         string xml = "<root>2005-12-13</root>";
 318                         XmlDocument doc = new XmlDocument ();
 319                         doc.LoadXml (xml);
 320                         XPathNavigator nav = doc.CreateNavigator ();
 321                         nav.MoveToFirstChild ();
 322                         AssertEquals ("#1", time, nav.ValueAsDateTime);
 323                         nav.MoveToFirstChild ();
 324                         AssertEquals ("#2", time, nav.ValueAsDateTime);
 325                 }
 326
 327                 [Test]
 328                 [ExpectedException (typeof (FormatException))]
 329                 public void ValueAsDateTimeFail ()
 330                 {
 331                         string xml = "<root>dating time</root>";
 332                         XmlDocument doc = new XmlDocument ();
 333                         doc.LoadXml (xml);
 334                         XPathNavigator nav = doc.CreateNavigator ();
 335                         nav.MoveToFirstChild ();
 336                         DateTime time = nav.ValueAsDateTime;
 337                 }
 338
 339                 [Test]
 340                 public void ValueAsDouble ()
 341                 {
 342                         string xml = "<root>3.14159265359</root>";
 343                         XmlDocument doc = new XmlDocument ();
 344                         doc.LoadXml (xml);
 345                         XPathNavigator nav = doc.CreateNavigator ();
 346                         nav.MoveToFirstChild ();
 347                         AssertEquals ("#1", 3.14159265359, nav.ValueAsDouble);
 348                         nav.MoveToFirstChild ();
 349                         AssertEquals ("#2", 3.14159265359, nav.ValueAsDouble);
 350                 }
 351
 352                 [Test]
 353                 [ExpectedException (typeof (FormatException))]
 354                 public void ValueAsDoubleFail ()
 355                 {
 356                         string xml = "<root>Double Dealer</root>";
 357                         XmlDocument doc = new XmlDocument ();
 358                         doc.LoadXml (xml);
 359                         XPathNavigator nav = doc.CreateNavigator ();
 360                         nav.MoveToFirstChild ();
 361                         Double dealer = nav.ValueAsDouble;
 362                 }
 363
 364                 [Test]
 365                 public void ValueAsInt ()
 366                 {
 367                         string xml = "<root>1</root>";
 368                         XmlDocument doc = new XmlDocument ();
 369                         doc.LoadXml (xml);
 370                         XPathNavigator nav = doc.CreateNavigator ();
 371                         nav.MoveToFirstChild ();
 372                         AssertEquals ("#1", 1, nav.ValueAsInt);
 373                         nav.MoveToFirstChild ();
 374                         AssertEquals ("#2", 1, nav.ValueAsInt);
 375                 }
 376
 377                 [Test]
 378                 // Here, it seems to be using XQueryConvert (whatever was called)
 379                 [ExpectedException (typeof (FormatException))]
 380                 public void ValueAsIntFail ()
 381                 {
 382                         string xml = "<root>1.0</root>";
 383                         XmlDocument doc = new XmlDocument ();
 384                         doc.LoadXml (xml);
 385                         XPathNavigator nav = doc.CreateNavigator ();
 386                         nav.MoveToFirstChild ();
 387                         int i = nav.ValueAsInt;
 388                 }
 389
 390                 [Test]
 391                 public void ValueAsLong ()
 392                 {
 393                         string xml = "<root>10000000000000000</root>";
 394                         XmlDocument doc = new XmlDocument ();
 395                         doc.LoadXml (xml);
 396                         XPathNavigator nav = doc.CreateNavigator ();
 397                         nav.MoveToFirstChild ();
 398                         AssertEquals ("#1", 10000000000000000, nav.ValueAsLong);
 399                         nav.MoveToFirstChild ();
 400                         AssertEquals ("#2", 10000000000000000, nav.ValueAsLong);
 401                 }
 402
 403                 [Test]
 404                 // Here, it seems to be using XQueryConvert (whatever was called)
 405                 [ExpectedException (typeof (FormatException))]
 406                 public void ValueAsLongFail ()
 407                 {
 408                         string xml = "<root>0x10000000000000000</root>";
 409                         XmlDocument doc = new XmlDocument ();
 410                         doc.LoadXml (xml);
 411                         XPathNavigator nav = doc.CreateNavigator ();
 412                         nav.MoveToFirstChild ();
 413                         long l = nav.ValueAsLong;
 414                 }
 415 #endif
 416         }
 417 }