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