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

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