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.XPath;\r
  17 \r
  18 using NUnit.Framework;\r
  19 \r
  20 namespace MonoTests.System.Xml\r
  21 {\r
  22         [TestFixture]\r
  23         public class XmlReaderTests : Assertion\r
  24         {\r
  25                 [SetUp]\r
  26                 public void GetReady ()\r
  27                 {\r
  28                         document = new XmlDocument ();\r
  29                         document.LoadXml (xml1);\r
  30                 }\r
  31 \r
  32                 XmlDocument document;\r
  33                 const string xml1 = "<root attr1='value1'><child /></root>";\r
  34                 const string xml2 = "<root><foo/><bar>test.</bar></root>";\r
  35                 const string xml3 = "<root>  test of <b>mixed</b> string.<![CDATA[ cdata string.]]></root>";\r
  36                 const string xml4 = "<root>test of <b>mixed</b> string.</root>";\r
  37                 XmlTextReader xtr;\r
  38                 XmlNodeReader xnr;\r
  39 \r
  40                 // copy from XmlTextReaderTests\r
  41                 private void AssertStartDocument (XmlReader xmlReader)\r
  42                 {\r
  43                         Assert (xmlReader.ReadState == ReadState.Initial);\r
  44                         Assert (xmlReader.NodeType == XmlNodeType.None);\r
  45                         Assert (xmlReader.Depth == 0);\r
  46                         Assert (!xmlReader.EOF);\r
  47                 }\r
  48 \r
  49                 private void AssertNode (\r
  50                         XmlReader xmlReader,\r
  51                         XmlNodeType nodeType,\r
  52                         int depth,\r
  53                         bool isEmptyElement,\r
  54                         string name,\r
  55                         string prefix,\r
  56                         string localName,\r
  57                         string namespaceURI,\r
  58                         string value,\r
  59                         int attributeCount)\r
  60                 {\r
  61                         Assert ("Read() return value", xmlReader.Read ());\r
  62                         Assert ("ReadState", xmlReader.ReadState == ReadState.Interactive);\r
  63                         Assert ("!EOF", !xmlReader.EOF);\r
  64                         AssertNodeValues (xmlReader, nodeType, depth, isEmptyElement, name, prefix, localName, namespaceURI, value, attributeCount);\r
  65                 }\r
  66 \r
  67                 private void AssertNodeValues (\r
  68                         XmlReader xmlReader,\r
  69                         XmlNodeType nodeType,\r
  70                         int depth,\r
  71                         bool isEmptyElement,\r
  72                         string name,\r
  73                         string prefix,\r
  74                         string localName,\r
  75                         string namespaceURI,\r
  76                         string value,\r
  77                         int attributeCount)\r
  78                 {\r
  79                         AssertEquals ("NodeType", nodeType, xmlReader.NodeType);\r
  80                         AssertEquals ("Depth", depth, xmlReader.Depth);\r
  81                         AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);\r
  82 \r
  83                         AssertEquals ("name", name, xmlReader.Name);\r
  84 \r
  85                         AssertEquals ("prefix", prefix, xmlReader.Prefix);\r
  86 \r
  87                         AssertEquals ("localName", localName, xmlReader.LocalName);\r
  88 \r
  89                         AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI);\r
  90 \r
  91                         AssertEquals ("hasValue", (value != String.Empty), xmlReader.HasValue);\r
  92 \r
  93                         AssertEquals ("Value", value, xmlReader.Value);\r
  94 \r
  95                         AssertEquals ("hasAttributes", attributeCount > 0, xmlReader.HasAttributes);\r
  96 \r
  97                         AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount);\r
  98                 }\r
  99 \r
 100                 private void AssertAttribute (\r
 101                         XmlReader xmlReader,\r
 102                         string name,\r
 103                         string prefix,\r
 104                         string localName,\r
 105                         string namespaceURI,\r
 106                         string value)\r
 107                 {\r
 108                         AssertEquals ("value", value, xmlReader [name]);\r
 109 \r
 110                         Assert (xmlReader.GetAttribute (name) == value);\r
 111 \r
 112                         if (namespaceURI != String.Empty) {\r
 113                                 Assert (xmlReader[localName, namespaceURI] == value);\r
 114                                 Assert (xmlReader.GetAttribute (localName, namespaceURI) == value);\r
 115                         }\r
 116                 }\r
 117 \r
 118                 private void AssertEndDocument (XmlReader xmlReader)\r
 119                 {\r
 120                         Assert ("could read", !xmlReader.Read ());\r
 121                         AssertEquals ("NodeType is not XmlNodeType.None", XmlNodeType.None, xmlReader.NodeType);\r
 122                         AssertEquals ("Depth is not 0", 0, xmlReader.Depth);\r
 123                         AssertEquals ("ReadState is not ReadState.EndOfFile",  ReadState.EndOfFile, xmlReader.ReadState);\r
 124                         Assert ("not EOF", xmlReader.EOF);\r
 125 \r
 126                         xmlReader.Close ();\r
 127                         AssertEquals ("ReadState is not ReadState.Cosed", ReadState.Closed, xmlReader.ReadState);\r
 128                 }\r
 129 \r
 130                 private delegate void TestMethod (XmlReader reader);\r
 131 \r
 132                 private void RunTest (string xml, TestMethod method)\r
 133                 {\r
 134                         xtr = new XmlTextReader (new StringReader (xml));\r
 135                         method (xtr);\r
 136 \r
 137                         document.XmlResolver = null;\r
 138                         document.LoadXml (xml);\r
 139                         xnr = new XmlNodeReader (document);\r
 140                         method (xnr);\r
 141 \r
 142                         xtr = new XmlTextReader (new StringReader (xml));\r
 143                         XmlValidatingReader xvr = new XmlValidatingReader (xtr);\r
 144                         method (xvr);\r
 145                 }\r
 146 \r
 147 \r
 148 \r
 149 \r
 150 \r
 151                 [Test]\r
 152                 public void InitialState ()\r
 153                 {\r
 154                         RunTest (xml1, new TestMethod (InitialState));\r
 155                 }\r
 156 \r
 157                 private void InitialState (XmlReader reader)\r
 158                 {\r
 159                         AssertEquals ("Depth", 0, reader.Depth);\r
 160                         AssertEquals ("EOF", false, reader.EOF);\r
 161                         AssertEquals ("HasValue", false, reader.HasValue);\r
 162                         AssertEquals ("IsEmptyElement", false, reader.IsEmptyElement);\r
 163                         AssertEquals ("LocalName", String.Empty, reader.LocalName);\r
 164                         AssertEquals ("NodeType", XmlNodeType.None, reader.NodeType);\r
 165                         AssertEquals ("ReadState", ReadState.Initial, reader.ReadState);\r
 166                 }\r
 167 \r
 168                 [Test]\r
 169                 public void Read ()\r
 170                 {\r
 171                         RunTest (xml1, new TestMethod (Read));\r
 172                 }\r
 173 \r
 174                 public void Read (XmlReader reader)\r
 175                 {\r
 176                         reader.Read ();\r
 177                         AssertEquals ("<root>.NodeType", XmlNodeType.Element, reader.NodeType);\r
 178                         AssertEquals ("<root>.Name", "root", reader.Name);\r
 179                         AssertEquals ("<root>.ReadState", ReadState.Interactive, reader.ReadState);\r
 180                         AssertEquals ("<root>.Depth", 0, reader.Depth);\r
 181 \r
 182                         // move to 'child'\r
 183                         reader.Read ();\r
 184                         AssertEquals ("<child/>.Depth", 1, reader.Depth);\r
 185                         AssertEquals ("<child/>.NodeType", XmlNodeType.Element, reader.NodeType);\r
 186                         AssertEquals ("<child/>.Name", "child", reader.Name);\r
 187 \r
 188                         reader.Read ();\r
 189                         AssertEquals ("</root>.Depth", 0, reader.Depth);\r
 190                         AssertEquals ("</root>.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
 191                         AssertEquals ("</root>.Name", "root", reader.Name);\r
 192 \r
 193                         reader.Read ();\r
 194                         AssertEquals ("end.EOF", true, reader.EOF);\r
 195                         AssertEquals ("end.NodeType", XmlNodeType.None, reader.NodeType);\r
 196                 }\r
 197 \r
 198                 [Test]\r
 199                 public void ReadEmptyElement ()\r
 200                 {\r
 201                         RunTest (xml2, new TestMethod (ReadEmptyElement));\r
 202                 }\r
 203 \r
 204                 public void ReadEmptyElement (XmlReader reader)\r
 205                 {\r
 206                         reader.Read (); // root\r
 207                         AssertEquals (false, reader.IsEmptyElement);\r
 208                         reader.Read (); // foo\r
 209                         AssertEquals ("foo", reader.Name);\r
 210                         AssertEquals (true, reader.IsEmptyElement);\r
 211                         reader.Read (); // bar\r
 212                         AssertEquals ("bar", reader.Name);\r
 213                         AssertEquals (false, reader.IsEmptyElement);\r
 214                 }\r
 215 \r
 216                 [Test]\r
 217                 public void ReadStringFromElement ()\r
 218                 {\r
 219                         RunTest (xml3, new TestMethod (ReadStringFromElement));\r
 220                 }\r
 221 \r
 222                 public void ReadStringFromElement (XmlReader reader)\r
 223                 {\r
 224                         // Note: ReadString() test works only when the reader is\r
 225                         // positioned at the container element.\r
 226                         // In case the reader is positioned at the first \r
 227                         // character node, XmlTextReader and XmlNodeReader works\r
 228                         // different!!\r
 229 \r
 230                         reader.Read ();\r
 231                         string s = reader.ReadString ();\r
 232                         AssertEquals ("readString.1.ret_val", "  test of ", s);\r
 233                         AssertEquals ("readString.1.Name", "b", reader.Name);\r
 234                         s = reader.ReadString ();\r
 235                         AssertEquals ("readString.2.ret_val", "mixed", s);\r
 236                         AssertEquals ("readString.2.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
 237                         s = reader.ReadString ();       // never proceeds.\r
 238                         AssertEquals ("readString.3.ret_val", String.Empty, s);\r
 239                         AssertEquals ("readString.3.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
 240                         reader.Read ();\r
 241                         AssertEquals ("readString.4.NodeType", XmlNodeType.Text, reader.NodeType);\r
 242                         AssertEquals ("readString.4.Value", " string.", reader.Value);\r
 243                         s = reader.ReadString ();       // reads the same Text node.\r
 244                         AssertEquals ("readString.5.ret_val", " string. cdata string.", s);\r
 245                         AssertEquals ("readString.5.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
 246                 }\r
 247 \r
 248                 [Test]\r
 249                 public void ReadInnerXml ()\r
 250                 {\r
 251                         const string xml = "<root><foo>test of <b>mixed</b> string.</foo><bar /></root>";\r
 252                         RunTest (xml, new TestMethod (ReadInnerXml));\r
 253                 }\r
 254 \r
 255                 public void ReadInnerXml (XmlReader reader)\r
 256                 {\r
 257                         reader.Read ();\r
 258                         reader.Read ();\r
 259                         AssertEquals ("initial.ReadState", ReadState.Interactive, reader.ReadState);\r
 260                         AssertEquals ("initial.EOF", false, reader.EOF);\r
 261                         AssertEquals ("initial.NodeType", XmlNodeType.Element, reader.NodeType);\r
 262                         string s = reader.ReadInnerXml ();\r
 263                         AssertEquals ("read_all", "test of <b>mixed</b> string.", s);\r
 264                         AssertEquals ("after.Name", "bar", reader.Name);\r
 265                         AssertEquals ("after.NodeType", XmlNodeType.Element, reader.NodeType);\r
 266                 }\r
 267 \r
 268 \r
 269                 [Test]\r
 270                 public void EmptyElement ()\r
 271                 {\r
 272                         RunTest ("<foo/>", new TestMethod (EmptyElement));\r
 273                 }\r
 274                 \r
 275                 public void EmptyElement (XmlReader xmlReader)\r
 276                 {\r
 277 \r
 278                         AssertStartDocument (xmlReader);\r
 279 \r
 280                         AssertNode (\r
 281                                 xmlReader, // xmlReader\r
 282                                 XmlNodeType.Element, // nodeType\r
 283                                 0, // depth\r
 284                                 true, // isEmptyElement\r
 285                                 "foo", // name\r
 286                                 String.Empty, // prefix\r
 287                                 "foo", // localName\r
 288                                 String.Empty, // namespaceURI\r
 289                                 String.Empty, // value\r
 290                                 0 // attributeCount\r
 291                         );\r
 292 \r
 293                         AssertEndDocument (xmlReader);\r
 294                 }\r
 295 \r
 296                 [Test]\r
 297                 public void NestedEmptyTag ()\r
 298                 {\r
 299                         string xml = "<foo><bar/></foo>";\r
 300                         RunTest (xml, new TestMethod (NestedEmptyTag));\r
 301                 }\r
 302 \r
 303                 public void NestedEmptyTag (XmlReader xmlReader)\r
 304                 {\r
 305                         AssertStartDocument (xmlReader);\r
 306 \r
 307                         AssertNode (\r
 308                                 xmlReader, // xmlReader\r
 309                                 XmlNodeType.Element, // nodeType\r
 310                                 0, //depth\r
 311                                 false, // isEmptyElement\r
 312                                 "foo", // name\r
 313                                 String.Empty, // prefix\r
 314                                 "foo", // localName\r
 315                                 String.Empty, // namespaceURI\r
 316                                 String.Empty, // value\r
 317                                 0 // attributeCount\r
 318                         );\r
 319 \r
 320                         AssertNode (\r
 321                                 xmlReader, // xmlReader\r
 322                                 XmlNodeType.Element, // nodeType\r
 323                                 1, //depth\r
 324                                 true, // isEmptyElement\r
 325                                 "bar", // name\r
 326                                 String.Empty, // prefix\r
 327                                 "bar", // localName\r
 328                                 String.Empty, // namespaceURI\r
 329                                 String.Empty, // value\r
 330                                 0 // attributeCount\r
 331                         );\r
 332 \r
 333                         AssertNode (\r
 334                                 xmlReader, // xmlReader\r
 335                                 XmlNodeType.EndElement, // nodeType\r
 336                                 0, //depth\r
 337                                 false, // isEmptyElement\r
 338                                 "foo", // name\r
 339                                 String.Empty, // prefix\r
 340                                 "foo", // localName\r
 341                                 String.Empty, // namespaceURI\r
 342                                 String.Empty, // value\r
 343                                 0 // attributeCount\r
 344                         );\r
 345 \r
 346                         AssertEndDocument (xmlReader);\r
 347                 }\r
 348 \r
 349                 [Test]\r
 350                 public void NestedText ()\r
 351                 {\r
 352                         string xml = "<foo>bar</foo>";\r
 353                         RunTest (xml, new TestMethod (NestedText));\r
 354                 }\r
 355 \r
 356                 public void NestedText (XmlReader xmlReader)\r
 357                 {\r
 358                         AssertStartDocument (xmlReader);\r
 359 \r
 360                         AssertNode (\r
 361                                 xmlReader, // xmlReader\r
 362                                 XmlNodeType.Element, // nodeType\r
 363                                 0, //depth\r
 364                                 false, // isEmptyElement\r
 365                                 "foo", // name\r
 366                                 String.Empty, // prefix\r
 367                                 "foo", // localName\r
 368                                 String.Empty, // namespaceURI\r
 369                                 String.Empty, // value\r
 370                                 0 // attributeCount\r
 371                         );\r
 372 \r
 373                         AssertNode (\r
 374                                 xmlReader, // xmlReader\r
 375                                 XmlNodeType.Text, // nodeType\r
 376                                 1, //depth\r
 377                                 false, // isEmptyElement\r
 378                                 String.Empty, // name\r
 379                                 String.Empty, // prefix\r
 380                                 String.Empty, // localName\r
 381                                 String.Empty, // namespaceURI\r
 382                                 "bar", // value\r
 383                                 0 // attributeCount\r
 384                         );\r
 385 \r
 386                         AssertNode (\r
 387                                 xmlReader, // xmlReader\r
 388                                 XmlNodeType.EndElement, // nodeType\r
 389                                 0, //depth\r
 390                                 false, // isEmptyElement\r
 391                                 "foo", // name\r
 392                                 String.Empty, // prefix\r
 393                                 "foo", // localName\r
 394                                 String.Empty, // namespaceURI\r
 395                                 String.Empty, // value\r
 396                                 0 // attributeCount\r
 397                         );\r
 398 \r
 399                         AssertEndDocument (xmlReader);\r
 400                 }\r
 401 \r
 402                 [Test]\r
 403                 public void EmptyElementWithAttributes ()\r
 404                 {\r
 405                         string xml = @"<foo bar=""baz"" quux='quuux' x:foo='x-foo' xmlns:x = 'urn:xfoo' />";\r
 406                         RunTest (xml, new TestMethod (EmptyElementWithAttributes ));\r
 407                 }\r
 408 \r
 409                 public void EmptyElementWithAttributes (XmlReader xmlReader)\r
 410                 {\r
 411 \r
 412                         AssertStartDocument (xmlReader);\r
 413 \r
 414                         AssertNode (\r
 415                                 xmlReader, // xmlReader\r
 416                                 XmlNodeType.Element, // nodeType\r
 417                                 0, //depth\r
 418                                 true, // isEmptyElement\r
 419                                 "foo", // name\r
 420                                 String.Empty, // prefix\r
 421                                 "foo", // localName\r
 422                                 String.Empty, // namespaceURI\r
 423                                 String.Empty, // value\r
 424                                 4 // attributeCount\r
 425                         );\r
 426 \r
 427                         AssertAttribute (\r
 428                                 xmlReader, // xmlReader\r
 429                                 "bar", // name\r
 430                                 String.Empty, // prefix\r
 431                                 "bar", // localName\r
 432                                 String.Empty, // namespaceURI\r
 433                                 "baz" // value\r
 434                         );\r
 435 \r
 436                         AssertAttribute (\r
 437                                 xmlReader, // xmlReader\r
 438                                 "quux", // name\r
 439                                 String.Empty, // prefix\r
 440                                 "quux", // localName\r
 441                                 String.Empty, // namespaceURI\r
 442                                 "quuux" // value\r
 443                         );\r
 444 \r
 445                         AssertAttribute (\r
 446                                 xmlReader, // xmlReader\r
 447                                 "notexist", // name\r
 448                                 String.Empty, // prefix\r
 449                                 "notexist", // localName\r
 450                                 String.Empty, // namespaceURI\r
 451                                 null // value\r
 452                         );\r
 453 \r
 454                         AssertAttribute (\r
 455                                 xmlReader, // xmlReader\r
 456                                 "x:foo", // name\r
 457                                 "x", // prefix\r
 458                                 "foo", // localName\r
 459                                 "urn:xfoo", // namespaceURI\r
 460                                 "x-foo" // value\r
 461                         );\r
 462 \r
 463                         AssertAttribute (\r
 464                                 xmlReader, // xmlReader\r
 465                                 "x:bar", // name\r
 466                                 "x", // prefix\r
 467                                 "bar", // localName\r
 468                                 "urn:xfoo", // namespaceURI\r
 469                                 null // value\r
 470                         );\r
 471 \r
 472                         AssertEndDocument (xmlReader);\r
 473                 }\r
 474 \r
 475                 [Test]\r
 476                 public void ProcessingInstructionBeforeDocumentElement ()\r
 477                 {\r
 478                         string xml = "<?foo bar?><baz/>";\r
 479                         RunTest (xml, new TestMethod (ProcessingInstructionBeforeDocumentElement));\r
 480                 }\r
 481 \r
 482                 public void ProcessingInstructionBeforeDocumentElement (XmlReader xmlReader)\r
 483                 {\r
 484                         AssertStartDocument (xmlReader);\r
 485 \r
 486                         AssertNode (\r
 487                                 xmlReader, // xmlReader\r
 488                                 XmlNodeType.ProcessingInstruction, // nodeType\r
 489                                 0, //depth\r
 490                                 false, // isEmptyElement\r
 491                                 "foo", // name\r
 492                                 String.Empty, // prefix\r
 493                                 "foo", // localName\r
 494                                 String.Empty, // namespaceURI\r
 495                                 "bar", // value\r
 496                                 0 // attributeCount\r
 497                         );\r
 498 \r
 499                         AssertNode (\r
 500                                 xmlReader, // xmlReader\r
 501                                 XmlNodeType.Element, // nodeType\r
 502                                 0, //depth\r
 503                                 true, // isEmptyElement\r
 504                                 "baz", // name\r
 505                                 String.Empty, // prefix\r
 506                                 "baz", // localName\r
 507                                 String.Empty, // namespaceURI\r
 508                                 String.Empty, // value\r
 509                                 0 // attributeCount\r
 510                         );\r
 511 \r
 512                         AssertEndDocument (xmlReader);\r
 513                 }\r
 514 \r
 515                 [Test]\r
 516                 public void CommentBeforeDocumentElement ()\r
 517                 {\r
 518                         string xml = "<!--foo--><bar/>";\r
 519                         RunTest (xml, new TestMethod (CommentBeforeDocumentElement));\r
 520                 }\r
 521 \r
 522                 public void CommentBeforeDocumentElement (XmlReader xmlReader)\r
 523                 {\r
 524                         AssertStartDocument (xmlReader);\r
 525 \r
 526                         AssertNode (\r
 527                                 xmlReader, // xmlReader\r
 528                                 XmlNodeType.Comment, // nodeType\r
 529                                 0, //depth\r
 530                                 false, // isEmptyElement\r
 531                                 String.Empty, // name\r
 532                                 String.Empty, // prefix\r
 533                                 String.Empty, // localName\r
 534                                 String.Empty, // namespaceURI\r
 535                                 "foo", // value\r
 536                                 0 // attributeCount\r
 537                         );\r
 538 \r
 539                         AssertNode (\r
 540                                 xmlReader, // xmlReader\r
 541                                 XmlNodeType.Element, // nodeType\r
 542                                 0, //depth\r
 543                                 true, // isEmptyElement\r
 544                                 "bar", // name\r
 545                                 String.Empty, // prefix\r
 546                                 "bar", // localName\r
 547                                 String.Empty, // namespaceURI\r
 548                                 String.Empty, // value\r
 549                                 0 // attributeCount\r
 550                         );\r
 551 \r
 552                         AssertEndDocument (xmlReader);\r
 553                 }\r
 554 \r
 555                 [Test]\r
 556                 public void PredefinedEntities ()\r
 557                 {\r
 558                         string xml = "<foo>&lt;&gt;&amp;&apos;&quot;</foo>";\r
 559                         RunTest (xml, new TestMethod (PredefinedEntities));\r
 560                 }\r
 561 \r
 562                 public void PredefinedEntities (XmlReader xmlReader)\r
 563                 {\r
 564                         AssertStartDocument (xmlReader);\r
 565 \r
 566                         AssertNode (\r
 567                                 xmlReader, // xmlReader\r
 568                                 XmlNodeType.Element, // nodeType\r
 569                                 0, //depth\r
 570                                 false, // isEmptyElement\r
 571                                 "foo", // name\r
 572                                 String.Empty, // prefix\r
 573                                 "foo", // localName\r
 574                                 String.Empty, // namespaceURI\r
 575                                 String.Empty, // value\r
 576                                 0 // attributeCount\r
 577                         );\r
 578 \r
 579                         AssertNode (\r
 580                                 xmlReader, // xmlReader\r
 581                                 XmlNodeType.Text, // nodeType\r
 582                                 1, //depth\r
 583                                 false, // isEmptyElement\r
 584                                 String.Empty, // name\r
 585                                 String.Empty, // prefix\r
 586                                 String.Empty, // localName\r
 587                                 String.Empty, // namespaceURI\r
 588                                 "<>&'\"", // value\r
 589                                 0 // attributeCount\r
 590                         );\r
 591 \r
 592                         AssertNode (\r
 593                                 xmlReader, // xmlReader\r
 594                                 XmlNodeType.EndElement, // nodeType\r
 595                                 0, //depth\r
 596                                 false, // isEmptyElement\r
 597                                 "foo", // name\r
 598                                 String.Empty, // prefix\r
 599                                 "foo", // localName\r
 600                                 String.Empty, // namespaceURI\r
 601                                 String.Empty, // value\r
 602                                 0 // attributeCount\r
 603                         );\r
 604 \r
 605                         AssertEndDocument (xmlReader);\r
 606                 }\r
 607 \r
 608                 [Test]\r
 609                 public void CharacterReferences ()\r
 610                 {\r
 611                         string xml = "<foo>&#70;&#x4F;&#x4f;</foo>";\r
 612                         RunTest (xml, new TestMethod (CharacterReferences));\r
 613                 }\r
 614 \r
 615                 public void CharacterReferences (XmlReader xmlReader)\r
 616                 {\r
 617                         AssertStartDocument (xmlReader);\r
 618 \r
 619                         AssertNode (\r
 620                                 xmlReader, // xmlReader\r
 621                                 XmlNodeType.Element, // nodeType\r
 622                                 0, //depth\r
 623                                 false, // isEmptyElement\r
 624                                 "foo", // name\r
 625                                 String.Empty, // prefix\r
 626                                 "foo", // localName\r
 627                                 String.Empty, // namespaceURI\r
 628                                 String.Empty, // value\r
 629                                 0 // attributeCount\r
 630                         );\r
 631 \r
 632                         AssertNode (\r
 633                                 xmlReader, // xmlReader\r
 634                                 XmlNodeType.Text, // nodeType\r
 635                                 1, //depth\r
 636                                 false, // isEmptyElement\r
 637                                 String.Empty, // name\r
 638                                 String.Empty, // prefix\r
 639                                 String.Empty, // localName\r
 640                                 String.Empty, // namespaceURI\r
 641                                 "FOO", // value\r
 642                                 0 // attributeCount\r
 643                         );\r
 644 \r
 645                         AssertNode (\r
 646                                 xmlReader, // xmlReader\r
 647                                 XmlNodeType.EndElement, // nodeType\r
 648                                 0, //depth\r
 649                                 false, // isEmptyElement\r
 650                                 "foo", // name\r
 651                                 String.Empty, // prefix\r
 652                                 "foo", // localName\r
 653                                 String.Empty, // namespaceURI\r
 654                                 String.Empty, // value\r
 655                                 0 // attributeCount\r
 656                         );\r
 657 \r
 658                         AssertEndDocument (xmlReader);\r
 659                 }\r
 660 \r
 661                 [Test]\r
 662                 public void PredefinedEntitiesInAttribute ()\r
 663                 {\r
 664                         string xml = "<foo bar='&lt;&gt;&amp;&apos;&quot;'/>";\r
 665                         RunTest (xml, new TestMethod (PredefinedEntitiesInAttribute ));\r
 666                 }\r
 667 \r
 668                 public void PredefinedEntitiesInAttribute (XmlReader xmlReader)\r
 669                 {\r
 670                         AssertStartDocument (xmlReader);\r
 671 \r
 672                         AssertNode (\r
 673                                 xmlReader, // xmlReader\r
 674                                 XmlNodeType.Element, // nodeType\r
 675                                 0, //depth\r
 676                                 true, // isEmptyElement\r
 677                                 "foo", // name\r
 678                                 String.Empty, // prefix\r
 679                                 "foo", // localName\r
 680                                 String.Empty, // namespaceURI\r
 681                                 String.Empty, // value\r
 682                                 1 // attributeCount\r
 683                         );\r
 684 \r
 685                         AssertAttribute (\r
 686                                 xmlReader, // xmlReader\r
 687                                 "bar", // name\r
 688                                 String.Empty, // prefix\r
 689                                 "bar", // localName\r
 690                                 String.Empty, // namespaceURI\r
 691                                 "<>&'\"" // value\r
 692                         );\r
 693 \r
 694                         AssertEndDocument (xmlReader);\r
 695                 }\r
 696 \r
 697                 [Test]\r
 698                 public void CharacterReferencesInAttribute ()\r
 699                 {\r
 700                         string xml = "<foo bar='&#70;&#x4F;&#x4f;'/>";\r
 701                         RunTest (xml, new TestMethod (CharacterReferencesInAttribute));\r
 702                 }\r
 703 \r
 704                 public void CharacterReferencesInAttribute (XmlReader xmlReader)\r
 705                 {\r
 706                         AssertStartDocument (xmlReader);\r
 707 \r
 708                         AssertNode (\r
 709                                 xmlReader, // xmlReader\r
 710                                 XmlNodeType.Element, // nodeType\r
 711                                 0, //depth\r
 712                                 true, // isEmptyElement\r
 713                                 "foo", // name\r
 714                                 String.Empty, // prefix\r
 715                                 "foo", // localName\r
 716                                 String.Empty, // namespaceURI\r
 717                                 String.Empty, // value\r
 718                                 1 // attributeCount\r
 719                         );\r
 720 \r
 721                         AssertAttribute (\r
 722                                 xmlReader, // xmlReader\r
 723                                 "bar", // name\r
 724                                 String.Empty, // prefix\r
 725                                 "bar", // localName\r
 726                                 String.Empty, // namespaceURI\r
 727                                 "FOO" // value\r
 728                         );\r
 729 \r
 730                         AssertEndDocument (xmlReader);\r
 731                 }\r
 732 \r
 733                 [Test]\r
 734                 public void CDATA ()\r
 735                 {\r
 736                         string xml = "<foo><![CDATA[<>&]]></foo>";\r
 737                         RunTest (xml, new TestMethod (CDATA));\r
 738                 }\r
 739 \r
 740                 public void CDATA (XmlReader xmlReader)\r
 741                 {\r
 742                         AssertStartDocument (xmlReader);\r
 743 \r
 744                         AssertNode (\r
 745                                 xmlReader, // xmlReader\r
 746                                 XmlNodeType.Element, // nodeType\r
 747                                 0, //depth\r
 748                                 false, // isEmptyElement\r
 749                                 "foo", // name\r
 750                                 String.Empty, // prefix\r
 751                                 "foo", // localName\r
 752                                 String.Empty, // namespaceURI\r
 753                                 String.Empty, // value\r
 754                                 0 // attributeCount\r
 755                         );\r
 756 \r
 757                         AssertNode (\r
 758                                 xmlReader, // xmlReader\r
 759                                 XmlNodeType.CDATA, // nodeType\r
 760                                 1, //depth\r
 761                                 false, // isEmptyElement\r
 762                                 String.Empty, // name\r
 763                                 String.Empty, // prefix\r
 764                                 String.Empty, // localName\r
 765                                 String.Empty, // namespaceURI\r
 766                                 "<>&", // value\r
 767                                 0 // attributeCount\r
 768                         );\r
 769 \r
 770                         AssertNode (\r
 771                                 xmlReader, // xmlReader\r
 772                                 XmlNodeType.EndElement, // nodeType\r
 773                                 0, //depth\r
 774                                 false, // isEmptyElement\r
 775                                 "foo", // name\r
 776                                 String.Empty, // prefix\r
 777                                 "foo", // localName\r
 778                                 String.Empty, // namespaceURI\r
 779                                 String.Empty, // value\r
 780                                 0 // attributeCount\r
 781                         );\r
 782 \r
 783                         AssertEndDocument (xmlReader);\r
 784                 }\r
 785 \r
 786                 [Test]\r
 787                 public void EmptyElementInDefaultNamespace ()\r
 788                 {\r
 789                         string xml = @"<foo xmlns='http://foo/' />";\r
 790                         RunTest (xml, new TestMethod (EmptyElementInDefaultNamespace));\r
 791                 }\r
 792 \r
 793                 public void EmptyElementInDefaultNamespace (XmlReader xmlReader)\r
 794                 {\r
 795                         AssertStartDocument (xmlReader);\r
 796 \r
 797                         AssertNode (\r
 798                                 xmlReader, // xmlReader\r
 799                                 XmlNodeType.Element, // nodeType\r
 800                                 0, // depth\r
 801                                 true, // isEmptyElement\r
 802                                 "foo", // name\r
 803                                 String.Empty, // prefix\r
 804                                 "foo", // localName\r
 805                                 "http://foo/", // namespaceURI\r
 806                                 String.Empty, // value\r
 807                                 1 // attributeCount\r
 808                         );\r
 809 \r
 810                         AssertAttribute (\r
 811                                 xmlReader, // xmlReader\r
 812                                 "xmlns", // name\r
 813                                 String.Empty, // prefix\r
 814                                 "xmlns", // localName\r
 815                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 816                                 "http://foo/" // value\r
 817                         );\r
 818 \r
 819                         AssertEquals ("http://foo/", xmlReader.LookupNamespace (String.Empty));\r
 820 \r
 821                         AssertEndDocument (xmlReader);\r
 822                 }\r
 823 \r
 824                 [Test]\r
 825                 public void ChildElementInNamespace ()\r
 826                 {\r
 827                         string xml = @"<foo:bar xmlns:foo='http://foo/'><baz:quux xmlns:baz='http://baz/' /></foo:bar>";\r
 828                         RunTest (xml, new TestMethod (ChildElementInNamespace));\r
 829                 }\r
 830 \r
 831                 public void ChildElementInNamespace (XmlReader xmlReader)\r
 832                 {\r
 833                         AssertStartDocument (xmlReader);\r
 834 \r
 835                         AssertNode (\r
 836                                 xmlReader, // xmlReader\r
 837                                 XmlNodeType.Element, // nodeType\r
 838                                 0, // depth\r
 839                                 false, // isEmptyElement\r
 840                                 "foo:bar", // name\r
 841                                 "foo", // prefix\r
 842                                 "bar", // localName\r
 843                                 "http://foo/", // namespaceURI\r
 844                                 String.Empty, // value\r
 845                                 1 // attributeCount\r
 846                         );\r
 847 \r
 848                         AssertAttribute (\r
 849                                 xmlReader, // xmlReader\r
 850                                 "xmlns:foo", // name\r
 851                                 "xmlns", // prefix\r
 852                                 "foo", // localName\r
 853                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 854                                 "http://foo/" // value\r
 855                         );\r
 856 \r
 857                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 858 \r
 859                         AssertNode (\r
 860                                 xmlReader, // xmlReader\r
 861                                 XmlNodeType.Element, // nodeType\r
 862                                 1, // depth\r
 863                                 true, // isEmptyElement\r
 864                                 "baz:quux", // name\r
 865                                 "baz", // prefix\r
 866                                 "quux", // localName\r
 867                                 "http://baz/", // namespaceURI\r
 868                                 String.Empty, // value\r
 869                                 1 // attributeCount\r
 870                         );\r
 871 \r
 872                         AssertAttribute (\r
 873                                 xmlReader, // xmlReader\r
 874                                 "xmlns:baz", // name\r
 875                                 "xmlns", // prefix\r
 876                                 "baz", // localName\r
 877                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 878                                 "http://baz/" // value\r
 879                         );\r
 880 \r
 881                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 882                         AssertEquals ("http://baz/", xmlReader.LookupNamespace ("baz"));\r
 883 \r
 884                         AssertNode (\r
 885                                 xmlReader, // xmlReader\r
 886                                 XmlNodeType.EndElement, // nodeType\r
 887                                 0, // depth\r
 888                                 false, // isEmptyElement\r
 889                                 "foo:bar", // name\r
 890                                 "foo", // prefix\r
 891                                 "bar", // localName\r
 892                                 "http://foo/", // namespaceURI\r
 893                                 String.Empty, // value\r
 894                                 0 // attributeCount\r
 895                         );\r
 896 \r
 897                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 898                         AssertNull (xmlReader.LookupNamespace ("baz"));\r
 899 \r
 900                         AssertEndDocument (xmlReader);\r
 901                 }\r
 902 \r
 903                 [Test]\r
 904                 public void ChildElementInDefaultNamespace ()\r
 905                 {\r
 906                         string xml = @"<foo:bar xmlns:foo='http://foo/'><baz xmlns='http://baz/' /></foo:bar>";\r
 907                         RunTest (xml, new TestMethod (ChildElementInDefaultNamespace));\r
 908                 }\r
 909 \r
 910                 public void ChildElementInDefaultNamespace (XmlReader xmlReader)\r
 911                 {\r
 912                         AssertStartDocument (xmlReader);\r
 913 \r
 914                         AssertNode (\r
 915                                 xmlReader, // xmlReader\r
 916                                 XmlNodeType.Element, // nodeType\r
 917                                 0, // depth\r
 918                                 false, // isEmptyElement\r
 919                                 "foo:bar", // name\r
 920                                 "foo", // prefix\r
 921                                 "bar", // localName\r
 922                                 "http://foo/", // namespaceURI\r
 923                                 String.Empty, // value\r
 924                                 1 // attributeCount\r
 925                         );\r
 926 \r
 927                         AssertAttribute (\r
 928                                 xmlReader, // xmlReader\r
 929                                 "xmlns:foo", // name\r
 930                                 "xmlns", // prefix\r
 931                                 "foo", // localName\r
 932                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 933                                 "http://foo/" // value\r
 934                         );\r
 935 \r
 936                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 937 \r
 938                         AssertNode (\r
 939                                 xmlReader, // xmlReader\r
 940                                 XmlNodeType.Element, // nodeType\r
 941                                 1, // depth\r
 942                                 true, // isEmptyElement\r
 943                                 "baz", // name\r
 944                                 String.Empty, // prefix\r
 945                                 "baz", // localName\r
 946                                 "http://baz/", // namespaceURI\r
 947                                 String.Empty, // value\r
 948                                 1 // attributeCount\r
 949                         );\r
 950 \r
 951                         AssertAttribute (\r
 952                                 xmlReader, // xmlReader\r
 953                                 "xmlns", // name\r
 954                                 String.Empty, // prefix\r
 955                                 "xmlns", // localName\r
 956                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 957                                 "http://baz/" // value\r
 958                         );\r
 959 \r
 960                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 961                         AssertEquals ("http://baz/", xmlReader.LookupNamespace (String.Empty));\r
 962 \r
 963                         AssertNode (\r
 964                                 xmlReader, // xmlReader\r
 965                                 XmlNodeType.EndElement, // nodeType\r
 966                                 0, // depth\r
 967                                 false, // isEmptyElement\r
 968                                 "foo:bar", // name\r
 969                                 "foo", // prefix\r
 970                                 "bar", // localName\r
 971                                 "http://foo/", // namespaceURI\r
 972                                 String.Empty, // value\r
 973                                 0 // attributeCount\r
 974                         );\r
 975 \r
 976                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 977 \r
 978                         AssertEndDocument (xmlReader);\r
 979                 }\r
 980 \r
 981                 [Test]\r
 982                 public void AttributeInNamespace ()\r
 983                 {\r
 984                         string xml = @"<foo bar:baz='quux' xmlns:bar='http://bar/' />";\r
 985                         RunTest (xml, new TestMethod (AttributeInNamespace));\r
 986                 }\r
 987 \r
 988                 public void AttributeInNamespace (XmlReader xmlReader)\r
 989                 {\r
 990                         AssertStartDocument (xmlReader);\r
 991 \r
 992                         AssertNode (\r
 993                                 xmlReader, // xmlReader\r
 994                                 XmlNodeType.Element, // nodeType\r
 995                                 0, // depth\r
 996                                 true, // isEmptyElement\r
 997                                 "foo", // name\r
 998                                 String.Empty, // prefix\r
 999                                 "foo", // localName\r
1000                                 String.Empty, // namespaceURI\r
1001                                 String.Empty, // value\r
1002                                 2 // attributeCount\r
1003                         );\r
1004 \r
1005                         AssertAttribute (\r
1006                                 xmlReader, // xmlReader\r
1007                                 "bar:baz", // name\r
1008                                 "bar", // prefix\r
1009                                 "baz", // localName\r
1010                                 "http://bar/", // namespaceURI\r
1011                                 "quux" // value\r
1012                         );\r
1013 \r
1014                         AssertAttribute (\r
1015                                 xmlReader, // xmlReader\r
1016                                 "xmlns:bar", // name\r
1017                                 "xmlns", // prefix\r
1018                                 "bar", // localName\r
1019                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
1020                                 "http://bar/" // value\r
1021                         );\r
1022 \r
1023                         AssertEquals ("http://bar/", xmlReader.LookupNamespace ("bar"));\r
1024 \r
1025                         AssertEndDocument (xmlReader);\r
1026                 }\r
1027 \r
1028                 [Test]\r
1029                 public void MoveToElementFromAttribute ()\r
1030                 {\r
1031                         string xml = @"<foo bar=""baz"" />";\r
1032                         RunTest (xml, new TestMethod (MoveToElementFromAttribute));\r
1033                 }\r
1034 \r
1035                 public void MoveToElementFromAttribute (XmlReader xmlReader)\r
1036                 {\r
1037                         Assert (xmlReader.Read ());\r
1038                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1039                         Assert (xmlReader.MoveToFirstAttribute ());\r
1040                         AssertEquals (XmlNodeType.Attribute, xmlReader.NodeType);\r
1041                         Assert (xmlReader.MoveToElement ());\r
1042                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1043                 }\r
1044 \r
1045                 [Test]\r
1046                 public void MoveToElementFromElement ()\r
1047                 {\r
1048                         string xml = @"<foo bar=""baz"" />";\r
1049                         RunTest (xml, new TestMethod (MoveToElementFromElement));\r
1050                 }\r
1051 \r
1052                 public void MoveToElementFromElement (XmlReader xmlReader)\r
1053                 {\r
1054                         Assert (xmlReader.Read ());\r
1055                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1056                         Assert (!xmlReader.MoveToElement ());\r
1057                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1058                 }\r
1059 \r
1060                 [Test]\r
1061                 public void MoveToFirstAttributeWithNoAttributes ()\r
1062                 {\r
1063                         string xml = @"<foo />";\r
1064                         RunTest (xml, new TestMethod (MoveToFirstAttributeWithNoAttributes));\r
1065                 }\r
1066 \r
1067                 public void MoveToFirstAttributeWithNoAttributes (XmlReader xmlReader)\r
1068                 {\r
1069                         Assert (xmlReader.Read ());\r
1070                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1071                         Assert (!xmlReader.MoveToFirstAttribute ());\r
1072                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1073                 }\r
1074 \r
1075                 [Test]\r
1076                 public void MoveToNextAttributeWithNoAttributes ()\r
1077                 {\r
1078                         string xml = @"<foo />";\r
1079                         RunTest (xml, new TestMethod (MoveToNextAttributeWithNoAttributes));\r
1080                 }\r
1081 \r
1082                 public void MoveToNextAttributeWithNoAttributes (XmlReader xmlReader)\r
1083                 {\r
1084                         Assert (xmlReader.Read ());\r
1085                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1086                         Assert (!xmlReader.MoveToNextAttribute ());\r
1087                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1088                 }\r
1089 \r
1090                 [Test]\r
1091                 public void MoveToNextAttribute()\r
1092                 {\r
1093                         string xml = @"<foo bar=""baz"" quux='quuux'/>";\r
1094                         RunTest (xml, new TestMethod (MoveToNextAttribute));\r
1095                 }\r
1096 \r
1097                 public void MoveToNextAttribute (XmlReader xmlReader)\r
1098                 {\r
1099                         AssertStartDocument (xmlReader);\r
1100 \r
1101                         AssertNode (\r
1102                                 xmlReader, // xmlReader\r
1103                                 XmlNodeType.Element, // nodeType\r
1104                                 0, //depth\r
1105                                 true, // isEmptyElement\r
1106                                 "foo", // name\r
1107                                 String.Empty, // prefix\r
1108                                 "foo", // localName\r
1109                                 String.Empty, // namespaceURI\r
1110                                 String.Empty, // value\r
1111                                 2 // attributeCount\r
1112                         );\r
1113 \r
1114                         AssertAttribute (\r
1115                                 xmlReader, // xmlReader\r
1116                                 "bar", // name\r
1117                                 String.Empty, // prefix\r
1118                                 "bar", // localName\r
1119                                 String.Empty, // namespaceURI\r
1120                                 "baz" // value\r
1121                         );\r
1122 \r
1123                         AssertAttribute (\r
1124                                 xmlReader, // xmlReader\r
1125                                 "quux", // name\r
1126                                 String.Empty, // prefix\r
1127                                 "quux", // localName\r
1128                                 String.Empty, // namespaceURI\r
1129                                 "quuux" // value\r
1130                         );\r
1131 \r
1132                         Assert (xmlReader.MoveToNextAttribute ());\r
1133                         AssertEquals ("bar", xmlReader.Name);\r
1134                         AssertEquals ("baz", xmlReader.Value);\r
1135 \r
1136                         Assert (xmlReader.MoveToNextAttribute ());\r
1137                         AssertEquals ("quux", xmlReader.Name);\r
1138                         AssertEquals ("quuux", xmlReader.Value);\r
1139 \r
1140                         Assert (!xmlReader.MoveToNextAttribute ());\r
1141 \r
1142                         Assert (xmlReader.MoveToElement ());\r
1143 \r
1144                         AssertNodeValues (\r
1145                                 xmlReader, // xmlReader\r
1146                                 XmlNodeType.Element, // nodeType\r
1147                                 0, //depth\r
1148                                 true, // isEmptyElement\r
1149                                 "foo", // name\r
1150                                 String.Empty, // prefix\r
1151                                 "foo", // localName\r
1152                                 String.Empty, // namespaceURI\r
1153                                 String.Empty, // value\r
1154                                 2 // attributeCount\r
1155                         );\r
1156 \r
1157                         AssertEndDocument (xmlReader);\r
1158                 }\r
1159 \r
1160                 [Test]\r
1161                 public void AttributeOrder ()\r
1162                 {\r
1163                         string xml = @"<foo _1='1' _2='2' _3='3' />";\r
1164                         RunTest (xml, new TestMethod (AttributeOrder));\r
1165                 }\r
1166 \r
1167                 public void AttributeOrder (XmlReader xmlReader)\r
1168                 {\r
1169                         Assert (xmlReader.Read ());\r
1170                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1171 \r
1172                         Assert (xmlReader.MoveToFirstAttribute ());\r
1173                         AssertEquals ("_1", xmlReader.Name);\r
1174                         Assert (xmlReader.MoveToNextAttribute ());\r
1175                         AssertEquals ("_2", xmlReader.Name);\r
1176                         Assert (xmlReader.MoveToNextAttribute ());\r
1177                         AssertEquals ("_3", xmlReader.Name);\r
1178 \r
1179                         Assert (!xmlReader.MoveToNextAttribute ());\r
1180                 }\r
1181 \r
1182                 [Test]\r
1183                 public void IndexerAndAttributes ()\r
1184                 {\r
1185                         string xml = @"<?xml version='1.0' standalone='no'?><foo _1='1' _2='2' _3='3' />";\r
1186                         RunTest (xml, new TestMethod (IndexerAndAttributes));\r
1187                 }\r
1188 \r
1189                 public void IndexerAndAttributes (XmlReader xmlReader)\r
1190                 {\r
1191                         Assert (xmlReader.Read ());\r
1192                         AssertEquals ("1.0", xmlReader ["version"]);\r
1193                         AssertEquals ("1.0", xmlReader.GetAttribute ("version"));\r
1194                         // XmlTextReader returns null, while XmlNodeReader returns "".\r
1195                         AssertEquals (null, xmlReader ["encoding"]);\r
1196                         AssertEquals (null, xmlReader.GetAttribute ("encoding"));\r
1197                         AssertEquals ("no", xmlReader ["standalone"]);\r
1198                         AssertEquals ("no", xmlReader.GetAttribute ("standalone"));\r
1199                         AssertEquals ("1.0", xmlReader [0]);\r
1200                         AssertEquals ("1.0", xmlReader.GetAttribute (0));\r
1201                         AssertEquals ("no", xmlReader [1]);\r
1202                         AssertEquals ("no", xmlReader.GetAttribute (1));\r
1203 \r
1204                         Assert (xmlReader.Read ());\r
1205                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1206                         AssertEquals ("1", xmlReader ["_1"]);\r
1207 \r
1208                         Assert (xmlReader.MoveToFirstAttribute ());\r
1209                         AssertEquals ("_1", xmlReader.Name);\r
1210                         AssertEquals ("1", xmlReader ["_1"]);\r
1211                         Assert (xmlReader.MoveToNextAttribute ());\r
1212                         AssertEquals ("_2", xmlReader.Name);\r
1213                         AssertEquals ("1", xmlReader ["_1"]);\r
1214                         Assert (xmlReader.MoveToNextAttribute ());\r
1215                         AssertEquals ("_3", xmlReader.Name);\r
1216                         AssertEquals ("1", xmlReader ["_1"]);\r
1217 \r
1218                         Assert (!xmlReader.MoveToNextAttribute ());\r
1219                 }\r
1220 \r
1221         }\r
1222 }\r