?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(DISTFILES): Comment out a few missing files.
[mono-project.git] / mcs / class / System.XML / Test / System.Xml / XmlTextReaderTests.cs
blob3aa7759157e3beaf9c88cc5bb5dcad06be942969
1 //
2 // XmlTextReaderTests.cs
3 //
4 // Authors:
5 // Jason Diamond (jason@injektilo.org)
6 // Martin Willemoes Hansen (mwh@sysrq.dk)
7 //
8 // (C) 2001, 2002 Jason Diamond http://injektilo.org/
9 //
10
11 using System;
12 using System.IO;
13 using System.Xml;
14 using System.Text;
15
16 using NUnit.Framework;
17
18 namespace MonoTests.System.Xml
19 {
20 [TestFixture]
21 public class XmlTextReaderTests : Assertion
22 {
23 private void AssertStartDocument (XmlReader xmlReader)
24 {
25 Assert (xmlReader.ReadState == ReadState.Initial);
26 Assert (xmlReader.NodeType == XmlNodeType.None);
27 Assert (xmlReader.Depth == 0);
28 Assert (!xmlReader.EOF);
29 }
30
31 private void AssertNode (
32 XmlReader xmlReader,
33 XmlNodeType nodeType,
34 int depth,
35 bool isEmptyElement,
36 string name,
37 string prefix,
38 string localName,
39 string namespaceURI,
40 string value,
41 int attributeCount)
42 {
43 Assert ("#Read", xmlReader.Read ());
44 Assert ("#ReadState", xmlReader.ReadState == ReadState.Interactive);
45 Assert (!xmlReader.EOF);
46 AssertNodeValues (xmlReader, nodeType, depth, isEmptyElement, name, prefix, localName, namespaceURI, value, attributeCount);
47 }
48
49 private void AssertNodeValues (
50 XmlReader xmlReader,
51 XmlNodeType nodeType,
52 int depth,
53 bool isEmptyElement,
54 string name,
55 string prefix,
56 string localName,
57 string namespaceURI,
58 string value,
59 int attributeCount)
60 {
61 AssertEquals ("NodeType", nodeType, xmlReader.NodeType);
62 AssertEquals ("Depth", depth, xmlReader.Depth);
63 AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);
64
65 AssertEquals ("name", name, xmlReader.Name);
66
67 AssertEquals ("prefix", prefix, xmlReader.Prefix);
68
69 AssertEquals ("localName", localName, xmlReader.LocalName);
70
71 AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI);
72
73 AssertEquals ("hasValue", (value != String.Empty), xmlReader.HasValue);
74
75 AssertEquals ("Value", value, xmlReader.Value);
76
77 AssertEquals ("hasAttributes", attributeCount > 0, xmlReader.HasAttributes);
78
79 AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount);
80 }
81
82 private void AssertAttribute (
83 XmlReader xmlReader,
84 string name,
85 string prefix,
86 string localName,
87 string namespaceURI,
88 string value)
89 {
90 AssertEquals ("value.Indexer", value, xmlReader [name]);
91
92 AssertEquals ("value.GetAttribute", value, xmlReader.GetAttribute (name));
93
94 if (namespaceURI != String.Empty) {
95 Assert (xmlReader[localName, namespaceURI] == value);
96 Assert (xmlReader.GetAttribute (localName, namespaceURI) == value);
97 }
98 }
99
100 private void AssertEndDocument (XmlReader xmlReader)
101 {
102 Assert ("could read", !xmlReader.Read ());
103 AssertEquals ("NodeType is not XmlNodeType.None", XmlNodeType.None, xmlReader.NodeType);
104 AssertEquals ("Depth is not 0", 0, xmlReader.Depth);
105 AssertEquals ("ReadState is not ReadState.EndOfFile", ReadState.EndOfFile, xmlReader.ReadState);
106 Assert ("not EOF", xmlReader.EOF);
107
108 xmlReader.Close ();
109 AssertEquals ("ReadState is not ReadState.Cosed", ReadState.Closed, xmlReader.ReadState);
110 }
111
112 [Test]
113 public void StartAndEndTagWithAttribute ()
114 {
115 string xml = @"<foo bar='baz'></foo>";
116 XmlReader xmlReader =
117 new XmlTextReader (new StringReader (xml));
118
119 AssertStartDocument (xmlReader);
120
121 AssertNode (
122 xmlReader, // xmlReader
123 XmlNodeType.Element, // nodeType
124 0, //depth
125 false, // isEmptyElement
126 "foo", // name
127 String.Empty, // prefix
128 "foo", // localName
129 String.Empty, // namespaceURI
130 String.Empty, // value
131 1 // attributeCount
132 );
133
134 AssertAttribute (
135 xmlReader, // xmlReader
136 "bar", // name
137 String.Empty, // prefix
138 "bar", // localName
139 String.Empty, // namespaceURI
140 "baz" // value
141 );
142
143 AssertNode (
144 xmlReader, // xmlReader
145 XmlNodeType.EndElement, // nodeType
146 0, //depth
147 false, // isEmptyElement
148 "foo", // name
149 String.Empty, // prefix
150 "foo", // localName
151 String.Empty, // namespaceURI
152 String.Empty, // value
153 0 // attributeCount
154 );
155
156 AssertEndDocument (xmlReader);
157 }
158
159 // expecting parser error
160 [Test]
161 public void EmptyElementWithBadName ()
162 {
163 string xml = "<1foo/>";
164 XmlReader xmlReader =
165 new XmlTextReader (new StringReader (xml));
166
167 bool caughtXmlException = false;
168
169 try {
170 xmlReader.Read();
171 } catch (XmlException) {
172 caughtXmlException = true;
173 }
174
175 Assert(caughtXmlException);
176 }
177
178 [Test]
179 public void EmptyElementWithStartAndEndTag ()
180 {
181 string xml = "<foo></foo>";
182 XmlReader xmlReader =
183 new XmlTextReader (new StringReader (xml));
184
185 AssertStartDocument (xmlReader);
186
187 AssertNode (
188 xmlReader, // xmlReader
189 XmlNodeType.Element, // nodeType
190 0, //depth
191 false, // isEmptyElement
192 "foo", // name
193 String.Empty, // prefix
194 "foo", // localName
195 String.Empty, // namespaceURI
196 String.Empty, // value
197 0 // attributeCount
198 );
199
200 AssertNode (
201 xmlReader, // xmlReader
202 XmlNodeType.EndElement, // nodeType
203 0, //depth
204 false, // isEmptyElement
205 "foo", // name
206 String.Empty, // prefix
207 "foo", // localName
208 String.Empty, // namespaceURI
209 String.Empty, // value
210 0 // attributeCount
211 );
212
213 AssertEndDocument (xmlReader);
214 }
215
216 // checking parser
217 [Test]
218 public void EmptyElementWithStartAndEndTagWithWhitespace ()
219 {
220 string xml = "<foo ></foo >";
221 XmlReader xmlReader =
222 new XmlTextReader (new StringReader (xml));
223
224 AssertStartDocument (xmlReader);
225
226 AssertNode (
227 xmlReader, // xmlReader
228 XmlNodeType.Element, // nodeType
229 0, //depth
230 false, // isEmptyElement
231 "foo", // name
232 String.Empty, // prefix
233 "foo", // localName
234 String.Empty, // namespaceURI
235 String.Empty, // value
236 0 // attributeCount
237 );
238
239 AssertNode (
240 xmlReader, // xmlReader
241 XmlNodeType.EndElement, // nodeType
242 0, //depth
243 false, // isEmptyElement
244 "foo", // name
245 String.Empty, // prefix
246 "foo", // localName
247 String.Empty, // namespaceURI
248 String.Empty, // value
249 0 // attributeCount
250 );
251
252 AssertEndDocument (xmlReader);
253 }
254
255 [Test]
256 public void EmptyElementWithAttribute ()
257 {
258 string xml = @"<foo bar=""baz""/>";
259 XmlReader xmlReader =
260 new XmlTextReader (new StringReader (xml));
261
262 AssertStartDocument (xmlReader);
263
264 AssertNode (
265 xmlReader, // xmlReader
266 XmlNodeType.Element, // nodeType
267 0, //depth
268 true, // isEmptyElement
269 "foo", // name
270 String.Empty, // prefix
271 "foo", // localName
272 String.Empty, // namespaceURI
273 String.Empty, // value
274 1 // attributeCount
275 );
276
277 AssertAttribute (
278 xmlReader, // xmlReader
279 "bar", // name
280 String.Empty, // prefix
281 "bar", // localName
282 String.Empty, // namespaceURI
283 "baz" // value
284 );
285
286 AssertEndDocument (xmlReader);
287 }
288
289 [Test]
290 public void EmptyElementInNamespace ()
291 {
292 string xml = @"<foo:bar xmlns:foo='http://foo/' />";
293 XmlReader xmlReader =
294 new XmlTextReader (new StringReader (xml));
295
296 AssertStartDocument (xmlReader);
297
298 AssertNode (
299 xmlReader, // xmlReader
300 XmlNodeType.Element, // nodeType
301 0, // depth
302 true, // isEmptyElement
303 "foo:bar", // name
304 "foo", // prefix
305 "bar", // localName
306 "http://foo/", // namespaceURI
307 String.Empty, // value
308 1 // attributeCount
309 );
310
311 AssertAttribute (
312 xmlReader, // xmlReader
313 "xmlns:foo", // name
314 "xmlns", // prefix
315 "foo", // localName
316 "http://www.w3.org/2000/xmlns/", // namespaceURI
317 "http://foo/" // value
318 );
319
320 AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
321
322 AssertEndDocument (xmlReader);
323 }
324
325 [Test]
326 public void EntityReferenceInAttribute ()
327 {
328 string xml = "<foo bar='&baz;'/>";
329 XmlReader xmlReader =
330 new XmlTextReader (new StringReader (xml));
331
332 AssertStartDocument (xmlReader);
333
334 AssertNode (
335 xmlReader, // xmlReader
336 XmlNodeType.Element, // nodeType
337 0, //depth
338 true, // isEmptyElement
339 "foo", // name
340 String.Empty, // prefix
341 "foo", // localName
342 String.Empty, // namespaceURI
343 String.Empty, // value
344 1 // attributeCount
345 );
346
347 AssertAttribute (
348 xmlReader, // xmlReader
349 "bar", // name
350 String.Empty, // prefix
351 "bar", // localName
352 String.Empty, // namespaceURI
353 "&baz;" // value
354 );
355
356 AssertEndDocument (xmlReader);
357 }
358
359 [Test]
360 public void IsName ()
361 {
362 Assert (XmlReader.IsName ("foo"));
363 Assert (!XmlReader.IsName ("1foo"));
364 Assert (!XmlReader.IsName (" foo"));
365 }
366
367 [Test]
368 public void IsNameToken ()
369 {
370 Assert (XmlReader.IsNameToken ("foo"));
371 Assert (XmlReader.IsNameToken ("1foo"));
372 Assert (!XmlReader.IsNameToken (" foo"));
373 }
374
375 [Test]
376 public void FragmentConstructor()
377 {
378 XmlDocument doc = new XmlDocument();
379 // doc.LoadXml("<root/>");
380
381 string xml = @"<foo><bar xmlns=""NSURI"">TEXT NODE</bar></foo>";
382 MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(xml));
383
384 XmlParserContext ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", "", "", "",
385 doc.BaseURI, "", XmlSpace.Default, Encoding.Default);
386
387 XmlTextReader xmlReader = new XmlTextReader(ms, XmlNodeType.Element, ctx);
388 AssertNode(xmlReader, XmlNodeType.Element, 0, false, "foo", "", "foo", "", "", 0);
389
390 AssertNode(xmlReader, XmlNodeType.Element, 1, false, "bar", "", "bar", "NSURI", "", 1);
391
392 AssertNode(xmlReader, XmlNodeType.Text, 2, false, "", "", "", "", "TEXT NODE", 0);
393
394 AssertNode(xmlReader, XmlNodeType.EndElement, 1, false, "bar", "", "bar", "NSURI", "", 0);
395
396 AssertNode(xmlReader, XmlNodeType.EndElement, 0, false, "foo", "", "foo", "", "", 0);
397
398 AssertEndDocument (xmlReader);
399 }
400
401 [Test]
402 public void AttributeWithCharacterReference ()
403 {
404 string xml = @"<a value='hello &amp; world' />";
405 XmlReader xmlReader =
406 new XmlTextReader (new StringReader (xml));
407 xmlReader.Read ();
408 AssertEquals ("hello & world", xmlReader ["value"]);
409 }
410
411 [Test]
412 public void AttributeWithEntityReference ()
413 {
414 string xml = @"<a value='hello &ent; world' />";
415 XmlReader xmlReader =
416 new XmlTextReader (new StringReader (xml));
417 xmlReader.Read ();
418 xmlReader.MoveToFirstAttribute ();
419 xmlReader.ReadAttributeValue ();
420 AssertEquals ("hello ", xmlReader.Value);
421 Assert (xmlReader.ReadAttributeValue ());
422 AssertEquals (XmlNodeType.EntityReference, xmlReader.NodeType);
423 AssertEquals ("ent", xmlReader.Name);
424 AssertEquals (XmlNodeType.EntityReference, xmlReader.NodeType);
425 Assert (xmlReader.ReadAttributeValue ());
426 AssertEquals (" world", xmlReader.Value);
427 AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
428 Assert (!xmlReader.ReadAttributeValue ());
429 AssertEquals (" world", xmlReader.Value); // remains
430 AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
431 xmlReader.ReadAttributeValue ();
432 AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
433 }
434
435 [Test]
436 public void QuoteChar ()
437 {
438 string xml = @"<a value='hello &amp; world' value2="""" />";
439 XmlReader xmlReader =
440 new XmlTextReader (new StringReader (xml));
441 xmlReader.Read ();
442 xmlReader.MoveToFirstAttribute ();
443 AssertEquals ("First", '\'', xmlReader.QuoteChar);
444 xmlReader.MoveToNextAttribute ();
445 AssertEquals ("Next", '"', xmlReader.QuoteChar);
446 xmlReader.MoveToFirstAttribute ();
447 AssertEquals ("First.Again", '\'', xmlReader.QuoteChar);
448 }
449
450 [Test]
451 public void ReadInnerXmlWrongInit ()
452 {
453 // This behavior is different from XmlNodeReader.
454 XmlReader reader = new XmlTextReader (new StringReader ("<root>test of <b>mixed</b> string.</root>"));
455 reader.ReadInnerXml ();
456 AssertEquals ("initial.ReadState", ReadState.Initial, reader.ReadState);
457 AssertEquals ("initial.EOF", false, reader.EOF);
458 AssertEquals ("initial.NodeType", XmlNodeType.None, reader.NodeType);
459 }
460
461 [Test]
462 public void EntityReference ()
463 {
464 string xml = "<foo>&bar;</foo>";
465 XmlReader xmlReader = new XmlTextReader (new StringReader (xml));
466 AssertNode (
467 xmlReader, // xmlReader
468 XmlNodeType.Element, // nodeType
469 0, //depth
470 false, // isEmptyElement
471 "foo", // name
472 String.Empty, // prefix
473 "foo", // localName
474 String.Empty, // namespaceURI
475 String.Empty, // value
476 0 // attributeCount
477 );
478
479 AssertNode (
480 xmlReader, // xmlReader
481 XmlNodeType.EntityReference, // nodeType
482 1, //depth
483 false, // isEmptyElement
484 "bar", // name
485 String.Empty, // prefix
486 "bar", // localName
487 String.Empty, // namespaceURI
488 String.Empty, // value
489 0 // attributeCount
490 );
491
492 AssertNode (
493 xmlReader, // xmlReader
494 XmlNodeType.EndElement, // nodeType
495 0, //depth
496 false, // isEmptyElement
497 "foo", // name
498 String.Empty, // prefix
499 "foo", // localName
500 String.Empty, // namespaceURI
501 String.Empty, // value
502 0 // attributeCount
503 );
504
505 AssertEndDocument (xmlReader);
506 }
507
508 [Test]
509 public void EntityReferenceInsideText ()
510 {
511 string xml = "<foo>bar&baz;quux</foo>";
512 XmlReader xmlReader = new XmlTextReader (new StringReader (xml));
513 AssertNode (
514 xmlReader, // xmlReader
515 XmlNodeType.Element, // nodeType
516 0, //depth
517 false, // isEmptyElement
518 "foo", // name
519 String.Empty, // prefix
520 "foo", // localName
521 String.Empty, // namespaceURI
522 String.Empty, // value
523 0 // attributeCount
524 );
525
526 AssertNode (
527 xmlReader, // xmlReader
528 XmlNodeType.Text, // nodeType
529 1, //depth
530 false, // isEmptyElement
531 String.Empty, // name
532 String.Empty, // prefix
533 String.Empty, // localName
534 String.Empty, // namespaceURI
535 "bar", // value
536 0 // attributeCount
537 );
538
539 AssertNode (
540 xmlReader, // xmlReader
541 XmlNodeType.EntityReference, // nodeType
542 1, //depth
543 false, // isEmptyElement
544 "baz", // name
545 String.Empty, // prefix
546 "baz", // localName
547 String.Empty, // namespaceURI
548 String.Empty, // value
549 0 // attributeCount
550 );
551
552 AssertNode (
553 xmlReader, // xmlReader
554 XmlNodeType.Text, // nodeType
555 1, //depth
556 false, // isEmptyElement
557 String.Empty, // name
558 String.Empty, // prefix
559 String.Empty, // localName
560 String.Empty, // namespaceURI
561 "quux", // value
562 0 // attributeCount
563 );
564
565 AssertNode (
566 xmlReader, // xmlReader
567 XmlNodeType.EndElement, // nodeType
568 0, //depth
569 false, // isEmptyElement
570 "foo", // name
571 String.Empty, // prefix
572 "foo", // localName
573 String.Empty, // namespaceURI
574 String.Empty, // value
575 0 // attributeCount
576 );
577
578 AssertEndDocument (xmlReader);
579 }
580
581 [Test]
582 [ExpectedException (typeof (XmlException))]
583 public void XmlDeclAfterWhitespace ()
584 {
585 XmlTextReader xtr = new XmlTextReader (
586 " <?xml version='1.0' ?><root />",
587 XmlNodeType.Document,
588 null);
589 xtr.Read (); // ws
590 xtr.Read (); // not-wf xmldecl
591 xtr.Close ();
592 }
593
594 [Test]
595 [ExpectedException (typeof (XmlException))]
596 public void XmlDeclAfterComment ()
597 {
598 XmlTextReader xtr = new XmlTextReader (
599 "<!-- comment --><?xml version='1.0' ?><root />",
600 XmlNodeType.Document,
601 null);
602 xtr.Read (); // comment
603 xtr.Read (); // not-wf xmldecl
604 xtr.Close ();
605 }
606
607 [Test]
608 [ExpectedException (typeof (XmlException))]
609 public void XmlDeclAfterProcessingInstruction ()
610 {
611 XmlTextReader xtr = new XmlTextReader (
612 "<?myPI let it go ?><?xml version='1.0' ?><root />",
613 XmlNodeType.Document,
614 null);
615 xtr.Read (); // PI
616 xtr.Read (); // not-wf xmldecl
617 xtr.Close ();
618 }
619
620 [Test]
621 [ExpectedException (typeof (XmlException))]
622 public void StartsFromEndElement ()
623 {
624 XmlTextReader xtr = new XmlTextReader (
625 "</root>",
626 XmlNodeType.Document,
627 null);
628 xtr.Read ();
629 xtr.Close ();
630 }
631
632 [Test]
633 public void ReadAsElementContent ()
634 {
635 XmlTextReader xtr = new XmlTextReader (
636 "<foo /><bar />", XmlNodeType.Element, null);
637 xtr.Read ();
638 xtr.Close ();
639 }
640
641 [Test]
642 public void ReadAsAttributeContent ()
643 {
644 XmlTextReader xtr = new XmlTextReader (
645 "test", XmlNodeType.Attribute, null);
646 xtr.Read ();
647 xtr.Close ();
648 }
649
650 [Test]
651 public void ExternalDocument ()
652 {
653 XmlDocument doc = new XmlDocument ();
654 doc.Load ("Test/XmlFiles/nested-dtd-test.xml");
655 }
656
657 [Test]
658 [ExpectedException (typeof (XmlException))]
659 public void NotAllowedCharRef ()
660 {
661 string xml = "<root>&#0;</root>";
662 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
663 xtr.Normalization = true;
664 xtr.Read ();
665 xtr.Read ();
666 xtr.Close ();
667 }
668
669 [Test]
670 public void NotAllowedCharRefButPassNormalizationFalse ()
671 {
672 string xml = "<root>&#0;</root>";
673 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
674 xtr.Read ();
675 xtr.Read ();
676 xtr.Close ();
677 }
678
679 [Test]
680 [ExpectedException (typeof (XmlException))]
681 [Ignore ("MS.NET 1.0 fails this test. The related spec is XML rec. 4.1")]
682 public void UndeclaredEntityInIntSubsetOnlyXml ()
683 {
684 string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
685 string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent2;
686 string xml = dtd + "<root>&ent;&ent2;</root>";
687 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
688 while (!xtr.EOF)
689 xtr.Read ();
690 xtr.Close ();
691 }
692
693 [Test]
694 [ExpectedException (typeof (XmlException))]
695 [Ignore ("MS.NET 1.0 fails this test. The related spec is XML rec. 4.1")]
696 public void UndeclaredEntityInStandaloneXml ()
697 {
698 string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
699 string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent2;
700 string xml = "<?xml version='1.0' standalone='yes' ?>"
701 + dtd + "<root>&ent;</root>";
702 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
703 while (!xtr.EOF)
704 xtr.Read ();
705 xtr.Close ();
706 }
707
708 [Test]
709 public void ExpandParameterEntity ()
710 {
711 string ent = "<!ENTITY foo \"foo-def\">";
712 string pe = "<!ENTITY % pe '" + ent + "'>";
713 string eldecl = "<!ELEMENT root ANY>";
714 string dtd = "<!DOCTYPE root[" + eldecl + pe + "%pe;]>";
715 string xml = dtd + "<root/>";
716 XmlDocument doc = new XmlDocument ();
717 doc.LoadXml (xml);
718 XmlEntity foo = doc.DocumentType.Entities.GetNamedItem ("foo") as XmlEntity;
719 AssertNotNull (foo);
720 AssertEquals ("foo-def", foo.InnerText);
721 }
722
723 [Test]
724 public void IfNamespacesThenProhibitedAttributes ()
725 {
726 string xml = @"<foo _1='1' xmlns:x='urn:x' x:_1='1' />";
727 XmlDocument doc = new XmlDocument ();
728 doc.LoadXml (xml);
729 }
730
731 [Test]
732 public void ReadBase64 ()
733 {
734 byte [] bytes = new byte [] {4,14,54,114,134,184,254,255};
735
736 string base64 = "<root><foo>BA42coa44</foo></root>";
737 XmlTextReader xtr = new XmlTextReader (base64, XmlNodeType.Document, null);
738 byte [] bytes2 = new byte [10];
739 xtr.Read (); // root
740 xtr.Read (); // foo
741 this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
742 "foo", String.Empty, String.Empty, 0);
743 AssertEquals (6, xtr.ReadBase64 (bytes2, 0, 10));
744 this.AssertNodeValues (xtr, XmlNodeType.EndElement, 0, false, "root", String.Empty,
745 "root", String.Empty, String.Empty, 0);
746 Assert (!xtr.Read ());
747 AssertEquals (4, bytes2 [0]);
748 AssertEquals (14, bytes2 [1]);
749 AssertEquals (54, bytes2 [2]);
750 AssertEquals (114, bytes2 [3]);
751 AssertEquals (134, bytes2 [4]);
752 AssertEquals (184, bytes2 [5]);
753 AssertEquals (0, bytes2 [6]);
754 xtr.Close ();
755
756 xtr = new XmlTextReader (base64, XmlNodeType.Document, null);
757 bytes2 = new byte [10];
758 xtr.Read (); // root
759 xtr.Read (); // foo
760 this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
761 "foo", String.Empty, String.Empty, 0);
762
763 // Read less than 4 (i.e. one Base64 block)
764 AssertEquals (1, xtr.ReadBase64 (bytes2, 0, 1));
765 this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
766 "foo", String.Empty, String.Empty, 0);
767 AssertEquals (4, bytes2 [0]);
768
769 AssertEquals (5, xtr.ReadBase64 (bytes2, 0, 10));
770 this.AssertNodeValues (xtr, XmlNodeType.EndElement, 0, false, "root", String.Empty,
771 "root", String.Empty, String.Empty, 0);
772 Assert (!xtr.Read ());
773 AssertEquals (14, bytes2 [0]);
774 AssertEquals (54, bytes2 [1]);
775 AssertEquals (114, bytes2 [2]);
776 AssertEquals (134, bytes2 [3]);
777 AssertEquals (184, bytes2 [4]);
778 AssertEquals (0, bytes2 [5]);
779 while (!xtr.EOF)
780 xtr.Read ();
781 xtr.Close ();
782 }
783
784 [Test]
785 public void ReadBase64Test2 ()
786 {
787 string xml = "<root/>";
788 XmlTextReader xtr = new XmlTextReader (new StringReader (xml));
789 xtr.Read ();
790 byte [] data = new byte [1];
791 xtr.ReadBase64 (data, 0, 1);
792 while (!xtr.EOF)
793 xtr.Read ();
794
795 xml = "<root></root>";
796 xtr = new XmlTextReader (new StringReader (xml));
797 xtr.Read ();
798 xtr.ReadBase64 (data, 0, 1);
799 while (!xtr.EOF)
800 xtr.Read ();
801 }
802
803 [Test]
804 [ExpectedException (typeof (XmlException))]
805 public void CheckNamespaceValidity1 ()
806 {
807 string xml = "<x:root />";
808 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
809 xtr.Read ();
810 }
811
812 [Test]
813 [ExpectedException (typeof (XmlException))]
814 public void CheckNamespaceValidity2 ()
815 {
816 string xml = "<root x:attr='val' />";
817 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
818 xtr.Read ();
819 }
820
821 [Test]
822 public void NamespaceFalse ()
823 {
824 string xml = "<x:root />";
825 XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
826 xtr.Namespaces = false;
827 xtr.Read ();
828 }
829
830 [Test]
831 public void NormalizationLineEnd ()
832 {
833 string s = "One\rtwo\nthree\r\nfour";
834 string t = "<hi><![CDATA[" + s + "]]></hi>";
835
836 XmlTextReader r = new XmlTextReader (new StringReader (t));
837 r.WhitespaceHandling = WhitespaceHandling.Significant;
838
839 r.Normalization = true;
840
841 s = r.ReadElementString ("hi");
842 AssertEquals ("One\ntwo\nthree\nfour", s);
843 }
844
845 [Test]
846 public void NormalizationAttributes ()
847 {
848 // does not normalize attribute values.
849 StringReader sr = new StringReader ("<!DOCTYPE root [<!ELEMENT root EMPTY><!ATTLIST root attr ID #IMPLIED>]><root attr=' value '/>");
850 XmlTextReader xtr = new XmlTextReader (sr);
851 xtr.Normalization = true;
852 xtr.Read ();
853 xtr.Read ();
854 xtr.MoveToFirstAttribute ();
855 AssertEquals (" value ", xtr.Value);
856 }
857
858 [Test]
859 public void CloseIsNotAlwaysEOF ()
860 {
861 // See bug #63505
862 XmlTextReader xtr = new XmlTextReader (
863 new StringReader ("<a></a><b></b>"));
864 xtr.Close ();
865 Assert (!xtr.EOF); // Close() != EOF
866 }
867
868 [Test]
869 public void CloseIsNotAlwaysEOF2 ()
870 {
871 XmlTextReader xtr = new XmlTextReader ("Test/XmlFiles/simple.xml");
872 xtr.Close ();
873 Assert (!xtr.EOF); // Close() != EOF
874 }
875
876 [Test]
877 public void IXmlLineInfo ()
878 {
879 // See bug #63507
880 XmlTextReader aux = new XmlTextReader (
881 new StringReader ("<all><hello></hello><bug></bug></all>"));
882 AssertEquals (0, aux.LineNumber);
883 AssertEquals (0, aux.LinePosition);
884 aux.MoveToContent();
885 AssertEquals (1, aux.LineNumber);
886 AssertEquals (2, aux.LinePosition);
887 aux.Read();
888 AssertEquals (1, aux.LineNumber);
889 AssertEquals (7, aux.LinePosition);
890 aux.ReadOuterXml();
891 AssertEquals (1, aux.LineNumber);
892 AssertEquals (22, aux.LinePosition);
893 aux.ReadInnerXml();
894 AssertEquals (1, aux.LineNumber);
895 AssertEquals (34, aux.LinePosition);
896 aux.Read();
897 AssertEquals (1, aux.LineNumber);
898 AssertEquals (38, aux.LinePosition);
899 aux.Close();
900 AssertEquals (0, aux.LineNumber);
901 AssertEquals (0, aux.LinePosition);
902 }
903 #if NET_2_0
904 [Test]
905 [ExpectedException (typeof (XmlException))]
906 public void ProhibitDtd ()
907 {
908 XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root []><root/>", XmlNodeType.Document, null);
909 xtr.ProhibitDtd = true;
910 while (!xtr.EOF)
911 xtr.Read ();
912 }
913
914 [Test]
915 public void Settings ()
916 {
917 XmlTextReader xtr = new XmlTextReader ("<root/>", XmlNodeType.Document, null);
918 AssertNull (xtr.Settings);
919 }
920
921 // Copied from XmlValidatingReaderTests.cs
922 [Test]
923 public void ExpandEntity ()
924 {
925 string intSubset = "<!ELEMENT root (#PCDATA)><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";
926 string dtd = "<!DOCTYPE root [" + intSubset + "]>";
927 string xml = dtd + "<root foo='&ent;' bar='internal &ent; value'>&ent;</root>";
928 XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
929 dvr.EntityHandling = EntityHandling.ExpandEntities;
930 dvr.Read (); // DTD
931 dvr.Read ();
932 AssertEquals (XmlNodeType.Element, dvr.NodeType);
933 AssertEquals ("root", dvr.Name);
934 Assert (dvr.MoveToFirstAttribute ());
935 AssertEquals ("foo", dvr.Name);
936 AssertEquals ("entity string", dvr.Value);
937 Assert (dvr.MoveToNextAttribute ());
938 AssertEquals ("bar", dvr.Name);
939 AssertEquals ("internal entity string value", dvr.Value);
940 AssertEquals ("entity string", dvr.ReadString ());
941 }
942
943 [Test]
944 public void PreserveEntity ()
945 {
946 string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";
947 string dtd = "<!DOCTYPE root [" + intSubset + "]>";
948 string xml = dtd + "<root foo='&ent;' bar='internal &ent; value' />";
949 XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
950 dvr.EntityHandling = EntityHandling.ExpandCharEntities;
951 dvr.Read (); // DTD
952 dvr.Read ();
953 AssertEquals (XmlNodeType.Element, dvr.NodeType);
954 AssertEquals ("root", dvr.Name);
955 Assert (dvr.MoveToFirstAttribute ());
956 AssertEquals ("foo", dvr.Name);
957 // MS BUG: it returns "entity string", however, entity should not be exanded.
958 AssertEquals ("&ent;", dvr.Value);
959 // ReadAttributeValue()
960 Assert (dvr.ReadAttributeValue ());
961 AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
962 AssertEquals ("ent", dvr.Name);
963 AssertEquals ("", dvr.Value);
964 Assert (!dvr.ReadAttributeValue ());
965
966 // bar
967 Assert (dvr.MoveToNextAttribute ());
968 AssertEquals ("bar", dvr.Name);
969 AssertEquals ("internal &ent; value", dvr.Value);
970 // ReadAttributeValue()
971 Assert (dvr.ReadAttributeValue ());
972 AssertEquals (XmlNodeType.Text, dvr.NodeType);
973 AssertEquals ("", dvr.Name);
974 AssertEquals ("internal ", dvr.Value);
975 Assert (dvr.ReadAttributeValue ());
976 AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
977 AssertEquals ("ent", dvr.Name);
978 AssertEquals ("", dvr.Value);
979 Assert (dvr.ReadAttributeValue ());
980 AssertEquals (XmlNodeType.Text, dvr.NodeType);
981 AssertEquals ("", dvr.Name);
982 AssertEquals (" value", dvr.Value);
983
984 }
985
986 [Test]
987 [ExpectedException (typeof (XmlException))]
988 public void ExpandEntityRejectsUndeclaredEntityAttr ()
989 {
990 XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root SYSTEM 'foo.dtd'><root attr='&rnt;'>&rnt;</root>", XmlNodeType.Document, null);
991 xtr.EntityHandling = EntityHandling.ExpandEntities;
992 xtr.XmlResolver = null;
993 xtr.Read ();
994 xtr.Read (); // attribute entity 'rnt' is undeclared
995 }
996
997 [Test]
998 [ExpectedException (typeof (XmlException))]
999 public void ExpandEntityRejectsUndeclaredEntityContent ()
1000 {
1001 XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root SYSTEM 'foo.dtd'><root>&rnt;</root>", XmlNodeType.Document, null);
1002 xtr.EntityHandling = EntityHandling.ExpandEntities;
1003 xtr.XmlResolver = null;
1004 xtr.Read ();
1005 xtr.Read ();
1006 xtr.Read (); // content entity 'rnt' is undeclared
1007 }
1008
1009 // mostly copied from XmlValidatingReaderTests.
1010 [Test]
1011 public void ResolveEntity ()
1012 {
1013 string ent1 = "<!ENTITY ent 'entity string'>";
1014 string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
1015 string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;
1016 string xml = dtd + "<root>&ent;&ent2;</root>";
1017 XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
1018 dvr.EntityHandling = EntityHandling.ExpandCharEntities;
1019 dvr.Read (); // DTD
1020 dvr.Read (); // root
1021 dvr.Read (); // &ent;
1022 AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
1023 AssertEquals (1, dvr.Depth);
1024 dvr.ResolveEntity ();
1025 // It is still entity reference.
1026 AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
1027 dvr.Read ();
1028 AssertEquals (XmlNodeType.Text, dvr.NodeType);
1029 AssertEquals (2, dvr.Depth);
1030 AssertEquals ("entity string", dvr.Value);
1031 dvr.Read ();
1032 AssertEquals (XmlNodeType.EndEntity, dvr.NodeType);
1033 AssertEquals (1, dvr.Depth);
1034 AssertEquals ("", dvr.Value);
1035
1036 dvr.Read (); // &ent2;
1037 AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
1038 AssertEquals (1, dvr.Depth);
1039 dvr.ResolveEntity ();
1040 // It is still entity reference.
1041 AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
1042 // It now became element node.
1043 dvr.Read ();
1044 AssertEquals (XmlNodeType.Element, dvr.NodeType);
1045 AssertEquals (2, dvr.Depth);
1046 }
1047
1048 // mostly copied from XmlValidatingReaderTests.
1049 [Test]
1050 public void ResolveEntity2 ()
1051 {
1052 string ent1 = "<!ENTITY ent 'entity string'>";
1053 string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";
1054 string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;
1055 string xml = dtd + "<root>&ent3;&ent2;</root>";
1056 XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
1057 dvr.EntityHandling = EntityHandling.ExpandCharEntities;
1058 dvr.Read (); // DTD
1059 dvr.Read (); // root
1060 dvr.Read (); // &ent3;
1061 AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
1062 // ent3 does not exists in this dtd.
1063 AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
1064 try {
1065 dvr.ResolveEntity ();
1066 Fail ("Attempt to resolve undeclared entity should fail.");
1067 } catch (XmlException) {
1068 }
1069 }
1070 #endif
1071 }
1072 }
Mirror of the official Mono project git repository