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