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

   1 //\r
   2 // System.Xml.XmlReaderCommonTests\r
   3 //\r
   4 // Authors:\r
   5 //   Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>\r
   6 //\r
   7 // (C) 2003 Atsushi Enomoto\r
   8 //  Note: Most of testcases are moved from XmlTextReaderTests.cs and\r
   9 //  XmlNodeReaderTests.cs.\r
  10 //\r
  11 \r
  12 using System;\r
  13 using System.IO;\r
  14 using System.Text;\r
  15 using System.Xml;\r
  16 using System.Xml.Schema;\r
  17 using System.Xml.XPath;\r
  18 \r
  19 using NUnit.Framework;\r
  20 \r
  21 namespace MonoTests.System.Xml\r
  22 {\r
  23         [TestFixture]\r
  24         public class XmlReaderTests\r
  25         {\r
  26                 [SetUp]\r
  27                 public void GetReady ()\r
  28                 {\r
  29                         document = new XmlDocument ();\r
  30                         document.LoadXml (xml1);\r
  31                 }\r
  32 \r
  33                 XmlDocument document;\r
  34                 const string xml1 = "<root attr1='value1'><child /></root>";\r
  35                 const string xml2 = "<root><foo/><bar>test.</bar></root>";\r
  36                 const string xml3 = "<root>  test of <b>mixed</b> string.<![CDATA[ cdata string.]]></root>";\r
  37                 const string xml4 = "<root>test of <b>mixed</b> string.</root>";\r
  38                 XmlTextReader xtr;\r
  39                 XmlNodeReader xnr;\r
  40 \r
  41                 // copy from XmlTextReaderTests\r
  42                 private void AssertStartDocument (XmlReader xmlReader)\r
  43                 {\r
  44                         Assert.IsTrue (xmlReader.ReadState == ReadState.Initial);\r
  45                         Assert.IsTrue (xmlReader.NodeType == XmlNodeType.None);\r
  46                         Assert.IsTrue (xmlReader.Depth == 0);\r
  47                         Assert.IsTrue (!xmlReader.EOF);\r
  48                 }\r
  49 \r
  50                 private void AssertNode (\r
  51                         XmlReader xmlReader,\r
  52                         XmlNodeType nodeType,\r
  53                         int depth,\r
  54                         bool isEmptyElement,\r
  55                         string name,\r
  56                         string prefix,\r
  57                         string localName,\r
  58                         string namespaceURI,\r
  59                         string value,\r
  60                         int attributeCount)\r
  61                 {\r
  62                         AssertNode ("", xmlReader, nodeType, depth,\r
  63                                 isEmptyElement, name, prefix, localName,\r
  64                                 namespaceURI, value, attributeCount);\r
  65                 }\r
  66 \r
  67                 private void AssertNode (\r
  68                         string label,\r
  69                         XmlReader xmlReader,\r
  70                         XmlNodeType nodeType,\r
  71                         int depth,\r
  72                         bool isEmptyElement,\r
  73                         string name,\r
  74                         string prefix,\r
  75                         string localName,\r
  76                         string namespaceURI,\r
  77                         string value,\r
  78                         int attributeCount)\r
  79                 {\r
  80                         Assert.IsTrue (xmlReader.Read (), label + " Read() return value");\r
  81                         Assert.IsTrue (xmlReader.ReadState == ReadState.Interactive, label + " ReadState");\r
  82                         Assert.IsTrue (!xmlReader.EOF, label + " !EOF");\r
  83                         AssertNodeValues (label, xmlReader, nodeType, depth,\r
  84                                 isEmptyElement, name, prefix, localName,\r
  85                                 namespaceURI, value, value != String.Empty,\r
  86                                 attributeCount, attributeCount > 0);\r
  87                 }\r
  88 \r
  89                 private void AssertNodeValues (\r
  90                         string label,\r
  91                         XmlReader xmlReader,\r
  92                         XmlNodeType nodeType,\r
  93                         int depth,\r
  94                         bool isEmptyElement,\r
  95                         string name,\r
  96                         string prefix,\r
  97                         string localName,\r
  98                         string namespaceURI,\r
  99                         string value,\r
 100                         int attributeCount)\r
 101                 {\r
 102                         AssertNodeValues (label, xmlReader, nodeType, depth,\r
 103                                 isEmptyElement, name, prefix, localName,\r
 104                                 namespaceURI, value, value != String.Empty,\r
 105                                 attributeCount, attributeCount > 0);\r
 106                 }\r
 107 \r
 108                 private void AssertNodeValues (\r
 109                         string label,\r
 110                         XmlReader xmlReader,\r
 111                         XmlNodeType nodeType,\r
 112                         int depth,\r
 113                         bool isEmptyElement,\r
 114                         string name,\r
 115                         string prefix,\r
 116                         string localName,\r
 117                         string namespaceURI,\r
 118                         string value,\r
 119                         bool hasValue,\r
 120                         int attributeCount,\r
 121                         bool hasAttributes)\r
 122                 {\r
 123                         label = String.Concat (label, "(", xmlReader.GetType ().Name, ")");\r
 124                         Assert.AreEqual (nodeType, xmlReader.NodeType, label + ": NodeType");\r
 125                         Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, label + ": IsEmptyElement");\r
 126 \r
 127                         Assert.AreEqual (name, xmlReader.Name, label + ": name");\r
 128 \r
 129                         Assert.AreEqual (prefix, xmlReader.Prefix, label + ": prefix");\r
 130 \r
 131                         Assert.AreEqual (localName, xmlReader.LocalName, label + ": localName");\r
 132 \r
 133                         Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, label + ": namespaceURI");\r
 134 \r
 135                         Assert.AreEqual (depth, xmlReader.Depth, label + ": Depth");\r
 136 \r
 137                         Assert.AreEqual (hasValue, xmlReader.HasValue, label + ": hasValue");\r
 138 \r
 139                         Assert.AreEqual (value, xmlReader.Value, label + ": Value");\r
 140 \r
 141                         Assert.AreEqual (hasAttributes, xmlReader.HasAttributes, label + ": hasAttributes");\r
 142 \r
 143                         Assert.AreEqual (attributeCount, xmlReader.AttributeCount, label + ": attributeCount");\r
 144                 }\r
 145 \r
 146                 private void AssertAttribute (\r
 147                         XmlReader xmlReader,\r
 148                         string name,\r
 149                         string prefix,\r
 150                         string localName,\r
 151                         string namespaceURI,\r
 152                         string value)\r
 153                 {\r
 154                         Assert.AreEqual (value, xmlReader [name], "value");\r
 155 \r
 156                         Assert.IsTrue (xmlReader.GetAttribute (name) == value);\r
 157 \r
 158                         if (namespaceURI != String.Empty) {\r
 159                                 Assert.IsTrue (xmlReader[localName, namespaceURI] == value);\r
 160                                 Assert.IsTrue (xmlReader.GetAttribute (localName, namespaceURI) == value);\r
 161                         }\r
 162                 }\r
 163 \r
 164                 private void AssertEndDocument (XmlReader xmlReader)\r
 165                 {\r
 166                         Assert.IsTrue (!xmlReader.Read (), "could read");\r
 167                         Assert.AreEqual (XmlNodeType.None, xmlReader.NodeType, "NodeType is not XmlNodeType.None");\r
 168                         Assert.AreEqual (0, xmlReader.Depth, "Depth is not 0");\r
 169                         Assert.AreEqual (ReadState.EndOfFile, xmlReader.ReadState, "ReadState is not ReadState.EndOfFile");\r
 170                         Assert.IsTrue (xmlReader.EOF, "not EOF");\r
 171 \r
 172                         xmlReader.Close ();\r
 173                         Assert.AreEqual (ReadState.Closed, xmlReader.ReadState, "ReadState is not ReadState.Cosed");\r
 174                 }\r
 175 \r
 176                 private delegate void TestMethod (XmlReader reader);\r
 177 \r
 178                 private void RunTest (string xml, TestMethod method)\r
 179                 {\r
 180                         xtr = new XmlTextReader (new StringReader (xml));\r
 181                         method (xtr);\r
 182 \r
 183                         // DTD validation\r
 184                         xtr = new XmlTextReader (new StringReader (xml));\r
 185                         XmlValidatingReader xvr = new XmlValidatingReader (xtr);\r
 186                         xvr.ValidationType = ValidationType.DTD;\r
 187                         xvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 188                         method (xvr);\r
 189 \r
 190                         // XSD validation\r
 191                         xtr = new XmlTextReader (new StringReader (xml));\r
 192                         xvr = new XmlValidatingReader (xtr);\r
 193                         xvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 194                         method (xvr);\r
 195 \r
 196                         document.XmlResolver = null;\r
 197                         document.LoadXml (xml);\r
 198                         xnr = new XmlNodeReader (document);\r
 199                         method (xnr);\r
 200 #if NET_2_0\r
 201 /*\r
 202                         // XPathNavigatorReader tests\r
 203                         System.Xml.XPath.XPathDocument doc = new System.Xml.XPath.XPathDocument (new StringReader (xml));\r
 204                         XmlReader xpr = doc.CreateNavigator ().ReadSubtree ();\r
 205                         method (xpr);\r
 206 */\r
 207 #endif\r
 208                 }\r
 209 \r
 210 \r
 211 \r
 212 \r
 213 \r
 214                 [Test]\r
 215                 public void InitialState ()\r
 216                 {\r
 217                         RunTest (xml1, new TestMethod (InitialState));\r
 218                 }\r
 219 \r
 220                 private void InitialState (XmlReader reader)\r
 221                 {\r
 222                         Assert.AreEqual (0, reader.Depth, "Depth");\r
 223                         Assert.AreEqual (false, reader.EOF, "EOF");\r
 224                         Assert.AreEqual (false, reader.HasValue, "HasValue");\r
 225                         Assert.AreEqual (false, reader.IsEmptyElement, "IsEmptyElement");\r
 226                         Assert.AreEqual (String.Empty, reader.LocalName, "LocalName");\r
 227                         Assert.AreEqual (XmlNodeType.None, reader.NodeType, "NodeType");\r
 228                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "ReadState");\r
 229                 }\r
 230 \r
 231                 [Test]\r
 232                 public void Read ()\r
 233                 {\r
 234                         RunTest (xml1, new TestMethod (Read));\r
 235                 }\r
 236 \r
 237                 public void Read (XmlReader reader)\r
 238                 {\r
 239                         reader.Read ();\r
 240                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "<root>.NodeType");\r
 241                         Assert.AreEqual ("root", reader.Name, "<root>.Name");\r
 242                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "<root>.ReadState");\r
 243                         Assert.AreEqual (0, reader.Depth, "<root>.Depth");\r
 244 \r
 245                         // move to 'child'\r
 246                         reader.Read ();\r
 247                         Assert.AreEqual (1, reader.Depth, "<child/>.Depth");\r
 248                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "<child/>.NodeType");\r
 249                         Assert.AreEqual ("child", reader.Name, "<child/>.Name");\r
 250 \r
 251                         reader.Read ();\r
 252                         Assert.AreEqual (0, reader.Depth, "</root>.Depth");\r
 253                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "</root>.NodeType");\r
 254                         Assert.AreEqual ("root", reader.Name, "</root>.Name");\r
 255 \r
 256                         reader.Read ();\r
 257                         Assert.AreEqual (true, reader.EOF, "end.EOF");\r
 258                         Assert.AreEqual (XmlNodeType.None, reader.NodeType, "end.NodeType");\r
 259                 }\r
 260 \r
 261                 [Test]\r
 262                 [Category ("NotDotNet")]\r
 263                 public void ReadAttributeValue ()\r
 264                 {\r
 265                         RunTest ("<root attr=''/>", new TestMethod (ReadAttributeValue));\r
 266                 }\r
 267 \r
 268                 public void ReadAttributeValue (XmlReader reader)\r
 269                 {\r
 270                         reader.Read (); // root\r
 271                         Assert.IsTrue (reader.MoveToFirstAttribute ());\r
 272                         // It looks like that MS.NET shows AttributeCount and\r
 273                         // HasAttributes as the same as element node!\r
 274                         this.AssertNodeValues ("#1",\r
 275                                 reader, XmlNodeType.Attribute,\r
 276                                 1, false, "attr", "", "attr", "", "", true, 1, true);\r
 277                         Assert.IsTrue (reader.ReadAttributeValue ());\r
 278                         // MS.NET XmlTextReader fails. Its Prefix returns \r
 279                         // null instead of "". It is fixed in MS.NET 2.0.\r
 280                         this.AssertNodeValues ("#2",\r
 281                                 reader, XmlNodeType.Text,\r
 282                                 2, false, "", "", "", "", "", true, 1, true);\r
 283                         Assert.IsTrue (reader.MoveToElement ());\r
 284                         this.AssertNodeValues ("#3",\r
 285                                 reader, XmlNodeType.Element,\r
 286                                 0, true, "root", "", "root", "", "", false, 1, true);\r
 287                 }\r
 288 \r
 289                 [Test]\r
 290                 public void ReadEmptyElement ()\r
 291                 {\r
 292                         RunTest (xml2, new TestMethod (ReadEmptyElement));\r
 293                 }\r
 294 \r
 295                 public void ReadEmptyElement (XmlReader reader)\r
 296                 {\r
 297                         reader.Read (); // root\r
 298                         Assert.AreEqual (false, reader.IsEmptyElement);\r
 299                         reader.Read (); // foo\r
 300                         Assert.AreEqual ("foo", reader.Name);\r
 301                         Assert.AreEqual (true, reader.IsEmptyElement);\r
 302                         reader.Read (); // bar\r
 303                         Assert.AreEqual ("bar", reader.Name);\r
 304                         Assert.AreEqual (false, reader.IsEmptyElement);\r
 305                 }\r
 306 \r
 307                 [Test]\r
 308                 public void ReadStringFromElement ()\r
 309                 {\r
 310                         RunTest (xml3, new TestMethod (ReadStringFromElement));\r
 311                 }\r
 312 \r
 313                 public void ReadStringFromElement (XmlReader reader)\r
 314                 {\r
 315                         // Note: ReadString() test works only when the reader is\r
 316                         // positioned at the container element.\r
 317                         // In case the reader is positioned at the first \r
 318                         // character node, XmlTextReader and XmlNodeReader works\r
 319                         // different!!\r
 320 \r
 321                         reader.Read ();\r
 322                         string s = reader.ReadString ();\r
 323                         Assert.AreEqual ("  test of ", s, "readString.1.ret_val");\r
 324                         Assert.AreEqual ("b", reader.Name, "readString.1.Name");\r
 325                         s = reader.ReadString ();\r
 326                         Assert.AreEqual ("mixed", s, "readString.2.ret_val");\r
 327                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.2.NodeType");\r
 328                         s = reader.ReadString ();       // never proceeds.\r
 329                         Assert.AreEqual (String.Empty, s, "readString.3.ret_val");\r
 330                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.3.NodeType");\r
 331                         reader.Read ();\r
 332                         Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "readString.4.NodeType");\r
 333                         Assert.AreEqual (" string.", reader.Value, "readString.4.Value");\r
 334                         s = reader.ReadString ();       // reads the same Text node.\r
 335                         Assert.AreEqual (" string. cdata string.", s, "readString.5.ret_val");\r
 336                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.5.NodeType");\r
 337                 }\r
 338 \r
 339                 [Test]\r
 340                 public void ReadInnerXml ()\r
 341                 {\r
 342                         const string xml = "<root><foo>test of <b>mixed</b> string.</foo><bar /></root>";\r
 343                         RunTest (xml, new TestMethod (ReadInnerXml));\r
 344                 }\r
 345 \r
 346                 public void ReadInnerXml (XmlReader reader)\r
 347                 {\r
 348                         reader.Read ();\r
 349                         reader.Read ();\r
 350                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "initial.ReadState");\r
 351                         Assert.AreEqual (false, reader.EOF, "initial.EOF");\r
 352                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "initial.NodeType");\r
 353                         string s = reader.ReadInnerXml ();\r
 354                         Assert.AreEqual ("test of <b>mixed</b> string.", s, "read_all");\r
 355                         Assert.AreEqual ("bar", reader.Name, "after.Name");\r
 356                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "after.NodeType");\r
 357                 }\r
 358 \r
 359 \r
 360                 [Test]\r
 361                 public void EmptyElement ()\r
 362                 {\r
 363                         RunTest ("<foo/>", new TestMethod (EmptyElement));\r
 364                 }\r
 365                 \r
 366                 public void EmptyElement (XmlReader xmlReader)\r
 367                 {\r
 368 \r
 369                         AssertStartDocument (xmlReader);\r
 370 \r
 371                         AssertNode (\r
 372                                 xmlReader, // xmlReader\r
 373                                 XmlNodeType.Element, // nodeType\r
 374                                 0, // depth\r
 375                                 true, // isEmptyElement\r
 376                                 "foo", // name\r
 377                                 String.Empty, // prefix\r
 378                                 "foo", // localName\r
 379                                 String.Empty, // namespaceURI\r
 380                                 String.Empty, // value\r
 381                                 0 // attributeCount\r
 382                         );\r
 383 \r
 384                         AssertEndDocument (xmlReader);\r
 385                 }\r
 386 \r
 387                 [Test]\r
 388                 public void NestedEmptyTag ()\r
 389                 {\r
 390                         string xml = "<foo><bar/></foo>";\r
 391                         RunTest (xml, new TestMethod (NestedEmptyTag));\r
 392                 }\r
 393 \r
 394                 public void NestedEmptyTag (XmlReader xmlReader)\r
 395                 {\r
 396                         AssertStartDocument (xmlReader);\r
 397 \r
 398                         AssertNode (\r
 399                                 "#1",\r
 400                                 xmlReader, // xmlReader\r
 401                                 XmlNodeType.Element, // nodeType\r
 402                                 0, //depth\r
 403                                 false, // isEmptyElement\r
 404                                 "foo", // name\r
 405                                 String.Empty, // prefix\r
 406                                 "foo", // localName\r
 407                                 String.Empty, // namespaceURI\r
 408                                 String.Empty, // value\r
 409                                 0 // attributeCount\r
 410                         );\r
 411 \r
 412                         AssertNode (\r
 413                                 "#2",\r
 414                                 xmlReader, // xmlReader\r
 415                                 XmlNodeType.Element, // nodeType\r
 416                                 1, //depth\r
 417                                 true, // isEmptyElement\r
 418                                 "bar", // name\r
 419                                 String.Empty, // prefix\r
 420                                 "bar", // localName\r
 421                                 String.Empty, // namespaceURI\r
 422                                 String.Empty, // value\r
 423                                 0 // attributeCount\r
 424                         );\r
 425 \r
 426                         AssertNode (\r
 427                                 "#3",\r
 428                                 xmlReader, // xmlReader\r
 429                                 XmlNodeType.EndElement, // nodeType\r
 430                                 0, //depth\r
 431                                 false, // isEmptyElement\r
 432                                 "foo", // name\r
 433                                 String.Empty, // prefix\r
 434                                 "foo", // localName\r
 435                                 String.Empty, // namespaceURI\r
 436                                 String.Empty, // value\r
 437                                 0 // attributeCount\r
 438                         );\r
 439 \r
 440                         AssertEndDocument (xmlReader);\r
 441                 }\r
 442 \r
 443                 [Test]\r
 444                 public void NestedText ()\r
 445                 {\r
 446                         string xml = "<foo>bar</foo>";\r
 447                         RunTest (xml, new TestMethod (NestedText));\r
 448                 }\r
 449 \r
 450                 public void NestedText (XmlReader xmlReader)\r
 451                 {\r
 452                         AssertStartDocument (xmlReader);\r
 453 \r
 454                         AssertNode (\r
 455                                 xmlReader, // xmlReader\r
 456                                 XmlNodeType.Element, // nodeType\r
 457                                 0, //depth\r
 458                                 false, // isEmptyElement\r
 459                                 "foo", // name\r
 460                                 String.Empty, // prefix\r
 461                                 "foo", // localName\r
 462                                 String.Empty, // namespaceURI\r
 463                                 String.Empty, // value\r
 464                                 0 // attributeCount\r
 465                         );\r
 466 \r
 467                         AssertNode (\r
 468                                 xmlReader, // xmlReader\r
 469                                 XmlNodeType.Text, // nodeType\r
 470                                 1, //depth\r
 471                                 false, // isEmptyElement\r
 472                                 String.Empty, // name\r
 473                                 String.Empty, // prefix\r
 474                                 String.Empty, // localName\r
 475                                 String.Empty, // namespaceURI\r
 476                                 "bar", // value\r
 477                                 0 // attributeCount\r
 478                         );\r
 479 \r
 480                         AssertNode (\r
 481                                 xmlReader, // xmlReader\r
 482                                 XmlNodeType.EndElement, // nodeType\r
 483                                 0, //depth\r
 484                                 false, // isEmptyElement\r
 485                                 "foo", // name\r
 486                                 String.Empty, // prefix\r
 487                                 "foo", // localName\r
 488                                 String.Empty, // namespaceURI\r
 489                                 String.Empty, // value\r
 490                                 0 // attributeCount\r
 491                         );\r
 492 \r
 493                         AssertEndDocument (xmlReader);\r
 494                 }\r
 495 \r
 496                 [Test]\r
 497                 public void EmptyElementWithAttributes ()\r
 498                 {\r
 499                         string xml = @"<foo bar=""baz"" quux='quuux' x:foo='x-foo' xmlns:x = 'urn:xfoo' />";\r
 500                         RunTest (xml, new TestMethod (EmptyElementWithAttributes ));\r
 501                 }\r
 502 \r
 503                 public void EmptyElementWithAttributes (XmlReader xmlReader)\r
 504                 {\r
 505 \r
 506                         AssertStartDocument (xmlReader);\r
 507 \r
 508                         AssertNode (\r
 509                                 xmlReader, // xmlReader\r
 510                                 XmlNodeType.Element, // nodeType\r
 511                                 0, //depth\r
 512                                 true, // isEmptyElement\r
 513                                 "foo", // name\r
 514                                 String.Empty, // prefix\r
 515                                 "foo", // localName\r
 516                                 String.Empty, // namespaceURI\r
 517                                 String.Empty, // value\r
 518                                 4 // attributeCount\r
 519                         );\r
 520 \r
 521                         AssertAttribute (\r
 522                                 xmlReader, // xmlReader\r
 523                                 "bar", // name\r
 524                                 String.Empty, // prefix\r
 525                                 "bar", // localName\r
 526                                 String.Empty, // namespaceURI\r
 527                                 "baz" // value\r
 528                         );\r
 529 \r
 530                         AssertAttribute (\r
 531                                 xmlReader, // xmlReader\r
 532                                 "quux", // name\r
 533                                 String.Empty, // prefix\r
 534                                 "quux", // localName\r
 535                                 String.Empty, // namespaceURI\r
 536                                 "quuux" // value\r
 537                         );\r
 538 \r
 539                         AssertAttribute (\r
 540                                 xmlReader, // xmlReader\r
 541                                 "notexist", // name\r
 542                                 String.Empty, // prefix\r
 543                                 "notexist", // localName\r
 544                                 String.Empty, // namespaceURI\r
 545                                 null // value\r
 546                         );\r
 547 \r
 548                         AssertAttribute (\r
 549                                 xmlReader, // xmlReader\r
 550                                 "x:foo", // name\r
 551                                 "x", // prefix\r
 552                                 "foo", // localName\r
 553                                 "urn:xfoo", // namespaceURI\r
 554                                 "x-foo" // value\r
 555                         );\r
 556 \r
 557                         AssertAttribute (\r
 558                                 xmlReader, // xmlReader\r
 559                                 "x:bar", // name\r
 560                                 "x", // prefix\r
 561                                 "bar", // localName\r
 562                                 "urn:xfoo", // namespaceURI\r
 563                                 null // value\r
 564                         );\r
 565 \r
 566                         AssertEndDocument (xmlReader);\r
 567                 }\r
 568 \r
 569                 [Test]\r
 570                 public void ProcessingInstructionBeforeDocumentElement ()\r
 571                 {\r
 572                         string xml = "<?foo bar?><baz/>";\r
 573                         RunTest (xml, new TestMethod (ProcessingInstructionBeforeDocumentElement));\r
 574                 }\r
 575 \r
 576                 public void ProcessingInstructionBeforeDocumentElement (XmlReader xmlReader)\r
 577                 {\r
 578                         AssertStartDocument (xmlReader);\r
 579 \r
 580                         AssertNode (\r
 581                                 xmlReader, // xmlReader\r
 582                                 XmlNodeType.ProcessingInstruction, // nodeType\r
 583                                 0, //depth\r
 584                                 false, // isEmptyElement\r
 585                                 "foo", // name\r
 586                                 String.Empty, // prefix\r
 587                                 "foo", // localName\r
 588                                 String.Empty, // namespaceURI\r
 589                                 "bar", // value\r
 590                                 0 // attributeCount\r
 591                         );\r
 592 \r
 593                         AssertNode (\r
 594                                 xmlReader, // xmlReader\r
 595                                 XmlNodeType.Element, // nodeType\r
 596                                 0, //depth\r
 597                                 true, // isEmptyElement\r
 598                                 "baz", // name\r
 599                                 String.Empty, // prefix\r
 600                                 "baz", // localName\r
 601                                 String.Empty, // namespaceURI\r
 602                                 String.Empty, // value\r
 603                                 0 // attributeCount\r
 604                         );\r
 605 \r
 606                         AssertEndDocument (xmlReader);\r
 607                 }\r
 608 \r
 609                 [Test]\r
 610                 public void CommentBeforeDocumentElement ()\r
 611                 {\r
 612                         string xml = "<!--foo--><bar/>";\r
 613                         RunTest (xml, new TestMethod (CommentBeforeDocumentElement));\r
 614                 }\r
 615 \r
 616                 public void CommentBeforeDocumentElement (XmlReader xmlReader)\r
 617                 {\r
 618                         AssertStartDocument (xmlReader);\r
 619 \r
 620                         AssertNode (\r
 621                                 xmlReader, // xmlReader\r
 622                                 XmlNodeType.Comment, // nodeType\r
 623                                 0, //depth\r
 624                                 false, // isEmptyElement\r
 625                                 String.Empty, // name\r
 626                                 String.Empty, // prefix\r
 627                                 String.Empty, // localName\r
 628                                 String.Empty, // namespaceURI\r
 629                                 "foo", // value\r
 630                                 0 // attributeCount\r
 631                         );\r
 632 \r
 633                         AssertNode (\r
 634                                 xmlReader, // xmlReader\r
 635                                 XmlNodeType.Element, // nodeType\r
 636                                 0, //depth\r
 637                                 true, // isEmptyElement\r
 638                                 "bar", // name\r
 639                                 String.Empty, // prefix\r
 640                                 "bar", // localName\r
 641                                 String.Empty, // namespaceURI\r
 642                                 String.Empty, // value\r
 643                                 0 // attributeCount\r
 644                         );\r
 645 \r
 646                         AssertEndDocument (xmlReader);\r
 647                 }\r
 648 \r
 649                 [Test]\r
 650                 public void PredefinedEntities ()\r
 651                 {\r
 652                         string xml = "<foo>&lt;&gt;&amp;&apos;&quot;</foo>";\r
 653                         RunTest (xml, new TestMethod (PredefinedEntities));\r
 654                 }\r
 655 \r
 656                 public void PredefinedEntities (XmlReader xmlReader)\r
 657                 {\r
 658                         AssertStartDocument (xmlReader);\r
 659 \r
 660                         AssertNode (\r
 661                                 xmlReader, // xmlReader\r
 662                                 XmlNodeType.Element, // nodeType\r
 663                                 0, //depth\r
 664                                 false, // isEmptyElement\r
 665                                 "foo", // name\r
 666                                 String.Empty, // prefix\r
 667                                 "foo", // localName\r
 668                                 String.Empty, // namespaceURI\r
 669                                 String.Empty, // value\r
 670                                 0 // attributeCount\r
 671                         );\r
 672 \r
 673                         AssertNode (\r
 674                                 xmlReader, // xmlReader\r
 675                                 XmlNodeType.Text, // nodeType\r
 676                                 1, //depth\r
 677                                 false, // isEmptyElement\r
 678                                 String.Empty, // name\r
 679                                 String.Empty, // prefix\r
 680                                 String.Empty, // localName\r
 681                                 String.Empty, // namespaceURI\r
 682                                 "<>&'\"", // value\r
 683                                 0 // attributeCount\r
 684                         );\r
 685 \r
 686                         AssertNode (\r
 687                                 xmlReader, // xmlReader\r
 688                                 XmlNodeType.EndElement, // nodeType\r
 689                                 0, //depth\r
 690                                 false, // isEmptyElement\r
 691                                 "foo", // name\r
 692                                 String.Empty, // prefix\r
 693                                 "foo", // localName\r
 694                                 String.Empty, // namespaceURI\r
 695                                 String.Empty, // value\r
 696                                 0 // attributeCount\r
 697                         );\r
 698 \r
 699                         AssertEndDocument (xmlReader);\r
 700                 }\r
 701 \r
 702                 [Test]\r
 703                 public void CharacterReferences ()\r
 704                 {\r
 705                         string xml = "<foo>&#70;&#x4F;&#x4f;</foo>";\r
 706                         RunTest (xml, new TestMethod (CharacterReferences));\r
 707                 }\r
 708 \r
 709                 public void CharacterReferences (XmlReader xmlReader)\r
 710                 {\r
 711                         AssertStartDocument (xmlReader);\r
 712 \r
 713                         AssertNode (\r
 714                                 xmlReader, // xmlReader\r
 715                                 XmlNodeType.Element, // nodeType\r
 716                                 0, //depth\r
 717                                 false, // isEmptyElement\r
 718                                 "foo", // name\r
 719                                 String.Empty, // prefix\r
 720                                 "foo", // localName\r
 721                                 String.Empty, // namespaceURI\r
 722                                 String.Empty, // value\r
 723                                 0 // attributeCount\r
 724                         );\r
 725 \r
 726                         AssertNode (\r
 727                                 xmlReader, // xmlReader\r
 728                                 XmlNodeType.Text, // nodeType\r
 729                                 1, //depth\r
 730                                 false, // isEmptyElement\r
 731                                 String.Empty, // name\r
 732                                 String.Empty, // prefix\r
 733                                 String.Empty, // localName\r
 734                                 String.Empty, // namespaceURI\r
 735                                 "FOO", // value\r
 736                                 0 // attributeCount\r
 737                         );\r
 738 \r
 739                         AssertNode (\r
 740                                 xmlReader, // xmlReader\r
 741                                 XmlNodeType.EndElement, // nodeType\r
 742                                 0, //depth\r
 743                                 false, // isEmptyElement\r
 744                                 "foo", // name\r
 745                                 String.Empty, // prefix\r
 746                                 "foo", // localName\r
 747                                 String.Empty, // namespaceURI\r
 748                                 String.Empty, // value\r
 749                                 0 // attributeCount\r
 750                         );\r
 751 \r
 752                         AssertEndDocument (xmlReader);\r
 753                 }\r
 754 \r
 755                 [Test]\r
 756                 public void PredefinedEntitiesInAttribute ()\r
 757                 {\r
 758                         string xml = "<foo bar='&lt;&gt;&amp;&apos;&quot;'/>";\r
 759                         RunTest (xml, new TestMethod (PredefinedEntitiesInAttribute ));\r
 760                 }\r
 761 \r
 762                 public void PredefinedEntitiesInAttribute (XmlReader xmlReader)\r
 763                 {\r
 764                         AssertStartDocument (xmlReader);\r
 765 \r
 766                         AssertNode (\r
 767                                 xmlReader, // xmlReader\r
 768                                 XmlNodeType.Element, // nodeType\r
 769                                 0, //depth\r
 770                                 true, // isEmptyElement\r
 771                                 "foo", // name\r
 772                                 String.Empty, // prefix\r
 773                                 "foo", // localName\r
 774                                 String.Empty, // namespaceURI\r
 775                                 String.Empty, // value\r
 776                                 1 // attributeCount\r
 777                         );\r
 778 \r
 779                         AssertAttribute (\r
 780                                 xmlReader, // xmlReader\r
 781                                 "bar", // name\r
 782                                 String.Empty, // prefix\r
 783                                 "bar", // localName\r
 784                                 String.Empty, // namespaceURI\r
 785                                 "<>&'\"" // value\r
 786                         );\r
 787 \r
 788                         AssertEndDocument (xmlReader);\r
 789                 }\r
 790 \r
 791                 [Test]\r
 792                 public void CharacterReferencesInAttribute ()\r
 793                 {\r
 794                         string xml = "<foo bar='&#70;&#x4F;&#x4f;'/>";\r
 795                         RunTest (xml, new TestMethod (CharacterReferencesInAttribute));\r
 796                 }\r
 797 \r
 798                 public void CharacterReferencesInAttribute (XmlReader xmlReader)\r
 799                 {\r
 800                         AssertStartDocument (xmlReader);\r
 801 \r
 802                         AssertNode (\r
 803                                 xmlReader, // xmlReader\r
 804                                 XmlNodeType.Element, // nodeType\r
 805                                 0, //depth\r
 806                                 true, // isEmptyElement\r
 807                                 "foo", // name\r
 808                                 String.Empty, // prefix\r
 809                                 "foo", // localName\r
 810                                 String.Empty, // namespaceURI\r
 811                                 String.Empty, // value\r
 812                                 1 // attributeCount\r
 813                         );\r
 814 \r
 815                         AssertAttribute (\r
 816                                 xmlReader, // xmlReader\r
 817                                 "bar", // name\r
 818                                 String.Empty, // prefix\r
 819                                 "bar", // localName\r
 820                                 String.Empty, // namespaceURI\r
 821                                 "FOO" // value\r
 822                         );\r
 823 \r
 824                         AssertEndDocument (xmlReader);\r
 825                 }\r
 826 \r
 827                 [Test]\r
 828                 public void CDATA ()\r
 829                 {\r
 830                         string xml = "<foo><![CDATA[<>&]]></foo>";\r
 831                         RunTest (xml, new TestMethod (CDATA));\r
 832                 }\r
 833 \r
 834                 public void CDATA (XmlReader xmlReader)\r
 835                 {\r
 836                         AssertStartDocument (xmlReader);\r
 837 \r
 838                         AssertNode (\r
 839                                 xmlReader, // xmlReader\r
 840                                 XmlNodeType.Element, // nodeType\r
 841                                 0, //depth\r
 842                                 false, // isEmptyElement\r
 843                                 "foo", // name\r
 844                                 String.Empty, // prefix\r
 845                                 "foo", // localName\r
 846                                 String.Empty, // namespaceURI\r
 847                                 String.Empty, // value\r
 848                                 0 // attributeCount\r
 849                         );\r
 850 \r
 851                         AssertNode (\r
 852                                 xmlReader, // xmlReader\r
 853                                 XmlNodeType.CDATA, // nodeType\r
 854                                 1, //depth\r
 855                                 false, // isEmptyElement\r
 856                                 String.Empty, // name\r
 857                                 String.Empty, // prefix\r
 858                                 String.Empty, // localName\r
 859                                 String.Empty, // namespaceURI\r
 860                                 "<>&", // value\r
 861                                 0 // attributeCount\r
 862                         );\r
 863 \r
 864                         AssertNode (\r
 865                                 xmlReader, // xmlReader\r
 866                                 XmlNodeType.EndElement, // nodeType\r
 867                                 0, //depth\r
 868                                 false, // isEmptyElement\r
 869                                 "foo", // name\r
 870                                 String.Empty, // prefix\r
 871                                 "foo", // localName\r
 872                                 String.Empty, // namespaceURI\r
 873                                 String.Empty, // value\r
 874                                 0 // attributeCount\r
 875                         );\r
 876 \r
 877                         AssertEndDocument (xmlReader);\r
 878                 }\r
 879 \r
 880                 [Test]\r
 881                 public void EmptyElementInDefaultNamespace ()\r
 882                 {\r
 883                         string xml = @"<foo xmlns='http://foo/' />";\r
 884                         RunTest (xml, new TestMethod (EmptyElementInDefaultNamespace));\r
 885                 }\r
 886 \r
 887                 public void EmptyElementInDefaultNamespace (XmlReader xmlReader)\r
 888                 {\r
 889                         AssertStartDocument (xmlReader);\r
 890 \r
 891                         AssertNode (\r
 892                                 xmlReader, // xmlReader\r
 893                                 XmlNodeType.Element, // nodeType\r
 894                                 0, // depth\r
 895                                 true, // isEmptyElement\r
 896                                 "foo", // name\r
 897                                 String.Empty, // prefix\r
 898                                 "foo", // localName\r
 899                                 "http://foo/", // namespaceURI\r
 900                                 String.Empty, // value\r
 901                                 1 // attributeCount\r
 902                         );\r
 903 \r
 904                         AssertAttribute (\r
 905                                 xmlReader, // xmlReader\r
 906                                 "xmlns", // name\r
 907                                 String.Empty, // prefix\r
 908                                 "xmlns", // localName\r
 909                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 910                                 "http://foo/" // value\r
 911                         );\r
 912 \r
 913                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace (String.Empty));\r
 914 \r
 915                         AssertEndDocument (xmlReader);\r
 916                 }\r
 917 \r
 918                 [Test]\r
 919                 public void ChildElementInNamespace ()\r
 920                 {\r
 921                         string xml = @"<foo:bar xmlns:foo='http://foo/'><baz:quux xmlns:baz='http://baz/' /></foo:bar>";\r
 922                         RunTest (xml, new TestMethod (ChildElementInNamespace));\r
 923                 }\r
 924 \r
 925                 public void ChildElementInNamespace (XmlReader xmlReader)\r
 926                 {\r
 927                         AssertStartDocument (xmlReader);\r
 928 \r
 929                         AssertNode (\r
 930                                 xmlReader, // xmlReader\r
 931                                 XmlNodeType.Element, // nodeType\r
 932                                 0, // depth\r
 933                                 false, // isEmptyElement\r
 934                                 "foo:bar", // name\r
 935                                 "foo", // prefix\r
 936                                 "bar", // localName\r
 937                                 "http://foo/", // namespaceURI\r
 938                                 String.Empty, // value\r
 939                                 1 // attributeCount\r
 940                         );\r
 941 \r
 942                         AssertAttribute (\r
 943                                 xmlReader, // xmlReader\r
 944                                 "xmlns:foo", // name\r
 945                                 "xmlns", // prefix\r
 946                                 "foo", // localName\r
 947                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 948                                 "http://foo/" // value\r
 949                         );\r
 950 \r
 951                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 952 \r
 953                         AssertNode (\r
 954                                 xmlReader, // xmlReader\r
 955                                 XmlNodeType.Element, // nodeType\r
 956                                 1, // depth\r
 957                                 true, // isEmptyElement\r
 958                                 "baz:quux", // name\r
 959                                 "baz", // prefix\r
 960                                 "quux", // localName\r
 961                                 "http://baz/", // namespaceURI\r
 962                                 String.Empty, // value\r
 963                                 1 // attributeCount\r
 964                         );\r
 965 \r
 966                         AssertAttribute (\r
 967                                 xmlReader, // xmlReader\r
 968                                 "xmlns:baz", // name\r
 969                                 "xmlns", // prefix\r
 970                                 "baz", // localName\r
 971                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 972                                 "http://baz/" // value\r
 973                         );\r
 974 \r
 975                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 976                         Assert.AreEqual ("http://baz/", xmlReader.LookupNamespace ("baz"));\r
 977 \r
 978                         AssertNode (\r
 979                                 xmlReader, // xmlReader\r
 980                                 XmlNodeType.EndElement, // nodeType\r
 981                                 0, // depth\r
 982                                 false, // isEmptyElement\r
 983                                 "foo:bar", // name\r
 984                                 "foo", // prefix\r
 985                                 "bar", // localName\r
 986                                 "http://foo/", // namespaceURI\r
 987                                 String.Empty, // value\r
 988                                 0 // attributeCount\r
 989                         );\r
 990 \r
 991                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 992                         Assert.IsNull (xmlReader.LookupNamespace ("baz"));\r
 993 \r
 994                         AssertEndDocument (xmlReader);\r
 995                 }\r
 996 \r
 997                 [Test]\r
 998                 public void ChildElementInDefaultNamespace ()\r
 999                 {\r
1000                         string xml = @"<foo:bar xmlns:foo='http://foo/'><baz xmlns='http://baz/' /></foo:bar>";\r
1001                         RunTest (xml, new TestMethod (ChildElementInDefaultNamespace));\r
1002                 }\r
1003 \r
1004                 public void ChildElementInDefaultNamespace (XmlReader xmlReader)\r
1005                 {\r
1006                         AssertStartDocument (xmlReader);\r
1007 \r
1008                         AssertNode (\r
1009                                 xmlReader, // xmlReader\r
1010                                 XmlNodeType.Element, // nodeType\r
1011                                 0, // depth\r
1012                                 false, // isEmptyElement\r
1013                                 "foo:bar", // name\r
1014                                 "foo", // prefix\r
1015                                 "bar", // localName\r
1016                                 "http://foo/", // namespaceURI\r
1017                                 String.Empty, // value\r
1018                                 1 // attributeCount\r
1019                         );\r
1020 \r
1021                         AssertAttribute (\r
1022                                 xmlReader, // xmlReader\r
1023                                 "xmlns:foo", // name\r
1024                                 "xmlns", // prefix\r
1025                                 "foo", // localName\r
1026                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
1027                                 "http://foo/" // value\r
1028                         );\r
1029 \r
1030                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
1031 \r
1032                         AssertNode (\r
1033                                 xmlReader, // xmlReader\r
1034                                 XmlNodeType.Element, // nodeType\r
1035                                 1, // depth\r
1036                                 true, // isEmptyElement\r
1037                                 "baz", // name\r
1038                                 String.Empty, // prefix\r
1039                                 "baz", // localName\r
1040                                 "http://baz/", // namespaceURI\r
1041                                 String.Empty, // value\r
1042                                 1 // attributeCount\r
1043                         );\r
1044 \r
1045                         AssertAttribute (\r
1046                                 xmlReader, // xmlReader\r
1047                                 "xmlns", // name\r
1048                                 String.Empty, // prefix\r
1049                                 "xmlns", // localName\r
1050                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
1051                                 "http://baz/" // value\r
1052                         );\r
1053 \r
1054                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
1055                         Assert.AreEqual ("http://baz/", xmlReader.LookupNamespace (String.Empty));\r
1056 \r
1057                         AssertNode (\r
1058                                 xmlReader, // xmlReader\r
1059                                 XmlNodeType.EndElement, // nodeType\r
1060                                 0, // depth\r
1061                                 false, // isEmptyElement\r
1062                                 "foo:bar", // name\r
1063                                 "foo", // prefix\r
1064                                 "bar", // localName\r
1065                                 "http://foo/", // namespaceURI\r
1066                                 String.Empty, // value\r
1067                                 0 // attributeCount\r
1068                         );\r
1069 \r
1070                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
1071 \r
1072                         AssertEndDocument (xmlReader);\r
1073                 }\r
1074 \r
1075                 [Test]\r
1076                 public void AttributeInNamespace ()\r
1077                 {\r
1078                         string xml = @"<foo bar:baz='quux' xmlns:bar='http://bar/' />";\r
1079                         RunTest (xml, new TestMethod (AttributeInNamespace));\r
1080                 }\r
1081 \r
1082                 public void AttributeInNamespace (XmlReader xmlReader)\r
1083                 {\r
1084                         AssertStartDocument (xmlReader);\r
1085 \r
1086                         AssertNode (\r
1087                                 xmlReader, // xmlReader\r
1088                                 XmlNodeType.Element, // nodeType\r
1089                                 0, // depth\r
1090                                 true, // isEmptyElement\r
1091                                 "foo", // name\r
1092                                 String.Empty, // prefix\r
1093                                 "foo", // localName\r
1094                                 String.Empty, // namespaceURI\r
1095                                 String.Empty, // value\r
1096                                 2 // attributeCount\r
1097                         );\r
1098 \r
1099                         AssertAttribute (\r
1100                                 xmlReader, // xmlReader\r
1101                                 "bar:baz", // name\r
1102                                 "bar", // prefix\r
1103                                 "baz", // localName\r
1104                                 "http://bar/", // namespaceURI\r
1105                                 "quux" // value\r
1106                         );\r
1107 \r
1108                         AssertAttribute (\r
1109                                 xmlReader, // xmlReader\r
1110                                 "xmlns:bar", // name\r
1111                                 "xmlns", // prefix\r
1112                                 "bar", // localName\r
1113                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
1114                                 "http://bar/" // value\r
1115                         );\r
1116 \r
1117                         Assert.AreEqual ("http://bar/", xmlReader.LookupNamespace ("bar"));\r
1118 \r
1119                         AssertEndDocument (xmlReader);\r
1120                 }\r
1121 \r
1122                 [Test]\r
1123                 public void MoveToElementFromAttribute ()\r
1124                 {\r
1125                         string xml = @"<foo bar=""baz"" />";\r
1126                         RunTest (xml, new TestMethod (MoveToElementFromAttribute));\r
1127                 }\r
1128 \r
1129                 public void MoveToElementFromAttribute (XmlReader xmlReader)\r
1130                 {\r
1131                         Assert.IsTrue (xmlReader.Read ());\r
1132                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1133                         Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
1134                         Assert.AreEqual (XmlNodeType.Attribute, xmlReader.NodeType);\r
1135                         Assert.IsTrue (xmlReader.MoveToElement ());\r
1136                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1137                 }\r
1138 \r
1139                 [Test]\r
1140                 public void MoveToElementFromElement ()\r
1141                 {\r
1142                         string xml = @"<foo bar=""baz"" />";\r
1143                         RunTest (xml, new TestMethod (MoveToElementFromElement));\r
1144                 }\r
1145 \r
1146                 public void MoveToElementFromElement (XmlReader xmlReader)\r
1147                 {\r
1148                         Assert.IsTrue (xmlReader.Read ());\r
1149                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1150                         Assert.IsTrue (!xmlReader.MoveToElement ());\r
1151                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1152                 }\r
1153 \r
1154                 [Test]\r
1155                 public void MoveToFirstAttributeWithNoAttributes ()\r
1156                 {\r
1157                         string xml = @"<foo />";\r
1158                         RunTest (xml, new TestMethod (MoveToFirstAttributeWithNoAttributes));\r
1159                 }\r
1160 \r
1161                 public void MoveToFirstAttributeWithNoAttributes (XmlReader xmlReader)\r
1162                 {\r
1163                         Assert.IsTrue (xmlReader.Read ());\r
1164                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1165                         Assert.IsTrue (!xmlReader.MoveToFirstAttribute ());\r
1166                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1167                 }\r
1168 \r
1169                 [Test]\r
1170                 public void MoveToNextAttributeWithNoAttributes ()\r
1171                 {\r
1172                         string xml = @"<foo />";\r
1173                         RunTest (xml, new TestMethod (MoveToNextAttributeWithNoAttributes));\r
1174                 }\r
1175 \r
1176                 public void MoveToNextAttributeWithNoAttributes (XmlReader xmlReader)\r
1177                 {\r
1178                         Assert.IsTrue (xmlReader.Read ());\r
1179                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1180                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1181                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1182                 }\r
1183 \r
1184                 [Test]\r
1185                 public void MoveToNextAttribute()\r
1186                 {\r
1187                         string xml = @"<foo bar=""baz"" quux='quuux'/>";\r
1188                         RunTest (xml, new TestMethod (MoveToNextAttribute));\r
1189                 }\r
1190 \r
1191                 public void MoveToNextAttribute (XmlReader xmlReader)\r
1192                 {\r
1193                         AssertStartDocument (xmlReader);\r
1194 \r
1195                         AssertNode (\r
1196                                 xmlReader, // xmlReader\r
1197                                 XmlNodeType.Element, // nodeType\r
1198                                 0, //depth\r
1199                                 true, // isEmptyElement\r
1200                                 "foo", // name\r
1201                                 String.Empty, // prefix\r
1202                                 "foo", // localName\r
1203                                 String.Empty, // namespaceURI\r
1204                                 String.Empty, // value\r
1205                                 2 // attributeCount\r
1206                         );\r
1207 \r
1208                         AssertAttribute (\r
1209                                 xmlReader, // xmlReader\r
1210                                 "bar", // name\r
1211                                 String.Empty, // prefix\r
1212                                 "bar", // localName\r
1213                                 String.Empty, // namespaceURI\r
1214                                 "baz" // value\r
1215                         );\r
1216 \r
1217                         AssertAttribute (\r
1218                                 xmlReader, // xmlReader\r
1219                                 "quux", // name\r
1220                                 String.Empty, // prefix\r
1221                                 "quux", // localName\r
1222                                 String.Empty, // namespaceURI\r
1223                                 "quuux" // value\r
1224                         );\r
1225 \r
1226                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1227                         Assert.AreEqual ("bar", xmlReader.Name);\r
1228                         Assert.AreEqual ("baz", xmlReader.Value);\r
1229 \r
1230                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1231                         Assert.AreEqual ("quux", xmlReader.Name);\r
1232                         Assert.AreEqual ("quuux", xmlReader.Value);\r
1233 \r
1234                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1235 \r
1236                         Assert.IsTrue (xmlReader.MoveToElement ());\r
1237 \r
1238                         AssertNodeValues (\r
1239                                 "#1",\r
1240                                 xmlReader, // xmlReader\r
1241                                 XmlNodeType.Element, // nodeType\r
1242                                 0, //depth\r
1243                                 true, // isEmptyElement\r
1244                                 "foo", // name\r
1245                                 String.Empty, // prefix\r
1246                                 "foo", // localName\r
1247                                 String.Empty, // namespaceURI\r
1248                                 String.Empty, // value\r
1249                                 2 // attributeCount\r
1250                         );\r
1251 \r
1252                         AssertEndDocument (xmlReader);\r
1253                 }\r
1254 \r
1255                 [Test]\r
1256 //              [Category ("NotDotNet")] // MS XmlNodeReader never moves to xml declaration.\r
1257                 [Ignore ("Too inconsistent reference implementations to determine which is correct behavior.")]\r
1258                 public void MoveToXmlDeclAttributes ()\r
1259                 {\r
1260                         string xml = "<?xml version=\"1.0\" standalone=\"yes\"?><root/>";\r
1261                         RunTest (xml, new TestMethod (MoveToXmlDeclAttributes));\r
1262                 }\r
1263 \r
1264                 public void MoveToXmlDeclAttributes (XmlReader xmlReader)\r
1265                 {\r
1266                         xmlReader.Read ();\r
1267                         this.AssertNodeValues ("#1", xmlReader, \r
1268                                 XmlNodeType.XmlDeclaration,\r
1269                                 0,\r
1270                                 false,\r
1271                                 "xml",\r
1272                                 String.Empty,\r
1273                                 "xml",\r
1274                                 String.Empty,\r
1275                                 "version=\"1.0\" standalone=\"yes\"",\r
1276                                 2);\r
1277                         Assert.IsTrue (xmlReader.MoveToFirstAttribute (), "MoveToFirstAttribute");\r
1278                         this.AssertNodeValues ("#2", xmlReader, \r
1279                                 XmlNodeType.Attribute,\r
1280                                 0, // FIXME: might be 1\r
1281                                 false,\r
1282                                 "version",\r
1283                                 String.Empty,\r
1284                                 "version",\r
1285                                 String.Empty,\r
1286                                 "1.0",\r
1287                                 2);\r
1288                         xmlReader.ReadAttributeValue ();\r
1289                         this.AssertNodeValues ("#3", xmlReader, \r
1290                                 XmlNodeType.Text,\r
1291                                 1, // FIXME might be 2\r
1292                                 false,\r
1293                                 String.Empty,\r
1294                                 null, // FIXME: should be String.Empty,\r
1295                                 String.Empty,\r
1296                                 null, // FIXME: should be String.Empty,\r
1297                                 "1.0",\r
1298                                 2);\r
1299                         xmlReader.MoveToNextAttribute ();\r
1300                         this.AssertNodeValues ("#4", xmlReader, \r
1301                                 XmlNodeType.Attribute,\r
1302                                 0, // FIXME: might be 1\r
1303                                 false,\r
1304                                 "standalone",\r
1305                                 String.Empty,\r
1306                                 "standalone",\r
1307                                 String.Empty,\r
1308                                 "yes",\r
1309                                 2);\r
1310                         xmlReader.ReadAttributeValue ();\r
1311                         this.AssertNodeValues ("#5", xmlReader, \r
1312                                 XmlNodeType.Text,\r
1313                                 1, // FIXME: might be 2\r
1314                                 false,\r
1315                                 String.Empty,\r
1316                                 null, // FIXME: should be String.Empty,\r
1317                                 String.Empty,\r
1318                                 null, // FIXME: should be String.Empty,\r
1319                                 "yes",\r
1320                                 2);\r
1321                 }\r
1322 \r
1323                 [Test]\r
1324                 public void AttributeOrder ()\r
1325                 {\r
1326                         string xml = @"<foo _1='1' _2='2' _3='3' />";\r
1327                         RunTest (xml, new TestMethod (AttributeOrder));\r
1328                 }\r
1329 \r
1330                 public void AttributeOrder (XmlReader xmlReader)\r
1331                 {\r
1332                         Assert.IsTrue (xmlReader.Read ());\r
1333                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1334 \r
1335                         Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
1336                         Assert.AreEqual ("_1", xmlReader.Name);\r
1337                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1338                         Assert.AreEqual ("_2", xmlReader.Name);\r
1339                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1340                         Assert.AreEqual ("_3", xmlReader.Name);\r
1341 \r
1342                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1343                 }\r
1344 \r
1345                 [Test]\r
1346                 [Category ("NotDotNet")]\r
1347                 public void IndexerAndAttributes ()\r
1348                 {\r
1349                         string xml = @"<?xml version='1.0' standalone='no'?><foo _1='1' _2='2' _3='3' />";\r
1350                         RunTest (xml, new TestMethod (IndexerAndAttributes));\r
1351                 }\r
1352 \r
1353                 public void IndexerAndAttributes (XmlReader xmlReader)\r
1354                 {\r
1355                         Assert.IsTrue (xmlReader.Read ());\r
1356                         Assert.AreEqual ("1.0", xmlReader ["version"]);\r
1357                         Assert.AreEqual ("1.0", xmlReader.GetAttribute ("version"));\r
1358                         // .NET 1.1 BUG. XmlTextReader returns null, while XmlNodeReader returns "".\r
1359                         Assert.AreEqual (null, xmlReader ["encoding"]);\r
1360                         Assert.AreEqual (null, xmlReader.GetAttribute ("encoding"));\r
1361                         Assert.AreEqual ("no", xmlReader ["standalone"]);\r
1362                         Assert.AreEqual ("no", xmlReader.GetAttribute ("standalone"));\r
1363                         Assert.AreEqual ("1.0", xmlReader [0]);\r
1364                         Assert.AreEqual ("1.0", xmlReader.GetAttribute (0));\r
1365                         Assert.AreEqual ("no", xmlReader [1]);\r
1366                         Assert.AreEqual ("no", xmlReader.GetAttribute (1));\r
1367 \r
1368                         Assert.IsTrue (xmlReader.Read ());\r
1369                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1370                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1371 \r
1372                         Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
1373                         Assert.AreEqual ("_1", xmlReader.Name);\r
1374                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1375                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1376                         Assert.AreEqual ("_2", xmlReader.Name);\r
1377                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1378                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1379                         Assert.AreEqual ("_3", xmlReader.Name);\r
1380                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1381 \r
1382                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1383                 }\r
1384 \r
1385                 [Test]\r
1386                 public void ProhibitedMultipleAttributes ()\r
1387                 {\r
1388                         string xml = @"<foo _1='1' _1='1' />";\r
1389                         try {\r
1390                                 RunTest (xml, new TestMethod (ReadAll));\r
1391                         } catch (XmlException) {\r
1392                         }\r
1393                         xml = @"<foo _1='1' _1='2' />";\r
1394                         try {\r
1395                                 RunTest (xml, new TestMethod (ReadAll));\r
1396                         } catch (XmlException) {\r
1397                         }\r
1398                 }\r
1399 \r
1400                 public void ReadAll (XmlReader xmlReader)\r
1401                 {\r
1402                         while (!xmlReader.EOF)\r
1403                                 xmlReader.Read ();\r
1404                 }\r
1405 \r
1406                 [Test]\r
1407                 public void SurrogatePairContent ()\r
1408                 {\r
1409                         string xml = "<root xmlns='&#x10100;'/>";\r
1410                         RunTest (xml, new TestMethod (SurrogatePairContent));\r
1411                 }\r
1412 \r
1413                 public void SurrogatePairContent (XmlReader xmlReader)\r
1414                 {\r
1415                         xmlReader.Read ();\r
1416                         Assert.AreEqual (true, xmlReader.MoveToAttribute ("xmlns"));\r
1417                         Assert.AreEqual ("xmlns", xmlReader.Name);\r
1418                         Assert.AreEqual (2, xmlReader.Value.Length);\r
1419                         Assert.AreEqual (0xD800, (int) xmlReader.Value [0]);\r
1420                         Assert.AreEqual (0xDD00, (int) xmlReader.Value [1]);\r
1421                 }\r
1422 \r
1423                 [Test]\r
1424                 public void ReadOuterXmlOnEndElement ()\r
1425                 {\r
1426                         string xml = "<root><foo></foo></root>";\r
1427                         RunTest (xml, new TestMethod (ReadOuterXmlOnEndElement));\r
1428                 }\r
1429 \r
1430                 public void ReadOuterXmlOnEndElement (XmlReader xmlReader)\r
1431                 {\r
1432                         xmlReader.Read ();\r
1433                         xmlReader.Read ();\r
1434                         xmlReader.Read ();\r
1435                         Assert.AreEqual (String.Empty, xmlReader.ReadOuterXml ());\r
1436                 }\r
1437 \r
1438                 [Test]\r
1439                 public void ReadInnerXmlOnEndElement ()\r
1440                 {\r
1441                         string xml = "<root><foo></foo></root>";\r
1442                         RunTest (xml, new TestMethod (ReadInnerXmlOnEndElement));\r
1443                 }\r
1444 \r
1445                 private void ReadInnerXmlOnEndElement (XmlReader xmlReader)\r
1446                 {\r
1447                         xmlReader.Read ();\r
1448                         xmlReader.Read ();\r
1449                         xmlReader.Read ();\r
1450                         Assert.AreEqual (String.Empty, xmlReader.ReadInnerXml ());\r
1451                 }\r
1452 \r
1453                 [Test]\r
1454                 public void LookupEmptyPrefix ()\r
1455                 {\r
1456                         string xml = "<root><foo></foo></root>";\r
1457                         RunTest (xml, new TestMethod (LookupEmptyPrefix));\r
1458                 }\r
1459 \r
1460                 void LookupEmptyPrefix (XmlReader xmlReader)\r
1461                 {\r
1462                         xmlReader.Read ();\r
1463                         Assert.IsNull (xmlReader.LookupNamespace (String.Empty));\r
1464                 }\r
1465 \r
1466                 [Test]\r
1467                 public void ReadStartElement ()\r
1468                 {\r
1469                         string xml = "<root>test</root>";\r
1470                         RunTest (xml, new TestMethod (ReadStartElement));\r
1471                 }\r
1472 \r
1473                 void ReadStartElement (XmlReader xr)\r
1474                 {\r
1475                         xr.Read ();\r
1476                         xr.ReadStartElement ();\r
1477                         // consume Element node.\r
1478                         Assert.AreEqual (XmlNodeType.Text, xr.NodeType);\r
1479                 }\r
1480 \r
1481                 [Test]\r
1482                 public void LookupNamespaceAtEndElement ()\r
1483                 {\r
1484                         string xml = "<root xmlns:x='urn:foo'><foo/></root>";\r
1485                         RunTest (xml, new TestMethod (LookupNamespaceAtEndElement));\r
1486                 }\r
1487 \r
1488                 void LookupNamespaceAtEndElement (XmlReader reader)\r
1489                 {\r
1490                         reader.Read ();\r
1491                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#1");\r
1492                         reader.Read ();\r
1493                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#2");\r
1494                         reader.Read ();\r
1495                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#3");\r
1496                 }\r
1497 \r
1498                 [Test]\r
1499                 public void ReadClosedReader ()\r
1500                 {\r
1501                         string xml = "<fin>aaa</fin>";\r
1502                         RunTest (xml, new TestMethod (ReadClosedReader));\r
1503                 }\r
1504 \r
1505                 void ReadClosedReader (XmlReader reader)\r
1506                 {\r
1507                         reader.Read ();\r
1508                         reader.Close();\r
1509                         reader.Read (); // silently returns false\r
1510                 }\r
1511 \r
1512 #if NET_2_0\r
1513                 [Test]\r
1514                 public void CreateSimple ()\r
1515                 {\r
1516                         XmlReaderSettings s = new XmlReaderSettings ();\r
1517                         s.ProhibitDtd = false;\r
1518                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml", s);\r
1519                         xr.Read ();\r
1520                         Assert.AreEqual (XmlNodeType.DocumentType, xr.NodeType, "#1");\r
1521                         xr.Read ();\r
1522                         Assert.AreEqual (XmlNodeType.Whitespace, xr.NodeType, "#2");\r
1523                         xr.Read ();\r
1524                         Assert.AreEqual (XmlNodeType.Element, xr.NodeType, "#3");\r
1525                 }\r
1526 \r
1527                 [Test]\r
1528                 [ExpectedException (typeof (XmlException))]\r
1529                 public void CreateSimpleProhibitDtd ()\r
1530                 {\r
1531                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml");\r
1532                         xr.Read ();\r
1533                 }\r
1534 \r
1535                 [Test]\r
1536                 // a bit revised version of bug #78706\r
1537                 public void CreateFromUrlClose ()\r
1538                 {\r
1539                         string file = "Test/XmlFiles/78706.xml";\r
1540                         try {\r
1541                                 if (!File.Exists (file))\r
1542                                         File.Create (file).Close ();\r
1543                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1544                                 s.CloseInput = false; // explicitly\r
1545                                 XmlReader r = XmlReader.Create (file, s);\r
1546                                 r.Close ();\r
1547                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1548                                 w.Close ();\r
1549                         } finally {\r
1550                                 if (File.Exists (file))\r
1551                                         File.Delete (file);\r
1552                         }\r
1553                 }\r
1554 \r
1555                 [Test]\r
1556                 // a bit revised version of bug #385638\r
1557                 public void CreateFromUrlClose2 ()\r
1558                 {\r
1559                         string file = "Test/XmlFiles/385638.xml";\r
1560                         try {\r
1561                                 if (File.Exists (file))\r
1562                                         File.Delete (file);\r
1563                                 using (TextWriter tw = File.CreateText (file))\r
1564                                         tw.Write ("<xml />");\r
1565                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1566                                 s.IgnoreWhitespace = true; // this results in XmlFilterReader, which is the key for this bug.\r
1567                                 XmlReader r = XmlReader.Create (file, s);\r
1568                                 r.Close ();\r
1569                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1570                                 w.Close ();\r
1571                         } finally {\r
1572                                 if (File.Exists (file))\r
1573                                         File.Delete (file);\r
1574                         }\r
1575                 }\r
1576 \r
1577                 [Test]\r
1578                 [ExpectedException (typeof (ArgumentException))]\r
1579                 public void Create_String_Empty ()\r
1580                 {\r
1581                         XmlReader.Create (String.Empty);\r
1582                 }\r
1583 \r
1584                 [Test]\r
1585                 public void ReadToDescendant ()\r
1586                 {\r
1587                         string xml = @"<root><foo/><bar/><foo> test text <bar><bar></bar></bar></foo></root>";\r
1588                         RunTest (xml, new TestMethod (ReadToDescendant));\r
1589                 }\r
1590 \r
1591                 void ReadToDescendant (XmlReader xmlReader)\r
1592                 {\r
1593                         // move to first <bar/>\r
1594                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#1");\r
1595                         // no children in <bar/>. It is empty.\r
1596                         Assert.IsTrue (!xmlReader.ReadToDescendant ("bar"), "#2");\r
1597                         Assert.AreEqual ("bar", xmlReader.Name, "#2-2");\r
1598 \r
1599                         // move to the second <foo>\r
1600                         xmlReader.Read ();\r
1601                         // move to the second <bar>\r
1602                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#3");\r
1603                         // move to <bar> inside <bar>...</bar>\r
1604                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#4");\r
1605                         // the next is EndElement of </bar>, so no move.\r
1606                         Assert.IsTrue (!xmlReader.ReadToDescendant ("bar"), "#5");\r
1607                         Assert.AreEqual (XmlNodeType.EndElement, xmlReader.NodeType, "#5-2");\r
1608                 }\r
1609 \r
1610                 [Test]\r
1611                 public void ReadToDescepdant2 ()\r
1612                 {\r
1613                         string xml = "<root/>";\r
1614                         RunTest (xml, new TestMethod (ReadToDescendant2));\r
1615                 }\r
1616 \r
1617                 void ReadToDescendant2 (XmlReader xmlReader)\r
1618                 {\r
1619                         // make sure that it works when the reader is at Initial state.\r
1620                         Assert.IsTrue (xmlReader.ReadToDescendant ("root"));\r
1621                 }\r
1622 \r
1623                 [Test]\r
1624                 public void ReadToFollowing ()\r
1625                 {\r
1626                         string xml = @"<root><foo/><bar/><foo><bar><bar></bar></bar></foo></root>";\r
1627                         RunTest (xml, new TestMethod (ReadToFollowing));\r
1628                 }\r
1629 \r
1630                 public void ReadToFollowing (XmlReader xmlReader)\r
1631                 {\r
1632                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#1");\r
1633                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#2");\r
1634                         Assert.AreEqual (2, xmlReader.Depth, "#2-2");\r
1635                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#3");\r
1636                         Assert.AreEqual (3, xmlReader.Depth, "#3-2");\r
1637                         Assert.IsTrue (!xmlReader.ReadToFollowing ("bar"), "#4");\r
1638                 }\r
1639 \r
1640                 [Test]\r
1641                 [Category ("NotDotNet")]\r
1642                 public void ReadToNextSiblingAtInitialState ()\r
1643                 {\r
1644                         string xml = @"<root></root>";\r
1645                         RunTest (xml, new TestMethod (ReadToNextSiblingAtInitialState ));\r
1646                 }\r
1647 \r
1648                 void ReadToNextSiblingAtInitialState (XmlReader xmlReader)\r
1649                 {\r
1650                         Assert.IsTrue (!xmlReader.ReadToNextSibling ("bar"), "#1");\r
1651                         Assert.IsTrue (!xmlReader.ReadToNextSibling ("root"), "#2");\r
1652                 }\r
1653 \r
1654                 [Test]\r
1655                 public void ReadToNextSibling ()\r
1656                 {\r
1657                         string xml = @"<root><foo/><bar attr='value'/><foo><pooh/><bar></bar><foo></foo><bar/></foo></root>";\r
1658                         RunTest (xml, new TestMethod (ReadToNextSibling));\r
1659                 }\r
1660 \r
1661                 void ReadToNextSibling (XmlReader xmlReader)\r
1662                 {\r
1663                         // It is funky, but without it MS.NET results in an infinite loop.\r
1664                         xmlReader.Read (); // root\r
1665 \r
1666                         xmlReader.Read (); // foo\r
1667                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#3");\r
1668 \r
1669                         Assert.AreEqual ("value", xmlReader.GetAttribute ("attr"), "#3-2");\r
1670                         xmlReader.Read (); // foo\r
1671                         xmlReader.Read (); // pooh\r
1672                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#4");\r
1673                         Assert.IsTrue (!xmlReader.IsEmptyElement, "#4-2");\r
1674                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#5");\r
1675                         Assert.IsTrue (xmlReader.IsEmptyElement, "#5-2");\r
1676                         Assert.IsTrue (xmlReader.Read (), "#6"); // /foo\r
1677 \r
1678                         AssertNodeValues ("#7", xmlReader,\r
1679                                 XmlNodeType.EndElement,\r
1680                                 1,              // Depth\r
1681                                 false,          // IsEmptyElement\r
1682                                 "foo",          // Name\r
1683                                 String.Empty,   // Prefix\r
1684                                 "foo",          // LocalName\r
1685                                 String.Empty,   // NamespaceURI\r
1686                                 String.Empty,   // Value\r
1687                                 false,          // HasValue\r
1688                                 0,              // AttributeCount\r
1689                                 false);         // HasAttributes\r
1690                 }\r
1691 \r
1692                 // bug #81451\r
1693                 [Test]\r
1694                 public void ReadToNextSibling2 ()\r
1695                 {\r
1696                         string xml = @"<root><baz><bar><foo attr='value'/></bar><foo attr='value2'><bar><foo /></bar></foo></baz></root>";\r
1697                         RunTest (xml, new TestMethod (ReadToNextSibling2));\r
1698                 }\r
1699 \r
1700                 void ReadToNextSibling2 (XmlReader r)\r
1701                 {\r
1702                         r.MoveToContent (); // ->root\r
1703                         r.Read (); // root->baz\r
1704                         r.Read (); // baz->bar\r
1705                         Assert.IsTrue (r.ReadToNextSibling ("foo"), "#1");\r
1706                         Assert.AreEqual ("value2", r.GetAttribute ("attr"), "#2");\r
1707                         r.Read (); // foo[@value='value2']->bar\r
1708                         Assert.IsTrue (!r.ReadToNextSibling ("foo"), "#3");\r
1709                         Assert.AreEqual (XmlNodeType.EndElement, r.NodeType, "#4");\r
1710                         Assert.AreEqual ("foo", r.LocalName, "#5");\r
1711                 }\r
1712 \r
1713                 // bug #347768\r
1714                 [Test]\r
1715                 public void ReadToNextSibling3 ()\r
1716                 {\r
1717                         string xml = @" <books> <book> <name>Happy C Sharp</name> </book> </books>";\r
1718                         XmlReader reader = XmlReader.Create (new StringReader (xml));\r
1719 \r
1720                         reader.MoveToContent ();\r
1721 \r
1722                         while (reader.Read ())\r
1723                                 reader.ReadToNextSibling ("book"); // should not result in an infinite loop\r
1724                 }\r
1725 \r
1726                 [Test]\r
1727                 public void ReadSubtree ()\r
1728                 {\r
1729                         string xml = @"<root><foo/><bar attr='value'></bar></root>";\r
1730                         RunTest (xml, new TestMethod (ReadSubtree));\r
1731                 }\r
1732 \r
1733                 void ReadSubtree (XmlReader reader)\r
1734                 {\r
1735                         reader.MoveToContent (); // root\r
1736                         reader.Read (); // foo\r
1737                         XmlReader st = reader.ReadSubtree (); // <foo/>\r
1738 \r
1739                         // MS bug: IsEmptyElement should be false here.\r
1740                         /*\r
1741                         AssertNodeValues ("#1", st,\r
1742                                 XmlNodeType.None,\r
1743                                 0,              // Depth\r
1744                                 false,          // IsEmptyElement\r
1745                                 String.Empty,   // Name\r
1746                                 String.Empty,   // Prefix\r
1747                                 String.Empty,   // LocalName\r
1748                                 String.Empty,   // NamespaceURI\r
1749                                 String.Empty,   // Value\r
1750                                 false,          // HasValue\r
1751                                 0,              // AttributeCount\r
1752                                 false);         // HasAttributes\r
1753                         */\r
1754                         Assert.AreEqual (XmlNodeType.None, st.NodeType, "#1");\r
1755 \r
1756                         st.Read ();\r
1757                         AssertNodeValues ("#2", st,\r
1758                                 XmlNodeType.Element,\r
1759                                 0,\r
1760                                 true,           // IsEmptyElement\r
1761                                 "foo",          // Name\r
1762                                 String.Empty,   // Prefix\r
1763                                 "foo",          // LocalName\r
1764                                 String.Empty,   // NamespaceURI\r
1765                                 String.Empty,   // Value\r
1766                                 false,          // HasValue\r
1767                                 0,              // AttributeCount\r
1768                                 false);         // HasAttributes\r
1769 \r
1770                         Assert.IsTrue (!st.Read (), "#3");\r
1771 \r
1772                         // At this state, reader is not positioned on <bar> yet\r
1773                         AssertNodeValues ("#3-2", reader,\r
1774                                 XmlNodeType.Element,\r
1775                                 1,              // Depth. It is 1 for main tree.\r
1776                                 true,           // IsEmptyElement\r
1777                                 "foo",          // Name\r
1778                                 String.Empty,   // Prefix\r
1779                                 "foo",          // LocalName\r
1780                                 String.Empty,   // NamespaceURI\r
1781                                 String.Empty,   // Value\r
1782                                 false,          // HasValue\r
1783                                 0,              // AttributeCount\r
1784                                 false);         // HasAttributes\r
1785 \r
1786                         reader.Read ();\r
1787 \r
1788                         AssertNodeValues ("#4", reader,\r
1789                                 XmlNodeType.Element,\r
1790                                 1,              // Depth. It is 1 for main tree.\r
1791                                 false,          // IsEmptyElement\r
1792                                 "bar",          // Name\r
1793                                 String.Empty,   // Prefix\r
1794                                 "bar",          // LocalName\r
1795                                 String.Empty,   // NamespaceURI\r
1796                                 String.Empty,   // Value\r
1797                                 false,          // HasValue\r
1798                                 1,              // AttributeCount\r
1799                                 true);          // HasAttributes\r
1800 \r
1801                         st = reader.ReadSubtree ();\r
1802                         st.Read (); // Initial -> Interactive\r
1803                         AssertNodeValues ("#5", st,\r
1804                                 XmlNodeType.Element,\r
1805                                 0,              // Depth. It is 0 for subtree.\r
1806                                 false,          // IsEmptyElement\r
1807                                 "bar",          // Name\r
1808                                 String.Empty,   // Prefix\r
1809                                 "bar",          // LocalName\r
1810                                 String.Empty,   // NamespaceURI\r
1811                                 String.Empty,   // Value\r
1812                                 false,          // HasValue\r
1813                                 1,              // AttributeCount\r
1814                                 true);          // HasAttributes\r
1815 \r
1816                         st.Read ();\r
1817                         AssertNodeValues ("#6-1", st,\r
1818                                 XmlNodeType.EndElement,\r
1819                                 0,              // Depth. It is 0 for subtree.\r
1820                                 false,          // IsEmptyElement\r
1821                                 "bar",          // Name\r
1822                                 String.Empty,   // Prefix\r
1823                                 "bar",          // LocalName\r
1824                                 String.Empty,   // NamespaceURI\r
1825                                 String.Empty,   // Value\r
1826                                 false,          // HasValue\r
1827                                 0,              // AttributeCount\r
1828                                 false);         // HasAttributes\r
1829 \r
1830                         AssertNodeValues ("#6-2", st,\r
1831                                 XmlNodeType.EndElement,\r
1832                                 0,              // Depth. It is 0 for subtree.\r
1833                                 false,          // IsEmptyElement\r
1834                                 "bar",          // Name\r
1835                                 String.Empty,   // Prefix\r
1836                                 "bar",          // LocalName\r
1837                                 String.Empty,   // NamespaceURI\r
1838                                 String.Empty,   // Value\r
1839                                 false,          // HasValue\r
1840                                 0,              // AttributeCount\r
1841                                 false);         // HasAttributes\r
1842 \r
1843                         Assert.IsTrue (!st.Read (), "#7");\r
1844                 }\r
1845 \r
1846                 [Test]\r
1847                 public void ReadInteger ()\r
1848                 {\r
1849                         string xml1 = "<root>1</root>";\r
1850                         XmlReader xr;\r
1851                         \r
1852                         xr = XmlReader.Create (new StringReader (xml1));\r
1853                         xr.Read ();\r
1854                         Assert.AreEqual ("1", xr.ReadElementContentAsString (), "#1");\r
1855 \r
1856                         AssertNodeValues ("#1-2", xr,\r
1857                                 XmlNodeType.None,\r
1858                                 0,              // Depth. It is 0 for subtree.\r
1859                                 false,          // IsEmptyElement\r
1860                                 String.Empty,   // Name\r
1861                                 String.Empty,   // Prefix\r
1862                                 String.Empty,   // LocalName\r
1863                                 String.Empty,   // NamespaceURI\r
1864                                 String.Empty,   // Value\r
1865                                 false,          // HasValue\r
1866                                 0,              // AttributeCount\r
1867                                 false);         // HasAttributes\r
1868 \r
1869                         xr = XmlReader.Create (new StringReader (xml1));\r
1870                         xr.Read ();\r
1871                         // this XmlReader has no schema, thus the value is untyped\r
1872                         Assert.AreEqual ("1", xr.ReadElementContentAsObject (), "#2");\r
1873 \r
1874                         xr = XmlReader.Create (new StringReader (xml1));\r
1875                         xr.Read ();\r
1876                         xr.Read ();\r
1877                         Assert.AreEqual ("1", xr.ReadContentAsString (), "#3");\r
1878 \r
1879                         xr = XmlReader.Create (new StringReader (xml1));\r
1880                         xr.Read ();\r
1881                         Assert.AreEqual (1, xr.ReadElementContentAsInt (), "#4");\r
1882 \r
1883                         xr = XmlReader.Create (new StringReader (xml1));\r
1884                         xr.Read ();\r
1885                         Assert.AreEqual (1, xr.ReadElementContentAs (typeof (int), null), "#5");\r
1886                 }\r
1887 \r
1888                 [Test]\r
1889                 [ExpectedException (typeof (XmlException))]\r
1890                 public void ReadContentAsIntFail ()\r
1891                 {\r
1892                         XmlReader xr = XmlReader.Create (\r
1893                                 new StringReader ("<doc>1.0</doc>"));\r
1894                         xr.Read ();\r
1895                         xr.ReadElementContentAsInt ();\r
1896                 }\r
1897 \r
1898                 [Test]\r
1899                 public void ReadDateTime ()\r
1900                 {\r
1901                         DateTime time = new DateTime (2006, 1, 2, 3, 4, 56);\r
1902                         string xml1 = "<root>2006-01-02T03:04:56</root>";\r
1903                         XmlReader xr;\r
1904 \r
1905                         xr = XmlReader.Create (new StringReader (xml1));\r
1906                         xr.Read ();\r
1907                         // this XmlReader has no schema, thus the value is untyped\r
1908                         Assert.AreEqual ("2006-01-02T03:04:56", xr.ReadElementContentAsString (), "#1");\r
1909 \r
1910                         xr = XmlReader.Create (new StringReader (xml1));\r
1911                         xr.Read ();\r
1912                         xr.Read ();\r
1913                         Assert.AreEqual (time, xr.ReadContentAsDateTime (), "#2");\r
1914 \r
1915                         xr = XmlReader.Create (new StringReader (xml1));\r
1916                         xr.Read ();\r
1917                         Assert.AreEqual (time, xr.ReadElementContentAsDateTime (), "#3");\r
1918 \r
1919                         xr = XmlReader.Create (new StringReader (xml1));\r
1920                         xr.Read ();\r
1921                         Assert.AreEqual (time, xr.ReadElementContentAs (typeof (DateTime), null), "#4");\r
1922                 }\r
1923 \r
1924                 [Test]\r
1925                 [ExpectedException (typeof (XmlException))]\r
1926                 public void ReadContentAsDateTimeFail ()\r
1927                 {\r
1928                         XmlReader xr = XmlReader.Create (\r
1929                                 new StringReader ("<doc>P1Y2M3D</doc>"));\r
1930                         xr.Read ();\r
1931                         xr.ReadElementContentAsDateTime ();\r
1932                 }\r
1933 \r
1934                 [Test]\r
1935                 public void ReadContentAs_QNameEmptyNSResolver ()\r
1936                 {\r
1937                         XmlReader xr = XmlReader.Create (\r
1938                                 new StringReader ("<doc xmlns:x='urn:foo'>x:el</doc>"));\r
1939                         xr.Read ();\r
1940                         object o = xr.ReadElementContentAs (\r
1941                                 typeof (XmlQualifiedName), null);\r
1942                         // without IXmlNamespaceResolver, it still resolves\r
1943                         // x:el as valid QName.\r
1944                         Assert.IsNotNull (o, "#1");\r
1945                         XmlQualifiedName q = o as XmlQualifiedName;\r
1946                         Assert.AreEqual (new XmlQualifiedName ("el", "urn:foo"), q, "#2 : " + o.GetType ());\r
1947                 }\r
1948 \r
1949                 [Test]\r
1950                 [ExpectedException (typeof (InvalidOperationException))]\r
1951                 public void ReadContentStringOnElementFail ()\r
1952                 {\r
1953                         XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
1954                         xr.Read ();\r
1955                         xr.ReadContentAsString ();\r
1956                 }\r
1957 \r
1958                 [Test]\r
1959                 public void ReadContentStringOnEndElement ()\r
1960                 {\r
1961                         XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
1962                         xr.Read ();\r
1963                         xr.Read ();\r
1964                         xr.Read ();\r
1965                         Assert.AreEqual (String.Empty, xr.ReadContentAsString ()); // does not fail, unlike at Element!\r
1966                 }\r
1967 \r
1968                 [Test]\r
1969                 public void ReadContentStringOnPI ()\r
1970                 {\r
1971                         XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
1972                         xr.Read ();\r
1973                         Assert.AreEqual (String.Empty, xr.ReadContentAsString ());\r
1974                 }\r
1975 \r
1976                 [Test]\r
1977                 [ExpectedException (typeof (InvalidOperationException))] // unlike ReadContentAsString()\r
1978                 public void ReadElementContentStringOnPI ()\r
1979                 {\r
1980                         XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
1981                         xr.Read ();\r
1982                         Assert.AreEqual (XmlNodeType.ProcessingInstruction, xr.NodeType);\r
1983                         xr.ReadElementContentAsString ();\r
1984                 }\r
1985 \r
1986                 [Test]\r
1987                 [ExpectedException (typeof (XmlException))]\r
1988                 public void ReadElementContentStringMixedContent ()\r
1989                 {\r
1990                         XmlReader xr = XmlReader.Create (\r
1991                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
1992                         xr.Read ();\r
1993                         // "child" is regarded as an invalid node.\r
1994                         string s = xr.ReadElementContentAsString ();\r
1995                 }\r
1996 \r
1997                 [Test]\r
1998                 public void ReadContentStringMixedContent ()\r
1999                 {\r
2000                         XmlReader xr = XmlReader.Create (\r
2001                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
2002                         xr.Read ();\r
2003                         xr.Read (); // from Text "123"\r
2004                         string s = xr.ReadContentAsString ();\r
2005                         Assert.AreEqual ("123", s, "#1");\r
2006                         Assert.AreEqual (XmlNodeType.Element, xr.NodeType, "#2");\r
2007                 }\r
2008 \r
2009                 [Test]\r
2010                 public void ReadElementContentAsString ()\r
2011                 {\r
2012                         XmlTextReader r = new XmlTextReader (\r
2013                                 "<root/>", XmlNodeType.Document, null);\r
2014                         r.Read ();\r
2015                         Assert.AreEqual (String.Empty, r.ReadElementContentAsString (), "#1");\r
2016                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#2");\r
2017                 }\r
2018 \r
2019                 [Test]\r
2020                 public void ReadElementContentAs ()\r
2021                 {\r
2022                         // as System.Object\r
2023 \r
2024                         XmlTextReader r = new XmlTextReader (\r
2025                                 "<root/>", XmlNodeType.Document, null);\r
2026                         r.Read ();\r
2027                         Assert.AreEqual (String.Empty, r.ReadElementContentAs (typeof (object), null), "#1");\r
2028                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#2");\r
2029 \r
2030                         // regardless of its value, the return value is string.\r
2031                         r = new XmlTextReader ("<root>1</root>", XmlNodeType.Document, null);\r
2032                         r.Read ();\r
2033                         Assert.AreEqual ("1", r.ReadElementContentAs (typeof (object), null), "#3");\r
2034                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#4");\r
2035                 }\r
2036 \r
2037                 [Test]\r
2038                 public void ReadContentStringOnAttribute ()\r
2039                 {\r
2040                         string xml = @"<root id='myId'><child /></root>";\r
2041                         RunTest (xml, new TestMethod (ReadContentStringOnAttribute));\r
2042                 }\r
2043 \r
2044                 void ReadContentStringOnAttribute (XmlReader reader)\r
2045                 {\r
2046                         reader.Read ();\r
2047                         Assert.IsTrue (reader.MoveToAttribute ("id"));\r
2048                         Assert.AreEqual ("myId", reader.ReadContentAsString ());\r
2049                 }\r
2050 \r
2051                 [Test]\r
2052                 public void ReadElementContentAsStringEmpty ()\r
2053                 {\r
2054                         string xml = "<root><sample/></root>";\r
2055                         RunTest (xml, new TestMethod (ReadElementContentAsStringEmpty));\r
2056                 }\r
2057 \r
2058                 void ReadElementContentAsStringEmpty (XmlReader reader)\r
2059                 {\r
2060                         reader.MoveToContent ();\r
2061                         reader.Read ();\r
2062                         Assert.AreEqual (String.Empty, reader.ReadElementContentAsString ("sample", ""));\r
2063                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType);\r
2064                 }\r
2065 \r
2066                 [Test]\r
2067                 public void ReadSubtreeClose ()\r
2068                 {\r
2069                         // bug #334752\r
2070                         string xml = @"<root><item-list><item id='a'/><item id='b'/></item-list></root>";\r
2071                         RunTest (xml, new TestMethod (ReadSubtreeClose));\r
2072                 }\r
2073 \r
2074                 void ReadSubtreeClose (XmlReader reader)\r
2075                 {\r
2076                         reader.ReadToFollowing ("item-list");\r
2077                         XmlReader sub = reader.ReadSubtree ();\r
2078                         sub.ReadToDescendant ("item");\r
2079                         sub.Close ();\r
2080                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#1");\r
2081                         Assert.AreEqual ("item-list", reader.Name, "#2");\r
2082                 }\r
2083 \r
2084                 [Test]\r
2085                 [ExpectedException (typeof (InvalidOperationException))]\r
2086                 public void ReadSubtreeOnNonElement ()\r
2087                 {\r
2088                         string xml = @"<x> <y/></x>";\r
2089                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2090                         r.Read (); // x\r
2091                         r.Read (); // ws\r
2092                         r.ReadSubtree ();\r
2093                 }\r
2094 \r
2095                 [Test]\r
2096                 [ExpectedException (typeof (InvalidOperationException))]\r
2097                 public void ReadSubtreeOnNonElement2 ()\r
2098                 {\r
2099                         string xml = @"<x> <y/></x>";\r
2100                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2101                         r.ReadSubtree ();\r
2102                 }\r
2103 \r
2104                 [Test]\r
2105                 public void ReadSubtreeEmptyElement ()\r
2106                 {\r
2107                         string xml = @"<x/>";\r
2108                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2109                         r.Read ();\r
2110                         XmlReader s = r.ReadSubtree ();\r
2111                         Assert.IsTrue (s.Read (), "#1");\r
2112                         Assert.AreEqual (XmlNodeType.Element, s.NodeType, "#2");\r
2113                         Assert.IsTrue (!s.Read (), "#3");\r
2114                         Assert.AreEqual (XmlNodeType.None, s.NodeType, "#4");\r
2115                 }\r
2116 \r
2117                 [Test]\r
2118                 public void ReadSubtreeEmptyElementWithAttribute ()\r
2119                 {\r
2120                         string xml = @"<root><x a='b'/></root>";\r
2121                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2122                         r.Read ();\r
2123                         r.Read ();\r
2124                         XmlReader r2 = r.ReadSubtree ();\r
2125                         Console.WriteLine ("X");\r
2126                         r2.Read ();\r
2127                         XmlReader r3 = r2.ReadSubtree ();\r
2128                         r2.MoveToFirstAttribute ();\r
2129                         Assert.IsTrue (!r.IsEmptyElement, "#1");\r
2130                         Assert.IsTrue (!r2.IsEmptyElement, "#2");\r
2131                         r3.Close ();\r
2132                         Assert.IsTrue (r.IsEmptyElement, "#3");\r
2133                         Assert.IsTrue (r2.IsEmptyElement, "#4");\r
2134                         r2.Close ();\r
2135                         Assert.IsTrue (r.IsEmptyElement, "#5");\r
2136                         Assert.IsTrue (r2.IsEmptyElement, "#6");\r
2137                 }\r
2138 \r
2139                 [Test]\r
2140                 public void ReadContentAsBase64 ()\r
2141                 {\r
2142                         byte[] randomData = new byte[24];\r
2143                         for (int i = 0; i < randomData.Length; i++)\r
2144                                 randomData [i] = (byte) i;\r
2145 \r
2146                         string xmlString = "<?xml version=\"1.0\"?><data>" +\r
2147                         Convert.ToBase64String (randomData) + "</data>";\r
2148                         TextReader textReader = new StringReader (xmlString);\r
2149                         XmlReader xmlReader = XmlReader.Create (textReader);\r
2150                         xmlReader.ReadToFollowing ("data");\r
2151 \r
2152                         int readBytes = 0;\r
2153                         byte[] buffer = new byte [24];\r
2154 \r
2155                         xmlReader.ReadStartElement ();\r
2156                         readBytes = xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length);\r
2157                         Assert.AreEqual (24, readBytes, "#1");\r
2158                         Assert.AreEqual (0, xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length), "#2");\r
2159                         StringWriter sw = new StringWriter ();\r
2160                         foreach (byte b in buffer) sw.Write ("{0:X02}", b);\r
2161                         Assert.AreEqual ("000102030405060708090A0B0C0D0E0F1011121314151617", sw.ToString (), "#3");\r
2162                 }\r
2163 \r
2164                 [Test]\r
2165                 public void ReadContentAsBase64_2 () // bug #480066\r
2166                 {\r
2167                         StringReader readerString = new StringReader ("<root><b64>TWFu</b64><b64>TWFu</b64>\r\n\t<b64>TWFu</b64><b64>TWFu</b64></root>");\r
2168                         XmlReaderSettings settingsXml = new XmlReaderSettings ();\r
2169                         settingsXml.XmlResolver = null;\r
2170                         using (var readerXml = XmlReader.Create (readerString, settingsXml)) {\r
2171                                 readerXml.MoveToContent ();\r
2172                                 readerXml.Read ();\r
2173                                 readerXml.ReadStartElement ("b64");\r
2174                                 const int bufferLength = 1024;\r
2175                                 byte [] buffer = new byte [bufferLength];\r
2176                                 readerXml.ReadContentAsBase64 (buffer, 0, bufferLength);\r
2177                                 Assert.AreEqual (XmlNodeType.EndElement, readerXml.NodeType, "#1");\r
2178                                 readerXml.Read ();\r
2179                                 Assert.AreEqual (XmlNodeType.Element, readerXml.NodeType, "#2");\r
2180                         }\r
2181                 }\r
2182                 \r
2183                 [Test]\r
2184                 public void ReadContentAsBase64_3 () // bug #543332                     \r
2185                 {\r
2186                         byte [] fakeState = new byte[25];\r
2187                         byte [] fixedSizeBuffer = new byte [25];\r
2188                         byte [] readDataBuffer = new byte [25];\r
2189                         var ms = new MemoryStream ();\r
2190                         var xw = XmlWriter.Create (ms);\r
2191                         xw.WriteStartElement ("root");\r
2192                         xw.WriteBase64 (fakeState, 0, fakeState.Length);\r
2193                         xw.WriteEndElement ();\r
2194                         xw.Close ();\r
2195                         var reader = XmlReader.Create (new MemoryStream (ms.ToArray ()));\r
2196                         reader.MoveToContent ();\r
2197                         // we cannot completely trust the length read to indicate the end.\r
2198                         int bytesRead;\r
2199                         bytesRead = reader.ReadElementContentAsBase64 (fixedSizeBuffer, 0, fixedSizeBuffer.Length);\r
2200                         Assert.AreEqual (25, bytesRead, "#1");\r
2201                         Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#2");\r
2202                         bytesRead = reader.ReadElementContentAsBase64 (fixedSizeBuffer, 0, fixedSizeBuffer.Length);\r
2203                         Assert.AreEqual (0, bytesRead, "#3");\r
2204                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");\r
2205                 }\r
2206 \r
2207                 [Test]\r
2208                 public void ReadElementContentAsQNameDefaultNS ()\r
2209                 {\r
2210                         var sw = new StringWriter ();\r
2211                         var xw = XmlWriter.Create (sw);\r
2212                         xw.WriteStartElement ("", "foo", "urn:foo");\r
2213                         xw.WriteValue (new XmlQualifiedName ("x", "urn:foo"));\r
2214                         xw.WriteEndElement ();\r
2215                         xw.Close ();\r
2216                         var xr = XmlReader.Create (new StringReader (sw.ToString ()));\r
2217                         xr.MoveToContent ();\r
2218                         var q = (XmlQualifiedName) xr.ReadElementContentAs (typeof (XmlQualifiedName), xr as IXmlNamespaceResolver);\r
2219                         Assert.AreEqual ("urn:foo", q.Namespace, "#1");\r
2220                 }\r
2221 #endif\r
2222         }\r
2223 }\r