mcs/class/System.XML/Test/System.Xml/XmlReaderSettingsTests.cs

   1 //
   2 // System.Xml.XmlReaderSettingsTests.cs
   3 //
   4 // Authors:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // (C)2004 Novell Inc.
   8 //
   9
  10 #if NET_2_0
  11 using System;
  12 using System.IO;
  13 using System.Text;
  14 using System.Xml;
  15 using System.Xml.Schema;
  16 using NUnit.Framework;
  17
  18 using ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags;
  19
  20 namespace MonoTests.System.Xml
  21 {
  22         [TestFixture]
  23         public class XmlReaderSettingsTests : Assertion
  24         {
  25                 public Stream CreateStream (string xml)
  26                 {
  27                         return new MemoryStream (Encoding.Unicode.GetBytes (xml));
  28                 }
  29
  30                 [Test]
  31                 public void DefaultValue ()
  32                 {
  33                         XmlReaderSettings s = new XmlReaderSettings ();
  34                         AssertEquals (true, s.CheckCharacters);
  35                         AssertEquals (ConformanceLevel.Document,
  36                                 s.ConformanceLevel);
  37                         Assert (s.ValidationType != ValidationType.DTD);
  38                         AssertEquals (false, s.IgnoreComments);
  39                         Assert (0 != (s.ValidationFlags &
  40                                 ValidationFlags.IgnoreInlineSchema));
  41                         AssertEquals (false, s.IgnoreProcessingInstructions);
  42                         Assert (0 != (s.ValidationFlags &
  43                                 ValidationFlags.IgnoreSchemaLocation));
  44                         Assert (0 != (s.ValidationFlags &
  45                                 ValidationFlags.IgnoreValidationWarnings));
  46                         Assert (0 == (s.ValidationFlags &
  47                                 ValidationFlags.IgnoreIdentityConstraints));
  48                         AssertEquals (false, s.IgnoreWhitespace);
  49                         AssertEquals (0, s.LineNumberOffset);
  50                         AssertEquals (0, s.LinePositionOffset);
  51                         AssertNull (s.NameTable);
  52                         AssertEquals (0, s.Schemas.Count);
  53                         Assert (s.ValidationType != ValidationType.Schema);
  54                 }
  55
  56                 [Test]
  57                 [ExpectedException (typeof (XmlException))]
  58                 public void SetSchemas ()
  59                 {
  60                         XmlReaderSettings s = new XmlReaderSettings ();
  61                         s.Schemas = new XmlSchemaSet ();
  62                 }
  63
  64                 [Test]
  65                 public void CloseInput ()
  66                 {
  67                         StringReader sr = new StringReader ("<root/><root/>");
  68                         XmlReader xtr = XmlReader.Create (sr); // default false
  69                         xtr.Read ();
  70                         xtr.Close ();
  71                         // It should without error, unlike usual XmlTextReader.
  72                         sr.ReadLine ();
  73                 }
  74
  75                 [Test]
  76                 public void CreateAndNormalization ()
  77                 {
  78                         StringReader sr = new StringReader (
  79                                 "<root attr='   value   '>test\rstring</root>");
  80                         XmlReaderSettings settings = new XmlReaderSettings ();
  81                         settings.CheckCharacters = false;
  82                         XmlReader xtr = XmlReader.Create (
  83                                 sr, null, null, settings);
  84                         xtr.Read ();
  85                         xtr.MoveToFirstAttribute ();
  86                         AssertEquals ("   value   ", xtr.Value);
  87                         xtr.Read ();
  88                         // Text string is normalized
  89                         AssertEquals ("test\nstring", xtr.Value);
  90                 }
  91
  92                 [Test]
  93                 public void CheckCharactersAndNormalization ()
  94                 {
  95                         // It should *not* raise an error (even Normalization
  96                         // is set by default).
  97                         StringReader sr = new StringReader (
  98                                 "<root attr='&#0;'>&#x0;</root>");
  99                         XmlReaderSettings settings = new XmlReaderSettings ();
 100                         settings.CheckCharacters = false;
 101                         XmlReader xtr = XmlReader.Create (
 102                                 sr, null, null, settings);
 103                         // After creation, changes on source XmlReaderSettings
 104                         // does not matter.
 105                         settings.CheckCharacters = false;
 106                         xtr.Read ();
 107                         xtr.MoveToFirstAttribute ();
 108                         AssertEquals ("\0", xtr.Value);
 109                         xtr.Read ();
 110                         AssertEquals ("\0", xtr.Value);
 111                 }
 112
 113                 // Hmm, does it really make sense? :-/
 114                 [Test]
 115                 public void CheckCharactersForNonTextReader ()
 116                 {
 117                         // It should *not* raise an error (even Normalization
 118                         // is set by default).
 119                         StringReader sr = new StringReader (
 120                                 "<root attr='&#0;'>&#x0;</root>");
 121                         XmlReaderSettings settings = new XmlReaderSettings ();
 122                         settings.CheckCharacters = false;
 123                         XmlReader xr = XmlReader.Create (
 124                                 sr, null, null, settings);
 125
 126                         // Enable character checking for XmlNodeReader.
 127                         settings.CheckCharacters = true;
 128                         XmlDocument doc = new XmlDocument ();
 129                         doc.Load (xr);
 130                         xr = XmlReader.Create (new XmlNodeReader (doc), settings);
 131
 132                         // But it won't work against XmlNodeReader.
 133                         xr.Read ();
 134                         xr.MoveToFirstAttribute ();
 135                         AssertEquals ("\0", xr.Value);
 136                         xr.Read ();
 137                         AssertEquals ("\0", xr.Value);
 138                 }
 139
 140                 [Test]
 141                 public void CreateAndSettings ()
 142                 {
 143                         AssertNotNull (XmlReader.Create (CreateStream ("<xml/>")).Settings);
 144                         AssertNotNull (XmlReader.Create ("Test/XmlFiles/simple.xml").Settings);
 145                 }
 146
 147                 [Test]
 148                 public void CreateAndNameTable ()
 149                 {
 150                         // By default NameTable is null, but some of
 151                         // XmlReader.Create() should not result in null
 152                         // reference exceptions.
 153                         XmlReaderSettings s = new XmlReaderSettings ();
 154                         XmlReader.Create (new StringReader ("<root/>"), null, null, s)
 155                                 .Read ();
 156                         XmlReader.Create (CreateStream ("<root/>"), null, Encoding.Unicode, null, s)
 157                                 .Read ();
 158                 }
 159         }
 160 }
 161 #endif