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 Assert ("Read() return value", xmlReader.Read ());
\r
63 Assert ("ReadState", xmlReader.ReadState == ReadState.Interactive);
\r
64 Assert ("!EOF", !xmlReader.EOF);
\r
65 AssertNodeValues ("", xmlReader, nodeType, depth,
\r
66 isEmptyElement, name, prefix, localName,
\r
67 namespaceURI, value, value != String.Empty,
\r
68 attributeCount, attributeCount > 0);
\r
71 private void AssertNodeValues (
\r
73 XmlReader xmlReader,
\r
74 XmlNodeType nodeType,
\r
76 bool isEmptyElement,
\r
80 string namespaceURI,
\r
84 AssertNodeValues (label, xmlReader, nodeType, depth,
\r
85 isEmptyElement, name, prefix, localName,
\r
86 namespaceURI, value, value != String.Empty,
\r
87 attributeCount, attributeCount > 0);
\r
90 private void AssertNodeValues (
\r
92 XmlReader xmlReader,
\r
93 XmlNodeType nodeType,
\r
95 bool isEmptyElement,
\r
99 string namespaceURI,
\r
102 int attributeCount,
\r
103 bool hasAttributes)
\r
105 label = String.Concat (label, "(", xmlReader.GetType ().Name, ")");
\r
106 AssertEquals (label + ": NodeType", nodeType, xmlReader.NodeType);
\r
107 AssertEquals (label + ": IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);
\r
109 AssertEquals (label + ": name", name, xmlReader.Name);
\r
111 AssertEquals (label + ": prefix", prefix, xmlReader.Prefix);
\r
113 AssertEquals (label + ": localName", localName, xmlReader.LocalName);
\r
115 AssertEquals (label + ": namespaceURI", namespaceURI, xmlReader.NamespaceURI);
\r
117 AssertEquals (label + ": Depth", depth, xmlReader.Depth);
\r
119 AssertEquals (label + ": hasValue", hasValue, xmlReader.HasValue);
\r
121 AssertEquals (label + ": Value", value, xmlReader.Value);
\r
123 AssertEquals (label + ": hasAttributes", hasAttributes, xmlReader.HasAttributes);
\r
125 AssertEquals (label + ": attributeCount", attributeCount, xmlReader.AttributeCount);
\r
128 private void AssertAttribute (
\r
129 XmlReader xmlReader,
\r
133 string namespaceURI,
\r
136 AssertEquals ("value", value, xmlReader [name]);
\r
138 Assert (xmlReader.GetAttribute (name) == value);
\r
140 if (namespaceURI != String.Empty) {
\r
141 Assert (xmlReader[localName, namespaceURI] == value);
\r
142 Assert (xmlReader.GetAttribute (localName, namespaceURI) == value);
\r
146 private void AssertEndDocument (XmlReader xmlReader)
\r
148 Assert ("could read", !xmlReader.Read ());
\r
149 AssertEquals ("NodeType is not XmlNodeType.None", XmlNodeType.None, xmlReader.NodeType);
\r
150 AssertEquals ("Depth is not 0", 0, xmlReader.Depth);
\r
151 AssertEquals ("ReadState is not ReadState.EndOfFile", ReadState.EndOfFile, xmlReader.ReadState);
\r
152 Assert ("not EOF", xmlReader.EOF);
\r
154 xmlReader.Close ();
\r
155 AssertEquals ("ReadState is not ReadState.Cosed", ReadState.Closed, xmlReader.ReadState);
\r
158 private delegate void TestMethod (XmlReader reader);
\r
160 private void RunTest (string xml, TestMethod method)
\r
162 xtr = new XmlTextReader (new StringReader (xml));
\r
166 xtr = new XmlTextReader (new StringReader (xml));
\r
167 XmlValidatingReader xvr = new XmlValidatingReader (xtr);
\r
168 xvr.ValidationType = ValidationType.DTD;
\r
169 xvr.EntityHandling = EntityHandling.ExpandCharEntities;
\r
173 xtr = new XmlTextReader (new StringReader (xml));
\r
174 xvr = new XmlValidatingReader (xtr);
\r
175 xvr.EntityHandling = EntityHandling.ExpandCharEntities;
\r
178 document.XmlResolver = null;
\r
179 document.LoadXml (xml);
\r
180 xnr = new XmlNodeReader (document);
\r
184 // XPathNavigatorReader tests
\r
185 System.Xml.XPath.XPathDocument doc = new System.Xml.XPath.XPathDocument (new StringReader (xml));
\r
186 XmlReader xpr = doc.CreateNavigator ().ReadSubtree ();
\r
197 public void InitialState ()
\r
199 RunTest (xml1, new TestMethod (InitialState));
\r
202 private void InitialState (XmlReader reader)
\r
204 AssertEquals ("Depth", 0, reader.Depth);
\r
205 AssertEquals ("EOF", false, reader.EOF);
\r
206 AssertEquals ("HasValue", false, reader.HasValue);
\r
207 AssertEquals ("IsEmptyElement", false, reader.IsEmptyElement);
\r
208 AssertEquals ("LocalName", String.Empty, reader.LocalName);
\r
209 AssertEquals ("NodeType", XmlNodeType.None, reader.NodeType);
\r
210 AssertEquals ("ReadState", ReadState.Initial, reader.ReadState);
\r
214 public void Read ()
\r
216 RunTest (xml1, new TestMethod (Read));
\r
219 public void Read (XmlReader reader)
\r
222 AssertEquals ("<root>.NodeType", XmlNodeType.Element, reader.NodeType);
\r
223 AssertEquals ("<root>.Name", "root", reader.Name);
\r
224 AssertEquals ("<root>.ReadState", ReadState.Interactive, reader.ReadState);
\r
225 AssertEquals ("<root>.Depth", 0, reader.Depth);
\r
229 AssertEquals ("<child/>.Depth", 1, reader.Depth);
\r
230 AssertEquals ("<child/>.NodeType", XmlNodeType.Element, reader.NodeType);
\r
231 AssertEquals ("<child/>.Name", "child", reader.Name);
\r
234 AssertEquals ("</root>.Depth", 0, reader.Depth);
\r
235 AssertEquals ("</root>.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
236 AssertEquals ("</root>.Name", "root", reader.Name);
\r
239 AssertEquals ("end.EOF", true, reader.EOF);
\r
240 AssertEquals ("end.NodeType", XmlNodeType.None, reader.NodeType);
\r
244 [Category ("NotDotNet")]
\r
245 public void ReadAttributeValue ()
\r
247 RunTest ("<root attr=''/>", new TestMethod (ReadAttributeValue));
\r
250 public void ReadAttributeValue (XmlReader reader)
\r
252 reader.Read (); // root
\r
253 Assert (reader.MoveToFirstAttribute ());
\r
254 // It looks like that MS.NET shows AttributeCount and
\r
255 // HasAttributes as the same as element node!
\r
256 this.AssertNodeValues ("#1",
\r
257 reader, XmlNodeType.Attribute,
\r
258 1, false, "attr", "", "attr", "", "", true, 1, true);
\r
259 Assert (reader.ReadAttributeValue ());
\r
260 // MS.NET XmlTextReader fails. Its Prefix returns
\r
261 // null instead of "". It is fixed in MS.NET 2.0.
\r
262 this.AssertNodeValues ("#2",
\r
263 reader, XmlNodeType.Text,
\r
264 2, false, "", "", "", "", "", true, 1, true);
\r
265 Assert (reader.MoveToElement ());
\r
266 this.AssertNodeValues ("#3",
\r
267 reader, XmlNodeType.Element,
\r
268 0, true, "root", "", "root", "", "", false, 1, true);
\r
272 public void ReadEmptyElement ()
\r
274 RunTest (xml2, new TestMethod (ReadEmptyElement));
\r
277 public void ReadEmptyElement (XmlReader reader)
\r
279 reader.Read (); // root
\r
280 AssertEquals (false, reader.IsEmptyElement);
\r
281 reader.Read (); // foo
\r
282 AssertEquals ("foo", reader.Name);
\r
283 AssertEquals (true, reader.IsEmptyElement);
\r
284 reader.Read (); // bar
\r
285 AssertEquals ("bar", reader.Name);
\r
286 AssertEquals (false, reader.IsEmptyElement);
\r
290 public void ReadStringFromElement ()
\r
292 RunTest (xml3, new TestMethod (ReadStringFromElement));
\r
295 public void ReadStringFromElement (XmlReader reader)
\r
297 // Note: ReadString() test works only when the reader is
\r
298 // positioned at the container element.
\r
299 // In case the reader is positioned at the first
\r
300 // character node, XmlTextReader and XmlNodeReader works
\r
304 string s = reader.ReadString ();
\r
305 AssertEquals ("readString.1.ret_val", " test of ", s);
\r
306 AssertEquals ("readString.1.Name", "b", reader.Name);
\r
307 s = reader.ReadString ();
\r
308 AssertEquals ("readString.2.ret_val", "mixed", s);
\r
309 AssertEquals ("readString.2.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
310 s = reader.ReadString (); // never proceeds.
\r
311 AssertEquals ("readString.3.ret_val", String.Empty, s);
\r
312 AssertEquals ("readString.3.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
314 AssertEquals ("readString.4.NodeType", XmlNodeType.Text, reader.NodeType);
\r
315 AssertEquals ("readString.4.Value", " string.", reader.Value);
\r
316 s = reader.ReadString (); // reads the same Text node.
\r
317 AssertEquals ("readString.5.ret_val", " string. cdata string.", s);
\r
318 AssertEquals ("readString.5.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
322 public void ReadInnerXml ()
\r
324 const string xml = "<root><foo>test of <b>mixed</b> string.</foo><bar /></root>";
\r
325 RunTest (xml, new TestMethod (ReadInnerXml));
\r
328 public void ReadInnerXml (XmlReader reader)
\r
332 AssertEquals ("initial.ReadState", ReadState.Interactive, reader.ReadState);
\r
333 AssertEquals ("initial.EOF", false, reader.EOF);
\r
334 AssertEquals ("initial.NodeType", XmlNodeType.Element, reader.NodeType);
\r
335 string s = reader.ReadInnerXml ();
\r
336 AssertEquals ("read_all", "test of <b>mixed</b> string.", s);
\r
337 AssertEquals ("after.Name", "bar", reader.Name);
\r
338 AssertEquals ("after.NodeType", XmlNodeType.Element, reader.NodeType);
\r
343 public void EmptyElement ()
\r
345 RunTest ("<foo/>", new TestMethod (EmptyElement));
\r
348 public void EmptyElement (XmlReader xmlReader)
\r
351 AssertStartDocument (xmlReader);
\r
354 xmlReader, // xmlReader
\r
355 XmlNodeType.Element, // nodeType
\r
357 true, // isEmptyElement
\r
359 String.Empty, // prefix
\r
360 "foo", // localName
\r
361 String.Empty, // namespaceURI
\r
362 String.Empty, // value
\r
363 0 // attributeCount
\r
366 AssertEndDocument (xmlReader);
\r
370 public void NestedEmptyTag ()
\r
372 string xml = "<foo><bar/></foo>";
\r
373 RunTest (xml, new TestMethod (NestedEmptyTag));
\r
376 public void NestedEmptyTag (XmlReader xmlReader)
\r
378 AssertStartDocument (xmlReader);
\r
381 xmlReader, // xmlReader
\r
382 XmlNodeType.Element, // nodeType
\r
384 false, // isEmptyElement
\r
386 String.Empty, // prefix
\r
387 "foo", // localName
\r
388 String.Empty, // namespaceURI
\r
389 String.Empty, // value
\r
390 0 // attributeCount
\r
394 xmlReader, // xmlReader
\r
395 XmlNodeType.Element, // nodeType
\r
397 true, // isEmptyElement
\r
399 String.Empty, // prefix
\r
400 "bar", // localName
\r
401 String.Empty, // namespaceURI
\r
402 String.Empty, // value
\r
403 0 // attributeCount
\r
407 xmlReader, // xmlReader
\r
408 XmlNodeType.EndElement, // nodeType
\r
410 false, // isEmptyElement
\r
412 String.Empty, // prefix
\r
413 "foo", // localName
\r
414 String.Empty, // namespaceURI
\r
415 String.Empty, // value
\r
416 0 // attributeCount
\r
419 AssertEndDocument (xmlReader);
\r
423 public void NestedText ()
\r
425 string xml = "<foo>bar</foo>";
\r
426 RunTest (xml, new TestMethod (NestedText));
\r
429 public void NestedText (XmlReader xmlReader)
\r
431 AssertStartDocument (xmlReader);
\r
434 xmlReader, // xmlReader
\r
435 XmlNodeType.Element, // nodeType
\r
437 false, // isEmptyElement
\r
439 String.Empty, // prefix
\r
440 "foo", // localName
\r
441 String.Empty, // namespaceURI
\r
442 String.Empty, // value
\r
443 0 // attributeCount
\r
447 xmlReader, // xmlReader
\r
448 XmlNodeType.Text, // nodeType
\r
450 false, // isEmptyElement
\r
451 String.Empty, // name
\r
452 String.Empty, // prefix
\r
453 String.Empty, // localName
\r
454 String.Empty, // namespaceURI
\r
456 0 // attributeCount
\r
460 xmlReader, // xmlReader
\r
461 XmlNodeType.EndElement, // nodeType
\r
463 false, // isEmptyElement
\r
465 String.Empty, // prefix
\r
466 "foo", // localName
\r
467 String.Empty, // namespaceURI
\r
468 String.Empty, // value
\r
469 0 // attributeCount
\r
472 AssertEndDocument (xmlReader);
\r
476 public void EmptyElementWithAttributes ()
\r
478 string xml = @"<foo bar=""baz"" quux='quuux' x:foo='x-foo' xmlns:x = 'urn:xfoo' />";
\r
479 RunTest (xml, new TestMethod (EmptyElementWithAttributes ));
\r
482 public void EmptyElementWithAttributes (XmlReader xmlReader)
\r
485 AssertStartDocument (xmlReader);
\r
488 xmlReader, // xmlReader
\r
489 XmlNodeType.Element, // nodeType
\r
491 true, // isEmptyElement
\r
493 String.Empty, // prefix
\r
494 "foo", // localName
\r
495 String.Empty, // namespaceURI
\r
496 String.Empty, // value
\r
497 4 // attributeCount
\r
501 xmlReader, // xmlReader
\r
503 String.Empty, // prefix
\r
504 "bar", // localName
\r
505 String.Empty, // namespaceURI
\r
510 xmlReader, // xmlReader
\r
512 String.Empty, // prefix
\r
513 "quux", // localName
\r
514 String.Empty, // namespaceURI
\r
519 xmlReader, // xmlReader
\r
520 "notexist", // name
\r
521 String.Empty, // prefix
\r
522 "notexist", // localName
\r
523 String.Empty, // namespaceURI
\r
528 xmlReader, // xmlReader
\r
531 "foo", // localName
\r
532 "urn:xfoo", // namespaceURI
\r
537 xmlReader, // xmlReader
\r
540 "bar", // localName
\r
541 "urn:xfoo", // namespaceURI
\r
545 AssertEndDocument (xmlReader);
\r
549 public void ProcessingInstructionBeforeDocumentElement ()
\r
551 string xml = "<?foo bar?><baz/>";
\r
552 RunTest (xml, new TestMethod (ProcessingInstructionBeforeDocumentElement));
\r
555 public void ProcessingInstructionBeforeDocumentElement (XmlReader xmlReader)
\r
557 AssertStartDocument (xmlReader);
\r
560 xmlReader, // xmlReader
\r
561 XmlNodeType.ProcessingInstruction, // nodeType
\r
563 false, // isEmptyElement
\r
565 String.Empty, // prefix
\r
566 "foo", // localName
\r
567 String.Empty, // namespaceURI
\r
569 0 // attributeCount
\r
573 xmlReader, // xmlReader
\r
574 XmlNodeType.Element, // nodeType
\r
576 true, // isEmptyElement
\r
578 String.Empty, // prefix
\r
579 "baz", // localName
\r
580 String.Empty, // namespaceURI
\r
581 String.Empty, // value
\r
582 0 // attributeCount
\r
585 AssertEndDocument (xmlReader);
\r
589 public void CommentBeforeDocumentElement ()
\r
591 string xml = "<!--foo--><bar/>";
\r
592 RunTest (xml, new TestMethod (CommentBeforeDocumentElement));
\r
595 public void CommentBeforeDocumentElement (XmlReader xmlReader)
\r
597 AssertStartDocument (xmlReader);
\r
600 xmlReader, // xmlReader
\r
601 XmlNodeType.Comment, // nodeType
\r
603 false, // isEmptyElement
\r
604 String.Empty, // name
\r
605 String.Empty, // prefix
\r
606 String.Empty, // localName
\r
607 String.Empty, // namespaceURI
\r
609 0 // attributeCount
\r
613 xmlReader, // xmlReader
\r
614 XmlNodeType.Element, // nodeType
\r
616 true, // isEmptyElement
\r
618 String.Empty, // prefix
\r
619 "bar", // localName
\r
620 String.Empty, // namespaceURI
\r
621 String.Empty, // value
\r
622 0 // attributeCount
\r
625 AssertEndDocument (xmlReader);
\r
629 public void PredefinedEntities ()
\r
631 string xml = "<foo><>&'"</foo>";
\r
632 RunTest (xml, new TestMethod (PredefinedEntities));
\r
635 public void PredefinedEntities (XmlReader xmlReader)
\r
637 AssertStartDocument (xmlReader);
\r
640 xmlReader, // xmlReader
\r
641 XmlNodeType.Element, // nodeType
\r
643 false, // isEmptyElement
\r
645 String.Empty, // prefix
\r
646 "foo", // localName
\r
647 String.Empty, // namespaceURI
\r
648 String.Empty, // value
\r
649 0 // attributeCount
\r
653 xmlReader, // xmlReader
\r
654 XmlNodeType.Text, // nodeType
\r
656 false, // isEmptyElement
\r
657 String.Empty, // name
\r
658 String.Empty, // prefix
\r
659 String.Empty, // localName
\r
660 String.Empty, // namespaceURI
\r
662 0 // attributeCount
\r
666 xmlReader, // xmlReader
\r
667 XmlNodeType.EndElement, // nodeType
\r
669 false, // isEmptyElement
\r
671 String.Empty, // prefix
\r
672 "foo", // localName
\r
673 String.Empty, // namespaceURI
\r
674 String.Empty, // value
\r
675 0 // attributeCount
\r
678 AssertEndDocument (xmlReader);
\r
682 public void CharacterReferences ()
\r
684 string xml = "<foo>FOO</foo>";
\r
685 RunTest (xml, new TestMethod (CharacterReferences));
\r
688 public void CharacterReferences (XmlReader xmlReader)
\r
690 AssertStartDocument (xmlReader);
\r
693 xmlReader, // xmlReader
\r
694 XmlNodeType.Element, // nodeType
\r
696 false, // isEmptyElement
\r
698 String.Empty, // prefix
\r
699 "foo", // localName
\r
700 String.Empty, // namespaceURI
\r
701 String.Empty, // value
\r
702 0 // attributeCount
\r
706 xmlReader, // xmlReader
\r
707 XmlNodeType.Text, // nodeType
\r
709 false, // isEmptyElement
\r
710 String.Empty, // name
\r
711 String.Empty, // prefix
\r
712 String.Empty, // localName
\r
713 String.Empty, // namespaceURI
\r
715 0 // attributeCount
\r
719 xmlReader, // xmlReader
\r
720 XmlNodeType.EndElement, // nodeType
\r
722 false, // isEmptyElement
\r
724 String.Empty, // prefix
\r
725 "foo", // localName
\r
726 String.Empty, // namespaceURI
\r
727 String.Empty, // value
\r
728 0 // attributeCount
\r
731 AssertEndDocument (xmlReader);
\r
735 public void PredefinedEntitiesInAttribute ()
\r
737 string xml = "<foo bar='<>&'"'/>";
\r
738 RunTest (xml, new TestMethod (PredefinedEntitiesInAttribute ));
\r
741 public void PredefinedEntitiesInAttribute (XmlReader xmlReader)
\r
743 AssertStartDocument (xmlReader);
\r
746 xmlReader, // xmlReader
\r
747 XmlNodeType.Element, // nodeType
\r
749 true, // isEmptyElement
\r
751 String.Empty, // prefix
\r
752 "foo", // localName
\r
753 String.Empty, // namespaceURI
\r
754 String.Empty, // value
\r
755 1 // attributeCount
\r
759 xmlReader, // xmlReader
\r
761 String.Empty, // prefix
\r
762 "bar", // localName
\r
763 String.Empty, // namespaceURI
\r
767 AssertEndDocument (xmlReader);
\r
771 public void CharacterReferencesInAttribute ()
\r
773 string xml = "<foo bar='FOO'/>";
\r
774 RunTest (xml, new TestMethod (CharacterReferencesInAttribute));
\r
777 public void CharacterReferencesInAttribute (XmlReader xmlReader)
\r
779 AssertStartDocument (xmlReader);
\r
782 xmlReader, // xmlReader
\r
783 XmlNodeType.Element, // nodeType
\r
785 true, // isEmptyElement
\r
787 String.Empty, // prefix
\r
788 "foo", // localName
\r
789 String.Empty, // namespaceURI
\r
790 String.Empty, // value
\r
791 1 // attributeCount
\r
795 xmlReader, // xmlReader
\r
797 String.Empty, // prefix
\r
798 "bar", // localName
\r
799 String.Empty, // namespaceURI
\r
803 AssertEndDocument (xmlReader);
\r
807 public void CDATA ()
\r
809 string xml = "<foo><![CDATA[<>&]]></foo>";
\r
810 RunTest (xml, new TestMethod (CDATA));
\r
813 public void CDATA (XmlReader xmlReader)
\r
815 AssertStartDocument (xmlReader);
\r
818 xmlReader, // xmlReader
\r
819 XmlNodeType.Element, // nodeType
\r
821 false, // isEmptyElement
\r
823 String.Empty, // prefix
\r
824 "foo", // localName
\r
825 String.Empty, // namespaceURI
\r
826 String.Empty, // value
\r
827 0 // attributeCount
\r
831 xmlReader, // xmlReader
\r
832 XmlNodeType.CDATA, // nodeType
\r
834 false, // isEmptyElement
\r
835 String.Empty, // name
\r
836 String.Empty, // prefix
\r
837 String.Empty, // localName
\r
838 String.Empty, // namespaceURI
\r
840 0 // attributeCount
\r
844 xmlReader, // xmlReader
\r
845 XmlNodeType.EndElement, // nodeType
\r
847 false, // isEmptyElement
\r
849 String.Empty, // prefix
\r
850 "foo", // localName
\r
851 String.Empty, // namespaceURI
\r
852 String.Empty, // value
\r
853 0 // attributeCount
\r
856 AssertEndDocument (xmlReader);
\r
860 public void EmptyElementInDefaultNamespace ()
\r
862 string xml = @"<foo xmlns='http://foo/' />";
\r
863 RunTest (xml, new TestMethod (EmptyElementInDefaultNamespace));
\r
866 public void EmptyElementInDefaultNamespace (XmlReader xmlReader)
\r
868 AssertStartDocument (xmlReader);
\r
871 xmlReader, // xmlReader
\r
872 XmlNodeType.Element, // nodeType
\r
874 true, // isEmptyElement
\r
876 String.Empty, // prefix
\r
877 "foo", // localName
\r
878 "http://foo/", // namespaceURI
\r
879 String.Empty, // value
\r
880 1 // attributeCount
\r
884 xmlReader, // xmlReader
\r
886 String.Empty, // prefix
\r
887 "xmlns", // localName
\r
888 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
889 "http://foo/" // value
\r
892 AssertEquals ("http://foo/", xmlReader.LookupNamespace (String.Empty));
\r
894 AssertEndDocument (xmlReader);
\r
898 public void ChildElementInNamespace ()
\r
900 string xml = @"<foo:bar xmlns:foo='http://foo/'><baz:quux xmlns:baz='http://baz/' /></foo:bar>";
\r
901 RunTest (xml, new TestMethod (ChildElementInNamespace));
\r
904 public void ChildElementInNamespace (XmlReader xmlReader)
\r
906 AssertStartDocument (xmlReader);
\r
909 xmlReader, // xmlReader
\r
910 XmlNodeType.Element, // nodeType
\r
912 false, // isEmptyElement
\r
915 "bar", // localName
\r
916 "http://foo/", // namespaceURI
\r
917 String.Empty, // value
\r
918 1 // attributeCount
\r
922 xmlReader, // xmlReader
\r
923 "xmlns:foo", // name
\r
925 "foo", // localName
\r
926 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
927 "http://foo/" // value
\r
930 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
933 xmlReader, // xmlReader
\r
934 XmlNodeType.Element, // nodeType
\r
936 true, // isEmptyElement
\r
937 "baz:quux", // name
\r
939 "quux", // localName
\r
940 "http://baz/", // namespaceURI
\r
941 String.Empty, // value
\r
942 1 // attributeCount
\r
946 xmlReader, // xmlReader
\r
947 "xmlns:baz", // name
\r
949 "baz", // localName
\r
950 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
951 "http://baz/" // value
\r
954 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
955 AssertEquals ("http://baz/", xmlReader.LookupNamespace ("baz"));
\r
958 xmlReader, // xmlReader
\r
959 XmlNodeType.EndElement, // nodeType
\r
961 false, // isEmptyElement
\r
964 "bar", // localName
\r
965 "http://foo/", // namespaceURI
\r
966 String.Empty, // value
\r
967 0 // attributeCount
\r
970 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
971 AssertNull (xmlReader.LookupNamespace ("baz"));
\r
973 AssertEndDocument (xmlReader);
\r
977 public void ChildElementInDefaultNamespace ()
\r
979 string xml = @"<foo:bar xmlns:foo='http://foo/'><baz xmlns='http://baz/' /></foo:bar>";
\r
980 RunTest (xml, new TestMethod (ChildElementInDefaultNamespace));
\r
983 public void ChildElementInDefaultNamespace (XmlReader xmlReader)
\r
985 AssertStartDocument (xmlReader);
\r
988 xmlReader, // xmlReader
\r
989 XmlNodeType.Element, // nodeType
\r
991 false, // isEmptyElement
\r
994 "bar", // localName
\r
995 "http://foo/", // namespaceURI
\r
996 String.Empty, // value
\r
997 1 // attributeCount
\r
1001 xmlReader, // xmlReader
\r
1002 "xmlns:foo", // name
\r
1003 "xmlns", // prefix
\r
1004 "foo", // localName
\r
1005 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
1006 "http://foo/" // value
\r
1009 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
1012 xmlReader, // xmlReader
\r
1013 XmlNodeType.Element, // nodeType
\r
1015 true, // isEmptyElement
\r
1017 String.Empty, // prefix
\r
1018 "baz", // localName
\r
1019 "http://baz/", // namespaceURI
\r
1020 String.Empty, // value
\r
1021 1 // attributeCount
\r
1025 xmlReader, // xmlReader
\r
1027 String.Empty, // prefix
\r
1028 "xmlns", // localName
\r
1029 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
1030 "http://baz/" // value
\r
1033 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
1034 AssertEquals ("http://baz/", xmlReader.LookupNamespace (String.Empty));
\r
1037 xmlReader, // xmlReader
\r
1038 XmlNodeType.EndElement, // nodeType
\r
1040 false, // isEmptyElement
\r
1041 "foo:bar", // name
\r
1043 "bar", // localName
\r
1044 "http://foo/", // namespaceURI
\r
1045 String.Empty, // value
\r
1046 0 // attributeCount
\r
1049 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
1051 AssertEndDocument (xmlReader);
\r
1055 public void AttributeInNamespace ()
\r
1057 string xml = @"<foo bar:baz='quux' xmlns:bar='http://bar/' />";
\r
1058 RunTest (xml, new TestMethod (AttributeInNamespace));
\r
1061 public void AttributeInNamespace (XmlReader xmlReader)
\r
1063 AssertStartDocument (xmlReader);
\r
1066 xmlReader, // xmlReader
\r
1067 XmlNodeType.Element, // nodeType
\r
1069 true, // isEmptyElement
\r
1071 String.Empty, // prefix
\r
1072 "foo", // localName
\r
1073 String.Empty, // namespaceURI
\r
1074 String.Empty, // value
\r
1075 2 // attributeCount
\r
1079 xmlReader, // xmlReader
\r
1080 "bar:baz", // name
\r
1082 "baz", // localName
\r
1083 "http://bar/", // namespaceURI
\r
1088 xmlReader, // xmlReader
\r
1089 "xmlns:bar", // name
\r
1090 "xmlns", // prefix
\r
1091 "bar", // localName
\r
1092 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
1093 "http://bar/" // value
\r
1096 AssertEquals ("http://bar/", xmlReader.LookupNamespace ("bar"));
\r
1098 AssertEndDocument (xmlReader);
\r
1102 public void MoveToElementFromAttribute ()
\r
1104 string xml = @"<foo bar=""baz"" />";
\r
1105 RunTest (xml, new TestMethod (MoveToElementFromAttribute));
\r
1108 public void MoveToElementFromAttribute (XmlReader xmlReader)
\r
1110 Assert (xmlReader.Read ());
\r
1111 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1112 Assert (xmlReader.MoveToFirstAttribute ());
\r
1113 AssertEquals (XmlNodeType.Attribute, xmlReader.NodeType);
\r
1114 Assert (xmlReader.MoveToElement ());
\r
1115 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1119 public void MoveToElementFromElement ()
\r
1121 string xml = @"<foo bar=""baz"" />";
\r
1122 RunTest (xml, new TestMethod (MoveToElementFromElement));
\r
1125 public void MoveToElementFromElement (XmlReader xmlReader)
\r
1127 Assert (xmlReader.Read ());
\r
1128 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1129 Assert (!xmlReader.MoveToElement ());
\r
1130 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1134 public void MoveToFirstAttributeWithNoAttributes ()
\r
1136 string xml = @"<foo />";
\r
1137 RunTest (xml, new TestMethod (MoveToFirstAttributeWithNoAttributes));
\r
1140 public void MoveToFirstAttributeWithNoAttributes (XmlReader xmlReader)
\r
1142 Assert (xmlReader.Read ());
\r
1143 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1144 Assert (!xmlReader.MoveToFirstAttribute ());
\r
1145 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1149 public void MoveToNextAttributeWithNoAttributes ()
\r
1151 string xml = @"<foo />";
\r
1152 RunTest (xml, new TestMethod (MoveToNextAttributeWithNoAttributes));
\r
1155 public void MoveToNextAttributeWithNoAttributes (XmlReader xmlReader)
\r
1157 Assert (xmlReader.Read ());
\r
1158 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1159 Assert (!xmlReader.MoveToNextAttribute ());
\r
1160 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1164 public void MoveToNextAttribute()
\r
1166 string xml = @"<foo bar=""baz"" quux='quuux'/>";
\r
1167 RunTest (xml, new TestMethod (MoveToNextAttribute));
\r
1170 public void MoveToNextAttribute (XmlReader xmlReader)
\r
1172 AssertStartDocument (xmlReader);
\r
1175 xmlReader, // xmlReader
\r
1176 XmlNodeType.Element, // nodeType
\r
1178 true, // isEmptyElement
\r
1180 String.Empty, // prefix
\r
1181 "foo", // localName
\r
1182 String.Empty, // namespaceURI
\r
1183 String.Empty, // value
\r
1184 2 // attributeCount
\r
1188 xmlReader, // xmlReader
\r
1190 String.Empty, // prefix
\r
1191 "bar", // localName
\r
1192 String.Empty, // namespaceURI
\r
1197 xmlReader, // xmlReader
\r
1199 String.Empty, // prefix
\r
1200 "quux", // localName
\r
1201 String.Empty, // namespaceURI
\r
1205 Assert (xmlReader.MoveToNextAttribute ());
\r
1206 AssertEquals ("bar", xmlReader.Name);
\r
1207 AssertEquals ("baz", xmlReader.Value);
\r
1209 Assert (xmlReader.MoveToNextAttribute ());
\r
1210 AssertEquals ("quux", xmlReader.Name);
\r
1211 AssertEquals ("quuux", xmlReader.Value);
\r
1213 Assert (!xmlReader.MoveToNextAttribute ());
\r
1215 Assert (xmlReader.MoveToElement ());
\r
1217 AssertNodeValues (
\r
1219 xmlReader, // xmlReader
\r
1220 XmlNodeType.Element, // nodeType
\r
1222 true, // isEmptyElement
\r
1224 String.Empty, // prefix
\r
1225 "foo", // localName
\r
1226 String.Empty, // namespaceURI
\r
1227 String.Empty, // value
\r
1228 2 // attributeCount
\r
1231 AssertEndDocument (xmlReader);
\r
1235 // [Category ("NotDotNet")] // MS XmlNodeReader never moves to xml declaration.
\r
1236 [Ignore ("Too inconsistent reference implementations to determine which is correct behavior.")]
\r
1237 public void MoveToXmlDeclAttributes ()
\r
1239 string xml = "<?xml version=\"1.0\" standalone=\"yes\"?><root/>";
\r
1240 RunTest (xml, new TestMethod (MoveToXmlDeclAttributes));
\r
1243 public void MoveToXmlDeclAttributes (XmlReader xmlReader)
\r
1245 xmlReader.Read ();
\r
1246 this.AssertNodeValues ("#1", xmlReader,
\r
1247 XmlNodeType.XmlDeclaration,
\r
1254 "version=\"1.0\" standalone=\"yes\"",
\r
1256 Assert ("MoveToFirstAttribute",
\r
1257 xmlReader.MoveToFirstAttribute ());
\r
1258 this.AssertNodeValues ("#2", xmlReader,
\r
1259 XmlNodeType.Attribute,
\r
1260 0, // FIXME: might be 1
\r
1268 xmlReader.ReadAttributeValue ();
\r
1269 this.AssertNodeValues ("#3", xmlReader,
\r
1271 1, // FIXME might be 2
\r
1274 null, // FIXME: should be String.Empty,
\r
1276 null, // FIXME: should be String.Empty,
\r
1279 xmlReader.MoveToNextAttribute ();
\r
1280 this.AssertNodeValues ("#4", xmlReader,
\r
1281 XmlNodeType.Attribute,
\r
1282 0, // FIXME: might be 1
\r
1290 xmlReader.ReadAttributeValue ();
\r
1291 this.AssertNodeValues ("#5", xmlReader,
\r
1293 1, // FIXME: might be 2
\r
1296 null, // FIXME: should be String.Empty,
\r
1298 null, // FIXME: should be String.Empty,
\r
1304 public void AttributeOrder ()
\r
1306 string xml = @"<foo _1='1' _2='2' _3='3' />";
\r
1307 RunTest (xml, new TestMethod (AttributeOrder));
\r
1310 public void AttributeOrder (XmlReader xmlReader)
\r
1312 Assert (xmlReader.Read ());
\r
1313 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1315 Assert (xmlReader.MoveToFirstAttribute ());
\r
1316 AssertEquals ("_1", xmlReader.Name);
\r
1317 Assert (xmlReader.MoveToNextAttribute ());
\r
1318 AssertEquals ("_2", xmlReader.Name);
\r
1319 Assert (xmlReader.MoveToNextAttribute ());
\r
1320 AssertEquals ("_3", xmlReader.Name);
\r
1322 Assert (!xmlReader.MoveToNextAttribute ());
\r
1326 [Category ("NotDotNet")]
\r
1327 public void IndexerAndAttributes ()
\r
1329 string xml = @"<?xml version='1.0' standalone='no'?><foo _1='1' _2='2' _3='3' />";
\r
1330 RunTest (xml, new TestMethod (IndexerAndAttributes));
\r
1333 public void IndexerAndAttributes (XmlReader xmlReader)
\r
1335 Assert (xmlReader.Read ());
\r
1336 AssertEquals ("1.0", xmlReader ["version"]);
\r
1337 AssertEquals ("1.0", xmlReader.GetAttribute ("version"));
\r
1338 // .NET 1.1 BUG. XmlTextReader returns null, while XmlNodeReader returns "".
\r
1339 AssertEquals (null, xmlReader ["encoding"]);
\r
1340 AssertEquals (null, xmlReader.GetAttribute ("encoding"));
\r
1341 AssertEquals ("no", xmlReader ["standalone"]);
\r
1342 AssertEquals ("no", xmlReader.GetAttribute ("standalone"));
\r
1343 AssertEquals ("1.0", xmlReader [0]);
\r
1344 AssertEquals ("1.0", xmlReader.GetAttribute (0));
\r
1345 AssertEquals ("no", xmlReader [1]);
\r
1346 AssertEquals ("no", xmlReader.GetAttribute (1));
\r
1348 Assert (xmlReader.Read ());
\r
1349 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1350 AssertEquals ("1", xmlReader ["_1"]);
\r
1352 Assert (xmlReader.MoveToFirstAttribute ());
\r
1353 AssertEquals ("_1", xmlReader.Name);
\r
1354 AssertEquals ("1", xmlReader ["_1"]);
\r
1355 Assert (xmlReader.MoveToNextAttribute ());
\r
1356 AssertEquals ("_2", xmlReader.Name);
\r
1357 AssertEquals ("1", xmlReader ["_1"]);
\r
1358 Assert (xmlReader.MoveToNextAttribute ());
\r
1359 AssertEquals ("_3", xmlReader.Name);
\r
1360 AssertEquals ("1", xmlReader ["_1"]);
\r
1362 Assert (!xmlReader.MoveToNextAttribute ());
\r
1366 public void ProhibitedMultipleAttributes ()
\r
1368 string xml = @"<foo _1='1' _1='1' />";
\r
1370 RunTest (xml, new TestMethod (ReadAll));
\r
1371 } catch (XmlException) {
\r
1373 xml = @"<foo _1='1' _1='2' />";
\r
1375 RunTest (xml, new TestMethod (ReadAll));
\r
1376 } catch (XmlException) {
\r
1380 public void ReadAll (XmlReader xmlReader)
\r
1382 while (!xmlReader.EOF)
\r
1383 xmlReader.Read ();
\r
1387 public void SurrogatePairContent ()
\r
1389 string xml = "<root xmlns='𐄀'/>";
\r
1390 RunTest (xml, new TestMethod (SurrogatePairContent));
\r
1393 public void SurrogatePairContent (XmlReader xmlReader)
\r
1395 xmlReader.Read ();
\r
1396 AssertEquals (true, xmlReader.MoveToAttribute ("xmlns"));
\r
1397 AssertEquals ("xmlns", xmlReader.Name);
\r
1398 AssertEquals (2, xmlReader.Value.Length);
\r
1399 AssertEquals (0xD800, (int) xmlReader.Value [0]);
\r
1400 AssertEquals (0xDD00, (int) xmlReader.Value [1]);
\r
1404 public void ReadOuterXmlOnEndElement ()
\r
1406 string xml = "<root><foo></foo></root>";
\r
1407 RunTest (xml, new TestMethod (ReadOuterXmlOnEndElement));
\r
1410 public void ReadOuterXmlOnEndElement (XmlReader xmlReader)
\r
1412 xmlReader.Read ();
\r
1413 xmlReader.Read ();
\r
1414 xmlReader.Read ();
\r
1415 AssertEquals (String.Empty, xmlReader.ReadOuterXml ());
\r
1419 public void ReadInnerXmlOnEndElement ()
\r
1421 string xml = "<root><foo></foo></root>";
\r
1422 RunTest (xml, new TestMethod (ReadInnerXmlOnEndElement));
\r
1425 private void ReadInnerXmlOnEndElement (XmlReader xmlReader)
\r
1427 xmlReader.Read ();
\r
1428 xmlReader.Read ();
\r
1429 xmlReader.Read ();
\r
1430 AssertEquals (String.Empty, xmlReader.ReadInnerXml ());
\r