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.XPath;
\r
18 using NUnit.Framework;
\r
20 namespace MonoTests.System.Xml
\r
23 public class XmlReaderTests : Assertion
\r
26 public void GetReady ()
\r
28 document = new XmlDocument ();
\r
29 document.LoadXml (xml1);
\r
32 XmlDocument document;
\r
33 const string xml1 = "<root attr1='value1'><child /></root>";
\r
34 const string xml2 = "<root><foo/><bar>test.</bar></root>";
\r
35 const string xml3 = "<root> test of <b>mixed</b> string.<![CDATA[ cdata string.]]></root>";
\r
36 const string xml4 = "<root>test of <b>mixed</b> string.</root>";
\r
40 // copy from XmlTextReaderTests
\r
41 private void AssertStartDocument (XmlReader xmlReader)
\r
43 Assert (xmlReader.ReadState == ReadState.Initial);
\r
44 Assert (xmlReader.NodeType == XmlNodeType.None);
\r
45 Assert (xmlReader.Depth == 0);
\r
46 Assert (!xmlReader.EOF);
\r
49 private void AssertNode (
\r
50 XmlReader xmlReader,
\r
51 XmlNodeType nodeType,
\r
53 bool isEmptyElement,
\r
57 string namespaceURI,
\r
61 Assert ("Read() return value", xmlReader.Read ());
\r
62 Assert ("ReadState", xmlReader.ReadState == ReadState.Interactive);
\r
63 Assert ("!EOF", !xmlReader.EOF);
\r
64 AssertNodeValues (xmlReader, nodeType, depth, isEmptyElement, name, prefix, localName, namespaceURI, value, attributeCount);
\r
67 private void AssertNodeValues (
\r
68 XmlReader xmlReader,
\r
69 XmlNodeType nodeType,
\r
71 bool isEmptyElement,
\r
75 string namespaceURI,
\r
79 AssertNodeValues (xmlReader, nodeType, depth, isEmptyElement, name, prefix, localName, namespaceURI, value, value != String.Empty, attributeCount, attributeCount > 0);
\r
82 private void AssertNodeValues (
\r
83 XmlReader xmlReader,
\r
84 XmlNodeType nodeType,
\r
86 bool isEmptyElement,
\r
90 string namespaceURI,
\r
96 AssertEquals ("NodeType", nodeType, xmlReader.NodeType);
\r
97 AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);
\r
99 AssertEquals ("name", name, xmlReader.Name);
\r
101 AssertEquals ("prefix", prefix, xmlReader.Prefix);
\r
103 AssertEquals ("localName", localName, xmlReader.LocalName);
\r
105 AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI);
\r
107 AssertEquals ("Depth", depth, xmlReader.Depth);
\r
109 AssertEquals ("hasValue", hasValue, xmlReader.HasValue);
\r
111 AssertEquals ("Value", value, xmlReader.Value);
\r
113 AssertEquals ("hasAttributes", hasAttributes, xmlReader.HasAttributes);
\r
115 AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount);
\r
118 private void AssertAttribute (
\r
119 XmlReader xmlReader,
\r
123 string namespaceURI,
\r
126 AssertEquals ("value", value, xmlReader [name]);
\r
128 Assert (xmlReader.GetAttribute (name) == value);
\r
130 if (namespaceURI != String.Empty) {
\r
131 Assert (xmlReader[localName, namespaceURI] == value);
\r
132 Assert (xmlReader.GetAttribute (localName, namespaceURI) == value);
\r
136 private void AssertEndDocument (XmlReader xmlReader)
\r
138 Assert ("could read", !xmlReader.Read ());
\r
139 AssertEquals ("NodeType is not XmlNodeType.None", XmlNodeType.None, xmlReader.NodeType);
\r
140 AssertEquals ("Depth is not 0", 0, xmlReader.Depth);
\r
141 AssertEquals ("ReadState is not ReadState.EndOfFile", ReadState.EndOfFile, xmlReader.ReadState);
\r
142 Assert ("not EOF", xmlReader.EOF);
\r
144 xmlReader.Close ();
\r
145 AssertEquals ("ReadState is not ReadState.Cosed", ReadState.Closed, xmlReader.ReadState);
\r
148 private delegate void TestMethod (XmlReader reader);
\r
150 private void RunTest (string xml, TestMethod method)
\r
152 xtr = new XmlTextReader (new StringReader (xml));
\r
156 xtr = new XmlTextReader (new StringReader (xml));
\r
157 XmlValidatingReader xvr = new XmlValidatingReader (xtr);
\r
158 xvr.ValidationType = ValidationType.DTD;
\r
159 xvr.EntityHandling = EntityHandling.ExpandCharEntities;
\r
163 xtr = new XmlTextReader (new StringReader (xml));
\r
164 xvr = new XmlValidatingReader (xtr);
\r
165 xvr.EntityHandling = EntityHandling.ExpandCharEntities;
\r
168 document.XmlResolver = null;
\r
169 document.LoadXml (xml);
\r
170 xnr = new XmlNodeReader (document);
\r
179 public void InitialState ()
\r
181 RunTest (xml1, new TestMethod (InitialState));
\r
184 private void InitialState (XmlReader reader)
\r
186 AssertEquals ("Depth", 0, reader.Depth);
\r
187 AssertEquals ("EOF", false, reader.EOF);
\r
188 AssertEquals ("HasValue", false, reader.HasValue);
\r
189 AssertEquals ("IsEmptyElement", false, reader.IsEmptyElement);
\r
190 AssertEquals ("LocalName", String.Empty, reader.LocalName);
\r
191 AssertEquals ("NodeType", XmlNodeType.None, reader.NodeType);
\r
192 AssertEquals ("ReadState", ReadState.Initial, reader.ReadState);
\r
196 public void Read ()
\r
198 RunTest (xml1, new TestMethod (Read));
\r
201 public void Read (XmlReader reader)
\r
204 AssertEquals ("<root>.NodeType", XmlNodeType.Element, reader.NodeType);
\r
205 AssertEquals ("<root>.Name", "root", reader.Name);
\r
206 AssertEquals ("<root>.ReadState", ReadState.Interactive, reader.ReadState);
\r
207 AssertEquals ("<root>.Depth", 0, reader.Depth);
\r
211 AssertEquals ("<child/>.Depth", 1, reader.Depth);
\r
212 AssertEquals ("<child/>.NodeType", XmlNodeType.Element, reader.NodeType);
\r
213 AssertEquals ("<child/>.Name", "child", reader.Name);
\r
216 AssertEquals ("</root>.Depth", 0, reader.Depth);
\r
217 AssertEquals ("</root>.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
218 AssertEquals ("</root>.Name", "root", reader.Name);
\r
221 AssertEquals ("end.EOF", true, reader.EOF);
\r
222 AssertEquals ("end.NodeType", XmlNodeType.None, reader.NodeType);
\r
226 public void ReadAttributeValue ()
\r
228 RunTest ("<root attr=''/>", new TestMethod (ReadAttributeValue));
\r
231 public void ReadAttributeValue (XmlReader reader)
\r
233 reader.Read (); // root
\r
234 Assert (reader.MoveToFirstAttribute ());
\r
235 // It looks like that MS.NET shows AttributeCount and
\r
236 // HasAttributes as the same as element node!
\r
237 this.AssertNodeValues (reader, XmlNodeType.Attribute,
\r
238 1, false, "attr", "", "attr", "", "", true, 1, true);
\r
239 Assert (reader.ReadAttributeValue ());
\r
240 // MS.NET XmlTextReader fails. Its Prefix returns null instead of "".
\r
241 this.AssertNodeValues (reader, XmlNodeType.Text,
\r
242 2, false, "", "", "", "", "", true, 1, true);
\r
243 Assert (reader.MoveToElement ());
\r
244 this.AssertNodeValues (reader, XmlNodeType.Element,
\r
245 0, true, "root", "", "root", "", "", false, 1, true);
\r
249 public void ReadEmptyElement ()
\r
251 RunTest (xml2, new TestMethod (ReadEmptyElement));
\r
254 public void ReadEmptyElement (XmlReader reader)
\r
256 reader.Read (); // root
\r
257 AssertEquals (false, reader.IsEmptyElement);
\r
258 reader.Read (); // foo
\r
259 AssertEquals ("foo", reader.Name);
\r
260 AssertEquals (true, reader.IsEmptyElement);
\r
261 reader.Read (); // bar
\r
262 AssertEquals ("bar", reader.Name);
\r
263 AssertEquals (false, reader.IsEmptyElement);
\r
267 public void ReadStringFromElement ()
\r
269 RunTest (xml3, new TestMethod (ReadStringFromElement));
\r
272 public void ReadStringFromElement (XmlReader reader)
\r
274 // Note: ReadString() test works only when the reader is
\r
275 // positioned at the container element.
\r
276 // In case the reader is positioned at the first
\r
277 // character node, XmlTextReader and XmlNodeReader works
\r
281 string s = reader.ReadString ();
\r
282 AssertEquals ("readString.1.ret_val", " test of ", s);
\r
283 AssertEquals ("readString.1.Name", "b", reader.Name);
\r
284 s = reader.ReadString ();
\r
285 AssertEquals ("readString.2.ret_val", "mixed", s);
\r
286 AssertEquals ("readString.2.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
287 s = reader.ReadString (); // never proceeds.
\r
288 AssertEquals ("readString.3.ret_val", String.Empty, s);
\r
289 AssertEquals ("readString.3.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
291 AssertEquals ("readString.4.NodeType", XmlNodeType.Text, reader.NodeType);
\r
292 AssertEquals ("readString.4.Value", " string.", reader.Value);
\r
293 s = reader.ReadString (); // reads the same Text node.
\r
294 AssertEquals ("readString.5.ret_val", " string. cdata string.", s);
\r
295 AssertEquals ("readString.5.NodeType", XmlNodeType.EndElement, reader.NodeType);
\r
299 public void ReadInnerXml ()
\r
301 const string xml = "<root><foo>test of <b>mixed</b> string.</foo><bar /></root>";
\r
302 RunTest (xml, new TestMethod (ReadInnerXml));
\r
305 public void ReadInnerXml (XmlReader reader)
\r
309 AssertEquals ("initial.ReadState", ReadState.Interactive, reader.ReadState);
\r
310 AssertEquals ("initial.EOF", false, reader.EOF);
\r
311 AssertEquals ("initial.NodeType", XmlNodeType.Element, reader.NodeType);
\r
312 string s = reader.ReadInnerXml ();
\r
313 AssertEquals ("read_all", "test of <b>mixed</b> string.", s);
\r
314 AssertEquals ("after.Name", "bar", reader.Name);
\r
315 AssertEquals ("after.NodeType", XmlNodeType.Element, reader.NodeType);
\r
320 public void EmptyElement ()
\r
322 RunTest ("<foo/>", new TestMethod (EmptyElement));
\r
325 public void EmptyElement (XmlReader xmlReader)
\r
328 AssertStartDocument (xmlReader);
\r
331 xmlReader, // xmlReader
\r
332 XmlNodeType.Element, // nodeType
\r
334 true, // isEmptyElement
\r
336 String.Empty, // prefix
\r
337 "foo", // localName
\r
338 String.Empty, // namespaceURI
\r
339 String.Empty, // value
\r
340 0 // attributeCount
\r
343 AssertEndDocument (xmlReader);
\r
347 public void NestedEmptyTag ()
\r
349 string xml = "<foo><bar/></foo>";
\r
350 RunTest (xml, new TestMethod (NestedEmptyTag));
\r
353 public void NestedEmptyTag (XmlReader xmlReader)
\r
355 AssertStartDocument (xmlReader);
\r
358 xmlReader, // xmlReader
\r
359 XmlNodeType.Element, // nodeType
\r
361 false, // isEmptyElement
\r
363 String.Empty, // prefix
\r
364 "foo", // localName
\r
365 String.Empty, // namespaceURI
\r
366 String.Empty, // value
\r
367 0 // attributeCount
\r
371 xmlReader, // xmlReader
\r
372 XmlNodeType.Element, // nodeType
\r
374 true, // isEmptyElement
\r
376 String.Empty, // prefix
\r
377 "bar", // localName
\r
378 String.Empty, // namespaceURI
\r
379 String.Empty, // value
\r
380 0 // attributeCount
\r
384 xmlReader, // xmlReader
\r
385 XmlNodeType.EndElement, // nodeType
\r
387 false, // isEmptyElement
\r
389 String.Empty, // prefix
\r
390 "foo", // localName
\r
391 String.Empty, // namespaceURI
\r
392 String.Empty, // value
\r
393 0 // attributeCount
\r
396 AssertEndDocument (xmlReader);
\r
400 public void NestedText ()
\r
402 string xml = "<foo>bar</foo>";
\r
403 RunTest (xml, new TestMethod (NestedText));
\r
406 public void NestedText (XmlReader xmlReader)
\r
408 AssertStartDocument (xmlReader);
\r
411 xmlReader, // xmlReader
\r
412 XmlNodeType.Element, // nodeType
\r
414 false, // isEmptyElement
\r
416 String.Empty, // prefix
\r
417 "foo", // localName
\r
418 String.Empty, // namespaceURI
\r
419 String.Empty, // value
\r
420 0 // attributeCount
\r
424 xmlReader, // xmlReader
\r
425 XmlNodeType.Text, // nodeType
\r
427 false, // isEmptyElement
\r
428 String.Empty, // name
\r
429 String.Empty, // prefix
\r
430 String.Empty, // localName
\r
431 String.Empty, // namespaceURI
\r
433 0 // attributeCount
\r
437 xmlReader, // xmlReader
\r
438 XmlNodeType.EndElement, // nodeType
\r
440 false, // isEmptyElement
\r
442 String.Empty, // prefix
\r
443 "foo", // localName
\r
444 String.Empty, // namespaceURI
\r
445 String.Empty, // value
\r
446 0 // attributeCount
\r
449 AssertEndDocument (xmlReader);
\r
453 public void EmptyElementWithAttributes ()
\r
455 string xml = @"<foo bar=""baz"" quux='quuux' x:foo='x-foo' xmlns:x = 'urn:xfoo' />";
\r
456 RunTest (xml, new TestMethod (EmptyElementWithAttributes ));
\r
459 public void EmptyElementWithAttributes (XmlReader xmlReader)
\r
462 AssertStartDocument (xmlReader);
\r
465 xmlReader, // xmlReader
\r
466 XmlNodeType.Element, // nodeType
\r
468 true, // isEmptyElement
\r
470 String.Empty, // prefix
\r
471 "foo", // localName
\r
472 String.Empty, // namespaceURI
\r
473 String.Empty, // value
\r
474 4 // attributeCount
\r
478 xmlReader, // xmlReader
\r
480 String.Empty, // prefix
\r
481 "bar", // localName
\r
482 String.Empty, // namespaceURI
\r
487 xmlReader, // xmlReader
\r
489 String.Empty, // prefix
\r
490 "quux", // localName
\r
491 String.Empty, // namespaceURI
\r
496 xmlReader, // xmlReader
\r
497 "notexist", // name
\r
498 String.Empty, // prefix
\r
499 "notexist", // localName
\r
500 String.Empty, // namespaceURI
\r
505 xmlReader, // xmlReader
\r
508 "foo", // localName
\r
509 "urn:xfoo", // namespaceURI
\r
514 xmlReader, // xmlReader
\r
517 "bar", // localName
\r
518 "urn:xfoo", // namespaceURI
\r
522 AssertEndDocument (xmlReader);
\r
526 public void ProcessingInstructionBeforeDocumentElement ()
\r
528 string xml = "<?foo bar?><baz/>";
\r
529 RunTest (xml, new TestMethod (ProcessingInstructionBeforeDocumentElement));
\r
532 public void ProcessingInstructionBeforeDocumentElement (XmlReader xmlReader)
\r
534 AssertStartDocument (xmlReader);
\r
537 xmlReader, // xmlReader
\r
538 XmlNodeType.ProcessingInstruction, // nodeType
\r
540 false, // isEmptyElement
\r
542 String.Empty, // prefix
\r
543 "foo", // localName
\r
544 String.Empty, // namespaceURI
\r
546 0 // attributeCount
\r
550 xmlReader, // xmlReader
\r
551 XmlNodeType.Element, // nodeType
\r
553 true, // isEmptyElement
\r
555 String.Empty, // prefix
\r
556 "baz", // localName
\r
557 String.Empty, // namespaceURI
\r
558 String.Empty, // value
\r
559 0 // attributeCount
\r
562 AssertEndDocument (xmlReader);
\r
566 public void CommentBeforeDocumentElement ()
\r
568 string xml = "<!--foo--><bar/>";
\r
569 RunTest (xml, new TestMethod (CommentBeforeDocumentElement));
\r
572 public void CommentBeforeDocumentElement (XmlReader xmlReader)
\r
574 AssertStartDocument (xmlReader);
\r
577 xmlReader, // xmlReader
\r
578 XmlNodeType.Comment, // nodeType
\r
580 false, // isEmptyElement
\r
581 String.Empty, // name
\r
582 String.Empty, // prefix
\r
583 String.Empty, // localName
\r
584 String.Empty, // namespaceURI
\r
586 0 // attributeCount
\r
590 xmlReader, // xmlReader
\r
591 XmlNodeType.Element, // nodeType
\r
593 true, // isEmptyElement
\r
595 String.Empty, // prefix
\r
596 "bar", // localName
\r
597 String.Empty, // namespaceURI
\r
598 String.Empty, // value
\r
599 0 // attributeCount
\r
602 AssertEndDocument (xmlReader);
\r
606 public void PredefinedEntities ()
\r
608 string xml = "<foo><>&'"</foo>";
\r
609 RunTest (xml, new TestMethod (PredefinedEntities));
\r
612 public void PredefinedEntities (XmlReader xmlReader)
\r
614 AssertStartDocument (xmlReader);
\r
617 xmlReader, // xmlReader
\r
618 XmlNodeType.Element, // nodeType
\r
620 false, // isEmptyElement
\r
622 String.Empty, // prefix
\r
623 "foo", // localName
\r
624 String.Empty, // namespaceURI
\r
625 String.Empty, // value
\r
626 0 // attributeCount
\r
630 xmlReader, // xmlReader
\r
631 XmlNodeType.Text, // nodeType
\r
633 false, // isEmptyElement
\r
634 String.Empty, // name
\r
635 String.Empty, // prefix
\r
636 String.Empty, // localName
\r
637 String.Empty, // namespaceURI
\r
639 0 // attributeCount
\r
643 xmlReader, // xmlReader
\r
644 XmlNodeType.EndElement, // nodeType
\r
646 false, // isEmptyElement
\r
648 String.Empty, // prefix
\r
649 "foo", // localName
\r
650 String.Empty, // namespaceURI
\r
651 String.Empty, // value
\r
652 0 // attributeCount
\r
655 AssertEndDocument (xmlReader);
\r
659 public void CharacterReferences ()
\r
661 string xml = "<foo>FOO</foo>";
\r
662 RunTest (xml, new TestMethod (CharacterReferences));
\r
665 public void CharacterReferences (XmlReader xmlReader)
\r
667 AssertStartDocument (xmlReader);
\r
670 xmlReader, // xmlReader
\r
671 XmlNodeType.Element, // nodeType
\r
673 false, // isEmptyElement
\r
675 String.Empty, // prefix
\r
676 "foo", // localName
\r
677 String.Empty, // namespaceURI
\r
678 String.Empty, // value
\r
679 0 // attributeCount
\r
683 xmlReader, // xmlReader
\r
684 XmlNodeType.Text, // nodeType
\r
686 false, // isEmptyElement
\r
687 String.Empty, // name
\r
688 String.Empty, // prefix
\r
689 String.Empty, // localName
\r
690 String.Empty, // namespaceURI
\r
692 0 // attributeCount
\r
696 xmlReader, // xmlReader
\r
697 XmlNodeType.EndElement, // nodeType
\r
699 false, // isEmptyElement
\r
701 String.Empty, // prefix
\r
702 "foo", // localName
\r
703 String.Empty, // namespaceURI
\r
704 String.Empty, // value
\r
705 0 // attributeCount
\r
708 AssertEndDocument (xmlReader);
\r
712 public void PredefinedEntitiesInAttribute ()
\r
714 string xml = "<foo bar='<>&'"'/>";
\r
715 RunTest (xml, new TestMethod (PredefinedEntitiesInAttribute ));
\r
718 public void PredefinedEntitiesInAttribute (XmlReader xmlReader)
\r
720 AssertStartDocument (xmlReader);
\r
723 xmlReader, // xmlReader
\r
724 XmlNodeType.Element, // nodeType
\r
726 true, // isEmptyElement
\r
728 String.Empty, // prefix
\r
729 "foo", // localName
\r
730 String.Empty, // namespaceURI
\r
731 String.Empty, // value
\r
732 1 // attributeCount
\r
736 xmlReader, // xmlReader
\r
738 String.Empty, // prefix
\r
739 "bar", // localName
\r
740 String.Empty, // namespaceURI
\r
744 AssertEndDocument (xmlReader);
\r
748 public void CharacterReferencesInAttribute ()
\r
750 string xml = "<foo bar='FOO'/>";
\r
751 RunTest (xml, new TestMethod (CharacterReferencesInAttribute));
\r
754 public void CharacterReferencesInAttribute (XmlReader xmlReader)
\r
756 AssertStartDocument (xmlReader);
\r
759 xmlReader, // xmlReader
\r
760 XmlNodeType.Element, // nodeType
\r
762 true, // isEmptyElement
\r
764 String.Empty, // prefix
\r
765 "foo", // localName
\r
766 String.Empty, // namespaceURI
\r
767 String.Empty, // value
\r
768 1 // attributeCount
\r
772 xmlReader, // xmlReader
\r
774 String.Empty, // prefix
\r
775 "bar", // localName
\r
776 String.Empty, // namespaceURI
\r
780 AssertEndDocument (xmlReader);
\r
784 public void CDATA ()
\r
786 string xml = "<foo><![CDATA[<>&]]></foo>";
\r
787 RunTest (xml, new TestMethod (CDATA));
\r
790 public void CDATA (XmlReader xmlReader)
\r
792 AssertStartDocument (xmlReader);
\r
795 xmlReader, // xmlReader
\r
796 XmlNodeType.Element, // nodeType
\r
798 false, // isEmptyElement
\r
800 String.Empty, // prefix
\r
801 "foo", // localName
\r
802 String.Empty, // namespaceURI
\r
803 String.Empty, // value
\r
804 0 // attributeCount
\r
808 xmlReader, // xmlReader
\r
809 XmlNodeType.CDATA, // nodeType
\r
811 false, // isEmptyElement
\r
812 String.Empty, // name
\r
813 String.Empty, // prefix
\r
814 String.Empty, // localName
\r
815 String.Empty, // namespaceURI
\r
817 0 // attributeCount
\r
821 xmlReader, // xmlReader
\r
822 XmlNodeType.EndElement, // nodeType
\r
824 false, // isEmptyElement
\r
826 String.Empty, // prefix
\r
827 "foo", // localName
\r
828 String.Empty, // namespaceURI
\r
829 String.Empty, // value
\r
830 0 // attributeCount
\r
833 AssertEndDocument (xmlReader);
\r
837 public void EmptyElementInDefaultNamespace ()
\r
839 string xml = @"<foo xmlns='http://foo/' />";
\r
840 RunTest (xml, new TestMethod (EmptyElementInDefaultNamespace));
\r
843 public void EmptyElementInDefaultNamespace (XmlReader xmlReader)
\r
845 AssertStartDocument (xmlReader);
\r
848 xmlReader, // xmlReader
\r
849 XmlNodeType.Element, // nodeType
\r
851 true, // isEmptyElement
\r
853 String.Empty, // prefix
\r
854 "foo", // localName
\r
855 "http://foo/", // namespaceURI
\r
856 String.Empty, // value
\r
857 1 // attributeCount
\r
861 xmlReader, // xmlReader
\r
863 String.Empty, // prefix
\r
864 "xmlns", // localName
\r
865 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
866 "http://foo/" // value
\r
869 AssertEquals ("http://foo/", xmlReader.LookupNamespace (String.Empty));
\r
871 AssertEndDocument (xmlReader);
\r
875 public void ChildElementInNamespace ()
\r
877 string xml = @"<foo:bar xmlns:foo='http://foo/'><baz:quux xmlns:baz='http://baz/' /></foo:bar>";
\r
878 RunTest (xml, new TestMethod (ChildElementInNamespace));
\r
881 public void ChildElementInNamespace (XmlReader xmlReader)
\r
883 AssertStartDocument (xmlReader);
\r
886 xmlReader, // xmlReader
\r
887 XmlNodeType.Element, // nodeType
\r
889 false, // isEmptyElement
\r
892 "bar", // localName
\r
893 "http://foo/", // namespaceURI
\r
894 String.Empty, // value
\r
895 1 // attributeCount
\r
899 xmlReader, // xmlReader
\r
900 "xmlns:foo", // name
\r
902 "foo", // localName
\r
903 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
904 "http://foo/" // value
\r
907 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
910 xmlReader, // xmlReader
\r
911 XmlNodeType.Element, // nodeType
\r
913 true, // isEmptyElement
\r
914 "baz:quux", // name
\r
916 "quux", // localName
\r
917 "http://baz/", // namespaceURI
\r
918 String.Empty, // value
\r
919 1 // attributeCount
\r
923 xmlReader, // xmlReader
\r
924 "xmlns:baz", // name
\r
926 "baz", // localName
\r
927 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
928 "http://baz/" // value
\r
931 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
932 AssertEquals ("http://baz/", xmlReader.LookupNamespace ("baz"));
\r
935 xmlReader, // xmlReader
\r
936 XmlNodeType.EndElement, // nodeType
\r
938 false, // isEmptyElement
\r
941 "bar", // localName
\r
942 "http://foo/", // namespaceURI
\r
943 String.Empty, // value
\r
944 0 // attributeCount
\r
947 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
948 AssertNull (xmlReader.LookupNamespace ("baz"));
\r
950 AssertEndDocument (xmlReader);
\r
954 public void ChildElementInDefaultNamespace ()
\r
956 string xml = @"<foo:bar xmlns:foo='http://foo/'><baz xmlns='http://baz/' /></foo:bar>";
\r
957 RunTest (xml, new TestMethod (ChildElementInDefaultNamespace));
\r
960 public void ChildElementInDefaultNamespace (XmlReader xmlReader)
\r
962 AssertStartDocument (xmlReader);
\r
965 xmlReader, // xmlReader
\r
966 XmlNodeType.Element, // nodeType
\r
968 false, // isEmptyElement
\r
971 "bar", // localName
\r
972 "http://foo/", // namespaceURI
\r
973 String.Empty, // value
\r
974 1 // attributeCount
\r
978 xmlReader, // xmlReader
\r
979 "xmlns:foo", // name
\r
981 "foo", // localName
\r
982 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
983 "http://foo/" // value
\r
986 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
989 xmlReader, // xmlReader
\r
990 XmlNodeType.Element, // nodeType
\r
992 true, // isEmptyElement
\r
994 String.Empty, // prefix
\r
995 "baz", // localName
\r
996 "http://baz/", // namespaceURI
\r
997 String.Empty, // value
\r
998 1 // attributeCount
\r
1002 xmlReader, // xmlReader
\r
1004 String.Empty, // prefix
\r
1005 "xmlns", // localName
\r
1006 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
1007 "http://baz/" // value
\r
1010 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
1011 AssertEquals ("http://baz/", xmlReader.LookupNamespace (String.Empty));
\r
1014 xmlReader, // xmlReader
\r
1015 XmlNodeType.EndElement, // nodeType
\r
1017 false, // isEmptyElement
\r
1018 "foo:bar", // name
\r
1020 "bar", // localName
\r
1021 "http://foo/", // namespaceURI
\r
1022 String.Empty, // value
\r
1023 0 // attributeCount
\r
1026 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
\r
1028 AssertEndDocument (xmlReader);
\r
1032 public void AttributeInNamespace ()
\r
1034 string xml = @"<foo bar:baz='quux' xmlns:bar='http://bar/' />";
\r
1035 RunTest (xml, new TestMethod (AttributeInNamespace));
\r
1038 public void AttributeInNamespace (XmlReader xmlReader)
\r
1040 AssertStartDocument (xmlReader);
\r
1043 xmlReader, // xmlReader
\r
1044 XmlNodeType.Element, // nodeType
\r
1046 true, // isEmptyElement
\r
1048 String.Empty, // prefix
\r
1049 "foo", // localName
\r
1050 String.Empty, // namespaceURI
\r
1051 String.Empty, // value
\r
1052 2 // attributeCount
\r
1056 xmlReader, // xmlReader
\r
1057 "bar:baz", // name
\r
1059 "baz", // localName
\r
1060 "http://bar/", // namespaceURI
\r
1065 xmlReader, // xmlReader
\r
1066 "xmlns:bar", // name
\r
1067 "xmlns", // prefix
\r
1068 "bar", // localName
\r
1069 "http://www.w3.org/2000/xmlns/", // namespaceURI
\r
1070 "http://bar/" // value
\r
1073 AssertEquals ("http://bar/", xmlReader.LookupNamespace ("bar"));
\r
1075 AssertEndDocument (xmlReader);
\r
1079 public void MoveToElementFromAttribute ()
\r
1081 string xml = @"<foo bar=""baz"" />";
\r
1082 RunTest (xml, new TestMethod (MoveToElementFromAttribute));
\r
1085 public void MoveToElementFromAttribute (XmlReader xmlReader)
\r
1087 Assert (xmlReader.Read ());
\r
1088 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1089 Assert (xmlReader.MoveToFirstAttribute ());
\r
1090 AssertEquals (XmlNodeType.Attribute, xmlReader.NodeType);
\r
1091 Assert (xmlReader.MoveToElement ());
\r
1092 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1096 public void MoveToElementFromElement ()
\r
1098 string xml = @"<foo bar=""baz"" />";
\r
1099 RunTest (xml, new TestMethod (MoveToElementFromElement));
\r
1102 public void MoveToElementFromElement (XmlReader xmlReader)
\r
1104 Assert (xmlReader.Read ());
\r
1105 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1106 Assert (!xmlReader.MoveToElement ());
\r
1107 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1111 public void MoveToFirstAttributeWithNoAttributes ()
\r
1113 string xml = @"<foo />";
\r
1114 RunTest (xml, new TestMethod (MoveToFirstAttributeWithNoAttributes));
\r
1117 public void MoveToFirstAttributeWithNoAttributes (XmlReader xmlReader)
\r
1119 Assert (xmlReader.Read ());
\r
1120 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1121 Assert (!xmlReader.MoveToFirstAttribute ());
\r
1122 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1126 public void MoveToNextAttributeWithNoAttributes ()
\r
1128 string xml = @"<foo />";
\r
1129 RunTest (xml, new TestMethod (MoveToNextAttributeWithNoAttributes));
\r
1132 public void MoveToNextAttributeWithNoAttributes (XmlReader xmlReader)
\r
1134 Assert (xmlReader.Read ());
\r
1135 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1136 Assert (!xmlReader.MoveToNextAttribute ());
\r
1137 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1141 public void MoveToNextAttribute()
\r
1143 string xml = @"<foo bar=""baz"" quux='quuux'/>";
\r
1144 RunTest (xml, new TestMethod (MoveToNextAttribute));
\r
1147 public void MoveToNextAttribute (XmlReader xmlReader)
\r
1149 AssertStartDocument (xmlReader);
\r
1152 xmlReader, // xmlReader
\r
1153 XmlNodeType.Element, // nodeType
\r
1155 true, // isEmptyElement
\r
1157 String.Empty, // prefix
\r
1158 "foo", // localName
\r
1159 String.Empty, // namespaceURI
\r
1160 String.Empty, // value
\r
1161 2 // attributeCount
\r
1165 xmlReader, // xmlReader
\r
1167 String.Empty, // prefix
\r
1168 "bar", // localName
\r
1169 String.Empty, // namespaceURI
\r
1174 xmlReader, // xmlReader
\r
1176 String.Empty, // prefix
\r
1177 "quux", // localName
\r
1178 String.Empty, // namespaceURI
\r
1182 Assert (xmlReader.MoveToNextAttribute ());
\r
1183 AssertEquals ("bar", xmlReader.Name);
\r
1184 AssertEquals ("baz", xmlReader.Value);
\r
1186 Assert (xmlReader.MoveToNextAttribute ());
\r
1187 AssertEquals ("quux", xmlReader.Name);
\r
1188 AssertEquals ("quuux", xmlReader.Value);
\r
1190 Assert (!xmlReader.MoveToNextAttribute ());
\r
1192 Assert (xmlReader.MoveToElement ());
\r
1194 AssertNodeValues (
\r
1195 xmlReader, // xmlReader
\r
1196 XmlNodeType.Element, // nodeType
\r
1198 true, // isEmptyElement
\r
1200 String.Empty, // prefix
\r
1201 "foo", // localName
\r
1202 String.Empty, // namespaceURI
\r
1203 String.Empty, // value
\r
1204 2 // attributeCount
\r
1207 AssertEndDocument (xmlReader);
\r
1211 [Ignore ("XmlNodeReader never moves to xml declaration.")]
\r
1212 public void MoveToXmlDeclAttributes ()
\r
1214 string xml = "<?xml version=\"1.0\" standalone=\"yes\"?><root/>";
\r
1215 RunTest (xml, new TestMethod (MoveToXmlDeclAttributes));
\r
1218 public void MoveToXmlDeclAttributes (XmlReader xmlReader)
\r
1220 xmlReader.Read ();
\r
1221 this.AssertNodeValues (xmlReader,
\r
1222 XmlNodeType.XmlDeclaration,
\r
1229 "version=\"1.0\" standalone=\"yes\"",
\r
1231 xmlReader.MoveToFirstAttribute ();
\r
1232 this.AssertNodeValues (xmlReader,
\r
1233 XmlNodeType.Attribute,
\r
1242 xmlReader.ReadAttributeValue ();
\r
1243 this.AssertNodeValues (xmlReader,
\r
1253 xmlReader.MoveToNextAttribute ();
\r
1254 this.AssertNodeValues (xmlReader,
\r
1255 XmlNodeType.Attribute,
\r
1264 xmlReader.ReadAttributeValue ();
\r
1265 this.AssertNodeValues (xmlReader,
\r
1278 public void AttributeOrder ()
\r
1280 string xml = @"<foo _1='1' _2='2' _3='3' />";
\r
1281 RunTest (xml, new TestMethod (AttributeOrder));
\r
1284 public void AttributeOrder (XmlReader xmlReader)
\r
1286 Assert (xmlReader.Read ());
\r
1287 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1289 Assert (xmlReader.MoveToFirstAttribute ());
\r
1290 AssertEquals ("_1", xmlReader.Name);
\r
1291 Assert (xmlReader.MoveToNextAttribute ());
\r
1292 AssertEquals ("_2", xmlReader.Name);
\r
1293 Assert (xmlReader.MoveToNextAttribute ());
\r
1294 AssertEquals ("_3", xmlReader.Name);
\r
1296 Assert (!xmlReader.MoveToNextAttribute ());
\r
1300 public void IndexerAndAttributes ()
\r
1302 string xml = @"<?xml version='1.0' standalone='no'?><foo _1='1' _2='2' _3='3' />";
\r
1303 RunTest (xml, new TestMethod (IndexerAndAttributes));
\r
1306 public void IndexerAndAttributes (XmlReader xmlReader)
\r
1308 Assert (xmlReader.Read ());
\r
1309 AssertEquals ("1.0", xmlReader ["version"]);
\r
1310 AssertEquals ("1.0", xmlReader.GetAttribute ("version"));
\r
1311 // .NET 1.1 BUG. XmlTextReader returns null, while XmlNodeReader returns "".
\r
1312 AssertEquals (null, xmlReader ["encoding"]);
\r
1313 AssertEquals (null, xmlReader.GetAttribute ("encoding"));
\r
1314 AssertEquals ("no", xmlReader ["standalone"]);
\r
1315 AssertEquals ("no", xmlReader.GetAttribute ("standalone"));
\r
1316 AssertEquals ("1.0", xmlReader [0]);
\r
1317 AssertEquals ("1.0", xmlReader.GetAttribute (0));
\r
1318 AssertEquals ("no", xmlReader [1]);
\r
1319 AssertEquals ("no", xmlReader.GetAttribute (1));
\r
1321 Assert (xmlReader.Read ());
\r
1322 AssertEquals (XmlNodeType.Element, xmlReader.NodeType);
\r
1323 AssertEquals ("1", xmlReader ["_1"]);
\r
1325 Assert (xmlReader.MoveToFirstAttribute ());
\r
1326 AssertEquals ("_1", xmlReader.Name);
\r
1327 AssertEquals ("1", xmlReader ["_1"]);
\r
1328 Assert (xmlReader.MoveToNextAttribute ());
\r
1329 AssertEquals ("_2", xmlReader.Name);
\r
1330 AssertEquals ("1", xmlReader ["_1"]);
\r
1331 Assert (xmlReader.MoveToNextAttribute ());
\r
1332 AssertEquals ("_3", xmlReader.Name);
\r
1333 AssertEquals ("1", xmlReader ["_1"]);
\r
1335 Assert (!xmlReader.MoveToNextAttribute ());
\r
1339 public void ProhibitedMultipleAttributes ()
\r
1341 string xml = @"<foo _1='1' _1='1' />";
\r
1343 RunTest (xml, new TestMethod (ReadAll));
\r
1344 } catch (XmlException) {
\r
1346 xml = @"<foo _1='1' _1='2' />";
\r
1348 RunTest (xml, new TestMethod (ReadAll));
\r
1349 } catch (XmlException) {
\r
1353 public void ReadAll (XmlReader xmlReader)
\r
1355 while (!xmlReader.EOF)
\r
1356 xmlReader.Read ();
\r
1360 public void SurrogatePairContent ()
\r
1362 string xml = "<root xmlns='𐄀'/>";
\r
1363 RunTest (xml, new TestMethod (SurrogatePairContent));
\r
1366 public void SurrogatePairContent (XmlReader xmlReader)
\r
1368 xmlReader.Read ();
\r
1369 AssertEquals (true, xmlReader.MoveToAttribute ("xmlns"));
\r
1370 AssertEquals ("xmlns", xmlReader.Name);
\r
1371 AssertEquals (2, xmlReader.Value.Length);
\r
1372 AssertEquals (0xD800, (int) xmlReader.Value [0]);
\r
1373 AssertEquals (0xDD00, (int) xmlReader.Value [1]);
\r
1377 public void ReadOuterXmlOnEndElement ()
\r
1379 string xml = "<root><foo></foo></root>";
\r
1380 RunTest (xml, new TestMethod (ReadOuterXmlOnEndElement));
\r
1383 public void ReadOuterXmlOnEndElement (XmlReader xmlReader)
\r
1385 xmlReader.Read ();
\r
1386 xmlReader.Read ();
\r
1387 xmlReader.Read ();
\r
1388 AssertEquals (String.Empty, xmlReader.ReadOuterXml ());
\r
1392 public void ReadInnerXmlOnEndElement ()
\r
1394 string xml = "<root><foo></foo></root>";
\r
1395 RunTest (xml, new TestMethod (ReadInnerXmlOnEndElement));
\r
1398 public void ReadInnerXmlOnEndElement (XmlReader xmlReader)
\r
1400 xmlReader.Read ();
\r
1401 xmlReader.Read ();
\r
1402 xmlReader.Read ();
\r
1403 AssertEquals (String.Empty, xmlReader.ReadInnerXml ());
\r