2 // System.Xml.XmlReaderCommonTests
\r
5 // Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
\r
7 // (C) 2003 Atsushi Enomoto
\r
8 // Note: Most of testcases are moved from XmlTextReaderTests.cs and
\r
9 // XmlNodeReaderTests.cs.
\r
16 using System.Xml.Schema;
\r
17 using System.Xml.XPath;
\r
19 using NUnit.Framework;
\r
21 namespace MonoTests.System.Xml
\r
24 public class XmlReaderTests : Assertion
\r
27 public void GetReady ()
\r
29 document = new XmlDocument ();
\r
30 document.LoadXml (xml1);
\r
33 XmlDocument document;
\r
34 const string xml1 = "<root attr1='value1'><child /></root>";
\r
35 const string xml2 = "<root><foo/><bar>test.</bar></root>";
\r
36 const string xml3 = "<root> test of <b>mixed</b> string.<![CDATA[ cdata string.]]></root>";
\r
37 const string xml4 = "<root>test of <b>mixed</b> string.</root>";
\r
41 // copy from XmlTextReaderTests
\r
42 private void AssertStartDocument (XmlReader xmlReader)
\r
44 Assert (xmlReader.ReadState == ReadState.Initial);
\r
45 Assert (xmlReader.NodeType == XmlNodeType.None);
\r
46 Assert (xmlReader.Depth == 0);
\r
47 Assert (!xmlReader.EOF);
\r
50 private void AssertNode (
\r
51 XmlReader xmlReader,
\r
52 XmlNodeType nodeType,
\r
54 bool isEmptyElement,
\r
58 string namespaceURI,
\r
62 AssertNode ("", xmlReader, nodeType, depth,
\r
63 isEmptyElement, name, prefix, localName,
\r
64 namespaceURI, value, attributeCount);
\r
67 private void AssertNode (
\r
69 XmlReader xmlReader,
\r
70 XmlNodeType nodeType,
\r
72 bool isEmptyElement,
\r
76 string namespaceURI,
\r
80 Assert (label + " Read() return value", xmlReader.Read ());
\r
81 Assert (label + " ReadState", xmlReader.ReadState == ReadState.Interactive);
\r
82 Assert (label + " !EOF", !xmlReader.EOF);
\r
83 AssertNodeValues (label, xmlReader, nodeType, depth,
\r
84 isEmptyElement, name, prefix, localName,
\r
85 namespaceURI, value, value != String.Empty,
\r
86 attributeCount, attributeCount > 0);
\r
89 private void AssertNodeValues (
\r
91 XmlReader xmlReader,
\r
92 XmlNodeType nodeType,
\r
94 bool isEmptyElement,
\r
98 string namespaceURI,
\r
100 int attributeCount)
\r
102 AssertNodeValues (label, xmlReader, nodeType, depth,
\r
103 isEmptyElement, name, prefix, localName,
\r
104 namespaceURI, value, value != String.Empty,
\r
105 attributeCount, attributeCount > 0);
\r
108 private void AssertNodeValues (
\r
110 XmlReader xmlReader,
\r
111 XmlNodeType nodeType,
\r
113 bool isEmptyElement,
\r
117 string namespaceURI,
\r
120 int attributeCount,
\r
121 bool hasAttributes)
\r
123 label = String.Concat (label, "(", xmlReader.GetType ().Name, ")");
\r
124 AssertEquals (label + ": NodeType", nodeType, xmlReader.NodeType);
\r
125 AssertEquals (label + ": IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);
\r
127 AssertEquals (label + ": name", name, xmlReader.Name);
\r
129 AssertEquals (label + ": prefix", prefix, xmlReader.Prefix);
\r
131 AssertEquals (label + ": localName", localName, xmlReader.LocalName);
\r
133 AssertEquals (label + ": namespaceURI", namespaceURI, xmlReader.NamespaceURI);
\r
135 AssertEquals (label + ": Depth", depth, xmlReader.Depth);
\r
137 AssertEquals (label + ": hasValue", hasValue, xmlReader.HasValue);
\r
139 AssertEquals (label + ": Value", value, xmlReader.Value);
\r
141 AssertEquals (label + ": hasAttributes", hasAttributes, xmlReader.HasAttributes);
\r
143 AssertEquals (label + ": attributeCount", attributeCount, xmlReader.AttributeCount);
\r
146 private void AssertAttribute (
\r
147 XmlReader xmlReader,
\r
151 string namespaceURI,
\r
154 AssertEquals ("value", value, xmlReader [name]);
\r
156 Assert (xmlReader.GetAttribute (name) == value);
\r
158 if (namespaceURI != String.Empty) {
\r
159 Assert (xmlReader[localName, namespaceURI] == value);
\r
160 Assert (xmlReader.GetAttribute (localName, namespaceURI) == value);
\r
164 private void AssertEndDocument (XmlReader xmlReader)
\r
166 Assert ("could read", !xmlReader.Read ());
\r
167 AssertEquals ("NodeType is not XmlNodeType.None", XmlNodeType.None, xmlReader.NodeType);
\r
168 AssertEquals ("Depth is not 0", 0, xmlReader.Depth);
\r
169 AssertEquals ("ReadState is not ReadState.EndOfFile", ReadState.EndOfFile, xmlReader.ReadState);
\r
170 Assert ("not EOF", xmlReader.EOF);
\r
172 xmlReader.Close ();
\r
173 AssertEquals ("ReadState is not ReadState.Cosed", ReadState.Closed, xmlReader.ReadState);
\r
176 private delegate void TestMethod (XmlReader reader);
\r
178 private void RunTest (string xml, TestMethod method)
\r
180 xtr = new XmlTextReader (new StringReader (xml));
\r
184 xtr = new XmlTextReader (new StringReader (xml));
\r
185 XmlValidatingReader xvr = new XmlValidatingReader (xtr);
\r
186 xvr.ValidationType = ValidationType.DTD;
\r
187 xvr.EntityHandling = EntityHandling.ExpandCharEntities;
\r
191 xtr = new XmlTextReader (new StringReader (xml));
\r
192 xvr = new XmlValidatingReader (xtr);
\r
193 xvr.EntityHandling = EntityHandling.ExpandCharEntities;
\r
196 document.XmlResolver = null;
\r
197 document.LoadXml (xml);
\r
198 xnr = new XmlNodeReader (document);
\r
202 // XPathNavigatorReader tests
\r
203 System.Xml.XPath.XPathDocument doc = new System.Xml.XPath.XPathDocument (new StringReader (xml));
\r
204 XmlReader xpr = doc.CreateNavigator ().ReadSubtree ();
\r
215 public void InitialState ()
\r
217 RunTest (xml1, new TestMethod (InitialState));
\r
220 private void InitialState (XmlReader reader)
\r
222 AssertEquals ("Depth", 0, reader.Depth);
\r
223 AssertEquals ("EOF", false, reader.EOF);
\r
224 AssertEquals ("HasValue", false, reader.HasValue);
\r
225 AssertEquals ("IsEmptyElement", false, reader.IsEmptyElement);
\r
226 AssertEquals ("LocalName", String.Empty, reader.LocalName);
\r
227 AssertEquals ("NodeType", XmlNodeType.None, reader.NodeType);
\r
228 AssertEquals ("ReadState", ReadState.Initial, reader.ReadState);
\r
232 public void Read ()
\r
234 RunTest (xml1, new TestMethod (Read));
\r
237 public void Read (XmlReader reader)
\r
240 AssertEquals ("<root>.NodeType", XmlNodeType.Element, reader.NodeType);
\r
241 AssertEquals ("<root>.Name", "root", reader.Name);
\r
242 AssertEquals ("<root>.ReadState", ReadState.Interactive, reader.ReadState);
\r
243 AssertEquals ("<root>.Depth", 0, reader.Depth);
\r
247 AssertEquals ("<child/>.Depth", 1, reader.Depth);
\r
248 AssertEquals ("<child/>.NodeType", XmlNodeType.Element, reader.NodeType);
\r
249 AssertEquals ("<child/>.Name", "child", reader.Name);
\r
252 AssertEquals ("</root>.Depth", 0, reader.Depth);
\r
253 AssertEquals ("</root>.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
254 AssertEquals ("</root>.Name", "root", reader.Name);
\r
257 AssertEquals ("end.EOF", true, reader.EOF);
\r
258 AssertEquals ("end.NodeType", XmlNodeType.None, reader.NodeType);
\r
262 [Category ("NotDotNet")]
\r
263 public void ReadAttributeValue ()
\r
265 RunTest ("<root attr=''/>", new TestMethod (ReadAttributeValue));
\r
268 public void ReadAttributeValue (XmlReader reader)
\r
270 reader.Read (); // root
\r
271 Assert (reader.MoveToFirstAttribute ());
\r
272 // It looks like that MS.NET shows AttributeCount and
\r
273 // HasAttributes as the same as element node!
\r
274 this.AssertNodeValues ("#1",
\r
275 reader, XmlNodeType.Attribute,
\r
276 1, false, "attr", "", "attr", "", "", true, 1, true);
\r
277 Assert (reader.ReadAttributeValue ());
\r
278 // MS.NET XmlTextReader fails. Its Prefix returns
\r
279 // null instead of "". It is fixed in MS.NET 2.0.
\r
280 this.AssertNodeValues ("#2",
\r
281 reader, XmlNodeType.Text,
\r
282 2, false, "", "", "", "", "", true, 1, true);
\r
283 Assert (reader.MoveToElement ());
\r
284 this.AssertNodeValues ("#3",
\r
285 reader, XmlNodeType.Element,
\r
286 0, true, "root", "", "root", "", "", false, 1, true);
\r
290 public void ReadEmptyElement ()
\r
292 RunTest (xml2, new TestMethod (ReadEmptyElement));
\r
295 public void ReadEmptyElement (XmlReader reader)
\r
297 reader.Read (); // root
\r
298 AssertEquals (false, reader.IsEmptyElement);
\r
299 reader.Read (); // foo
\r
300 AssertEquals ("foo", reader.Name);
\r
301 AssertEquals (true, reader.IsEmptyElement);
\r
302 reader.Read (); // bar
\r
303 AssertEquals ("bar", reader.Name);
\r
304 AssertEquals (false, reader.IsEmptyElement);
\r
308 public void ReadStringFromElement ()
\r
310 RunTest (xml3, new TestMethod (ReadStringFromElement));
\r
313 public void ReadStringFromElement (XmlReader reader)
\r
315 // Note: ReadString() test works only when the reader is
\r
316 // positioned at the container element.
\r
317 // In case the reader is positioned at the first
\r
318 // character node, XmlTextReader and XmlNodeReader works
\r
322 string s = reader.ReadString ();
\r
323 AssertEquals ("readString.1.ret_val", " test of ", s);
\r
324 AssertEquals ("readString.1.Name", "b", reader.Name);
\r
325 s = reader.ReadString ();
\r
326 AssertEquals ("readString.2.ret_val", "mixed", s);
\r
327 AssertEquals ("readString.2.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
328 s = reader.ReadString (); // never proceeds.
\r
329 AssertEquals ("readString.3.ret_val", String.Empty, s);
\r
330 AssertEquals ("readString.3.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
332 AssertEquals ("readString.4.NodeType", XmlNodeType.Text, reader.NodeType);
\r
333 AssertEquals ("readString.4.Value", " string.", reader.Value);
\r
334 s = reader.ReadString (); // reads the same Text node.
\r
335 AssertEquals ("readString.5.ret_val", " string. cdata string.", s);
\r
336 AssertEquals ("readString.5.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
340 public void ReadInnerXml ()
\r
342 const string xml = "<root><foo>test of <b>mixed</b> string.</foo><bar /></root>";
\r
343 RunTest (xml, new TestMethod (ReadInnerXml));
\r
346 public void ReadInnerXml (XmlReader reader)
\r
350 AssertEquals ("initial.ReadState", ReadState.Interactive, reader.ReadState);
\r
351 AssertEquals ("initial.EOF", false, reader.EOF);
\r
352 AssertEquals ("initial.NodeType", XmlNodeType.Element, reader.NodeType);
\r
353 string s = reader.ReadInnerXml ();
\r
354 AssertEquals ("read_all", "test of <b>mixed</b> string.", s);
\r
355 AssertEquals ("after.Name", "bar", reader.Name);
\r
356 AssertEquals ("after.NodeType", XmlNodeType.Element, reader.NodeType);
\r
361 public void EmptyElement ()
\r
363 RunTest ("<foo/>", new TestMethod (EmptyElement));
\r
366 public void EmptyElement (XmlReader xmlReader)
\r
369 AssertStartDocument (xmlReader);
\r
372 xmlReader, // xmlReader
\r
373 XmlNodeType.Element, // nodeType
\r
375 true, // isEmptyElement
\r
377 String.Empty, // prefix
\r
378 "foo", // localName
\r
379 String.Empty, // namespaceURI
\r
380 String.Empty, // value
\r
381 0 // attributeCount
\r
384 AssertEndDocument (xmlReader);
\r
388 public void NestedEmptyTag ()
\r
390 string xml = "<foo><bar/></foo>";
\r
391 RunTest (xml, new TestMethod (NestedEmptyTag));
\r
394 public void NestedEmptyTag (XmlReader xmlReader)
\r
396 AssertStartDocument (xmlReader);
\r
400 xmlReader, // xmlReader
\r
401 XmlNodeType.Element, // nodeType
\r
403 false, // isEmptyElement
\r
405 String.Empty, // prefix
\r
406 "foo", // localName
\r
407 String.Empty, // namespaceURI
\r
408 String.Empty, // value
\r
409 0 // attributeCount
\r
414 xmlReader, // xmlReader
\r
415 XmlNodeType.Element, // nodeType
\r
417 true, // isEmptyElement
\r
419 String.Empty, // prefix
\r
420 "bar", // localName
\r
421 String.Empty, // namespaceURI
\r
422 String.Empty, // value
\r
423 0 // attributeCount
\r
428 xmlReader, // xmlReader
\r
429 XmlNodeType.EndElement, // nodeType
\r
431 false, // isEmptyElement
\r
433 String.Empty, // prefix
\r
434 "foo", // localName
\r
435 String.Empty, // namespaceURI
\r
436 String.Empty, // value
\r
437 0 // attributeCount
\r
440 AssertEndDocument (xmlReader);
\r
444 public void NestedText ()
\r
446 string xml = "<foo>bar</foo>";
\r
447 RunTest (xml, new TestMethod (NestedText));
\r
450 public void NestedText (XmlReader xmlReader)
\r
452 AssertStartDocument (xmlReader);
\r
455 xmlReader, // xmlReader
\r
456 XmlNodeType.Element, // nodeType
\r
458 false, // isEmptyElement
\r
460 String.Empty, // prefix
\r
461 "foo", // localName
\r
462 String.Empty, // namespaceURI
\r
463 String.Empty, // value
\r
464 0 // attributeCount
\r
468 xmlReader, // xmlReader
\r
469 XmlNodeType.Text, // nodeType
\r
471 false, // isEmptyElement
\r
472 String.Empty, // name
\r
473 String.Empty, // prefix
\r
474 String.Empty, // localName
\r
475 String.Empty, // namespaceURI
\r
477 0 // attributeCount
\r
481 xmlReader, // xmlReader
\r
482 XmlNodeType.EndElement, // nodeType
\r
484 false, // isEmptyElement
\r
486 String.Empty, // prefix
\r
487 "foo", // localName
\r
488 String.Empty, // namespaceURI
\r
489 String.Empty, // value
\r
490 0 // attributeCount
\r
493 AssertEndDocument (xmlReader);
\r
497 public void EmptyElementWithAttributes ()
\r
499 string xml = @"<foo bar=""baz"" quux='quuux' x:foo='x-foo' xmlns:x = 'urn:xfoo' />";
\r
500 RunTest (xml, new TestMethod (EmptyElementWithAttributes ));
\r
503 public void EmptyElementWithAttributes (XmlReader xmlReader)
\r
506 AssertStartDocument (xmlReader);
\r
509 xmlReader, // xmlReader
\r
510 XmlNodeType.Element, // nodeType
\r
512 true, // isEmptyElement
\r
514 String.Empty, // prefix
\r
515 "foo", // localName
\r
516 String.Empty, // namespaceURI
\r
517 String.Empty, // value
\r
518 4 // attributeCount
\r
522 xmlReader, // xmlReader
\r
524 String.Empty, // prefix
\r
525 "bar", // localName
\r
526 String.Empty, // namespaceURI
\r
531 xmlReader, // xmlReader
\r
533 String.Empty, // prefix
\r
534 "quux", // localName
\r
535 String.Empty, // namespaceURI
\r
540 xmlReader, // xmlReader
\r
541 "notexist", // name
\r
542 String.Empty, // prefix
\r
543 "notexist", // localName
\r
544 String.Empty, // namespaceURI
\r
549 xmlReader, // xmlReader
\r
552 "foo", // localName
\r
553 "urn:xfoo", // namespaceURI
\r
558 xmlReader, // xmlReader
\r
561 "bar", // localName
\r
562 "urn:xfoo", // namespaceURI
\r
566 AssertEndDocument (xmlReader);
\r
570 public void ProcessingInstructionBeforeDocumentElement ()
\r
572 string xml = "<?foo bar?><baz/>";
\r
573 RunTest (xml, new TestMethod (ProcessingInstructionBeforeDocumentElement));
\r
576 public void ProcessingInstructionBeforeDocumentElement (XmlReader xmlReader)
\r
578 AssertStartDocument (xmlReader);
\r
581 xmlReader, // xmlReader
\r
582 XmlNodeType.ProcessingInstruction, // nodeType
\r
584 false, // isEmptyElement
\r
586 String.Empty, // prefix
\r
587 "foo", // localName
\r
588 String.Empty, // namespaceURI
\r
590 0 // attributeCount
\r
594 xmlReader, // xmlReader
\r
595 XmlNodeType.Element, // nodeType
\r
597 true, // isEmptyElement
\r
599 String.Empty, // prefix
\r
600 "baz", // localName
\r
601 String.Empty, // namespaceURI
\r
602 String.Empty, // value
\r
603 0 // attributeCount
\r
606 AssertEndDocument (xmlReader);
\r
610 public void CommentBeforeDocumentElement ()
\r
612 string xml = "<!--foo--><bar/>";
\r
613 RunTest (xml, new TestMethod (CommentBeforeDocumentElement));
\r
616 public void CommentBeforeDocumentElement (XmlReader xmlReader)
\r
618 AssertStartDocument (xmlReader);
\r
621 xmlReader, // xmlReader
\r
622 XmlNodeType.Comment, // nodeType
\r
624 false, // isEmptyElement
\r
625 String.Empty, // name
\r
626 String.Empty, // prefix
\r
627 String.Empty, // localName
\r
628 String.Empty, // namespaceURI
\r
630 0 // attributeCount
\r
634 xmlReader, // xmlReader
\r
635 XmlNodeType.Element, // nodeType
\r
637 true, // isEmptyElement
\r
639 String.Empty, // prefix
\r
640 "bar", // localName
\r
641 String.Empty, // namespaceURI
\r
642 String.Empty, // value
\r
643 0 // attributeCount
\r
646 AssertEndDocument (xmlReader);
\r
650 public void PredefinedEntities ()
\r
652 string xml = "<foo><>&'"</foo>";
\r
653 RunTest (xml, new TestMethod (PredefinedEntities));
\r
656 public void PredefinedEntities (XmlReader xmlReader)
\r
658 AssertStartDocument (xmlReader);
\r
661 xmlReader, // xmlReader
\r
662 XmlNodeType.Element, // nodeType
\r
664 false, // isEmptyElement
\r
666 String.Empty, // prefix
\r
667 "foo", // localName
\r
668 String.Empty, // namespaceURI
\r
669 String.Empty, // value
\r
670 0 // attributeCount
\r
674 xmlReader, // xmlReader
\r
675 XmlNodeType.Text, // nodeType
\r
677 false, // isEmptyElement
\r
678 String.Empty, // name
\r
679 String.Empty, // prefix
\r
680 String.Empty, // localName
\r
681 String.Empty, // namespaceURI
\r
683 0 // attributeCount
\r
687 xmlReader, // xmlReader
\r
688 XmlNodeType.EndElement, // nodeType
\r
690 false, // isEmptyElement
\r
692 String.Empty, // prefix
\r
693 "foo", // localName
\r
694 String.Empty, // namespaceURI
\r
695 String.Empty, // value
\r
696 0 // attributeCount
\r
699 AssertEndDocument (xmlReader);
\r
703 public void CharacterReferences ()
\r
705 string xml = "<foo>FOO</foo>";
\r
706 RunTest (xml, new TestMethod (CharacterReferences));
\r
709 public void CharacterReferences (XmlReader xmlReader)
\r
711 AssertStartDocument (xmlReader);
\r
714 xmlReader, // xmlReader
\r
715 XmlNodeType.Element, // nodeType
\r
717 false, // isEmptyElement
\r
719 String.Empty, // prefix
\r
720 "foo", // localName
\r
721 String.Empty, // namespaceURI
\r
722 String.Empty, // value
\r
723 0 // attributeCount
\r
727 xmlReader, // xmlReader
\r
728 XmlNodeType.Text, // nodeType
\r
730 false, // isEmptyElement
\r
731 String.Empty, // name
\r
732 String.Empty, // prefix
\r
733 String.Empty, // localName
\r
734 String.Empty, // namespaceURI
\r
736 0 // attributeCount
\r
740 xmlReader, // xmlReader
\r
741 XmlNodeType.EndElement, // nodeType
\r
743 false, // isEmptyElement
\r
745 String.Empty, // prefix
\r
746 "foo", // localName
\r
747 String.Empty, // namespaceURI
\r
748 String.Empty, // value
\r
749 0 // attributeCount
\r
752 AssertEndDocument (xmlReader);
\r
756 public void PredefinedEntitiesInAttribute ()
\r
758 string xml = "<foo bar='<>&'"'/>";
\r
759 RunTest (xml, new TestMethod (PredefinedEntitiesInAttribute ));
\r
762 public void PredefinedEntitiesInAttribute (XmlReader xmlReader)
\r
764 AssertStartDocument (xmlReader);
\r
767 xmlReader, // xmlReader
\r
768 XmlNodeType.Element, // nodeType
\r
770 true, // isEmptyElement
\r
772 String.Empty, // prefix
\r
773 "foo", // localName
\r
774 String.Empty, // namespaceURI
\r
775 String.Empty, // value
\r
776 1 // attributeCount
\r
780 xmlReader, // xmlReader
\r
782 String.Empty, // prefix
\r
783 "bar", // localName
\r
784 String.Empty, // namespaceURI
\r
788 AssertEndDocument (xmlReader);
\r
792 public void CharacterReferencesInAttribute ()
\r
794 string xml = "<foo bar='FOO'/>";
\r
795 RunTest (xml, new TestMethod (CharacterReferencesInAttribute));
\r
798 public void CharacterReferencesInAttribute (XmlReader xmlReader)
\r
800 AssertStartDocument (xmlReader);
\r
803 xmlReader, // xmlReader
\r
804 XmlNodeType.Element, // nodeType
\r
806 true, // isEmptyElement
\r
808 String.Empty, // prefix
\r
809 "foo", // localName
\r
810 String.Empty, // namespaceURI
\r
811 String.Empty, // value
\r
812 1 // attributeCount
\r
816 xmlReader, // xmlReader
\r
818 String.Empty, // prefix
\r
819 "bar", // localName
\r
820 String.Empty, // namespaceURI
\r
824 AssertEndDocument (xmlReader);
\r
828 public void CDATA ()
\r
830 string xml = "<foo><![CDATA[<>&]]></foo>";
\r
831 RunTest (xml, new TestMethod (CDATA));
\r
834 public void CDATA (XmlReader xmlReader)
\r
836 AssertStartDocument (xmlReader);
\r
839 xmlReader, // xmlReader
\r
840 XmlNodeType.Element, // nodeType
\r
842 false, // isEmptyElement
\r
844 String.Empty, // prefix
\r
845 "foo", // localName
\r
846 String.Empty, // namespaceURI
\r
847 String.Empty, // value
\r
848 0 // attributeCount
\r
852 xmlReader, // xmlReader
\r
853 XmlNodeType.CDATA, // nodeType
\r
855 false, // isEmptyElement
\r
856 String.Empty, // name
\r
857 String.Empty, // prefix
\r
858 String.Empty, // localName
\r
859 String.Empty, // namespaceURI
\r
861 0 // attributeCount
\r
865 xmlReader, // xmlReader
\r
866 XmlNodeType.EndElement, // nodeType
\r
868 false, // isEmptyElement
\r
870 String.Empty, // prefix
\r
871 "foo", // localName
\r
872 String.Empty, // namespaceURI
\r
873 String.Empty, // value
\r
874 0 // attributeCount
\r
877 AssertEndDocument (xmlReader);
\r
881 public void EmptyElementInDefaultNamespace ()
\r
883 string xml = @"<foo xmlns='http://foo/' />";
\r
884 RunTest (xml, new TestMethod (EmptyElementInDefaultNamespace));
\r
887 public void EmptyElementInDefaultNamespace (XmlReader xmlReader)
\r
889 AssertStartDocument (xmlReader);
\r
892 xmlReader, // xmlReader
\r
893 XmlNodeType.Element, // nodeType
\r
895 true, // isEmptyElement
\r
897 String.Empty, // prefix
\r
898 "foo", // localName
\r
899 "http://foo/", // namespaceURI
\r
900 String.Empty, // value
\r
901 1 // attributeCount
\r
905 xmlReader, // xmlReader
\r
907 String.Empty, // prefix
\r
908 "xmlns", // localName
\r
909 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
910 "http://foo/" // value
\r
913 AssertEquals ("http://foo/", xmlReader.LookupNamespace (String.Empty));
\r
915 AssertEndDocument (xmlReader);
\r
919 public void ChildElementInNamespace ()
\r
921 string xml = @"<foo:bar xmlns:foo='http://foo/'><baz:quux xmlns:baz='http://baz/' /></foo:bar>";
\r
922 RunTest (xml, new TestMethod (ChildElementInNamespace));
\r
925 public void ChildElementInNamespace (XmlReader xmlReader)
\r
927 AssertStartDocument (xmlReader);
\r
930 xmlReader, // xmlReader
\r
931 XmlNodeType.Element, // nodeType
\r
933 false, // isEmptyElement
\r
936 "bar", // localName
\r
937 "http://foo/", // namespaceURI
\r
938 String.Empty, // value
\r
939 1 // attributeCount
\r
943 xmlReader, // xmlReader
\r
944 "xmlns:foo", // name
\r
946 "foo", // localName
\r
947 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
948 "http://foo/" // value
\r
951 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
954 xmlReader, // xmlReader
\r
955 XmlNodeType.Element, // nodeType
\r
957 true, // isEmptyElement
\r
958 "baz:quux", // name
\r
960 "quux", // localName
\r
961 "http://baz/", // namespaceURI
\r
962 String.Empty, // value
\r
963 1 // attributeCount
\r
967 xmlReader, // xmlReader
\r
968 "xmlns:baz", // name
\r
970 "baz", // localName
\r
971 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
972 "http://baz/" // value
\r
975 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
976 AssertEquals ("http://baz/", xmlReader.LookupNamespace ("baz"));
\r
979 xmlReader, // xmlReader
\r
980 XmlNodeType.EndElement, // nodeType
\r
982 false, // isEmptyElement
\r
985 "bar", // localName
\r
986 "http://foo/", // namespaceURI
\r
987 String.Empty, // value
\r
988 0 // attributeCount
\r
991 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
992 AssertNull (xmlReader.LookupNamespace ("baz"));
\r
994 AssertEndDocument (xmlReader);
\r
998 public void ChildElementInDefaultNamespace ()
\r
1000 string xml = @"<foo:bar xmlns:foo='http://foo/'><baz xmlns='http://baz/' /></foo:bar>";
\r
1001 RunTest (xml, new TestMethod (ChildElementInDefaultNamespace));
\r
1004 public void ChildElementInDefaultNamespace (XmlReader xmlReader)
\r
1006 AssertStartDocument (xmlReader);
\r
1009 xmlReader, // xmlReader
\r
1010 XmlNodeType.Element, // nodeType
\r
1012 false, // isEmptyElement
\r
1013 "foo:bar", // name
\r
1015 "bar", // localName
\r
1016 "http://foo/", // namespaceURI
\r
1017 String.Empty, // value
\r
1018 1 // attributeCount
\r
1022 xmlReader, // xmlReader
\r
1023 "xmlns:foo", // name
\r
1024 "xmlns", // prefix
\r
1025 "foo", // localName
\r
1026 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
1027 "http://foo/" // value
\r
1030 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
1033 xmlReader, // xmlReader
\r
1034 XmlNodeType.Element, // nodeType
\r
1036 true, // isEmptyElement
\r
1038 String.Empty, // prefix
\r
1039 "baz", // localName
\r
1040 "http://baz/", // namespaceURI
\r
1041 String.Empty, // value
\r
1042 1 // attributeCount
\r
1046 xmlReader, // xmlReader
\r
1048 String.Empty, // prefix
\r
1049 "xmlns", // localName
\r
1050 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
1051 "http://baz/" // value
\r
1054 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
1055 AssertEquals ("http://baz/", xmlReader.LookupNamespace (String.Empty));
\r
1058 xmlReader, // xmlReader
\r
1059 XmlNodeType.EndElement, // nodeType
\r
1061 false, // isEmptyElement
\r
1062 "foo:bar", // name
\r
1064 "bar", // localName
\r
1065 "http://foo/", // namespaceURI
\r
1066 String.Empty, // value
\r
1067 0 // attributeCount
\r
1070 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
1072 AssertEndDocument (xmlReader);
\r
1076 public void AttributeInNamespace ()
\r
1078 string xml = @"<foo bar:baz='quux' xmlns:bar='http://bar/' />";
\r
1079 RunTest (xml, new TestMethod (AttributeInNamespace));
\r
1082 public void AttributeInNamespace (XmlReader xmlReader)
\r
1084 AssertStartDocument (xmlReader);
\r
1087 xmlReader, // xmlReader
\r
1088 XmlNodeType.Element, // nodeType
\r
1090 true, // isEmptyElement
\r
1092 String.Empty, // prefix
\r
1093 "foo", // localName
\r
1094 String.Empty, // namespaceURI
\r
1095 String.Empty, // value
\r
1096 2 // attributeCount
\r
1100 xmlReader, // xmlReader
\r
1101 "bar:baz", // name
\r
1103 "baz", // localName
\r
1104 "http://bar/", // namespaceURI
\r
1109 xmlReader, // xmlReader
\r
1110 "xmlns:bar", // name
\r
1111 "xmlns", // prefix
\r
1112 "bar", // localName
\r
1113 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
1114 "http://bar/" // value
\r
1117 AssertEquals ("http://bar/", xmlReader.LookupNamespace ("bar"));
\r
1119 AssertEndDocument (xmlReader);
\r
1123 public void MoveToElementFromAttribute ()
\r
1125 string xml = @"<foo bar=""baz"" />";
\r
1126 RunTest (xml, new TestMethod (MoveToElementFromAttribute));
\r
1129 public void MoveToElementFromAttribute (XmlReader xmlReader)
\r
1131 Assert (xmlReader.Read ());
\r
1132 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1133 Assert (xmlReader.MoveToFirstAttribute ());
\r
1134 AssertEquals (XmlNodeType.Attribute, xmlReader.NodeType);
\r
1135 Assert (xmlReader.MoveToElement ());
\r
1136 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1140 public void MoveToElementFromElement ()
\r
1142 string xml = @"<foo bar=""baz"" />";
\r
1143 RunTest (xml, new TestMethod (MoveToElementFromElement));
\r
1146 public void MoveToElementFromElement (XmlReader xmlReader)
\r
1148 Assert (xmlReader.Read ());
\r
1149 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1150 Assert (!xmlReader.MoveToElement ());
\r
1151 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1155 public void MoveToFirstAttributeWithNoAttributes ()
\r
1157 string xml = @"<foo />";
\r
1158 RunTest (xml, new TestMethod (MoveToFirstAttributeWithNoAttributes));
\r
1161 public void MoveToFirstAttributeWithNoAttributes (XmlReader xmlReader)
\r
1163 Assert (xmlReader.Read ());
\r
1164 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1165 Assert (!xmlReader.MoveToFirstAttribute ());
\r
1166 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1170 public void MoveToNextAttributeWithNoAttributes ()
\r
1172 string xml = @"<foo />";
\r
1173 RunTest (xml, new TestMethod (MoveToNextAttributeWithNoAttributes));
\r
1176 public void MoveToNextAttributeWithNoAttributes (XmlReader xmlReader)
\r
1178 Assert (xmlReader.Read ());
\r
1179 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1180 Assert (!xmlReader.MoveToNextAttribute ());
\r
1181 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1185 public void MoveToNextAttribute()
\r
1187 string xml = @"<foo bar=""baz"" quux='quuux'/>";
\r
1188 RunTest (xml, new TestMethod (MoveToNextAttribute));
\r
1191 public void MoveToNextAttribute (XmlReader xmlReader)
\r
1193 AssertStartDocument (xmlReader);
\r
1196 xmlReader, // xmlReader
\r
1197 XmlNodeType.Element, // nodeType
\r
1199 true, // isEmptyElement
\r
1201 String.Empty, // prefix
\r
1202 "foo", // localName
\r
1203 String.Empty, // namespaceURI
\r
1204 String.Empty, // value
\r
1205 2 // attributeCount
\r
1209 xmlReader, // xmlReader
\r
1211 String.Empty, // prefix
\r
1212 "bar", // localName
\r
1213 String.Empty, // namespaceURI
\r
1218 xmlReader, // xmlReader
\r
1220 String.Empty, // prefix
\r
1221 "quux", // localName
\r
1222 String.Empty, // namespaceURI
\r
1226 Assert (xmlReader.MoveToNextAttribute ());
\r
1227 AssertEquals ("bar", xmlReader.Name);
\r
1228 AssertEquals ("baz", xmlReader.Value);
\r
1230 Assert (xmlReader.MoveToNextAttribute ());
\r
1231 AssertEquals ("quux", xmlReader.Name);
\r
1232 AssertEquals ("quuux", xmlReader.Value);
\r
1234 Assert (!xmlReader.MoveToNextAttribute ());
\r
1236 Assert (xmlReader.MoveToElement ());
\r
1238 AssertNodeValues (
\r
1240 xmlReader, // xmlReader
\r
1241 XmlNodeType.Element, // nodeType
\r
1243 true, // isEmptyElement
\r
1245 String.Empty, // prefix
\r
1246 "foo", // localName
\r
1247 String.Empty, // namespaceURI
\r
1248 String.Empty, // value
\r
1249 2 // attributeCount
\r
1252 AssertEndDocument (xmlReader);
\r
1256 // [Category ("NotDotNet")] // MS XmlNodeReader never moves to xml declaration.
\r
1257 [Ignore ("Too inconsistent reference implementations to determine which is correct behavior.")]
\r
1258 public void MoveToXmlDeclAttributes ()
\r
1260 string xml = "<?xml version=\"1.0\" standalone=\"yes\"?><root/>";
\r
1261 RunTest (xml, new TestMethod (MoveToXmlDeclAttributes));
\r
1264 public void MoveToXmlDeclAttributes (XmlReader xmlReader)
\r
1266 xmlReader.Read ();
\r
1267 this.AssertNodeValues ("#1", xmlReader,
\r
1268 XmlNodeType.XmlDeclaration,
\r
1275 "version=\"1.0\" standalone=\"yes\"",
\r
1277 Assert ("MoveToFirstAttribute",
\r
1278 xmlReader.MoveToFirstAttribute ());
\r
1279 this.AssertNodeValues ("#2", xmlReader,
\r
1280 XmlNodeType.Attribute,
\r
1281 0, // FIXME: might be 1
\r
1289 xmlReader.ReadAttributeValue ();
\r
1290 this.AssertNodeValues ("#3", xmlReader,
\r
1292 1, // FIXME might be 2
\r
1295 null, // FIXME: should be String.Empty,
\r
1297 null, // FIXME: should be String.Empty,
\r
1300 xmlReader.MoveToNextAttribute ();
\r
1301 this.AssertNodeValues ("#4", xmlReader,
\r
1302 XmlNodeType.Attribute,
\r
1303 0, // FIXME: might be 1
\r
1311 xmlReader.ReadAttributeValue ();
\r
1312 this.AssertNodeValues ("#5", xmlReader,
\r
1314 1, // FIXME: might be 2
\r
1317 null, // FIXME: should be String.Empty,
\r
1319 null, // FIXME: should be String.Empty,
\r
1325 public void AttributeOrder ()
\r
1327 string xml = @"<foo _1='1' _2='2' _3='3' />";
\r
1328 RunTest (xml, new TestMethod (AttributeOrder));
\r
1331 public void AttributeOrder (XmlReader xmlReader)
\r
1333 Assert (xmlReader.Read ());
\r
1334 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1336 Assert (xmlReader.MoveToFirstAttribute ());
\r
1337 AssertEquals ("_1", xmlReader.Name);
\r
1338 Assert (xmlReader.MoveToNextAttribute ());
\r
1339 AssertEquals ("_2", xmlReader.Name);
\r
1340 Assert (xmlReader.MoveToNextAttribute ());
\r
1341 AssertEquals ("_3", xmlReader.Name);
\r
1343 Assert (!xmlReader.MoveToNextAttribute ());
\r
1347 [Category ("NotDotNet")]
\r
1348 public void IndexerAndAttributes ()
\r
1350 string xml = @"<?xml version='1.0' standalone='no'?><foo _1='1' _2='2' _3='3' />";
\r
1351 RunTest (xml, new TestMethod (IndexerAndAttributes));
\r
1354 public void IndexerAndAttributes (XmlReader xmlReader)
\r
1356 Assert (xmlReader.Read ());
\r
1357 AssertEquals ("1.0", xmlReader ["version"]);
\r
1358 AssertEquals ("1.0", xmlReader.GetAttribute ("version"));
\r
1359 // .NET 1.1 BUG. XmlTextReader returns null, while XmlNodeReader returns "".
\r
1360 AssertEquals (null, xmlReader ["encoding"]);
\r
1361 AssertEquals (null, xmlReader.GetAttribute ("encoding"));
\r
1362 AssertEquals ("no", xmlReader ["standalone"]);
\r
1363 AssertEquals ("no", xmlReader.GetAttribute ("standalone"));
\r
1364 AssertEquals ("1.0", xmlReader [0]);
\r
1365 AssertEquals ("1.0", xmlReader.GetAttribute (0));
\r
1366 AssertEquals ("no", xmlReader [1]);
\r
1367 AssertEquals ("no", xmlReader.GetAttribute (1));
\r
1369 Assert (xmlReader.Read ());
\r
1370 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1371 AssertEquals ("1", xmlReader ["_1"]);
\r
1373 Assert (xmlReader.MoveToFirstAttribute ());
\r
1374 AssertEquals ("_1", xmlReader.Name);
\r
1375 AssertEquals ("1", xmlReader ["_1"]);
\r
1376 Assert (xmlReader.MoveToNextAttribute ());
\r
1377 AssertEquals ("_2", xmlReader.Name);
\r
1378 AssertEquals ("1", xmlReader ["_1"]);
\r
1379 Assert (xmlReader.MoveToNextAttribute ());
\r
1380 AssertEquals ("_3", xmlReader.Name);
\r
1381 AssertEquals ("1", xmlReader ["_1"]);
\r
1383 Assert (!xmlReader.MoveToNextAttribute ());
\r
1387 public void ProhibitedMultipleAttributes ()
\r
1389 string xml = @"<foo _1='1' _1='1' />";
\r
1391 RunTest (xml, new TestMethod (ReadAll));
\r
1392 } catch (XmlException) {
\r
1394 xml = @"<foo _1='1' _1='2' />";
\r
1396 RunTest (xml, new TestMethod (ReadAll));
\r
1397 } catch (XmlException) {
\r
1401 public void ReadAll (XmlReader xmlReader)
\r
1403 while (!xmlReader.EOF)
\r
1404 xmlReader.Read ();
\r
1408 public void SurrogatePairContent ()
\r
1410 string xml = "<root xmlns='𐄀'/>";
\r
1411 RunTest (xml, new TestMethod (SurrogatePairContent));
\r
1414 public void SurrogatePairContent (XmlReader xmlReader)
\r
1416 xmlReader.Read ();
\r
1417 AssertEquals (true, xmlReader.MoveToAttribute ("xmlns"));
\r
1418 AssertEquals ("xmlns", xmlReader.Name);
\r
1419 AssertEquals (2, xmlReader.Value.Length);
\r
1420 AssertEquals (0xD800, (int) xmlReader.Value [0]);
\r
1421 AssertEquals (0xDD00, (int) xmlReader.Value [1]);
\r
1425 public void ReadOuterXmlOnEndElement ()
\r
1427 string xml = "<root><foo></foo></root>";
\r
1428 RunTest (xml, new TestMethod (ReadOuterXmlOnEndElement));
\r
1431 public void ReadOuterXmlOnEndElement (XmlReader xmlReader)
\r
1433 xmlReader.Read ();
\r
1434 xmlReader.Read ();
\r
1435 xmlReader.Read ();
\r
1436 AssertEquals (String.Empty, xmlReader.ReadOuterXml ());
\r
1440 public void ReadInnerXmlOnEndElement ()
\r
1442 string xml = "<root><foo></foo></root>";
\r
1443 RunTest (xml, new TestMethod (ReadInnerXmlOnEndElement));
\r
1446 private void ReadInnerXmlOnEndElement (XmlReader xmlReader)
\r
1448 xmlReader.Read ();
\r
1449 xmlReader.Read ();
\r
1450 xmlReader.Read ();
\r
1451 AssertEquals (String.Empty, xmlReader.ReadInnerXml ());
\r
1455 public void LookupEmptyPrefix ()
\r
1457 string xml = "<root><foo></foo></root>";
\r
1458 RunTest (xml, new TestMethod (LookupEmptyPrefix));
\r
1461 void LookupEmptyPrefix (XmlReader xmlReader)
\r
1463 xmlReader.Read ();
\r
1464 AssertNull (xmlReader.LookupNamespace (String.Empty));
\r
1468 public void ReadStartElement ()
\r
1470 string xml = "<root>test</root>";
\r
1471 RunTest (xml, new TestMethod (ReadStartElement));
\r
1474 void ReadStartElement (XmlReader xr)
\r
1477 xr.ReadStartElement ();
\r
1478 // consume Element node.
\r
1479 AssertEquals (XmlNodeType.Text, xr.NodeType);
\r
1483 public void LookupNamespaceAtEndElement ()
\r
1485 string xml = "<root xmlns:x='urn:foo'><foo/></root>";
\r
1486 RunTest (xml, new TestMethod (LookupNamespaceAtEndElement));
\r
1489 void LookupNamespaceAtEndElement (XmlReader reader)
\r
1492 AssertEquals ("#1", "urn:foo", reader.LookupNamespace ("x"));
\r
1494 AssertEquals ("#2", "urn:foo", reader.LookupNamespace ("x"));
\r
1496 AssertEquals ("#3", "urn:foo", reader.LookupNamespace ("x"));
\r
1500 public void ReadClosedReader ()
\r
1502 string xml = "<fin>aaa</fin>";
\r
1503 RunTest (xml, new TestMethod (ReadClosedReader));
\r
1506 void ReadClosedReader (XmlReader reader)
\r
1510 reader.Read (); // silently returns false
\r
1515 public void CreateSimple ()
\r
1517 XmlReaderSettings s = new XmlReaderSettings ();
\r
1518 s.ProhibitDtd = false;
\r
1519 XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml", s);
\r
1521 AssertEquals ("#1", XmlNodeType.DocumentType, xr.NodeType);
\r
1523 AssertEquals ("#2", XmlNodeType.Whitespace, xr.NodeType);
\r
1525 AssertEquals ("#3", XmlNodeType.Element, xr.NodeType);
\r
1529 [ExpectedException (typeof (XmlException))]
\r
1530 public void CreateSimpleProhibitDtd ()
\r
1532 XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml");
\r
1537 // a bit revised version of bug #78706
\r
1538 public void CreateFromUrlClose ()
\r
1540 string file = "Test/XmlFiles/78706.xml";
\r
1542 if (!File.Exists (file))
\r
1543 File.Create (file).Close ();
\r
1544 XmlReaderSettings s = new XmlReaderSettings ();
\r
1545 s.CloseInput = false; // explicitly
\r
1546 XmlReader r = XmlReader.Create (file, s);
\r
1548 XmlTextWriter w = new XmlTextWriter (file, null);
\r
1551 if (File.Exists (file))
\r
1552 File.Delete (file);
\r
1557 public void ReadToDescendant ()
\r
1559 string xml = @"<root><foo/><bar/><foo> test text <bar><bar></bar></bar></foo></root>";
\r
1560 RunTest (xml, new TestMethod (ReadToDescendant));
\r
1563 void ReadToDescendant (XmlReader xmlReader)
\r
1565 // move to first <bar/>
\r
1566 Assert ("#1", xmlReader.ReadToDescendant ("bar"));
\r
1567 // no children in <bar/>. It is empty.
\r
1568 Assert ("#2", !xmlReader.ReadToDescendant ("bar"));
\r
1569 AssertEquals ("#2-2", "bar", xmlReader.Name);
\r
1571 // move to the second <foo>
\r
1572 xmlReader.Read ();
\r
1573 // move to the second <bar>
\r
1574 Assert ("#3", xmlReader.ReadToDescendant ("bar"));
\r
1575 // move to <bar> inside <bar>...</bar>
\r
1576 Assert ("#4", xmlReader.ReadToDescendant ("bar"));
\r
1577 // the next is EndElement of </bar>, so no move.
\r
1578 Assert ("#5", !xmlReader.ReadToDescendant ("bar"));
\r
1579 AssertEquals ("#5-2", XmlNodeType.EndElement, xmlReader.NodeType);
\r
1583 public void ReadToDescepdant2 ()
\r
1585 string xml = "<root/>";
\r
1586 RunTest (xml, new TestMethod (ReadToDescendant2));
\r
1589 void ReadToDescendant2 (XmlReader xmlReader)
\r
1591 // make sure that it works when the reader is at Initial state.
\r
1592 Assert (xmlReader.ReadToDescendant ("root"));
\r
1596 public void ReadToFollowing ()
\r
1598 string xml = @"<root><foo/><bar/><foo><bar><bar></bar></bar></foo></root>";
\r
1599 RunTest (xml, new TestMethod (ReadToFollowing));
\r
1602 public void ReadToFollowing (XmlReader xmlReader)
\r
1604 Assert ("#1", xmlReader.ReadToFollowing ("bar"));
\r
1605 Assert ("#2", xmlReader.ReadToFollowing ("bar"));
\r
1606 AssertEquals ("#2-2", 2, xmlReader.Depth);
\r
1607 Assert ("#3", xmlReader.ReadToFollowing ("bar"));
\r
1608 AssertEquals ("#3-2", 3, xmlReader.Depth);
\r
1609 Assert ("#4", !xmlReader.ReadToFollowing ("bar"));
\r
1613 [Category ("NotDotNet")]
\r
1614 public void ReadToNextSiblingAtInitialState ()
\r
1616 string xml = @"<root></root>";
\r
1617 RunTest (xml, new TestMethod (ReadToNextSiblingAtInitialState ));
\r
1620 void ReadToNextSiblingAtInitialState (XmlReader xmlReader)
\r
1622 Assert ("#1", !xmlReader.ReadToNextSibling ("bar"));
\r
1623 Assert ("#2", !xmlReader.ReadToNextSibling ("root"));
\r
1627 public void ReadToNextSibling ()
\r
1629 string xml = @"<root><foo/><bar attr='value'/><foo><pooh/><bar></bar><foo></foo><bar/></foo></root>";
\r
1630 RunTest (xml, new TestMethod (ReadToNextSibling));
\r
1633 void ReadToNextSibling (XmlReader xmlReader)
\r
1635 // It is funky, but without it MS.NET results in an infinite loop.
\r
1636 xmlReader.Read (); // root
\r
1638 xmlReader.Read (); // foo
\r
1639 Assert ("#3", xmlReader.ReadToNextSibling ("bar"));
\r
1641 AssertEquals ("#3-2", "value", xmlReader.GetAttribute ("attr"));
\r
1642 xmlReader.Read (); // foo
\r
1643 xmlReader.Read (); // pooh
\r
1644 Assert ("#4", xmlReader.ReadToNextSibling ("bar"));
\r
1645 Assert ("#4-2", !xmlReader.IsEmptyElement);
\r
1646 Assert ("#5", xmlReader.ReadToNextSibling ("bar"));
\r
1647 Assert ("#5-2", xmlReader.IsEmptyElement);
\r
1648 Assert ("#6", xmlReader.Read ()); // /foo
\r
1650 AssertNodeValues ("#7", xmlReader,
\r
1651 XmlNodeType.EndElement,
\r
1653 false, // IsEmptyElement
\r
1655 String.Empty, // Prefix
\r
1656 "foo", // LocalName
\r
1657 String.Empty, // NamespaceURI
\r
1658 String.Empty, // Value
\r
1659 false, // HasValue
\r
1660 0, // AttributeCount
\r
1661 false); // HasAttributes
\r
1666 public void ReadToNextSibling2 ()
\r
1668 string xml = @"<root><baz><bar><foo attr='value'/></bar><foo attr='value2'><bar><foo /></bar></foo></baz></root>";
\r
1669 RunTest (xml, new TestMethod (ReadToNextSibling2));
\r
1672 void ReadToNextSibling2 (XmlReader r)
\r
1674 r.MoveToContent (); // ->root
\r
1675 r.Read (); // root->baz
\r
1676 r.Read (); // baz->bar
\r
1677 Assert ("#1", r.ReadToNextSibling ("foo"));
\r
1678 AssertEquals ("#2", "value2", r.GetAttribute ("attr"));
\r
1679 r.Read (); // foo[@value='value2']->bar
\r
1680 Assert ("#3", !r.ReadToNextSibling ("foo"));
\r
1681 AssertEquals ("#4", XmlNodeType.EndElement, r.NodeType);
\r
1682 AssertEquals ("#5", "foo", r.LocalName);
\r
1687 public void ReadToNextSibling3 ()
\r
1689 string xml = @" <books> <book> <name>Happy C Sharp</name> </book> </books>";
\r
1690 XmlReader reader = XmlReader.Create (new StringReader (xml));
\r
1692 reader.MoveToContent ();
\r
1694 while (reader.Read ())
\r
1695 reader.ReadToNextSibling ("book"); // should not result in an infinite loop
\r
1699 public void ReadSubtree ()
\r
1701 string xml = @"<root><foo/><bar attr='value'></bar></root>";
\r
1702 RunTest (xml, new TestMethod (ReadSubtree));
\r
1705 void ReadSubtree (XmlReader reader)
\r
1707 reader.MoveToContent (); // root
\r
1708 reader.Read (); // foo
\r
1709 XmlReader st = reader.ReadSubtree (); // <foo/>
\r
1711 // MS bug: IsEmptyElement should be false here.
\r
1713 AssertNodeValues ("#1", st,
\r
1716 false, // IsEmptyElement
\r
1717 String.Empty, // Name
\r
1718 String.Empty, // Prefix
\r
1719 String.Empty, // LocalName
\r
1720 String.Empty, // NamespaceURI
\r
1721 String.Empty, // Value
\r
1722 false, // HasValue
\r
1723 0, // AttributeCount
\r
1724 false); // HasAttributes
\r
1726 AssertEquals ("#1", XmlNodeType.None, st.NodeType);
\r
1729 AssertNodeValues ("#2", st,
\r
1730 XmlNodeType.Element,
\r
1732 true, // IsEmptyElement
\r
1734 String.Empty, // Prefix
\r
1735 "foo", // LocalName
\r
1736 String.Empty, // NamespaceURI
\r
1737 String.Empty, // Value
\r
1738 false, // HasValue
\r
1739 0, // AttributeCount
\r
1740 false); // HasAttributes
\r
1742 Assert ("#3", !st.Read ());
\r
1744 // At this state, reader is not positioned on <bar> yet
\r
1745 AssertNodeValues ("#3-2", reader,
\r
1746 XmlNodeType.Element,
\r
1747 1, // Depth. It is 1 for main tree.
\r
1748 true, // IsEmptyElement
\r
1750 String.Empty, // Prefix
\r
1751 "foo", // LocalName
\r
1752 String.Empty, // NamespaceURI
\r
1753 String.Empty, // Value
\r
1754 false, // HasValue
\r
1755 0, // AttributeCount
\r
1756 false); // HasAttributes
\r
1760 AssertNodeValues ("#4", reader,
\r
1761 XmlNodeType.Element,
\r
1762 1, // Depth. It is 1 for main tree.
\r
1763 false, // IsEmptyElement
\r
1765 String.Empty, // Prefix
\r
1766 "bar", // LocalName
\r
1767 String.Empty, // NamespaceURI
\r
1768 String.Empty, // Value
\r
1769 false, // HasValue
\r
1770 1, // AttributeCount
\r
1771 true); // HasAttributes
\r
1773 st = reader.ReadSubtree ();
\r
1774 st.Read (); // Initial -> Interactive
\r
1775 AssertNodeValues ("#5", st,
\r
1776 XmlNodeType.Element,
\r
1777 0, // Depth. It is 0 for subtree.
\r
1778 false, // IsEmptyElement
\r
1780 String.Empty, // Prefix
\r
1781 "bar", // LocalName
\r
1782 String.Empty, // NamespaceURI
\r
1783 String.Empty, // Value
\r
1784 false, // HasValue
\r
1785 1, // AttributeCount
\r
1786 true); // HasAttributes
\r
1789 AssertNodeValues ("#6-1", st,
\r
1790 XmlNodeType.EndElement,
\r
1791 0, // Depth. It is 0 for subtree.
\r
1792 false, // IsEmptyElement
\r
1794 String.Empty, // Prefix
\r
1795 "bar", // LocalName
\r
1796 String.Empty, // NamespaceURI
\r
1797 String.Empty, // Value
\r
1798 false, // HasValue
\r
1799 0, // AttributeCount
\r
1800 false); // HasAttributes
\r
1802 AssertNodeValues ("#6-2", st,
\r
1803 XmlNodeType.EndElement,
\r
1804 0, // Depth. It is 0 for subtree.
\r
1805 false, // IsEmptyElement
\r
1807 String.Empty, // Prefix
\r
1808 "bar", // LocalName
\r
1809 String.Empty, // NamespaceURI
\r
1810 String.Empty, // Value
\r
1811 false, // HasValue
\r
1812 0, // AttributeCount
\r
1813 false); // HasAttributes
\r
1815 Assert ("#7", !st.Read ());
\r
1819 public void ReadInteger ()
\r
1821 string xml1 = "<root>1</root>";
\r
1824 xr = XmlReader.Create (new StringReader (xml1));
\r
1826 AssertEquals ("#1", "1", xr.ReadElementContentAsString ());
\r
1828 AssertNodeValues ("#1-2", xr,
\r
1830 0, // Depth. It is 0 for subtree.
\r
1831 false, // IsEmptyElement
\r
1832 String.Empty, // Name
\r
1833 String.Empty, // Prefix
\r
1834 String.Empty, // LocalName
\r
1835 String.Empty, // NamespaceURI
\r
1836 String.Empty, // Value
\r
1837 false, // HasValue
\r
1838 0, // AttributeCount
\r
1839 false); // HasAttributes
\r
1841 xr = XmlReader.Create (new StringReader (xml1));
\r
1843 // this XmlReader has no schema, thus the value is untyped
\r
1844 AssertEquals ("#2", "1", xr.ReadElementContentAsObject ());
\r
1846 xr = XmlReader.Create (new StringReader (xml1));
\r
1849 AssertEquals ("#3", "1", xr.ReadContentAsString ());
\r
1851 xr = XmlReader.Create (new StringReader (xml1));
\r
1853 AssertEquals ("#4", 1, xr.ReadElementContentAsInt ());
\r
1855 xr = XmlReader.Create (new StringReader (xml1));
\r
1857 AssertEquals ("#5", 1, xr.ReadElementContentAs (typeof (int), null));
\r
1861 [ExpectedException (typeof (XmlException))]
\r
1862 public void ReadContentAsIntFail ()
\r
1864 XmlReader xr = XmlReader.Create (
\r
1865 new StringReader ("<doc>1.0</doc>"));
\r
1867 xr.ReadElementContentAsInt ();
\r
1871 public void ReadDateTime ()
\r
1873 DateTime time = new DateTime (2006, 1, 2, 3, 4, 56);
\r
1874 string xml1 = "<root>2006-01-02T03:04:56</root>";
\r
1877 xr = XmlReader.Create (new StringReader (xml1));
\r
1879 // this XmlReader has no schema, thus the value is untyped
\r
1880 AssertEquals ("#1", "2006-01-02T03:04:56",
\r
1881 xr.ReadElementContentAsString ());
\r
1883 xr = XmlReader.Create (new StringReader (xml1));
\r
1886 AssertEquals ("#2", time, xr.ReadContentAsDateTime ());
\r
1888 xr = XmlReader.Create (new StringReader (xml1));
\r
1890 AssertEquals ("#3", time, xr.ReadElementContentAsDateTime ());
\r
1892 xr = XmlReader.Create (new StringReader (xml1));
\r
1894 AssertEquals ("#4", time, xr.ReadElementContentAs (typeof (DateTime), null));
\r
1898 [ExpectedException (typeof (XmlException))]
\r
1899 public void ReadContentAsDateTimeFail ()
\r
1901 XmlReader xr = XmlReader.Create (
\r
1902 new StringReader ("<doc>P1Y2M3D</doc>"));
\r
1904 xr.ReadElementContentAsDateTime ();
\r
1908 public void ReadContentAs_QNameEmptyNSResolver ()
\r
1910 XmlReader xr = XmlReader.Create (
\r
1911 new StringReader ("<doc xmlns:x='urn:foo'>x:el</doc>"));
\r
1913 object o = xr.ReadElementContentAs (
\r
1914 typeof (XmlQualifiedName), null);
\r
1915 // without IXmlNamespaceResolver, it still resolves
\r
1916 // x:el as valid QName.
\r
1917 AssertNotNull ("#1", o);
\r
1918 XmlQualifiedName q = o as XmlQualifiedName;
\r
1919 AssertEquals ("#2 : " + o.GetType (),
\r
1920 new XmlQualifiedName ("el", "urn:foo"), q);
\r
1924 [ExpectedException (typeof (InvalidOperationException))]
\r
1925 public void ReadContentStringOnElementFail ()
\r
1927 XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));
\r
1929 xr.ReadContentAsString ();
\r
1933 [ExpectedException (typeof (XmlException))]
\r
1934 public void ReadElementContentStringMixedContent ()
\r
1936 XmlReader xr = XmlReader.Create (
\r
1937 new StringReader ("<doc>123<child>456</child>789</doc>"));
\r
1939 // "child" is regarded as an invalid node.
\r
1940 string s = xr.ReadElementContentAsString ();
\r
1944 public void ReadContentStringMixedContent ()
\r
1946 XmlReader xr = XmlReader.Create (
\r
1947 new StringReader ("<doc>123<child>456</child>789</doc>"));
\r
1949 xr.Read (); // from Text "123"
\r
1950 string s = xr.ReadContentAsString ();
\r
1951 AssertEquals ("#1", "123", s);
\r
1952 AssertEquals ("#2", XmlNodeType.Element, xr.NodeType);
\r
1956 public void ReadElementContentAsString ()
\r
1958 XmlTextReader r = new XmlTextReader (
\r
1959 "<root/>", XmlNodeType.Document, null);
\r
1961 AssertEquals ("#1",
\r
1962 String.Empty, r.ReadElementContentAsString ());
\r
1963 AssertEquals ("#2",
\r
1964 XmlNodeType.None, r.NodeType);
\r
1968 public void ReadElementContentAs ()
\r
1970 // as System.Object
\r
1972 XmlTextReader r = new XmlTextReader (
\r
1973 "<root/>", XmlNodeType.Document, null);
\r
1975 AssertEquals ("#1",
\r
1976 String.Empty, r.ReadElementContentAs (typeof (object), null));
\r
1977 AssertEquals ("#2",
\r
1978 XmlNodeType.None, r.NodeType);
\r
1980 // regardless of its value, the return value is string.
\r
1981 r = new XmlTextReader ("<root>1</root>", XmlNodeType.Document, null);
\r
1983 AssertEquals ("#3",
\r
1984 "1", r.ReadElementContentAs (typeof (object), null));
\r
1985 AssertEquals ("#4",
\r
1986 XmlNodeType.None, r.NodeType);
\r
1990 public void ReadContentStringOnAttribute ()
\r
1992 string xml = @"<root id='myId'><child /></root>";
\r
1993 RunTest (xml, new TestMethod (ReadContentStringOnAttribute));
\r
1996 void ReadContentStringOnAttribute (XmlReader reader)
\r
1999 Assert (reader.MoveToAttribute ("id"));
\r
2000 AssertEquals ("myId", reader.ReadContentAsString ());
\r
2004 public void ReadElementContentAsStringEmpty ()
\r
2006 string xml = "<root><sample/></root>";
\r
2007 RunTest (xml, new TestMethod (ReadElementContentAsStringEmpty));
\r
2010 void ReadElementContentAsStringEmpty (XmlReader reader)
\r
2012 reader.MoveToContent ();
\r
2014 AssertEquals (String.Empty, reader.ReadElementContentAsString ("sample", ""));
\r
2015 AssertEquals (XmlNodeType.EndElement, reader.NodeType);
\r
2019 public void ReadSubtreeClose ()
\r
2022 string xml = @"<root><item-list><item id='a'/><item id='b'/></item-list></root>";
\r
2023 RunTest (xml, new TestMethod (ReadSubtreeClose));
\r
2026 void ReadSubtreeClose (XmlReader reader)
\r
2028 reader.ReadToFollowing ("item-list");
\r
2029 XmlReader sub = reader.ReadSubtree ();
\r
2030 sub.ReadToDescendant ("item");
\r
2032 AssertEquals ("#1", XmlNodeType.EndElement, reader.NodeType);
\r
2033 AssertEquals ("#2", "item-list", reader.Name);
\r