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.Net;
  14 using System.Text;
  15 using System.Xml;
  16 using System.Xml.Schema;
  17 using NUnit.Framework;
  18
  19 using ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags;
  20 using AssertType = NUnit.Framework.Assert;
  21
  22 namespace MonoTests.System.Xml
  23 {
  24         [TestFixture]
  25         public class XmlReaderSettingsTests : Assertion
  26         {
  27                 public Stream CreateStream (string xml)
  28                 {
  29                         return new MemoryStream (Encoding.UTF8.GetBytes (xml));
  30                 }
  31
  32                 [Test]
  33                 public void DefaultValue ()
  34                 {
  35                         XmlReaderSettings s = new XmlReaderSettings ();
  36                         AssertEquals ("CheckCharacters", true, s.CheckCharacters);
  37                         AssertEquals ("ConformanceLevel", ConformanceLevel.Document,
  38                                 s.ConformanceLevel);
  39                         AssertEquals ("ValidationType", ValidationType.None, s.ValidationType);
  40                         AssertEquals ("IgnoreComments", false, s.IgnoreComments);
  41                         Assert ("ProcessInlineSchema", 0 == (s.ValidationFlags &
  42                                 ValidationFlags.ProcessInlineSchema));
  43                         AssertEquals ("IgnorePI", false, s.IgnoreProcessingInstructions);
  44                         Assert ("ProcessSchemaLocation", 0 == (s.ValidationFlags &
  45                                 ValidationFlags.ProcessSchemaLocation));
  46                         Assert ("ReportValidationWarnings", 0 == (s.ValidationFlags &
  47                                 ValidationFlags.ReportValidationWarnings));
  48                         Assert ("ProcessIdentityConstraints", 0 != (s.ValidationFlags &
  49                                 ValidationFlags.ProcessIdentityConstraints));
  50                         // No one should use this flag BTW if someone wants
  51                         // code to be conformant to W3C XML Schema standard.
  52                         Assert ("AllowXmlAttributes", 0 != (s.ValidationFlags &
  53                                 ValidationFlags.AllowXmlAttributes));
  54                         AssertEquals ("IgnoreWhitespace", false, s.IgnoreWhitespace);
  55                         AssertEquals ("LineNumberOffset", 0, s.LineNumberOffset);
  56                         AssertEquals ("LinePositionOffset", 0, s.LinePositionOffset);
  57                         AssertNull ("NameTable", s.NameTable);
  58                         AssertEquals ("Schemas.Count", 0, s.Schemas.Count);
  59                 }
  60
  61                 [Test]
  62                 public void SetSchemas ()
  63                 {
  64                         XmlReaderSettings s = new XmlReaderSettings ();
  65                         s.Schemas = new XmlSchemaSet ();
  66                 }
  67
  68                 [Test]
  69                 public void SetSchemasNull ()
  70                 {
  71                         XmlReaderSettings s = new XmlReaderSettings ();
  72                         s.Schemas = null;
  73                 }
  74
  75                 [Test]
  76                 public void CloseInput ()
  77                 {
  78                         StringReader sr = new StringReader ("<root/><root/>");
  79                         XmlReader xtr = XmlReader.Create (sr); // default false
  80                         xtr.Read ();
  81                         xtr.Close ();
  82                         // It should without error, unlike usual XmlTextReader.
  83                         sr.ReadLine ();
  84                 }
  85
  86                 [Test]
  87                 public void CreateAndNormalization ()
  88                 {
  89                         StringReader sr = new StringReader (
  90                                 "<root attr='   value   '>test\rstring</root>");
  91                         XmlReaderSettings settings = new XmlReaderSettings ();
  92                         settings.CheckCharacters = false;
  93                         XmlReader xtr = XmlReader.Create (
  94                                 sr, settings);
  95                         xtr.Read ();
  96                         xtr.MoveToFirstAttribute ();
  97                         AssertEquals ("   value   ", xtr.Value);
  98                         xtr.Read ();
  99                         // Text string is normalized
 100                         AssertEquals ("test\nstring", xtr.Value);
 101                 }
 102
 103                 [Test]
 104                 public void CheckCharactersAndNormalization ()
 105                 {
 106                         // It should *not* raise an error (even Normalization
 107                         // is set by default).
 108                         StringReader sr = new StringReader (
 109                                 "<root attr='&#0;'>&#x0;</root>");
 110                         XmlReaderSettings settings = new XmlReaderSettings ();
 111                         settings.CheckCharacters = false;
 112                         XmlReader xtr = XmlReader.Create (
 113                                 sr, settings);
 114                         // After creation, changes on source XmlReaderSettings
 115                         // does not matter.
 116                         settings.CheckCharacters = false;
 117                         xtr.Read ();
 118                         xtr.MoveToFirstAttribute ();
 119                         AssertEquals ("\0", xtr.Value);
 120                         xtr.Read ();
 121                         AssertEquals ("\0", xtr.Value);
 122                 }
 123
 124                 // Hmm, does it really make sense? :-/
 125                 [Test]
 126                 public void CheckCharactersForNonTextReader ()
 127                 {
 128                         // It should *not* raise an error (even Normalization
 129                         // is set by default).
 130                         StringReader sr = new StringReader (
 131                                 "<root attr='&#0;'>&#x0;</root>");
 132                         XmlReaderSettings settings = new XmlReaderSettings ();
 133                         settings.CheckCharacters = false;
 134                         XmlReader xr = XmlReader.Create (
 135                                 sr, settings);
 136
 137                         // Enable character checking for XmlNodeReader.
 138                         settings.CheckCharacters = true;
 139                         XmlDocument doc = new XmlDocument ();
 140                         doc.Load (xr);
 141                         xr = XmlReader.Create (new XmlNodeReader (doc), settings);
 142
 143                         // But it won't work against XmlNodeReader.
 144                         xr.Read ();
 145                         xr.MoveToFirstAttribute ();
 146                         AssertEquals ("\0", xr.Value);
 147                         xr.Read ();
 148                         AssertEquals ("\0", xr.Value);
 149                 }
 150
 151                 [Test]
 152                 public void CreateAndSettings ()
 153                 {
 154                         AssertNotNull (XmlReader.Create (CreateStream ("<xml/>")).Settings);
 155                         AssertNotNull (XmlReader.Create ("Test/XmlFiles/simple.xml").Settings);
 156                 }
 157
 158                 [Test]
 159                 public void CreateAndNameTable ()
 160                 {
 161                         // By default NameTable is null, but some of
 162                         // XmlReader.Create() should not result in null
 163                         // reference exceptions.
 164                         XmlReaderSettings s = new XmlReaderSettings ();
 165                         XmlReader.Create (new StringReader ("<root/>"), s, String.Empty)
 166                                 .Read ();
 167                         XmlReader.Create (new StringReader ("<root/>"), s, (XmlParserContext) null)
 168                                 .Read ();
 169                         XmlReader.Create (CreateStream ("<root/>"), s, String.Empty)
 170                                 .Read ();
 171                         XmlReader.Create (CreateStream ("<root/>"), s, (XmlParserContext) null)
 172                                 .Read ();
 173                 }
 174
 175                 #region ConformanceLevel
 176
 177                 [Test]
 178                 public void InferConformanceLevel ()
 179                 {
 180                         XmlReader xr = XmlReader.Create (new StringReader ("<foo/><bar/>"));
 181
 182                         AssertType.AreEqual (ConformanceLevel.Document, xr.Settings.ConformanceLevel);
 183                 }
 184
 185                 [Test]
 186                 public void InferWrappedReaderConformance ()
 187                 {
 188                         // Actually this test is weird, since XmlTextReader
 189                         // instance here does not have XmlReaderSettings.
 190                         XmlReaderSettings settings = new XmlReaderSettings ();
 191                         settings.ConformanceLevel = ConformanceLevel.Auto;
 192                         XmlReader xr = XmlReader.Create (
 193                                 XmlReader.Create (new StringReader ("<foo/><bar/>")),
 194                                 settings);
 195                         AssertType.AreEqual (ConformanceLevel.Document, xr.Settings.ConformanceLevel);
 196                 }
 197
 198                 [Test]
 199                 [ExpectedException (typeof (XmlException))]
 200                 public void CreateConformanceDocument ()
 201                 {
 202                         XmlReaderSettings s = new XmlReaderSettings ();
 203                         s.ConformanceLevel = ConformanceLevel.Document;
 204                         XmlReader xr = XmlReader.Create (new StringReader (
 205                                 "<foo/><bar/>"), s);
 206                         while (!xr.EOF)
 207                                 xr.Read ();
 208                 }
 209
 210                 [Test]
 211                 public void CreateConformanceFragment ()
 212                 {
 213                         XmlReaderSettings settings = new XmlReaderSettings ();
 214                         settings.ConformanceLevel = ConformanceLevel.Fragment;
 215                         XmlReader xr = XmlReader.Create (new StringReader (
 216                                 "<foo/><bar/>"), settings);
 217                         while (!xr.EOF)
 218                                 xr.Read ();
 219                 }
 220
 221                 [Test]
 222                 [ExpectedException (typeof (InvalidOperationException))]
 223                 public void CreateConformanceChangeToDocument ()
 224                 {
 225                         // Actually this test is weird, since XmlTextReader
 226                         // instance here does not have XmlReaderSettings.
 227                         XmlReaderSettings settings = new XmlReaderSettings ();
 228                         settings.ConformanceLevel = ConformanceLevel.Document;
 229                         XmlReader xr = XmlReader.Create (
 230                                 new XmlTextReader ("<foo/><bar/>", XmlNodeType.Element, null),
 231                                 settings);
 232                         while (!xr.EOF)
 233                                 xr.Read ();
 234                 }
 235
 236                 [Test]
 237                 [ExpectedException (typeof (InvalidOperationException))]
 238                 public void CreateConformanceChangeToFragment ()
 239                 {
 240                         // Actually this test is weird, since XmlTextReader
 241                         // instance here does not have XmlReaderSettings.
 242                         XmlReaderSettings settings = new XmlReaderSettings ();
 243                         settings.ConformanceLevel = ConformanceLevel.Fragment;
 244                         XmlReader xr = XmlReader.Create (
 245                                 new XmlTextReader ("<foo/>", XmlNodeType.Document, null),
 246                                 settings);
 247                         while (!xr.EOF)
 248                                 xr.Read ();
 249                 }
 250
 251                 [Test]
 252                 public void CreateConformanceLevelExplicitAuto ()
 253                 {
 254                         // Even if we specify ConformanceLevel.Auto explicitly,
 255                         // XmlTextReader's ConformanceLevel becomes .Document.
 256                         XmlReaderSettings settings = new XmlReaderSettings ();
 257                         settings.ConformanceLevel = ConformanceLevel.Auto;
 258                         XmlReader xr = XmlReader.Create (
 259                                 new XmlTextReader ("<foo/>", XmlNodeType.Document, null),
 260                                 settings);
 261                         AssertType.AreEqual (ConformanceLevel.Document, xr.Settings.ConformanceLevel);
 262                 }
 263
 264                 [Test]
 265                 public void CreateKeepConformance ()
 266                 {
 267                         XmlReaderSettings settings;
 268                         XmlReader xr;
 269
 270                         // Fragment -> Fragment
 271                         settings = new XmlReaderSettings ();
 272                         settings.ConformanceLevel = ConformanceLevel.Fragment;
 273                         xr = XmlReader.Create (
 274                                 XmlReader.Create (new StringReader ("<foo/>"), settings),
 275                                 settings);
 276                         while (!xr.EOF)
 277                                 xr.Read ();
 278
 279                         // Document -> Document
 280                         settings.ConformanceLevel = ConformanceLevel.Document;
 281                         xr = XmlReader.Create (
 282                                 XmlReader.Create (new StringReader ("<foo/>"), settings),
 283                                 settings);
 284                         while (!xr.EOF)
 285                                 xr.Read ();
 286                 }
 287
 288                 #endregion
 289
 290                 [Test]
 291                 public void CreateClonesSettings ()
 292                 {
 293                         XmlReaderSettings settings = new XmlReaderSettings ();
 294                         XmlReader xr = XmlReader.Create (new StringReader ("<doc/>"), settings);
 295                         AssertType.IsFalse (Object.ReferenceEquals (settings, xr.Settings));
 296                 }
 297
 298                 [Test]
 299                 public void CreateValidatorFromNonIXmlNamespaceResolver ()
 300                 {
 301                         XmlReaderSettings settings = new XmlReaderSettings ();
 302                         settings.Schemas.Add (null, "Test/XmlFiles/xsd/xml.xsd");
 303                         settings.ValidationType = ValidationType.Schema;
 304                         XmlReader xr = XmlReader.Create (new StringReader ("<root/>"));
 305                         XmlReader dr = new Commons.Xml.XmlDefaultReader (xr);
 306                         // XmlDefaultReader does not implement IXmlNamespaceResolver
 307                         // but don't reject because of that fact.
 308                         XmlReader r = XmlReader.Create (dr, settings);
 309                 }
 310
 311                 [Test]
 312                 public void NullResolver ()
 313                 {
 314                         XmlReaderSettings settings = new XmlReaderSettings ();
 315                         settings.XmlResolver = null;
 316                         using (XmlReader xr = XmlReader.Create ("Test/XmlFiles/simple.xml", settings)) {
 317                                 while (!xr.EOF)
 318                                         xr.Read ();
 319                         }
 320                 }
 321
 322                 class ThrowExceptionResolver : XmlResolver
 323                 {
 324                         public override ICredentials Credentials {
 325                                 set { }
 326                         }
 327
 328                         public override object GetEntity (Uri uri, string type, Type expected)
 329                         {
 330                                 throw new ApplicationException ("error");
 331                         }
 332                 }
 333
 334                 [Test]
 335                 [ExpectedException (typeof (ApplicationException))]
 336                 public void CustomResolverUsedForXmlStream ()
 337                 {
 338                         XmlReaderSettings settings = new XmlReaderSettings ();
 339                         settings.XmlResolver = new ThrowExceptionResolver ();
 340                         using (XmlReader xr = XmlReader.Create ("Test/XmlFiles/simple.xml", settings)) {
 341                                 while (!xr.EOF)
 342                                         xr.Read ();
 343                         }
 344                 }
 345
 346                 [Test]
 347                 [ExpectedException (typeof (ApplicationException))]
 348                 public void ValidationEventHandler ()
 349                 {
 350                         XmlReaderSettings settings = new XmlReaderSettings ();
 351                         settings.Schemas.Add (new XmlSchema ());
 352                         settings.ValidationType = ValidationType.Schema;
 353                         settings.ValidationEventHandler += delegate (object o, ValidationEventArgs e) {
 354                                 throw new ApplicationException ();
 355                         };
 356                         XmlReader r = XmlReader.Create (
 357                                 new StringReader ("<root/>"), settings);
 358                         while (!r.EOF)
 359                                 r.Read ();
 360                 }
 361
 362                 [Test]
 363                 [ExpectedException (typeof (XmlSchemaValidationException))]
 364                 // make sure that Create(string,XmlReaderSettings) returns
 365                 // validating XmlReader.
 366                 public void CreateFromUrlWithValidation ()
 367                 {
 368                         XmlReaderSettings settings = new XmlReaderSettings();
 369                         XmlSchema xs = new XmlSchema ();
 370                         settings.Schemas.Add (xs);
 371                         settings.ValidationType = ValidationType.Schema;
 372                         using (XmlReader r = XmlReader.Create ("Test/XmlFiles/simple.xml", settings)) {
 373                                 r.Read ();
 374                         }
 375                 }
 376
 377                 [Test]
 378                 public void ResolveEntities () // bug #81000
 379                 {
 380                         XmlReaderSettings s = new XmlReaderSettings ();
 381                         s.ProhibitDtd = false;
 382                         s.XmlResolver = new XmlResolver81000 ();
 383
 384                         string xml = "<!DOCTYPE root SYSTEM \"foo.dtd\"><root>&alpha;</root>";
 385                         XmlReader r = XmlReader.Create (new StringReader (xml), s);
 386                         r.Read ();
 387                         r.Read ();
 388                         r.Read ();
 389                         // not EntityReference but Text
 390                         AssertEquals ("#1", XmlNodeType.Text, r.NodeType);
 391                         r.Read ();
 392                         AssertEquals ("#2", XmlNodeType.EndElement, r.NodeType);
 393                 }
 394
 395                 public class XmlResolver81000 : XmlResolver
 396                 {
 397                         public override ICredentials Credentials { set {} }
 398
 399                         public override object GetEntity (Uri uri, string role, Type type)
 400                         {
 401                                 return new MemoryStream (Encoding.UTF8.GetBytes ("<!ENTITY alpha \"bravo\">"));
 402                         }
 403                 }
 404
 405                 [Test]
 406                 public void IgnoreComments () // Bug #82062.
 407                 {
 408                         string xml = "<root><!-- ignore --></root>";
 409                         XmlReaderSettings s = new XmlReaderSettings ();
 410                         s.IgnoreComments = true;
 411                         XmlReader r = XmlReader.Create (new StringReader (xml), s);
 412                         r.Read ();
 413                         r.Read ();
 414                         AssertEquals (String.Empty, r.Value); // should not be at the comment node.
 415                 }
 416
 417                 [Test]
 418                 public void CreateSetsBaseUri () // bug #392385
 419                 {
 420                         XmlReader r = XmlReader.Create (new StringReader ("<x/>"), new XmlReaderSettings (), "urn:foo");
 421                         AssertEquals ("urn:foo", r.BaseURI);
 422                 }
 423         }
 424 }
 425 #endif