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