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

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