2 // XmlTextReaderTests.cs
5 // Jason Diamond (jason@injektilo.org)
6 // Martin Willemoes Hansen (mwh@sysrq.dk)
8 // (C) 2001, 2002 Jason Diamond http://injektilo.org/
16 using NUnit.Framework;
18 namespace MonoTests.System.Xml
21 public class XmlTextReaderTests
23 private void AssertStartDocument (XmlReader xmlReader)
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);
31 private void AssertNode (
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);
49 private void AssertNodeValues (
61 Assert.AreEqual (nodeType, xmlReader.NodeType, "NodeType");
62 Assert.AreEqual (depth, xmlReader.Depth, "Depth");
63 Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, "IsEmptyElement");
65 Assert.AreEqual (name, xmlReader.Name, "name");
67 Assert.AreEqual (prefix, xmlReader.Prefix, "prefix");
69 Assert.AreEqual (localName, xmlReader.LocalName, "localName");
71 Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, "namespaceURI");
73 Assert.AreEqual ((value != String.Empty), xmlReader.HasValue, "hasValue");
75 Assert.AreEqual (value, xmlReader.Value, "Value");
77 Assert.AreEqual (attributeCount > 0, xmlReader.HasAttributes, "hasAttributes");
79 Assert.AreEqual (attributeCount, xmlReader.AttributeCount, "attributeCount");
82 private void AssertAttribute (
90 Assert.AreEqual (value, xmlReader [name], "value.Indexer");
92 Assert.AreEqual (value, xmlReader.GetAttribute (name), "value.GetAttribute");
94 if (namespaceURI != String.Empty) {
95 Assert.IsTrue (xmlReader[localName, namespaceURI] == value);
96 Assert.IsTrue (xmlReader.GetAttribute (localName, namespaceURI) == value);
100 private void AssertEndDocument (XmlReader xmlReader)
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");
109 Assert.AreEqual (ReadState.Closed, xmlReader.ReadState, "ReadState is not ReadState.Cosed");
113 public void StartAndEndTagWithAttribute ()
115 string xml = @"<foo bar='baz'></foo>";
116 XmlReader xmlReader =
117 new XmlTextReader (new StringReader (xml));
119 AssertStartDocument (xmlReader);
122 xmlReader, // xmlReader
123 XmlNodeType.Element, // nodeType
125 false, // isEmptyElement
127 String.Empty, // prefix
129 String.Empty, // namespaceURI
130 String.Empty, // value
135 xmlReader, // xmlReader
137 String.Empty, // prefix
139 String.Empty, // namespaceURI
144 xmlReader, // xmlReader
145 XmlNodeType.EndElement, // nodeType
147 false, // isEmptyElement
149 String.Empty, // prefix
151 String.Empty, // namespaceURI
152 String.Empty, // value
156 AssertEndDocument (xmlReader);
159 // expecting parser error
161 public void EmptyElementWithBadName ()
163 string xml = "<1foo/>";
164 XmlReader xmlReader =
165 new XmlTextReader (new StringReader (xml));
167 bool caughtXmlException = false;
171 } catch (XmlException) {
172 caughtXmlException = true;
175 Assert.IsTrue (caughtXmlException);
179 public void EmptyElementWithStartAndEndTag ()
181 string xml = "<foo></foo>";
182 XmlReader xmlReader =
183 new XmlTextReader (new StringReader (xml));
185 AssertStartDocument (xmlReader);
188 xmlReader, // xmlReader
189 XmlNodeType.Element, // nodeType
191 false, // isEmptyElement
193 String.Empty, // prefix
195 String.Empty, // namespaceURI
196 String.Empty, // value
201 xmlReader, // xmlReader
202 XmlNodeType.EndElement, // nodeType
204 false, // isEmptyElement
206 String.Empty, // prefix
208 String.Empty, // namespaceURI
209 String.Empty, // value
213 AssertEndDocument (xmlReader);
218 public void EmptyElementWithStartAndEndTagWithWhitespace ()
220 string xml = "<foo ></foo >";
221 XmlReader xmlReader =
222 new XmlTextReader (new StringReader (xml));
224 AssertStartDocument (xmlReader);
227 xmlReader, // xmlReader
228 XmlNodeType.Element, // nodeType
230 false, // isEmptyElement
232 String.Empty, // prefix
234 String.Empty, // namespaceURI
235 String.Empty, // value
240 xmlReader, // xmlReader
241 XmlNodeType.EndElement, // nodeType
243 false, // isEmptyElement
245 String.Empty, // prefix
247 String.Empty, // namespaceURI
248 String.Empty, // value
252 AssertEndDocument (xmlReader);
256 public void EmptyElementWithAttribute ()
258 string xml = @"<foo bar=""baz""/>";
259 XmlReader xmlReader =
260 new XmlTextReader (new StringReader (xml));
262 AssertStartDocument (xmlReader);
265 xmlReader, // xmlReader
266 XmlNodeType.Element, // nodeType
268 true, // isEmptyElement
270 String.Empty, // prefix
272 String.Empty, // namespaceURI
273 String.Empty, // value
278 xmlReader, // xmlReader
280 String.Empty, // prefix
282 String.Empty, // namespaceURI
286 AssertEndDocument (xmlReader);
290 public void EmptyElementInNamespace ()
292 string xml = @"<foo:bar xmlns:foo='http://foo/' />";
293 XmlReader xmlReader =
294 new XmlTextReader (new StringReader (xml));
296 AssertStartDocument (xmlReader);
299 xmlReader, // xmlReader
300 XmlNodeType.Element, // nodeType
302 true, // isEmptyElement
306 "http://foo/", // namespaceURI
307 String.Empty, // value
312 xmlReader, // xmlReader
316 "http://www.w3.org/2000/xmlns/", // namespaceURI
317 "http://foo/" // value
320 Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));
322 AssertEndDocument (xmlReader);
326 public void EntityReferenceInAttribute ()
328 string xml = "<foo bar='&baz;'/>";
329 XmlReader xmlReader =
330 new XmlTextReader (new StringReader (xml));
332 AssertStartDocument (xmlReader);
335 xmlReader, // xmlReader
336 XmlNodeType.Element, // nodeType
338 true, // isEmptyElement
340 String.Empty, // prefix
342 String.Empty, // namespaceURI
343 String.Empty, // value
348 xmlReader, // xmlReader
350 String.Empty, // prefix
352 String.Empty, // namespaceURI
356 AssertEndDocument (xmlReader);
360 public void IsName ()
362 Assert.IsTrue (XmlReader.IsName ("foo"));
363 Assert.IsTrue (!XmlReader.IsName ("1foo"));
364 Assert.IsTrue (!XmlReader.IsName (" foo"));
368 public void IsNameToken ()
370 Assert.IsTrue (XmlReader.IsNameToken ("foo"));
371 Assert.IsTrue (XmlReader.IsNameToken ("1foo"));
372 Assert.IsTrue (!XmlReader.IsNameToken (" foo"));
376 public void FragmentConstructor()
378 XmlDocument doc = new XmlDocument();
379 // doc.LoadXml("<root/>");
381 string xml = @"<foo><bar xmlns=""NSURI"">TEXT NODE</bar></foo>";
382 MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(xml));
384 XmlParserContext ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", "", "", "",
385 doc.BaseURI, "", XmlSpace.Default, Encoding.Default);
387 XmlTextReader xmlReader = new XmlTextReader(ms, XmlNodeType.Element, ctx);
388 AssertNode(xmlReader, XmlNodeType.Element, 0, false, "foo", "", "foo", "", "", 0);
390 AssertNode(xmlReader, XmlNodeType.Element, 1, false, "bar", "", "bar", "NSURI", "", 1);
392 AssertNode(xmlReader, XmlNodeType.Text, 2, false, "", "", "", "", "TEXT NODE", 0);
394 AssertNode(xmlReader, XmlNodeType.EndElement, 1, false, "bar", "", "bar", "NSURI", "", 0);
396 AssertNode(xmlReader, XmlNodeType.EndElement, 0, false, "foo", "", "foo", "", "", 0);
398 AssertEndDocument (xmlReader);
402 public void AttributeWithCharacterReference ()
404 string xml = @"<a value='hello & world' />";
405 XmlReader xmlReader =
406 new XmlTextReader (new StringReader (xml));
408 Assert.AreEqual ("hello & world", xmlReader ["value"]);
412 public void AttributeWithEntityReference ()
414 string xml = @"<a value='hello &ent; world' />";
415 XmlReader xmlReader =
416 new XmlTextReader (new StringReader (xml));
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);
436 public void QuoteChar ()
438 string xml = @"<a value='hello & world' value2="""" />";
439 XmlReader xmlReader =
440 new XmlTextReader (new StringReader (xml));
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");
451 public void ReadInnerXmlWrongInit ()
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");
462 public void EntityReference ()
464 string xml = "<foo>&bar;</foo>";
465 XmlReader xmlReader = new XmlTextReader (new StringReader (xml));
467 xmlReader, // xmlReader
468 XmlNodeType.Element, // nodeType
470 false, // isEmptyElement
472 String.Empty, // prefix
474 String.Empty, // namespaceURI
475 String.Empty, // value
480 xmlReader, // xmlReader
481 XmlNodeType.EntityReference, // nodeType
483 false, // isEmptyElement
485 String.Empty, // prefix
487 String.Empty, // namespaceURI
488 String.Empty, // value
493 xmlReader, // xmlReader
494 XmlNodeType.EndElement, // nodeType
496 false, // isEmptyElement
498 String.Empty, // prefix
500 String.Empty, // namespaceURI
501 String.Empty, // value
505 AssertEndDocument (xmlReader);
509 public void EntityReferenceInsideText ()
511 string xml = "<foo>bar&baz;quux</foo>";
512 XmlReader xmlReader = new XmlTextReader (new StringReader (xml));
514 xmlReader, // xmlReader
515 XmlNodeType.Element, // nodeType
517 false, // isEmptyElement
519 String.Empty, // prefix
521 String.Empty, // namespaceURI
522 String.Empty, // value
527 xmlReader, // xmlReader
528 XmlNodeType.Text, // nodeType
530 false, // isEmptyElement
531 String.Empty, // name
532 String.Empty, // prefix
533 String.Empty, // localName
534 String.Empty, // namespaceURI
540 xmlReader, // xmlReader
541 XmlNodeType.EntityReference, // nodeType
543 false, // isEmptyElement
545 String.Empty, // prefix
547 String.Empty, // namespaceURI
548 String.Empty, // value
553 xmlReader, // xmlReader
554 XmlNodeType.Text, // nodeType
556 false, // isEmptyElement
557 String.Empty, // name
558 String.Empty, // prefix
559 String.Empty, // localName
560 String.Empty, // namespaceURI
566 xmlReader, // xmlReader
567 XmlNodeType.EndElement, // nodeType
569 false, // isEmptyElement
571 String.Empty, // prefix
573 String.Empty, // namespaceURI
574 String.Empty, // value
578 AssertEndDocument (xmlReader);
582 [ExpectedException (typeof (XmlException))]
583 public void XmlDeclAfterWhitespace ()
585 XmlTextReader xtr = new XmlTextReader (
586 " <?xml version='1.0' ?><root />",
587 XmlNodeType.Document,
590 xtr.Read (); // not-wf xmldecl
595 [ExpectedException (typeof (XmlException))]
596 public void XmlDeclAfterComment ()
598 XmlTextReader xtr = new XmlTextReader (
599 "<!-- comment --><?xml version='1.0' ?><root />",
600 XmlNodeType.Document,
602 xtr.Read (); // comment
603 xtr.Read (); // not-wf xmldecl
608 [ExpectedException (typeof (XmlException))]
609 public void XmlDeclAfterProcessingInstruction ()
611 XmlTextReader xtr = new XmlTextReader (
612 "<?myPI let it go ?><?xml version='1.0' ?><root />",
613 XmlNodeType.Document,
616 xtr.Read (); // not-wf xmldecl
621 [ExpectedException (typeof (XmlException))]
622 public void StartsFromEndElement ()
624 XmlTextReader xtr = new XmlTextReader (
626 XmlNodeType.Document,
633 public void ReadAsElementContent ()
635 XmlTextReader xtr = new XmlTextReader (
636 "<foo /><bar />", XmlNodeType.Element, null);
642 public void ReadAsAttributeContent ()
644 XmlTextReader xtr = new XmlTextReader (
645 "test", XmlNodeType.Attribute, null);
651 public void ExternalDocument ()
653 XmlDocument doc = new XmlDocument ();
654 doc.Load ("Test/XmlFiles/nested-dtd-test.xml");
658 [ExpectedException (typeof (XmlException))]
659 public void NotAllowedCharRef ()
661 string xml = "<root>�</root>";
662 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
663 xtr.Normalization = true;
670 public void NotAllowedCharRefButPassNormalizationFalse ()
672 string xml = "<root>�</root>";
673 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
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 ()
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);
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 ()
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);
709 public void ExpandParameterEntity ()
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 ();
718 XmlEntity foo = doc.DocumentType.Entities.GetNamedItem ("foo") as XmlEntity;
719 Assert.IsNotNull (foo);
720 Assert.AreEqual ("foo-def", foo.InnerText);
724 public void IfNamespacesThenProhibitedAttributes ()
726 string xml = @"<foo _1='1' xmlns:x='urn:x' x:_1='1' />";
727 XmlDocument doc = new XmlDocument ();
732 public void ReadBase64 ()
734 byte [] bytes = new byte [] {4,14,54,114,134,184,254,255};
736 string base64 = "<root><foo>BA42coa44</foo></root>";
737 XmlTextReader xtr = new XmlTextReader (base64, XmlNodeType.Document, null);
738 byte [] bytes2 = new byte [10];
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]);
756 xtr = new XmlTextReader (base64, XmlNodeType.Document, null);
757 bytes2 = new byte [10];
760 this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
761 "foo", String.Empty, String.Empty, 0);
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]);
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]);
785 public void ReadBase64Test2 ()
787 string xml = "<root/>";
788 XmlTextReader xtr = new XmlTextReader (new StringReader (xml));
790 byte [] data = new byte [1];
791 xtr.ReadBase64 (data, 0, 1);
795 xml = "<root></root>";
796 xtr = new XmlTextReader (new StringReader (xml));
798 xtr.ReadBase64 (data, 0, 1);
804 [ExpectedException (typeof (XmlException))]
805 public void CheckNamespaceValidity1 ()
807 string xml = "<x:root />";
808 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
813 [ExpectedException (typeof (XmlException))]
814 public void CheckNamespaceValidity2 ()
816 string xml = "<root x:attr='val' />";
817 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
822 public void NamespaceFalse ()
824 string xml = "<x:root />";
825 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
826 xtr.Namespaces = false;
831 public void NormalizationLineEnd ()
833 string s = "One\rtwo\nthree\r\nfour";
834 string t = "<hi><![CDATA[" + s + "]]></hi>";
836 XmlTextReader r = new XmlTextReader (new StringReader (t));
837 r.WhitespaceHandling = WhitespaceHandling.Significant;
839 r.Normalization = true;
841 s = r.ReadElementString ("hi");
842 Assert.AreEqual ("One\ntwo\nthree\nfour", s);
846 public void NormalizationAttributes ()
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;
854 xtr.MoveToFirstAttribute ();
855 Assert.AreEqual (" value ", xtr.Value);
859 public void CloseIsNotAlwaysEOF ()
862 XmlTextReader xtr = new XmlTextReader (
863 new StringReader ("<a></a><b></b>"));
865 Assert.IsTrue (!xtr.EOF); // Close() != EOF
869 public void CloseIsNotAlwaysEOF2 ()
871 XmlTextReader xtr = new XmlTextReader ("Test/XmlFiles/simple.xml");
873 Assert.IsTrue (!xtr.EOF); // Close() != EOF
877 public void IXmlLineInfo ()
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);
885 Assert.AreEqual (1, aux.LineNumber);
886 Assert.AreEqual (2, aux.LinePosition);
888 Assert.AreEqual (1, aux.LineNumber);
889 Assert.AreEqual (7, aux.LinePosition);
891 Assert.AreEqual (1, aux.LineNumber);
892 Assert.AreEqual (22, aux.LinePosition);
894 Assert.AreEqual (1, aux.LineNumber);
895 Assert.AreEqual (34, aux.LinePosition);
897 Assert.AreEqual (1, aux.LineNumber);
898 Assert.AreEqual (38, aux.LinePosition);
900 Assert.AreEqual (0, aux.LineNumber);
901 Assert.AreEqual (0, aux.LinePosition);
905 public void AttributeNormalizationWrapped ()
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);
914 xvr.MoveToFirstAttribute ();
915 Assert.AreEqual (" value string", xvr.Value);
919 [ExpectedException (typeof (XmlException))]
920 public void ProhibitDtd ()
922 XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root []><root/>", XmlNodeType.Document, null);
923 xtr.ProhibitDtd = true;
929 public void Settings ()
931 XmlTextReader xtr = new XmlTextReader ("<root/>", XmlNodeType.Document, null);
932 Assert.IsNull (xtr.Settings);
935 // Copied from XmlValidatingReaderTests.cs
937 public void ExpandEntity ()
939 string intSubset = "<!ELEMENT root (#PCDATA)><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";
940 string dtd = "<!DOCTYPE root [" + intSubset + "]>";
941 string xml = dtd + "<root foo='&ent;' bar='internal &ent; value'>&ent;</root>";
942 XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
943 dvr.EntityHandling = EntityHandling.ExpandEntities;
946 Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
947 Assert.AreEqual ("root", dvr.Name);
948 Assert.IsTrue (dvr.MoveToFirstAttribute ());
949 Assert.AreEqual ("foo", dvr.Name);
950 Assert.AreEqual ("entity string", dvr.Value);
951 Assert.IsTrue (dvr.MoveToNextAttribute ());
952 Assert.AreEqual ("bar", dvr.Name);
953 Assert.AreEqual ("internal entity string value", dvr.Value);
954 Assert.AreEqual ("entity string", dvr.ReadString ());
958 public void PreserveEntity ()
960 string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";
961 string dtd = "<!DOCTYPE root [" + intSubset + "]>";
962 string xml = dtd + "<root foo='&ent;' bar='internal &ent; value' />";
963 XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
964 dvr.EntityHandling = EntityHandling.ExpandCharEntities;
967 Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
968 Assert.AreEqual ("root", dvr.Name);
969 Assert.IsTrue (dvr.MoveToFirstAttribute ());
970 Assert.AreEqual ("foo", dvr.Name);
971 // MS BUG: it returns "entity string", however, entity should not be exanded.
972 Assert.AreEqual ("&ent;", dvr.Value);
973 // ReadAttributeValue()
974 Assert.IsTrue (dvr.ReadAttributeValue ());
975 Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
976 Assert.AreEqual ("ent", dvr.Name);
977 Assert.AreEqual ("", dvr.Value);
978 Assert.IsTrue (!dvr.ReadAttributeValue ());
981 Assert.IsTrue (dvr.MoveToNextAttribute ());
982 Assert.AreEqual ("bar", dvr.Name);
983 Assert.AreEqual ("internal &ent; value", dvr.Value);
984 // ReadAttributeValue()
985 Assert.IsTrue (dvr.ReadAttributeValue ());
986 Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
987 Assert.AreEqual ("", dvr.Name);
988 Assert.AreEqual ("internal ", dvr.Value);
989 Assert.IsTrue (dvr.ReadAttributeValue ());
990 Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
991 Assert.AreEqual ("ent", dvr.Name);
992 Assert.AreEqual ("", dvr.Value);
993 Assert.IsTrue (dvr.ReadAttributeValue ());
994 Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
995 Assert.AreEqual ("", dvr.Name);
996 Assert.AreEqual (" value", dvr.Value);
1001 [ExpectedException (typeof (XmlException))]
1002 public void ExpandEntityRejectsUndeclaredEntityAttr ()
1004 XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root SYSTEM 'foo.dtd'><root attr='&rnt;'>&rnt;</root>", XmlNodeType.Document, null);
1005 xtr.EntityHandling = EntityHandling.ExpandEntities;
1006 xtr.XmlResolver = null;
1008 xtr.Read (); // attribute entity 'rnt' is undeclared
1012 [ExpectedException (typeof (XmlException))]
1013 public void ExpandEntityRejectsUndeclaredEntityContent ()
1015 XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root SYSTEM 'foo.dtd'><root>&rnt;</root>", XmlNodeType.Document, null);
1016 xtr.EntityHandling = EntityHandling.ExpandEntities;
1017 xtr.XmlResolver = null;
1020 xtr.Read (); // content entity 'rnt' is undeclared
1023 // mostly copied from XmlValidatingReaderTests.
1025 public void ResolveEntity ()
1027 string ent1 = "<!ENTITY ent 'entity string'>";
1028 string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
1029 string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;
1030 string xml = dtd + "<root>&ent;&ent2;</root>";
1031 XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
1032 dvr.EntityHandling = EntityHandling.ExpandCharEntities;
1034 dvr.Read (); // root
1035 dvr.Read (); // &ent;
1036 Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1037 Assert.AreEqual (1, dvr.Depth);
1038 dvr.ResolveEntity ();
1039 // It is still entity reference.
1040 Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1042 Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
1043 Assert.AreEqual (2, dvr.Depth);
1044 Assert.AreEqual ("entity string", dvr.Value);
1046 Assert.AreEqual (XmlNodeType.EndEntity, dvr.NodeType);
1047 Assert.AreEqual (1, dvr.Depth);
1048 Assert.AreEqual ("", dvr.Value);
1050 dvr.Read (); // &ent2;
1051 Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1052 Assert.AreEqual (1, dvr.Depth);
1053 dvr.ResolveEntity ();
1054 // It is still entity reference.
1055 Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1056 // It now became element node.
1058 Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
1059 Assert.AreEqual (2, dvr.Depth);
1062 // mostly copied from XmlValidatingReaderTests.
1064 public void ResolveEntity2 ()
1066 string ent1 = "<!ENTITY ent 'entity string'>";
1067 string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
1068 string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;
1069 string xml = dtd + "<root>&ent3;&ent2;</root>";
1070 XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
1071 dvr.EntityHandling = EntityHandling.ExpandCharEntities;
1073 dvr.Read (); // root
1074 dvr.Read (); // &ent3;
1075 Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1076 // ent3 does not exist in this dtd.
1077 Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
1079 dvr.ResolveEntity ();
1080 Assert.Fail ("Attempt to resolve undeclared entity should fail.");
1081 } catch (XmlException) {
1086 public void SurrogatePair ()
1088 string xml = @"<!DOCTYPE test [<!ELEMENT test ANY>
1089 <!ENTITY % a '<!ENTITY ref " + "\"\uF090\u8080\"" + @">'>
1092 <test>&ref;</test>";
1093 XmlValidatingReader r = new XmlValidatingReader (xml, XmlNodeType.Document, null);
1098 Assert.AreEqual (0xf090, (int) r.Value [0], "#1");
1099 Assert.AreEqual (0x8080, (int) r.Value [1], "#1");
1103 [ExpectedException (typeof (XmlException))]
1104 public void EntityDeclarationNotWF ()
1106 string xml = @"<!DOCTYPE doc [
1107 <!ELEMENT doc (#PCDATA)>
1109 <!ENTITY e '<foo&>'>
1112 XmlTextReader xtr = new XmlTextReader (xml,
1113 XmlNodeType.Document, null);
1117 [Test] // bug #76102
1118 public void SurrogateAtReaderByteCache ()
1120 XmlTextReader xtr = null;
1122 xtr = new XmlTextReader (File.OpenText ("Test/XmlFiles/76102.xml"));
1131 [Test] // bug #76247
1132 public void SurrogateRoundtrip ()
1134 byte [] data = new byte [] {0x3c, 0x61, 0x3e, 0xf0,
1135 0xa8, 0xa7, 0x80, 0x3c, 0x2f, 0x61, 0x3e};
1136 XmlTextReader xtr = new XmlTextReader (
1137 new MemoryStream (data));
1139 string line = xtr.ReadString ();
1140 int [] arr = new int [line.Length];
1141 for (int i = 0; i < line.Length; i++)
1142 arr [i] = (int) line [i];
1143 Assert.AreEqual (new int [] {0xd862, 0xddc0}, arr);
1147 [ExpectedException (typeof (XmlException))]
1148 public void RejectEmptyNamespaceWithNonEmptyPrefix ()
1150 XmlTextReader xtr = new XmlTextReader ("<root xmlns:my='' />",
1151 XmlNodeType.Document, null);
1156 public void EncodingProperty ()
1158 string xml = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n<root>\n<node>\nvalue\n</node>\n</root>";
1159 XmlTextReader xr = new XmlTextReader (xml, XmlNodeType.Document, null);
1160 Assert.IsNull (xr.Encoding, "#1");
1162 Assert.AreEqual (Encoding.Unicode, xr.Encoding, "#2");
1166 public void WhitespaceHandlingSignificant ()
1168 XmlTextReader xtr = new XmlTextReader ("<root> <child xml:space='preserve'> <descendant xml:space='default'> </descendant> </child><child xml:space='default'> </child> </root>",
1169 XmlNodeType.Document, null);
1170 xtr.WhitespaceHandling = WhitespaceHandling.Significant;
1172 xtr.Read (); // root
1173 xtr.Read (); // child. skip whitespaces
1174 Assert.AreEqual (XmlNodeType.Element, xtr.NodeType, "#1");
1175 xtr.Read (); // significant whitespaces
1176 Assert.AreEqual (XmlNodeType.SignificantWhitespace, xtr.NodeType, "#2");
1178 Assert.AreEqual ("descendant", xtr.LocalName, "#3");
1179 xtr.Read (); // end of descendant. skip whitespaces
1180 Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#4");
1181 xtr.Read (); // significant whitespaces
1182 Assert.AreEqual (XmlNodeType.SignificantWhitespace, xtr.NodeType, "#5");
1183 xtr.Read (); // end of child
1184 xtr.Read (); // child
1185 xtr.Read (); // end of child. skip whitespaces
1186 Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#6");
1187 xtr.Read (); // end of root. skip whitespaces
1188 Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#7");
1192 public void WhitespaceHandlingNone ()
1194 XmlTextReader xtr = new XmlTextReader ("<root> <child xml:space='preserve'> <descendant xml:space='default'> </descendant> </child><child xml:space='default'> </child> </root>",
1195 XmlNodeType.Document, null);
1196 xtr.WhitespaceHandling = WhitespaceHandling.None;
1198 xtr.Read (); // root
1199 xtr.Read (); // child. skip whitespaces
1200 Assert.AreEqual (XmlNodeType.Element, xtr.NodeType, "#1");
1201 xtr.Read (); // descendant. skip significant whitespaces
1202 Assert.AreEqual ("descendant", xtr.LocalName, "#2");
1203 xtr.Read (); // end of descendant. skip whitespaces
1204 Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#3");
1205 xtr.Read (); // end of child. skip significant whitespaces
1206 xtr.Read (); // child
1207 xtr.Read (); // end of child. skip whitespaces
1208 Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#6");
1209 xtr.Read (); // end of root. skip whitespaces
1210 Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#7");
1214 [Ignore ("bug in Microsoft referencesource")]
1215 public void WhitespacesAfterTextDeclaration ()
1217 XmlTextReader xtr = new XmlTextReader (
1218 "<?xml version='1.0' encoding='utf-8' ?> <x/>",
1219 XmlNodeType.Element,
1222 Assert.AreEqual (XmlNodeType.Whitespace, xtr.NodeType, "#1");
1223 Assert.AreEqual (" ", xtr.Value, "#2");
1228 public void NotationPERef ()
1230 string xml = "<!DOCTYPE root SYSTEM 'Test/XmlFiles/79683.dtd'><root/>";
1231 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1236 [Test] // bug #80308
1237 public void ReadCharsNested ()
1239 char[] buf = new char [4];
1241 string xml = "<root><text>AAAA</text></root>";
1242 string [] strings = new string [] {
1243 "<tex", "t>AA", "AA</", "text", ">"};
1244 XmlTextReader r = new XmlTextReader (
1245 xml, XmlNodeType.Document, null);
1248 if (r.NodeType == XmlNodeType.Element)
1249 while ((c = r.ReadChars (buf, 0, buf.Length)) > 0)
1250 Assert.AreEqual (strings [n++], new string (buf, 0, c), "at " + n);
1251 Assert.AreEqual (5, n, "total lines");
1254 [Test] // bug #81294
1255 public void DtdCommentContainsCloseBracket ()
1257 string xml = @"<!DOCTYPE kanjidic2 [<!ELEMENT kanjidic2 EMPTY> <!-- ] --> ]><kanjidic2 />";
1258 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1264 public void CloseTagAfterTextWithTrailingCRNormalized () // bug #398374
1266 string xml = "<root><foo>some text\r</foo></root>";
1267 XmlTextReader r = new XmlTextReader (xml, XmlNodeType.Document, null);
1268 r.Normalization = true;
1274 public void Bug412657 ()
1276 string s = "<Verifier id='SimpleIntVerifier'/>";
1277 MemoryStream stream = new MemoryStream (Encoding.UTF8.GetBytes(s));
1278 XmlParserContext ctx = new XmlParserContext (null, null, null, XmlSpace.Default);
1279 Assert.IsNull (ctx.NamespaceManager, "#1");
1280 Assert.IsNull (ctx.NameTable, "#2");
1281 XmlReader reader = new XmlTextReader (stream, XmlNodeType.Element, ctx);
1282 Assert.IsNull (ctx.NamespaceManager, "#1");
1283 reader.Read (); // should not raise NRE.
1287 [ExpectedException (typeof (XmlException))]
1288 public void InvalidUTF ()
1290 byte [] data = new byte [] {0x4d, 0x53, 0x43, 0x46,
1291 0x00, 0x00, 0x00, 0x00, 0xab, 0x0a};
1292 XmlTextReader xtr = new XmlTextReader (
1293 new MemoryStream (data));
1298 public void ParserContextNullNameTable ()
1300 string input = "<?xml version='1.0' encoding='UTF-8'?><plist version='1.0'></plist>";
1301 XmlParserContext context = new XmlParserContext (null, null, null, XmlSpace.None); // null NameTable
1302 XmlTextReader xtr = new XmlTextReader (input, XmlNodeType.Document, context);
1308 public void ParsingWithNSMgrSubclass ()
1310 XmlNamespaceManager nsMgr = new XmlNamespaceManager (new NameTable ());
1311 nsMgr.AddNamespace ("foo", "bar");
1312 XmlParserContext inputContext = new XmlParserContext (null, nsMgr, null, XmlSpace.None);
1313 XmlReader xr = XmlReader.Create (new StringReader ("<empty/>"), new XmlReaderSettings (), inputContext);
1315 XmlNamespaceManager aMgr = new MyNS (xr);
1316 XmlParserContext inputContext2 = new XmlParserContext(null, aMgr, null, XmlSpace.None);
1317 XmlReader xr2 = XmlReader.Create (new StringReader ("<foo:haha>namespace test</foo:haha>"), new XmlReaderSettings (), inputContext2);
1319 while (xr2.Read ()) {}
1324 // The MyNS subclass chains namespace lookups
1325 class MyNS : XmlNamespaceManager {
1326 private XmlReader xr;
1329 public MyNS (XmlReader xr)
1330 : base (xr.NameTable) {
1334 public override string LookupNamespace (string prefix) {
1335 string str = base.LookupNamespace (prefix);
1336 if (!string.IsNullOrEmpty (str))
1339 return xr.LookupNamespace (prefix);
1340 return String.Empty;
1345 public void EmptyXmlBase ()
1347 XmlDocument doc = new XmlDocument ();
1348 doc.LoadXml ("<root xml:base='' />");
1352 public void GetAttribute ()
1354 StringReader sr = new StringReader("<rootElement myAttribute=\"the value\"></rootElement>");
1355 using (XmlReader reader = XmlReader.Create(sr)) {
1357 Assert.AreEqual (reader.GetAttribute("myAttribute", null), "the value", "#1");
1361 [Test] // bug #675384
1362 public void ReadCharsWithVeryLimitedBuffer ()
1364 var r = new XmlTextReader ("<root><child>a</child></root>", XmlNodeType.Document, null);
1366 char [] buff = new char [1];
1368 var sb = new StringBuilder ();
1370 read = r.ReadChars (buff, 0, buff.Length);
1372 sb.Append (buff [0]);
1374 Assert.AreEqual ("<child>a</child>", sb.ToString (), "#1");
1378 public void BOMLessUTF16Detection () // bug #674580
1380 var ms = new MemoryStream (Encoding.Unicode.GetBytes ("<root />"));
1381 var xtr = new XmlTextReader (ms);
1386 public void XmlDeclarationReadAttributeValue ()
1388 const string input = "<?xml version=\"1.0\" encoding=\"utf-8\"?><hello />";
1389 var reader = new XmlTextReader (new StringReader (input));
1390 reader.WhitespaceHandling = WhitespaceHandling.All;
1393 Assert.AreEqual ("1.0", reader.GetAttribute ("version"), "#0");
1394 Assert.AreEqual ("utf-8", reader.GetAttribute ("encoding"), "#0-2");
1396 Assert.IsTrue (reader.MoveToNextAttribute (), "#1");
1397 Assert.AreEqual ("1.0", reader.Value, "#1-1");
1398 Assert.IsTrue (reader.ReadAttributeValue (), "#2");
1399 Assert.AreEqual ("1.0", reader.Value, "#3");
1400 Assert.IsFalse (reader.ReadAttributeValue (), "#4");
1402 Assert.IsTrue (reader.MoveToNextAttribute (), "#5");
1403 Assert.AreEqual ("utf-8", reader.Value, "#5-1");
1404 Assert.IsTrue (reader.ReadAttributeValue (), "#6");
1405 Assert.AreEqual ("utf-8", reader.Value, "#7");
1406 Assert.IsFalse (reader.ReadAttributeValue (), "#8");
1408 Assert.IsFalse (reader.MoveToNextAttribute (), "#9");
1409 Assert.IsFalse (reader.ReadAttributeValue (), "#10");
1413 public void XmlDeclarationReadAttributeValue2 ()
1415 const string input = "<?xml version=\"1.0\" encoding=\"utf-8\"?><hello />";
1416 var reader = new XmlTextReader (new StringReader (input));
1417 reader.WhitespaceHandling = WhitespaceHandling.All;
1419 Assert.IsTrue (reader.MoveToNextAttribute (), "#1a");
1420 Assert.IsTrue (reader.ReadAttributeValue (), "#1b");
1421 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#1c");
1422 Assert.AreEqual ("1.0", reader.Value, "#1d");
1423 Assert.IsFalse (reader.ReadAttributeValue(), "#1e");
1425 Assert.IsTrue (reader.MoveToNextAttribute(), "#2a");
1426 Assert.IsTrue (reader.ReadAttributeValue(), "#2b");
1427 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#2c");
1428 Assert.AreEqual ("utf-8", reader.Value, "#2d");
1429 Assert.IsFalse (reader.ReadAttributeValue(), "#2e");
1431 Assert.IsFalse (reader.MoveToNextAttribute(), "#3");
1432 Assert.IsFalse (reader.ReadAttributeValue(), "#4");
1433 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#5");
1437 public void Whitespaces ()
1439 const string xml = "<?xml version=\"1.0\"?><test> <foo name=\"Hello\"> <value>World</value> </foo> <foo name=\"Foo\"><value>Bar</value></foo></test>";
1440 var reader = new XmlTextReader (new StringReader (xml));
1441 //reader.WhitespaceHandling = WhitespaceHandling.All;
1444 Assert.AreEqual (XmlNodeType.XmlDeclaration, reader.NodeType, "#1a");
1446 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#1b");
1447 Assert.AreEqual ("test", reader.Name, "#1c");
1450 if (reader.NodeType == XmlNodeType.Whitespace)
1453 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#2a");
1454 Assert.AreEqual ("foo", reader.Name, "#2b");
1456 var doc = new XmlDocument ();
1457 //doc.PreserveWhitespace = true;
1458 doc.ReadNode (reader);
1460 Assert.AreEqual (XmlNodeType.Whitespace, reader.NodeType, "#3");
1463 if (reader.NodeType == XmlNodeType.Whitespace)
1466 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#4");
1467 Assert.AreEqual ("foo", reader.Name, "#4b");
1469 doc.ReadNode (reader);
1471 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#5");