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

   1 //
   2 // XmlTextReaderTests.cs
   3 //
   4 // Authors:
   5 //   Jason Diamond (jason@injektilo.org)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //
   8 // (C) 2001, 2002 Jason Diamond  http://injektilo.org/
   9 //
  10
  11 using System;
  12 using System.IO;
  13 using System.Xml;
  14 using System.Text;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.System.Xml
  19 {
  20         [TestFixture]
  21         public class XmlTextReaderTests
  22         {
  23                 private void AssertStartDocument (XmlReader xmlReader)
  24                 {
  25                         Assert.IsTrue (xmlReader.ReadState == ReadState.Initial);
  26                         Assert.IsTrue (xmlReader.NodeType == XmlNodeType.None);
  27                         Assert.IsTrue (xmlReader.Depth == 0);
  28                         Assert.IsTrue (!xmlReader.EOF);
  29                 }
  30
  31                 private void AssertNode (
  32                         XmlReader xmlReader,
  33                         XmlNodeType nodeType,
  34                         int depth,
  35                         bool isEmptyElement,
  36                         string name,
  37                         string prefix,
  38                         string localName,
  39                         string namespaceURI,
  40                         string value,
  41                         int attributeCount)
  42                 {
  43                         Assert.IsTrue (xmlReader.Read (), "#Read");
  44                         Assert.IsTrue (xmlReader.ReadState == ReadState.Interactive, "#ReadState");
  45                         Assert.IsTrue (!xmlReader.EOF);
  46                         AssertNodeValues (xmlReader, nodeType, depth, isEmptyElement, name, prefix, localName, namespaceURI, value, attributeCount);
  47                 }
  48
  49                 private void AssertNodeValues (
  50                         XmlReader xmlReader,
  51                         XmlNodeType nodeType,
  52                         int depth,
  53                         bool isEmptyElement,
  54                         string name,
  55                         string prefix,
  56                         string localName,
  57                         string namespaceURI,
  58                         string value,
  59                         int attributeCount)
  60                 {
  61                         Assert.AreEqual (nodeType, xmlReader.NodeType, "NodeType");
  62                         Assert.AreEqual (depth, xmlReader.Depth, "Depth");
  63                         Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, "IsEmptyElement");
  64
  65                         Assert.AreEqual (name, xmlReader.Name, "name");
  66
  67                         Assert.AreEqual (prefix, xmlReader.Prefix, "prefix");
  68
  69                         Assert.AreEqual (localName, xmlReader.LocalName, "localName");
  70
  71                         Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, "namespaceURI");
  72
  73                         Assert.AreEqual ((value != String.Empty), xmlReader.HasValue, "hasValue");
  74
  75                         Assert.AreEqual (value, xmlReader.Value, "Value");
  76
  77                         Assert.AreEqual (attributeCount > 0, xmlReader.HasAttributes, "hasAttributes");
  78
  79                         Assert.AreEqual (attributeCount, xmlReader.AttributeCount, "attributeCount");
  80                 }
  81
  82                 private void AssertAttribute (
  83                         XmlReader xmlReader,
  84                         string name,
  85                         string prefix,
  86                         string localName,
  87                         string namespaceURI,
  88                         string value)
  89                 {
  90                         Assert.AreEqual (value, xmlReader [name], "value.Indexer");
  91
  92                         Assert.AreEqual (value, xmlReader.GetAttribute (name), "value.GetAttribute");
  93
  94                         if (namespaceURI != String.Empty) {
  95                                 Assert.IsTrue (xmlReader[localName, namespaceURI] == value);
  96                                 Assert.IsTrue (xmlReader.GetAttribute (localName, namespaceURI) == value);
  97                         }
  98                 }
  99
 100                 private void AssertEndDocument (XmlReader xmlReader)
 101                 {
 102                         Assert.IsTrue (!xmlReader.Read (), "could read");
 103                         Assert.AreEqual (XmlNodeType.None, xmlReader.NodeType, "NodeType is not XmlNodeType.None");
 104                         Assert.AreEqual (0, xmlReader.Depth, "Depth is not 0");
 105                         Assert.AreEqual (ReadState.EndOfFile, xmlReader.ReadState, "ReadState is not ReadState.EndOfFile");
 106                         Assert.IsTrue (xmlReader.EOF, "not EOF");
 107
 108                         xmlReader.Close ();
 109                         Assert.AreEqual (ReadState.Closed, xmlReader.ReadState, "ReadState is not ReadState.Cosed");
 110                 }
 111
 112                 [Test]
 113                 public void StartAndEndTagWithAttribute ()
 114                 {
 115                         string xml = @"<foo bar='baz'></foo>";
 116                         XmlReader xmlReader =
 117                                 new XmlTextReader (new StringReader (xml));
 118
 119                         AssertStartDocument (xmlReader);
 120
 121                         AssertNode (
 122                                 xmlReader, // xmlReader
 123                                 XmlNodeType.Element, // nodeType
 124                                 0, //depth
 125                                 false, // isEmptyElement
 126                                 "foo", // name
 127                                 String.Empty, // prefix
 128                                 "foo", // localName
 129                                 String.Empty, // namespaceURI
 130                                 String.Empty, // value
 131                                 1 // attributeCount
 132                         );
 133
 134                         AssertAttribute (
 135                                 xmlReader, // xmlReader
 136                                 "bar", // name
 137                                 String.Empty, // prefix
 138                                 "bar", // localName
 139                                 String.Empty, // namespaceURI
 140                                 "baz" // value
 141                         );
 142
 143                         AssertNode (
 144                                 xmlReader, // xmlReader
 145                                 XmlNodeType.EndElement, // nodeType
 146                                 0, //depth
 147                                 false, // isEmptyElement
 148                                 "foo", // name
 149                                 String.Empty, // prefix
 150                                 "foo", // localName
 151                                 String.Empty, // namespaceURI
 152                                 String.Empty, // value
 153                                 0 // attributeCount
 154                         );
 155
 156                         AssertEndDocument (xmlReader);
 157                 }
 158
 159                 // expecting parser error
 160                 [Test]
 161                 public void EmptyElementWithBadName ()
 162                 {
 163                         string xml = "<1foo/>";
 164                         XmlReader xmlReader =
 165                                 new XmlTextReader (new StringReader (xml));
 166
 167                         bool caughtXmlException = false;
 168
 169                         try {
 170                                 xmlReader.Read();
 171                         } catch (XmlException) {
 172                                 caughtXmlException = true;
 173                         }
 174
 175                         Assert.IsTrue (caughtXmlException);
 176                 }
 177
 178                 [Test]
 179                 public void EmptyElementWithStartAndEndTag ()
 180                 {
 181                         string xml = "<foo></foo>";
 182                         XmlReader xmlReader =
 183                                 new XmlTextReader (new StringReader (xml));
 184
 185                         AssertStartDocument (xmlReader);
 186
 187                         AssertNode (
 188                                 xmlReader, // xmlReader
 189                                 XmlNodeType.Element, // nodeType
 190                                 0, //depth
 191                                 false, // isEmptyElement
 192                                 "foo", // name
 193                                 String.Empty, // prefix
 194                                 "foo", // localName
 195                                 String.Empty, // namespaceURI
 196                                 String.Empty, // value
 197                                 0 // attributeCount
 198                         );
 199
 200                         AssertNode (
 201                                 xmlReader, // xmlReader
 202                                 XmlNodeType.EndElement, // nodeType
 203                                 0, //depth
 204                                 false, // isEmptyElement
 205                                 "foo", // name
 206                                 String.Empty, // prefix
 207                                 "foo", // localName
 208                                 String.Empty, // namespaceURI
 209                                 String.Empty, // value
 210                                 0 // attributeCount
 211                         );
 212
 213                         AssertEndDocument (xmlReader);
 214                 }
 215
 216                 // checking parser
 217                 [Test]
 218                 public void EmptyElementWithStartAndEndTagWithWhitespace ()
 219                 {
 220                         string xml = "<foo ></foo >";
 221                         XmlReader xmlReader =
 222                                 new XmlTextReader (new StringReader (xml));
 223
 224                         AssertStartDocument (xmlReader);
 225
 226                         AssertNode (
 227                                 xmlReader, // xmlReader
 228                                 XmlNodeType.Element, // nodeType
 229                                 0, //depth
 230                                 false, // isEmptyElement
 231                                 "foo", // name
 232                                 String.Empty, // prefix
 233                                 "foo", // localName
 234                                 String.Empty, // namespaceURI
 235                                 String.Empty, // value
 236                                 0 // attributeCount
 237                         );
 238
 239                         AssertNode (
 240                                 xmlReader, // xmlReader
 241                                 XmlNodeType.EndElement, // nodeType
 242                                 0, //depth
 243                                 false, // isEmptyElement
 244                                 "foo", // name
 245                                 String.Empty, // prefix
 246                                 "foo", // localName
 247                                 String.Empty, // namespaceURI
 248                                 String.Empty, // value
 249                                 0 // attributeCount
 250                         );
 251
 252                         AssertEndDocument (xmlReader);
 253                 }
 254
 255                 [Test]
 256                 public void EmptyElementWithAttribute ()
 257                 {
 258                         string xml = @"<foo bar=""baz""/>";
 259                         XmlReader xmlReader =
 260                                 new XmlTextReader (new StringReader (xml));
 261
 262                         AssertStartDocument (xmlReader);
 263
 264                         AssertNode (
 265                                 xmlReader, // xmlReader
 266                                 XmlNodeType.Element, // nodeType
 267                                 0, //depth
 268                                 true, // isEmptyElement
 269                                 "foo", // name
 270                                 String.Empty, // prefix
 271                                 "foo", // localName
 272                                 String.Empty, // namespaceURI
 273                                 String.Empty, // value
 274                                 1 // attributeCount
 275                         );
 276
 277                         AssertAttribute (
 278                                 xmlReader, // xmlReader
 279                                 "bar", // name
 280                                 String.Empty, // prefix
 281                                 "bar", // localName
 282                                 String.Empty, // namespaceURI
 283                                 "baz" // value
 284                         );
 285
 286                         AssertEndDocument (xmlReader);
 287                 }
 288
 289                 [Test]
 290                 public void EmptyElementInNamespace ()
 291                 {
 292                         string xml = @"<foo:bar xmlns:foo='http://foo/' />";
 293                         XmlReader xmlReader =
 294                                 new XmlTextReader (new StringReader (xml));
 295
 296                         AssertStartDocument (xmlReader);
 297
 298                         AssertNode (
 299                                 xmlReader, // xmlReader
 300                                 XmlNodeType.Element, // nodeType
 301                                 0, // depth
 302                                 true, // isEmptyElement
 303                                 "foo:bar", // name
 304                                 "foo", // prefix
 305                                 "bar", // localName
 306                                 "http://foo/", // namespaceURI
 307                                 String.Empty, // value
 308                                 1 // attributeCount
 309                         );
 310
 311                         AssertAttribute (
 312                                 xmlReader, // xmlReader
 313                                 "xmlns:foo", // name
 314                                 "xmlns", // prefix
 315                                 "foo", // localName
 316                                 "http://www.w3.org/2000/xmlns/", // namespaceURI
 317                                 "http://foo/" // value
 318                         );
 319
 320                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));
 321
 322                         AssertEndDocument (xmlReader);
 323                 }
 324
 325                 [Test]
 326                 public void EntityReferenceInAttribute ()
 327                 {
 328                         string xml = "<foo bar='&baz;'/>";
 329                         XmlReader xmlReader =
 330                                 new XmlTextReader (new StringReader (xml));
 331
 332                         AssertStartDocument (xmlReader);
 333
 334                         AssertNode (
 335                                 xmlReader, // xmlReader
 336                                 XmlNodeType.Element, // nodeType
 337                                 0, //depth
 338                                 true, // isEmptyElement
 339                                 "foo", // name
 340                                 String.Empty, // prefix
 341                                 "foo", // localName
 342                                 String.Empty, // namespaceURI
 343                                 String.Empty, // value
 344                                 1 // attributeCount
 345                         );
 346
 347                         AssertAttribute (
 348                                 xmlReader, // xmlReader
 349                                 "bar", // name
 350                                 String.Empty, // prefix
 351                                 "bar", // localName
 352                                 String.Empty, // namespaceURI
 353                                 "&baz;" // value
 354                         );
 355
 356                         AssertEndDocument (xmlReader);
 357                 }
 358
 359                 [Test]
 360                 public void IsName ()
 361                 {
 362                         Assert.IsTrue (XmlReader.IsName ("foo"));
 363                         Assert.IsTrue (!XmlReader.IsName ("1foo"));
 364                         Assert.IsTrue (!XmlReader.IsName (" foo"));
 365                 }
 366
 367                 [Test]
 368                 public void IsNameToken ()
 369                 {
 370                         Assert.IsTrue (XmlReader.IsNameToken ("foo"));
 371                         Assert.IsTrue (XmlReader.IsNameToken ("1foo"));
 372                         Assert.IsTrue (!XmlReader.IsNameToken (" foo"));
 373                 }
 374
 375                 [Test]
 376                 public void FragmentConstructor()
 377                 {
 378                         XmlDocument doc = new XmlDocument();
 379 //                      doc.LoadXml("<root/>");
 380
 381                         string xml = @"<foo><bar xmlns=""NSURI"">TEXT NODE</bar></foo>";
 382                         MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(xml));
 383
 384                         XmlParserContext ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", "", "", "",
 385                                 doc.BaseURI, "", XmlSpace.Default, Encoding.Default);
 386
 387                         XmlTextReader xmlReader = new XmlTextReader(ms, XmlNodeType.Element, ctx);
 388                         AssertNode(xmlReader, XmlNodeType.Element, 0, false, "foo", "", "foo", "", "", 0);
 389
 390                         AssertNode(xmlReader, XmlNodeType.Element, 1, false, "bar", "", "bar", "NSURI", "", 1);
 391
 392                         AssertNode(xmlReader, XmlNodeType.Text, 2, false, "", "", "", "", "TEXT NODE", 0);
 393
 394                         AssertNode(xmlReader, XmlNodeType.EndElement, 1, false, "bar", "", "bar", "NSURI", "", 0);
 395
 396                         AssertNode(xmlReader, XmlNodeType.EndElement, 0, false, "foo", "", "foo", "", "", 0);
 397
 398                         AssertEndDocument (xmlReader);
 399                 }
 400
 401                 [Test]
 402                 public void AttributeWithCharacterReference ()
 403                 {
 404                         string xml = @"<a value='hello &amp; world' />";
 405                         XmlReader xmlReader =
 406                                 new XmlTextReader (new StringReader (xml));
 407                         xmlReader.Read ();
 408                         Assert.AreEqual ("hello & world", xmlReader ["value"]);
 409                 }
 410
 411                 [Test]
 412                 public void AttributeWithEntityReference ()
 413                 {
 414                         string xml = @"<a value='hello &ent; world' />";
 415                         XmlReader xmlReader =
 416                                 new XmlTextReader (new StringReader (xml));
 417                         xmlReader.Read ();
 418                         xmlReader.MoveToFirstAttribute ();
 419                         xmlReader.ReadAttributeValue ();
 420                         Assert.AreEqual ("hello ", xmlReader.Value);
 421                         Assert.IsTrue (xmlReader.ReadAttributeValue ());
 422                         Assert.AreEqual (XmlNodeType.EntityReference, xmlReader.NodeType);
 423                         Assert.AreEqual ("ent", xmlReader.Name);
 424                         Assert.AreEqual (XmlNodeType.EntityReference, xmlReader.NodeType);
 425                         Assert.IsTrue (xmlReader.ReadAttributeValue ());
 426                         Assert.AreEqual (" world", xmlReader.Value);
 427                         Assert.AreEqual (XmlNodeType.Text, xmlReader.NodeType);
 428                         Assert.IsTrue (!xmlReader.ReadAttributeValue ());
 429                         Assert.AreEqual (" world", xmlReader.Value); // remains
 430                         Assert.AreEqual (XmlNodeType.Text, xmlReader.NodeType);
 431                         xmlReader.ReadAttributeValue ();
 432                         Assert.AreEqual (XmlNodeType.Text, xmlReader.NodeType);
 433                 }
 434
 435                 [Test]
 436                 public void QuoteChar ()
 437                 {
 438                         string xml = @"<a value='hello &amp; world' value2="""" />";
 439                         XmlReader xmlReader =
 440                                 new XmlTextReader (new StringReader (xml));
 441                         xmlReader.Read ();
 442                         xmlReader.MoveToFirstAttribute ();
 443                         Assert.AreEqual ('\'', xmlReader.QuoteChar, "First");
 444                         xmlReader.MoveToNextAttribute ();
 445                         Assert.AreEqual ('"', xmlReader.QuoteChar, "Next");
 446                         xmlReader.MoveToFirstAttribute ();
 447                         Assert.AreEqual ('\'', xmlReader.QuoteChar, "First.Again");
 448                 }
 449
 450                 [Test]
 451                 public void ReadInnerXmlWrongInit ()
 452                 {
 453                         // This behavior is different from XmlNodeReader.
 454                         XmlReader reader = new XmlTextReader (new StringReader ("<root>test of <b>mixed</b> string.</root>"));
 455                         reader.ReadInnerXml ();
 456                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "initial.ReadState");
 457                         Assert.AreEqual (false, reader.EOF, "initial.EOF");
 458                         Assert.AreEqual (XmlNodeType.None, reader.NodeType, "initial.NodeType");
 459                 }
 460
 461                 [Test]
 462                 public void EntityReference ()
 463                 {
 464                         string xml = "<foo>&bar;</foo>";
 465                         XmlReader xmlReader = new XmlTextReader (new StringReader (xml));
 466                         AssertNode (
 467                                 xmlReader, // xmlReader
 468                                 XmlNodeType.Element, // nodeType
 469                                 0, //depth
 470                                 false, // isEmptyElement
 471                                 "foo", // name
 472                                 String.Empty, // prefix
 473                                 "foo", // localName
 474                                 String.Empty, // namespaceURI
 475                                 String.Empty, // value
 476                                 0 // attributeCount
 477                         );
 478
 479                         AssertNode (
 480                                 xmlReader, // xmlReader
 481                                 XmlNodeType.EntityReference, // nodeType
 482                                 1, //depth
 483                                 false, // isEmptyElement
 484                                 "bar", // name
 485                                 String.Empty, // prefix
 486                                 "bar", // localName
 487                                 String.Empty, // namespaceURI
 488                                 String.Empty, // value
 489                                 0 // attributeCount
 490                         );
 491
 492                         AssertNode (
 493                                 xmlReader, // xmlReader
 494                                 XmlNodeType.EndElement, // nodeType
 495                                 0, //depth
 496                                 false, // isEmptyElement
 497                                 "foo", // name
 498                                 String.Empty, // prefix
 499                                 "foo", // localName
 500                                 String.Empty, // namespaceURI
 501                                 String.Empty, // value
 502                                 0 // attributeCount
 503                         );
 504
 505                         AssertEndDocument (xmlReader);
 506                 }
 507
 508                 [Test]
 509                 public void EntityReferenceInsideText ()
 510                 {
 511                         string xml = "<foo>bar&baz;quux</foo>";
 512                         XmlReader xmlReader = new XmlTextReader (new StringReader (xml));
 513                         AssertNode (
 514                                 xmlReader, // xmlReader
 515                                 XmlNodeType.Element, // nodeType
 516                                 0, //depth
 517                                 false, // isEmptyElement
 518                                 "foo", // name
 519                                 String.Empty, // prefix
 520                                 "foo", // localName
 521                                 String.Empty, // namespaceURI
 522                                 String.Empty, // value
 523                                 0 // attributeCount
 524                         );
 525
 526                         AssertNode (
 527                                 xmlReader, // xmlReader
 528                                 XmlNodeType.Text, // nodeType
 529                                 1, //depth
 530                                 false, // isEmptyElement
 531                                 String.Empty, // name
 532                                 String.Empty, // prefix
 533                                 String.Empty, // localName
 534                                 String.Empty, // namespaceURI
 535                                 "bar", // value
 536                                 0 // attributeCount
 537                         );
 538
 539                         AssertNode (
 540                                 xmlReader, // xmlReader
 541                                 XmlNodeType.EntityReference, // nodeType
 542                                 1, //depth
 543                                 false, // isEmptyElement
 544                                 "baz", // name
 545                                 String.Empty, // prefix
 546                                 "baz", // localName
 547                                 String.Empty, // namespaceURI
 548                                 String.Empty, // value
 549                                 0 // attributeCount
 550                         );
 551
 552                         AssertNode (
 553                                 xmlReader, // xmlReader
 554                                 XmlNodeType.Text, // nodeType
 555                                 1, //depth
 556                                 false, // isEmptyElement
 557                                 String.Empty, // name
 558                                 String.Empty, // prefix
 559                                 String.Empty, // localName
 560                                 String.Empty, // namespaceURI
 561                                 "quux", // value
 562                                 0 // attributeCount
 563                         );
 564
 565                         AssertNode (
 566                                 xmlReader, // xmlReader
 567                                 XmlNodeType.EndElement, // nodeType
 568                                 0, //depth
 569                                 false, // isEmptyElement
 570                                 "foo", // name
 571                                 String.Empty, // prefix
 572                                 "foo", // localName
 573                                 String.Empty, // namespaceURI
 574                                 String.Empty, // value
 575                                 0 // attributeCount
 576                         );
 577
 578                         AssertEndDocument (xmlReader);
 579                 }
 580
 581                 [Test]
 582                 [ExpectedException (typeof (XmlException))]
 583                 public void XmlDeclAfterWhitespace ()
 584                 {
 585                         XmlTextReader xtr = new XmlTextReader (
 586                                 " <?xml version='1.0' ?><root />",
 587                                 XmlNodeType.Document,
 588                                 null);
 589                         xtr.Read ();    // ws
 590                         xtr.Read ();    // not-wf xmldecl
 591                         xtr.Close ();
 592                 }
 593
 594                 [Test]
 595                 [ExpectedException (typeof (XmlException))]
 596                 public void XmlDeclAfterComment ()
 597                 {
 598                         XmlTextReader xtr = new XmlTextReader (
 599                                 "<!-- comment --><?xml version='1.0' ?><root />",
 600                                 XmlNodeType.Document,
 601                                 null);
 602                         xtr.Read ();    // comment
 603                         xtr.Read ();    // not-wf xmldecl
 604                         xtr.Close ();
 605                 }
 606
 607                 [Test]
 608                 [ExpectedException (typeof (XmlException))]
 609                 public void XmlDeclAfterProcessingInstruction ()
 610                 {
 611                         XmlTextReader xtr = new XmlTextReader (
 612                                 "<?myPI let it go ?><?xml version='1.0' ?><root />",
 613                                 XmlNodeType.Document,
 614                                 null);
 615                         xtr.Read ();    // PI
 616                         xtr.Read ();    // not-wf xmldecl
 617                         xtr.Close ();
 618                 }
 619
 620                 [Test]
 621                 [ExpectedException (typeof (XmlException))]
 622                 public void StartsFromEndElement ()
 623                 {
 624                         XmlTextReader xtr = new XmlTextReader (
 625                                 "</root>",
 626                                 XmlNodeType.Document,
 627                                 null);
 628                         xtr.Read ();
 629                         xtr.Close ();
 630                 }
 631
 632                 [Test]
 633                 public void ReadAsElementContent ()
 634                 {
 635                         XmlTextReader xtr = new XmlTextReader (
 636                                 "<foo /><bar />", XmlNodeType.Element, null);
 637                         xtr.Read ();
 638                         xtr.Close ();
 639                 }
 640
 641                 [Test]
 642                 public void ReadAsAttributeContent ()
 643                 {
 644                         XmlTextReader xtr = new XmlTextReader (
 645                                 "test", XmlNodeType.Attribute, null);
 646                         xtr.Read ();
 647                         xtr.Close ();
 648                 }
 649
 650                 [Test]
 651                 public void ExternalDocument ()
 652                 {
 653                         XmlDocument doc = new XmlDocument ();
 654                         doc.Load ("Test/XmlFiles/nested-dtd-test.xml");
 655                 }
 656
 657                 [Test]
 658                 [ExpectedException (typeof (XmlException))]
 659                 public void NotAllowedCharRef ()
 660                 {
 661                         string xml = "<root>&#0;</root>";
 662                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
 663                         xtr.Normalization = true;
 664                         xtr.Read ();
 665                         xtr.Read ();
 666                         xtr.Close ();
 667                 }
 668
 669                 [Test]
 670                 public void NotAllowedCharRefButPassNormalizationFalse ()
 671                 {
 672                         string xml = "<root>&#0;</root>";
 673                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
 674                         xtr.Read ();
 675                         xtr.Read ();
 676                         xtr.Close ();
 677                 }
 678
 679                 [Test]
 680                 [ExpectedException (typeof (XmlException))]
 681                 [Ignore ("MS.NET 1.0 does not pass this test. The related spec is XML rec. 4.1")]
 682                 public void UndeclaredEntityInIntSubsetOnlyXml ()
 683                 {
 684                         string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
 685                         string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent2;
 686                         string xml = dtd + "<root>&ent;&ent2;</root>";
 687                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
 688                         while (!xtr.EOF)
 689                                 xtr.Read ();
 690                         xtr.Close ();
 691                 }
 692
 693                 [Test]
 694                 [ExpectedException (typeof (XmlException))]
 695                 [Ignore ("MS.NET 1.0 does not pass this test. The related spec is XML rec. 4.1")]
 696                 public void UndeclaredEntityInStandaloneXml ()
 697                 {
 698                         string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
 699                         string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent2;
 700                         string xml = "<?xml version='1.0' standalone='yes' ?>"
 701                                 + dtd + "<root>&ent;</root>";
 702                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
 703                         while (!xtr.EOF)
 704                                 xtr.Read ();
 705                         xtr.Close ();
 706                 }
 707
 708                 [Test]
 709                 public void ExpandParameterEntity ()
 710                 {
 711                         string ent = "<!ENTITY foo \"foo-def\">";
 712                         string pe = "<!ENTITY % pe '" + ent + "'>";
 713                         string eldecl = "<!ELEMENT root ANY>";
 714                         string dtd = "<!DOCTYPE root[" + eldecl + pe + "%pe;]>";
 715                         string xml = dtd + "<root/>";
 716                         XmlDocument doc = new XmlDocument ();
 717                         doc.LoadXml (xml);
 718                         XmlEntity foo = doc.DocumentType.Entities.GetNamedItem ("foo") as XmlEntity;
 719                         Assert.IsNotNull (foo);
 720                         Assert.AreEqual ("foo-def", foo.InnerText);
 721                 }
 722
 723                 [Test]
 724                 public void IfNamespacesThenProhibitedAttributes ()
 725                 {
 726                         string xml = @"<foo _1='1' xmlns:x='urn:x' x:_1='1' />";
 727                         XmlDocument doc = new XmlDocument ();
 728                         doc.LoadXml (xml);
 729                 }
 730
 731                 [Test]
 732                 public void ReadBase64 ()
 733                 {
 734                         byte [] bytes = new byte [] {4,14,54,114,134,184,254,255};
 735
 736                         string base64 = "<root><foo>BA42coa44</foo></root>";
 737                         XmlTextReader xtr = new XmlTextReader (base64, XmlNodeType.Document, null);
 738                         byte [] bytes2 = new byte [10];
 739                         xtr.Read ();    // root
 740                         xtr.Read ();    // foo
 741                         this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
 742                                 "foo", String.Empty, String.Empty, 0);
 743                         Assert.AreEqual (6, xtr.ReadBase64 (bytes2, 0, 10));
 744                         this.AssertNodeValues (xtr, XmlNodeType.EndElement, 0, false, "root", String.Empty,
 745                                 "root", String.Empty, String.Empty, 0);
 746                         Assert.IsTrue (!xtr.Read ());
 747                         Assert.AreEqual (4, bytes2 [0]);
 748                         Assert.AreEqual (14, bytes2 [1]);
 749                         Assert.AreEqual (54, bytes2 [2]);
 750                         Assert.AreEqual (114, bytes2 [3]);
 751                         Assert.AreEqual (134, bytes2 [4]);
 752                         Assert.AreEqual (184, bytes2 [5]);
 753                         Assert.AreEqual (0, bytes2 [6]);
 754                         xtr.Close ();
 755
 756                         xtr = new XmlTextReader (base64, XmlNodeType.Document, null);
 757                         bytes2 = new byte [10];
 758                         xtr.Read ();    // root
 759                         xtr.Read ();    // foo
 760                         this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
 761                                 "foo", String.Empty, String.Empty, 0);
 762
 763                         // Read less than 4 (i.e. one Base64 block)
 764                         Assert.AreEqual (1, xtr.ReadBase64 (bytes2, 0, 1));
 765                         this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
 766                                 "foo", String.Empty, String.Empty, 0);
 767                         Assert.AreEqual (4, bytes2 [0]);
 768
 769                         Assert.AreEqual (5, xtr.ReadBase64 (bytes2, 0, 10));
 770                         this.AssertNodeValues (xtr, XmlNodeType.EndElement, 0, false, "root", String.Empty,
 771                                 "root", String.Empty, String.Empty, 0);
 772                         Assert.IsTrue (!xtr.Read ());
 773                         Assert.AreEqual (14, bytes2 [0]);
 774                         Assert.AreEqual (54, bytes2 [1]);
 775                         Assert.AreEqual (114, bytes2 [2]);
 776                         Assert.AreEqual (134, bytes2 [3]);
 777                         Assert.AreEqual (184, bytes2 [4]);
 778                         Assert.AreEqual (0, bytes2 [5]);
 779                         while (!xtr.EOF)
 780                                 xtr.Read ();
 781                         xtr.Close ();
 782                 }
 783
 784                 [Test]
 785                 public void ReadBase64Test2 ()
 786                 {
 787                         string xml = "<root/>";
 788                         XmlTextReader xtr = new XmlTextReader (new StringReader (xml));
 789                         xtr.Read ();
 790                         byte [] data = new byte [1];
 791                         xtr.ReadBase64 (data, 0, 1);
 792                         while (!xtr.EOF)
 793                                 xtr.Read ();
 794
 795                         xml = "<root></root>";
 796                         xtr = new XmlTextReader (new StringReader (xml));
 797                         xtr.Read ();
 798                         xtr.ReadBase64 (data, 0, 1);
 799                         while (!xtr.EOF)
 800                                 xtr.Read ();
 801                 }
 802
 803                 [Test]
 804                 [ExpectedException (typeof (XmlException))]
 805                 public void CheckNamespaceValidity1 ()
 806                 {
 807                         string xml = "<x:root />";
 808                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
 809                         xtr.Read ();
 810                 }
 811
 812                 [Test]
 813                 [ExpectedException (typeof (XmlException))]
 814                 public void CheckNamespaceValidity2 ()
 815                 {
 816                         string xml = "<root x:attr='val' />";
 817                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
 818                         xtr.Read ();
 819                 }
 820
 821                 [Test]
 822                 public void NamespaceFalse ()
 823                 {
 824                         string xml = "<x:root />";
 825                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
 826                         xtr.Namespaces = false;
 827                         xtr.Read ();
 828                 }
 829
 830                 [Test]
 831                 public void NormalizationLineEnd ()
 832                 {
 833                         string s = "One\rtwo\nthree\r\nfour";
 834                         string t = "<hi><![CDATA[" + s + "]]></hi>";
 835
 836                         XmlTextReader r = new XmlTextReader (new StringReader (t));
 837                         r.WhitespaceHandling = WhitespaceHandling.Significant;
 838
 839                         r.Normalization = true;
 840
 841                         s = r.ReadElementString ("hi");
 842                         Assert.AreEqual ("One\ntwo\nthree\nfour", s);
 843                 }
 844
 845                 [Test]
 846                 public void NormalizationAttributes ()
 847                 {
 848                         // does not normalize attribute values.
 849                         StringReader sr = new StringReader ("<!DOCTYPE root [<!ELEMENT root EMPTY><!ATTLIST root attr ID #IMPLIED>]><root attr='   value   '/>");
 850                         XmlTextReader xtr = new XmlTextReader (sr);
 851                         xtr.Normalization = true;
 852                         xtr.Read ();
 853                         xtr.Read ();
 854                         xtr.MoveToFirstAttribute ();
 855                         Assert.AreEqual ("   value   ", xtr.Value);
 856                 }
 857
 858                 [Test]
 859                 public void CloseIsNotAlwaysEOF ()
 860                 {
 861                         // See bug #63505
 862                         XmlTextReader xtr = new XmlTextReader (
 863                                 new StringReader ("<a></a><b></b>"));
 864                         xtr.Close ();
 865                         Assert.IsTrue (!xtr.EOF); // Close() != EOF
 866                 }
 867
 868                 [Test]
 869                 public void CloseIsNotAlwaysEOF2 ()
 870                 {
 871                         XmlTextReader xtr = new XmlTextReader ("Test/XmlFiles/simple.xml");
 872                         xtr.Close ();
 873                         Assert.IsTrue (!xtr.EOF); // Close() != EOF
 874                 }
 875
 876                 [Test]
 877                 public void IXmlLineInfo ()
 878                 {
 879                         // See bug #63507
 880                         XmlTextReader aux = new XmlTextReader (
 881                                 new StringReader ("<all><hello></hello><bug></bug></all>"));
 882                         Assert.AreEqual (0, aux.LineNumber);
 883                         Assert.AreEqual (0, aux.LinePosition);
 884                         aux.MoveToContent();
 885                         Assert.AreEqual (1, aux.LineNumber);
 886                         Assert.AreEqual (2, aux.LinePosition);
 887                         aux.Read();
 888                         Assert.AreEqual (1, aux.LineNumber);
 889                         Assert.AreEqual (7, aux.LinePosition);
 890                         aux.ReadOuterXml();
 891                         Assert.AreEqual (1, aux.LineNumber);
 892                         Assert.AreEqual (22, aux.LinePosition);
 893                         aux.ReadInnerXml();
 894                         Assert.AreEqual (1, aux.LineNumber);
 895                         Assert.AreEqual (34, aux.LinePosition);
 896                         aux.Read();
 897                         Assert.AreEqual (1, aux.LineNumber);
 898                         Assert.AreEqual (38, aux.LinePosition);
 899                         aux.Close();
 900                         Assert.AreEqual (0, aux.LineNumber);
 901                         Assert.AreEqual (0, aux.LinePosition);
 902                 }
 903
 904                 [Test]
 905                 public void AttributeNormalizationWrapped ()
 906                 {
 907                         // When XmlValidatingReader there used to be a problem.
 908                         string xml = "<root attr=' value\nstring' />";
 909                         XmlTextReader xtr = new XmlTextReader (xml,
 910                                 XmlNodeType.Document, null);
 911                         xtr.Normalization = true;
 912                         XmlValidatingReader xvr = new XmlValidatingReader (xtr);
 913                         xvr.Read ();
 914                         xvr.MoveToFirstAttribute ();
 915                         Assert.AreEqual (" value string", xvr.Value);
 916                 }
 917
 918                 [Test]
 919                 [ExpectedException (typeof (XmlException))]
 920                 public void ProhibitDtd ()
 921                 {
 922                         XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root []><root/>", XmlNodeType.Document, null);
 923                         xtr.ProhibitDtd = true;
 924                         while (!xtr.EOF)
 925                                 xtr.Read ();
 926                 }
 927
 928 #if NET_2_0
 929                 [Test]
 930                 public void Settings ()
 931                 {
 932                         XmlTextReader xtr = new XmlTextReader ("<root/>", XmlNodeType.Document, null);
 933                         Assert.IsNull (xtr.Settings);
 934                 }
 935
 936                 // Copied from XmlValidatingReaderTests.cs
 937                 [Test]
 938                 public void ExpandEntity ()
 939                 {
 940                         string intSubset = "<!ELEMENT root (#PCDATA)><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";
 941                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";
 942                         string xml = dtd + "<root foo='&ent;' bar='internal &ent; value'>&ent;</root>";
 943                         XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
 944                         dvr.EntityHandling = EntityHandling.ExpandEntities;
 945                         dvr.Read ();    // DTD
 946                         dvr.Read ();
 947                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
 948                         Assert.AreEqual ("root", dvr.Name);
 949                         Assert.IsTrue (dvr.MoveToFirstAttribute ());
 950                         Assert.AreEqual ("foo", dvr.Name);
 951                         Assert.AreEqual ("entity string", dvr.Value);
 952                         Assert.IsTrue (dvr.MoveToNextAttribute ());
 953                         Assert.AreEqual ("bar", dvr.Name);
 954                         Assert.AreEqual ("internal entity string value", dvr.Value);
 955                         Assert.AreEqual ("entity string", dvr.ReadString ());
 956                 }
 957
 958                 [Test]
 959                 public void PreserveEntity ()
 960                 {
 961                         string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";
 962                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";
 963                         string xml = dtd + "<root foo='&ent;' bar='internal &ent; value' />";
 964                         XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
 965                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;
 966                         dvr.Read ();    // DTD
 967                         dvr.Read ();
 968                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
 969                         Assert.AreEqual ("root", dvr.Name);
 970                         Assert.IsTrue (dvr.MoveToFirstAttribute ());
 971                         Assert.AreEqual ("foo", dvr.Name);
 972                         // MS BUG: it returns "entity string", however, entity should not be exanded.
 973                         Assert.AreEqual ("&ent;", dvr.Value);
 974                         //  ReadAttributeValue()
 975                         Assert.IsTrue (dvr.ReadAttributeValue ());
 976                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
 977                         Assert.AreEqual ("ent", dvr.Name);
 978                         Assert.AreEqual ("", dvr.Value);
 979                         Assert.IsTrue (!dvr.ReadAttributeValue ());
 980
 981                         // bar
 982                         Assert.IsTrue (dvr.MoveToNextAttribute ());
 983                         Assert.AreEqual ("bar", dvr.Name);
 984                         Assert.AreEqual ("internal &ent; value", dvr.Value);
 985                         //  ReadAttributeValue()
 986                         Assert.IsTrue (dvr.ReadAttributeValue ());
 987                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
 988                         Assert.AreEqual ("", dvr.Name);
 989                         Assert.AreEqual ("internal ", dvr.Value);
 990                         Assert.IsTrue (dvr.ReadAttributeValue ());
 991                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
 992                         Assert.AreEqual ("ent", dvr.Name);
 993                         Assert.AreEqual ("", dvr.Value);
 994                         Assert.IsTrue (dvr.ReadAttributeValue ());
 995                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
 996                         Assert.AreEqual ("", dvr.Name);
 997                         Assert.AreEqual (" value", dvr.Value);
 998
 999                 }
1000
1001                 [Test]
1002                 [ExpectedException (typeof (XmlException))]
1003                 public void ExpandEntityRejectsUndeclaredEntityAttr ()
1004                 {
1005                         XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root SYSTEM 'foo.dtd'><root attr='&rnt;'>&rnt;</root>", XmlNodeType.Document, null);
1006                         xtr.EntityHandling = EntityHandling.ExpandEntities;
1007                         xtr.XmlResolver = null;
1008                         xtr.Read ();
1009                         xtr.Read (); // attribute entity 'rnt' is undeclared
1010                 }
1011
1012                 [Test]
1013                 [ExpectedException (typeof (XmlException))]
1014                 public void ExpandEntityRejectsUndeclaredEntityContent ()
1015                 {
1016                         XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root SYSTEM 'foo.dtd'><root>&rnt;</root>", XmlNodeType.Document, null);
1017                         xtr.EntityHandling = EntityHandling.ExpandEntities;
1018                         xtr.XmlResolver = null;
1019                         xtr.Read ();
1020                         xtr.Read ();
1021                         xtr.Read (); // content entity 'rnt' is undeclared
1022                 }
1023
1024                 // mostly copied from XmlValidatingReaderTests.
1025                 [Test]
1026                 public void ResolveEntity ()
1027                 {
1028                         string ent1 = "<!ENTITY ent 'entity string'>";
1029                         string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
1030                         string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;
1031                         string xml = dtd + "<root>&ent;&ent2;</root>";
1032                         XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
1033                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;
1034                         dvr.Read ();    // DTD
1035                         dvr.Read ();    // root
1036                         dvr.Read ();    // &ent;
1037                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1038                         Assert.AreEqual (1, dvr.Depth);
1039                         dvr.ResolveEntity ();
1040                         // It is still entity reference.
1041                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1042                         dvr.Read ();
1043                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
1044                         Assert.AreEqual (2, dvr.Depth);
1045                         Assert.AreEqual ("entity string", dvr.Value);
1046                         dvr.Read ();
1047                         Assert.AreEqual (XmlNodeType.EndEntity, dvr.NodeType);
1048                         Assert.AreEqual (1, dvr.Depth);
1049                         Assert.AreEqual ("", dvr.Value);
1050
1051                         dvr.Read ();    // &ent2;
1052                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1053                         Assert.AreEqual (1, dvr.Depth);
1054                         dvr.ResolveEntity ();
1055                         // It is still entity reference.
1056                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1057                         // It now became element node.
1058                         dvr.Read ();
1059                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
1060                         Assert.AreEqual (2, dvr.Depth);
1061                 }
1062
1063                 // mostly copied from XmlValidatingReaderTests.
1064                 [Test]
1065                 public void ResolveEntity2 ()
1066                 {
1067                         string ent1 = "<!ENTITY ent 'entity string'>";
1068                         string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
1069                         string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;
1070                         string xml = dtd + "<root>&ent3;&ent2;</root>";
1071                         XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
1072                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;
1073                         dvr.Read ();    // DTD
1074                         dvr.Read ();    // root
1075                         dvr.Read ();    // &ent3;
1076                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1077                         // ent3 does not exists in this dtd.
1078                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1079                         try {
1080                                 dvr.ResolveEntity ();
1081                                 Assert.Fail ("Attempt to resolve undeclared entity should fail.");
1082                         } catch (XmlException) {
1083                         }
1084                 }
1085 #endif
1086
1087                 [Test]
1088                 public void SurrogatePair ()
1089                 {
1090                         string xml = @"<!DOCTYPE test [<!ELEMENT test ANY>
1091                 <!ENTITY % a '<!ENTITY ref " + "\"\uF090\u8080\"" + @">'>
1092                 %a;
1093         ]>
1094         <test>&ref;</test>";
1095                         XmlValidatingReader r = new XmlValidatingReader (xml, XmlNodeType.Document, null);
1096                         r.Read ();
1097                         r.Read ();
1098                         r.Read ();
1099                         r.Read ();
1100                         Assert.AreEqual (0xf090, (int) r.Value [0], "#1");
1101                         Assert.AreEqual (0x8080, (int) r.Value [1], "#1");
1102                 }
1103
1104                 [Test]
1105                 [ExpectedException (typeof (XmlException))]
1106                 public void EntityDeclarationNotWF ()
1107                 {
1108                         string xml = @"<!DOCTYPE doc [
1109                                 <!ELEMENT doc (#PCDATA)>
1110                                 <!ENTITY e ''>
1111                                 <!ENTITY e '<foo&>'>
1112                                 ]>
1113                                 <doc>&e;</doc> ";
1114                         XmlTextReader xtr = new XmlTextReader (xml,
1115                                 XmlNodeType.Document, null);
1116                         xtr.Read ();
1117                 }
1118
1119                 [Test] // bug #76102
1120                 public void SurrogateAtReaderByteCache ()
1121                 {
1122                         XmlTextReader xtr = null;
1123                         try {
1124                                 xtr = new XmlTextReader (File.OpenText ("Test/XmlFiles/76102.xml"));
1125                                 while (!xtr.EOF)
1126                                         xtr.Read ();
1127                         } finally {
1128                                 if (xtr != null)
1129                                         xtr.Close ();
1130                         }
1131                 }
1132
1133                 [Test] // bug #76247
1134                 public void SurrogateRoundtrip ()
1135                 {
1136                         byte [] data = new byte [] {0x3c, 0x61, 0x3e, 0xf0,
1137                                 0xa8, 0xa7, 0x80, 0x3c, 0x2f, 0x61, 0x3e};
1138                         XmlTextReader xtr = new XmlTextReader (
1139                                 new MemoryStream (data));
1140                         xtr.Read ();
1141                         string line = xtr.ReadString ();
1142                         int [] arr = new int [line.Length];
1143                         for (int i = 0; i < line.Length; i++)
1144                                 arr [i] = (int) line [i];
1145                         Assert.AreEqual (new int [] {0xd862, 0xddc0}, arr);
1146                 }
1147
1148                 [Test]
1149                 [ExpectedException (typeof (XmlException))]
1150                 public void RejectEmptyNamespaceWithNonEmptyPrefix ()
1151                 {
1152                         XmlTextReader xtr = new XmlTextReader ("<root xmlns:my='' />",
1153                                 XmlNodeType.Document, null);
1154                         xtr.Read ();
1155                 }
1156
1157                 [Test]
1158                 public void EncodingProperty ()
1159                 {
1160                         string xml = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n<root>\n<node>\nvalue\n</node>\n</root>";
1161                         XmlTextReader xr = new XmlTextReader (xml, XmlNodeType.Document, null);
1162                         Assert.IsNull (xr.Encoding, "#1");
1163                         xr.Read ();
1164                         Assert.AreEqual (Encoding.Unicode, xr.Encoding, "#2");
1165                 }
1166
1167                 [Test]
1168                 public void WhitespaceHandlingSignificant ()
1169                 {
1170                         XmlTextReader xtr = new XmlTextReader ("<root>  <child xml:space='preserve'>    <descendant xml:space='default'>    </descendant>   </child><child xml:space='default'>   </child>  </root>",
1171                                 XmlNodeType.Document, null);
1172                         xtr.WhitespaceHandling = WhitespaceHandling.Significant;
1173
1174                         xtr.Read (); // root
1175                         xtr.Read (); // child. skip whitespaces
1176                         Assert.AreEqual (XmlNodeType.Element, xtr.NodeType, "#1");
1177                         xtr.Read (); // significant whitespaces
1178                         Assert.AreEqual (XmlNodeType.SignificantWhitespace, xtr.NodeType, "#2");
1179                         xtr.Read ();
1180                         Assert.AreEqual ("descendant", xtr.LocalName, "#3");
1181                         xtr.Read (); // end of descendant. skip whitespaces
1182                         Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#4");
1183                         xtr.Read (); // significant whitespaces
1184                         Assert.AreEqual (XmlNodeType.SignificantWhitespace, xtr.NodeType, "#5");
1185                         xtr.Read (); // end of child
1186                         xtr.Read (); // child
1187                         xtr.Read (); // end of child. skip whitespaces
1188                         Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#6");
1189                         xtr.Read (); // end of root. skip whitespaces
1190                         Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#7");
1191                 }
1192
1193                 [Test]
1194                 public void WhitespaceHandlingNone ()
1195                 {
1196                         XmlTextReader xtr = new XmlTextReader ("<root>  <child xml:space='preserve'>    <descendant xml:space='default'>    </descendant>   </child><child xml:space='default'>   </child>  </root>",
1197                                 XmlNodeType.Document, null);
1198                         xtr.WhitespaceHandling = WhitespaceHandling.None;
1199
1200                         xtr.Read (); // root
1201                         xtr.Read (); // child. skip whitespaces
1202                         Assert.AreEqual (XmlNodeType.Element, xtr.NodeType, "#1");
1203                         xtr.Read (); // descendant. skip significant whitespaces
1204                         Assert.AreEqual ("descendant", xtr.LocalName, "#2");
1205                         xtr.Read (); // end of descendant. skip whitespaces
1206                         Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#3");
1207                         xtr.Read (); // end of child. skip significant whitespaces
1208                         xtr.Read (); // child
1209                         xtr.Read (); // end of child. skip whitespaces
1210                         Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#6");
1211                         xtr.Read (); // end of root. skip whitespaces
1212                         Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#7");
1213                 }
1214
1215                 [Test]
1216                 public void WhitespacesAfterTextDeclaration ()
1217                 {
1218                         XmlTextReader xtr = new XmlTextReader (
1219                                 "<?xml version='1.0' encoding='utf-8' ?> <x/>",
1220                                 XmlNodeType.Element,
1221                                 null);
1222                         xtr.Read ();
1223                         Assert.AreEqual (XmlNodeType.Whitespace, xtr.NodeType, "#1");
1224                         Assert.AreEqual (" ", xtr.Value, "#2");
1225                 }
1226
1227                 // bug #79683
1228                 [Test]
1229                 public void NotationPERef ()
1230                 {
1231                         string xml = "<!DOCTYPE root SYSTEM 'Test/XmlFiles/79683.dtd'><root/>";
1232                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1233                         while (!xtr.EOF)
1234                                 xtr.Read ();
1235                 }
1236
1237                 [Test] // bug #80308
1238                 public void ReadCharsNested ()
1239                 {
1240                         char[] buf = new char [4];
1241
1242                         string xml = "<root><text>AAAA</text></root>";
1243                         string [] strings = new string [] {
1244                                 "<tex", "t>AA", "AA</", "text", ">"};
1245                         XmlTextReader r = new XmlTextReader (
1246                                 xml, XmlNodeType.Document, null);
1247                         int c, n = 0;
1248                         while (r.Read ())
1249                                 if (r.NodeType == XmlNodeType.Element)
1250                                         while ((c = r.ReadChars (buf, 0, buf.Length)) > 0)
1251                                                 Assert.AreEqual (strings [n++], new string (buf, 0, c), "at " + n);
1252                         Assert.AreEqual (5, n, "total lines");
1253                 }
1254
1255                 [Test] // bug #81294
1256                 public void DtdCommentContainsCloseBracket ()
1257                 {
1258                         string xml = @"<!DOCTYPE kanjidic2 [<!ELEMENT kanjidic2 EMPTY> <!-- ] --> ]><kanjidic2 />";
1259                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1260                         while (!xtr.EOF)
1261                                 xtr.Read ();
1262                 }
1263
1264                 [Test]
1265                 public void CloseTagAfterTextWithTrailingCRNormalized () // bug #398374
1266                 {
1267                         string xml = "<root><foo>some text\r</foo></root>";
1268                         XmlTextReader r = new XmlTextReader (xml, XmlNodeType.Document, null);
1269                         r.Normalization = true;
1270                         while (!r.EOF)
1271                                 r.Read ();
1272                 }
1273
1274                 [Test]
1275                 public void Bug412657 ()
1276                 {
1277                         string s = "<Verifier id='SimpleIntVerifier'/>";
1278                         MemoryStream stream = new MemoryStream (Encoding.UTF8.GetBytes(s));
1279                         XmlParserContext ctx = new XmlParserContext (null, null, null, XmlSpace.Default);
1280                         Assert.IsNull (ctx.NamespaceManager, "#1");
1281                         Assert.IsNull (ctx.NameTable, "#2");
1282                         XmlReader reader = new XmlTextReader (stream, XmlNodeType.Element, ctx);
1283                         Assert.IsNull (ctx.NamespaceManager, "#1");
1284                         reader.Read (); // should not raise NRE.
1285                 }
1286
1287                 [Test]
1288                 [ExpectedException (typeof (XmlException))]
1289                 public void InvalidUTF ()
1290                 {
1291                         byte [] data = new byte [] {0x4d, 0x53, 0x43, 0x46,
1292                                 0x00, 0x00, 0x00, 0x00, 0xab, 0x0a};
1293                         XmlTextReader xtr = new XmlTextReader (
1294                                 new MemoryStream (data));
1295                         xtr.Read ();
1296                 }
1297
1298                 [Test]
1299                 public void ParserContextNullNameTable ()
1300                 {
1301                         string input = "<?xml version='1.0' encoding='UTF-8'?><plist version='1.0'></plist>";
1302                         XmlParserContext context = new XmlParserContext (null, null, null, XmlSpace.None); // null NameTable
1303                         XmlTextReader xtr = new XmlTextReader (input, XmlNodeType.Document, context);
1304                         while (!xtr.EOF)
1305                                 xtr.Read ();
1306                 }
1307
1308                 [Test]
1309                 public void ParsingWithNSMgrSubclass ()
1310                 {
1311                         XmlNamespaceManager nsMgr = new XmlNamespaceManager (new NameTable ());
1312                         nsMgr.AddNamespace ("foo", "bar");
1313                         XmlParserContext inputContext = new XmlParserContext (null, nsMgr, null, XmlSpace.None);
1314                         XmlReader xr = XmlReader.Create (new StringReader ("<empty/>"), new XmlReaderSettings (), inputContext);
1315
1316                         XmlNamespaceManager aMgr = new MyNS (xr);
1317                         XmlParserContext inputContext2 = new XmlParserContext(null, aMgr, null, XmlSpace.None);
1318                         XmlReader xr2 = XmlReader.Create (new StringReader ("<foo:haha>namespace test</foo:haha>"), new XmlReaderSettings (), inputContext2);
1319
1320                         while (xr2.Read ()) {}
1321
1322                 }
1323
1324
1325                 // The MyNS subclass chains namespace lookups
1326                 class MyNS : XmlNamespaceManager {
1327                         private XmlReader xr;
1328
1329
1330                         public MyNS (XmlReader xr)
1331                                 : base (xr.NameTable) {
1332                                 this.xr = xr;
1333                         }
1334
1335                         public override string LookupNamespace (string prefix) {
1336                                 string str = base.LookupNamespace (prefix);
1337                                 if (!string.IsNullOrEmpty (str))
1338                                         return str;
1339                                 if (xr != null)
1340                                         return xr.LookupNamespace (prefix);
1341                                 return String.Empty;
1342                         }
1343                 }
1344
1345                 [Test]
1346                 public void EmptyXmlBase ()
1347                 {
1348                         XmlDocument doc = new XmlDocument ();
1349                         doc.LoadXml ("<root xml:base='' />");
1350                 }
1351
1352                 [Test]
1353                 public void GetAttribute ()
1354                 {
1355                         StringReader sr = new StringReader("<rootElement myAttribute=\"the value\"></rootElement>");
1356                         using (XmlReader reader = XmlReader.Create(sr)) {
1357                                 reader.Read ();
1358                                 Assert.AreEqual (reader.GetAttribute("myAttribute", null), "the value", "#1");
1359                         }
1360                 }
1361
1362                 [Test] // bug #675384
1363                 public void ReadCharsWithVeryLimitedBuffer ()
1364                 {
1365                         var r = new XmlTextReader ("<root><child>a</child></root>", XmlNodeType.Document, null);
1366                         r.MoveToContent ();
1367                         char [] buff = new char [1];
1368                         int read = 0;
1369                         var sb = new StringBuilder ();
1370                         do {
1371                                 read = r.ReadChars (buff, 0, buff.Length);
1372                         if (read > 0)
1373                                 sb.Append (buff [0]);
1374                         } while (read > 0);
1375                         Assert.AreEqual ("<child>a</child>", sb.ToString (), "#1");
1376                 }
1377
1378                 [Test]
1379                 public void BOMLessUTF16Detection () // bug #674580
1380                 {
1381                         var ms = new MemoryStream (Encoding.Unicode.GetBytes ("<root />"));
1382                         var xtr = new XmlTextReader (ms);
1383                         xtr.Read ();
1384                 }
1385         }
1386 }