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

   1 //\r
   2 // MonoTests.System.Xml.XsdValidatingReaderTests.cs\r
   3 //\r
   4 // Author:\r
   5 //      Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>\r
   6 //\r
   7 // (C)2003 Atsushi Enomoto\r
   8 // (C)2005-2007 Novell, Inc.\r
   9 //\r
  10 using System;\r
  11 using System.IO;\r
  12 using System.Net;\r
  13 using System.Xml;\r
  14 using System.Xml.Schema;\r
  15 using NUnit.Framework;\r
  16 \r
  17 namespace MonoTests.System.Xml\r
  18 {\r
  19         [TestFixture]\r
  20         public class XsdValidatingReaderTests : Assertion\r
  21         {\r
  22                 public XsdValidatingReaderTests ()\r
  23                 {\r
  24                 }\r
  25 \r
  26                 XmlReader xtr;\r
  27                 XmlValidatingReader xvr;\r
  28 \r
  29                 private XmlValidatingReader PrepareXmlReader (string xml)\r
  30                 {\r
  31                         XmlReader reader = new XmlTextReader (xml, XmlNodeType.Document, null);\r
  32 //                      XmlDocument doc = new XmlDocument ();\r
  33 //                      doc.LoadXml (xml);\r
  34 //                      XmlReader reader = new XmlNodeReader (doc);\r
  35 \r
  36                         return new XmlValidatingReader (reader);\r
  37                 }\r
  38 \r
  39                 [Test]\r
  40                 public void TestEmptySchema ()\r
  41                 {\r
  42                         string xml = "<root/>";\r
  43                         xvr = PrepareXmlReader (xml);\r
  44                         xvr.ValidationType = ValidationType.Schema;\r
  45                         xvr.Read ();    // Is is missing schema component.\r
  46                 }\r
  47 \r
  48                 [Test]\r
  49                 public void TestSimpleValidation ()\r
  50                 {\r
  51                         string xml = "<root/>";\r
  52                         xvr = PrepareXmlReader (xml);\r
  53                         AssertEquals (ValidationType.Auto, xvr.ValidationType);\r
  54                         XmlSchema schema = new XmlSchema ();\r
  55                         XmlSchemaElement elem = new XmlSchemaElement ();\r
  56                         elem.Name = "root";\r
  57                         schema.Items.Add (elem);\r
  58                         xvr.Schemas.Add (schema);\r
  59                         xvr.Read ();    // root\r
  60                         AssertEquals (ValidationType.Auto, xvr.ValidationType);\r
  61                         xvr.Read ();    // EOF\r
  62 \r
  63                         xml = "<hoge/>";\r
  64                         xvr = PrepareXmlReader (xml);\r
  65                         xvr.Schemas.Add (schema);\r
  66                         try {\r
  67                                 xvr.Read ();\r
  68                                 Fail ("element mismatch is incorrectly allowed");\r
  69                         } catch (XmlSchemaException) {\r
  70                         }\r
  71 \r
  72                         xml = "<hoge xmlns='urn:foo' />";\r
  73                         xvr = PrepareXmlReader (xml);\r
  74                         xvr.Schemas.Add (schema);\r
  75                         try {\r
  76                                 xvr.Read ();\r
  77                                 Fail ("Element in different namespace is incorrectly allowed.");\r
  78                         } catch (XmlSchemaException) {\r
  79                         }\r
  80                 }\r
  81 \r
  82                 [Test]\r
  83                 public void TestReadTypedValueSimple ()\r
  84                 {\r
  85                         string xml = "<root>12</root>";\r
  86                         XmlSchema schema = new XmlSchema ();\r
  87                         XmlSchemaElement elem = new XmlSchemaElement ();\r
  88                         elem.Name = "root";\r
  89                         elem.SchemaTypeName = new XmlQualifiedName ("integer", XmlSchema.Namespace);\r
  90                         schema.Items.Add (elem);\r
  91 \r
  92                         // Lap 1:\r
  93                         \r
  94                         xvr = PrepareXmlReader (xml);\r
  95                         xvr.Schemas.Add (schema);\r
  96                         // Read directly from root.\r
  97                         object o = xvr.ReadTypedValue ();\r
  98                         AssertEquals (ReadState.Initial, xvr.ReadState);\r
  99                         AssertNull (o);\r
 100 \r
 101                         xvr.Read ();    // element root\r
 102                         AssertEquals (XmlNodeType.Element, xvr.NodeType);\r
 103                         AssertNotNull (xvr.SchemaType);\r
 104                         Assert (xvr.SchemaType is XmlSchemaDatatype);\r
 105                         o = xvr.ReadTypedValue ();      // read "12"\r
 106                         AssertEquals (XmlNodeType.EndElement, xvr.NodeType);\r
 107                         AssertNotNull (o);\r
 108                         AssertEquals (typeof (decimal), o.GetType ());\r
 109                         decimal n = (decimal) o;\r
 110                         AssertEquals (12, n);\r
 111                         Assert (!xvr.EOF);\r
 112                         AssertEquals ("root", xvr.Name);\r
 113                         AssertNull (xvr.SchemaType);    // EndElement's type\r
 114 \r
 115                         // Lap 2:\r
 116 \r
 117                         xvr = PrepareXmlReader (xml);\r
 118                         xvr.Schemas.Add (schema);\r
 119                         xvr.Read ();    // root\r
 120                         XmlSchemaDatatype dt = xvr.SchemaType as XmlSchemaDatatype;\r
 121                         AssertNotNull (dt);\r
 122                         AssertEquals (typeof (decimal), dt.ValueType);\r
 123                         AssertEquals (XmlTokenizedType.None, dt.TokenizedType);\r
 124                         xvr.Read ();    // text "12"\r
 125                         AssertNull (xvr.SchemaType);\r
 126                         o = xvr.ReadTypedValue ();\r
 127                         // ReadTypedValue is different from ReadString().\r
 128                         AssertNull (o);\r
 129                 }\r
 130 \r
 131                 [Test]\r
 132                 [Ignore ("XML Schema validator should not be available for validating non namespace-aware XmlReader that handled colon as a name character")]\r
 133                 public void TestNamespacesFalse ()\r
 134                 {\r
 135                         // This tests if Namespaces=false is specified, then\r
 136                         // the reader's NamespaceURI should be always string.Empty and\r
 137                         // validation should be done against such schema that has target ns as "".\r
 138                         string xml = "<x:root xmlns:x='urn:foo' />";\r
 139                         xvr = PrepareXmlReader (xml);\r
 140                         xvr.Namespaces = false;\r
 141                         AssertEquals (ValidationType.Auto, xvr.ValidationType);\r
 142                         XmlSchema schema = new XmlSchema ();\r
 143                         schema.TargetNamespace = "urn:foo";\r
 144                         XmlSchemaElement elem = new XmlSchemaElement ();\r
 145                         elem.Name = "root";\r
 146                         schema.Items.Add (elem);\r
 147                         xvr.Schemas.Add (schema);\r
 148                         xvr.Read ();    // root\r
 149                         Assert (!xvr.Namespaces);\r
 150                         AssertEquals ("x:root", xvr.Name);\r
 151                         // LocalName may contain colons.\r
 152                         AssertEquals ("x:root", xvr.LocalName);\r
 153                         // NamespaceURI is not supplied.\r
 154                         AssertEquals ("", xvr.NamespaceURI);\r
 155                 }\r
 156 \r
 157                 [Test]\r
 158                 public void TestReadTypedAttributeValue ()\r
 159                 {\r
 160                         string xml = "<root attr='12'></root>";\r
 161                         XmlSchema schema = new XmlSchema ();\r
 162                         XmlSchemaElement elem = new XmlSchemaElement ();\r
 163                         elem.Name = "root";\r
 164                         XmlSchemaComplexType ct = new XmlSchemaComplexType ();\r
 165                         XmlSchemaAttribute attr = new XmlSchemaAttribute ();\r
 166                         attr.Name = "attr";\r
 167                         attr.SchemaTypeName = new XmlQualifiedName ("int", XmlSchema.Namespace);\r
 168                         ct.Attributes.Add (attr);\r
 169                         elem.SchemaType = ct;\r
 170                         schema.Items.Add (elem);\r
 171 \r
 172                         xvr = PrepareXmlReader (xml);\r
 173                         xvr.Schemas.Add (schema);\r
 174                         xvr.Read ();\r
 175                         AssertEquals ("root", xvr.Name);\r
 176                         Assert (xvr.MoveToNextAttribute ());    // attr\r
 177                         AssertEquals ("attr", xvr.Name);\r
 178                         XmlSchemaDatatype dt = xvr.SchemaType as XmlSchemaDatatype;\r
 179                         AssertNotNull (dt);\r
 180                         AssertEquals (typeof (int), dt.ValueType);\r
 181                         AssertEquals (XmlTokenizedType.None, dt.TokenizedType);\r
 182                         object o = xvr.ReadTypedValue ();\r
 183                         AssertEquals (XmlNodeType.Attribute, xvr.NodeType);\r
 184                         AssertEquals (typeof (int), o.GetType ());\r
 185                         int n = (int) o;\r
 186                         AssertEquals (12, n);\r
 187                         Assert (xvr.ReadAttributeValue ());     // can read = seems not proceed.\r
 188                 }\r
 189 \r
 190                 [Test]\r
 191                 public void DuplicateSchemaAssignment ()\r
 192                 {\r
 193                         string xml = @"<data\r
 194                         xmlns='http://www.test.com/schemas/'\r
 195                         xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'\r
 196                         xsi:schemaLocation='http://www.test.com/schemas/ /home/user/schema.xsd' />";\r
 197                         string xsd = @"<xs:schema\r
 198                         targetNamespace='http://www.test.com/schemas/'\r
 199                         xmlns:xs='http://www.w3.org/2001/XMLSchema'\r
 200                         xmlns='http://www.test.com/schemas/' >\r
 201                         <xs:element name='data' /></xs:schema>";\r
 202 \r
 203                         string xmlns = "http://www.test.com/schemas/";\r
 204 \r
 205                         XmlValidatingReader xvr = new XmlValidatingReader (\r
 206                                 xml, XmlNodeType.Document, null);\r
 207                         XmlSchemaCollection schemas = new XmlSchemaCollection ();\r
 208                         schemas.Add (XmlSchema.Read (new XmlTextReader (\r
 209                                 xsd, XmlNodeType.Document, null), null));\r
 210                         xvr.Schemas.Add (schemas);\r
 211                         while (!xvr.EOF)\r
 212                                 xvr.Read ();\r
 213                 }\r
 214 \r
 215                 [Test] // bug #76234\r
 216                 public void DTDValidatorNamespaceHandling ()\r
 217                 {\r
 218                         string xml = "<xml xmlns='urn:a'> <foo> <a:bar xmlns='urn:b' xmlns:a='urn:a' /> <bug /> </foo> </xml>";\r
 219                         XmlValidatingReader vr = new XmlValidatingReader (\r
 220                                 xml, XmlNodeType.Document, null);\r
 221                         vr.Read ();\r
 222                         vr.Read (); // whitespace\r
 223                         AssertEquals ("#1", String.Empty, vr.NamespaceURI);\r
 224                         vr.Read (); // foo\r
 225                         AssertEquals ("#2", "urn:a", vr.NamespaceURI);\r
 226                         vr.Read (); // whitespace\r
 227                         vr.Read (); // a:bar\r
 228                         AssertEquals ("#3", "urn:a", vr.NamespaceURI);\r
 229                         vr.Read (); // whitespace\r
 230                         vr.Read (); // bug\r
 231                         AssertEquals ("#4", "urn:a", vr.NamespaceURI);\r
 232                 }\r
 233 \r
 234                 [Test]\r
 235                 public void MultipleSchemaInSchemaLocation ()\r
 236                 {\r
 237                         XmlTextReader xtr = new XmlTextReader ("Test/XmlFiles/xsd/multi-schemaLocation.xml");\r
 238                         XmlValidatingReader vr = new XmlValidatingReader (xtr);\r
 239                         while (!vr.EOF)\r
 240                                 vr.Read ();\r
 241                 }\r
 242 \r
 243                 [Test]\r
 244                 public void ReadTypedValueSimpleTypeRestriction ()\r
 245                 {\r
 246                         string xml = "<root>xx</root><!-- after -->";\r
 247                         string xsd = @"\r
 248 <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
 249   <xs:element name='root'>\r
 250     <xs:simpleType>\r
 251       <xs:restriction base='xs:string'>\r
 252         <xs:minLength value='2' />\r
 253       </xs:restriction>\r
 254     </xs:simpleType>\r
 255   </xs:element>\r
 256 </xs:schema>";\r
 257                         XmlTextReader xir = \r
 258                                 new XmlTextReader (xml, XmlNodeType.Document, null);\r
 259                         XmlTextReader xsr =\r
 260                                 new XmlTextReader (xsd, XmlNodeType.Document, null);\r
 261                         XmlValidatingReader vr = new XmlValidatingReader (xir);\r
 262                         vr.Schemas.Add (XmlSchema.Read (xsr, null));\r
 263                         vr.Read (); // root\r
 264                         AssertEquals ("xx", vr.ReadTypedValue ());\r
 265                         AssertEquals (XmlNodeType.EndElement, vr.NodeType);\r
 266                 }\r
 267 \r
 268                 // If we normalize string before validating with facets,\r
 269                 // this test will fail. It will also fail if ReadTypedValue()\r
 270                 // ignores whitespace nodes.\r
 271                 [Test]\r
 272                 public void ReadTypedValueWhitespaces ()\r
 273                 {\r
 274                         string xml = "<root>  </root><!-- after -->";\r
 275                         string xsd = @"\r
 276 <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
 277   <xs:element name='root'>\r
 278     <xs:simpleType>\r
 279       <xs:restriction base='xs:string'>\r
 280         <xs:minLength value='2' />\r
 281       </xs:restriction>\r
 282     </xs:simpleType>\r
 283   </xs:element>\r
 284 </xs:schema>";\r
 285                         XmlTextReader xir = \r
 286                                 new XmlTextReader (xml, XmlNodeType.Document, null);\r
 287                         XmlTextReader xsr =\r
 288                                 new XmlTextReader (xsd, XmlNodeType.Document, null);\r
 289                         XmlValidatingReader vr = new XmlValidatingReader (xir);\r
 290                         vr.Schemas.Add (XmlSchema.Read (xsr, null));\r
 291                         vr.Read (); // root\r
 292                         AssertEquals ("  ", vr.ReadTypedValue ());\r
 293                         AssertEquals (XmlNodeType.EndElement, vr.NodeType);\r
 294                 }\r
 295 \r
 296                 [Test] // bug #77241\r
 297                 public void EmptyContentAllowWhitespace ()\r
 298                 {\r
 299                         string doc = @"\r
 300 <root>\r
 301         <!-- some comment -->\r
 302         <child/>\r
 303 </root>\r
 304 ";\r
 305                         string schema = @"\r
 306 <xsd:schema xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">\r
 307     <xsd:element name=""root"">\r
 308         <xsd:complexType>\r
 309             <xsd:sequence>\r
 310                 <xsd:element name=""child"" type=""xsd:string"" />\r
 311             </xsd:sequence>\r
 312         </xsd:complexType>\r
 313     </xsd:element>\r
 314 </xsd:schema>\r
 315 ";\r
 316                         XmlValidatingReader reader = new XmlValidatingReader (\r
 317                                 new XmlTextReader (new StringReader (doc)));\r
 318                         reader.Schemas.Add (null,\r
 319                                 new XmlTextReader (new StringReader (schema)));\r
 320                         while (reader.Read ())\r
 321                                 ;\r
 322                 }\r
 323 \r
 324                 [Test] // bug #79650\r
 325 #if NET_2_0\r
 326                 // annoyance\r
 327                 [ExpectedException (typeof (XmlSchemaValidationException))]\r
 328 #else\r
 329                 [ExpectedException (typeof (XmlSchemaException))]\r
 330 #endif\r
 331                 public void EnumerationFacetOnAttribute ()\r
 332                 {\r
 333                         string xml = "<test mode='NOT A ENUMERATION VALUE' />";\r
 334                         XmlSchema schema = XmlSchema.Read (new XmlTextReader ("Test/XmlFiles/xsd/79650.xsd"), null);\r
 335                         XmlValidatingReader xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 336                         xvr.ValidationType = ValidationType.Schema;\r
 337                         xvr.Schemas.Add (schema);\r
 338                         while (!xvr.EOF)\r
 339                                 xvr.Read ();\r
 340                 }\r
 341 \r
 342                 class XmlErrorResolver : XmlResolver\r
 343                 {\r
 344                         public override ICredentials Credentials {\r
 345                                 set { }\r
 346                         }\r
 347 \r
 348                         public override object GetEntity (Uri uri, string role, Type type)\r
 349                         {\r
 350                                 throw new Exception ();\r
 351                         }\r
 352                 }\r
 353 \r
 354                 [Test] // bug #79924\r
 355                 public void ValidationTypeNoneIgnoreSchemaLocations ()\r
 356                 {\r
 357                         string xml = "<project xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:noNamespaceSchemaLocation='nosuchschema.xsd'/>";\r
 358                         XmlValidatingReader vr = new XmlValidatingReader (\r
 359                                 new XmlTextReader (new StringReader (xml)));\r
 360                         vr.ValidationType = ValidationType.None;\r
 361                         vr.XmlResolver = new XmlErrorResolver ();\r
 362                         while (!vr.EOF)\r
 363                                 vr.Read ();\r
 364                 }\r
 365 \r
 366                 [Test] // bug #336625\r
 367                 public void ValidationTypeNoneIgnoreLocatedSchemaErrors ()\r
 368                 {\r
 369                         string xml = "<test xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:noNamespaceSchemaLocation='Test/XmlFiles/xsd/336625.xsd'/>";\r
 370                         XmlValidatingReader vr = new XmlValidatingReader (\r
 371                                 new XmlTextReader (new StringReader (xml)));\r
 372                         vr.ValidationType = ValidationType.None;\r
 373                         while (!vr.EOF)\r
 374                                 vr.Read ();\r
 375                 }\r
 376 \r
 377                 [Test]\r
 378                 public void Bug81360 ()\r
 379                 {\r
 380                         string schemaFile = "Test/XmlFiles/xsd/81360.xsd";\r
 381                         XmlTextReader treader = new XmlTextReader (schemaFile);\r
 382                         XmlSchema sc = XmlSchema.Read (treader, null);\r
 383                         sc.Compile (null);\r
 384                         string xml = @"<body xmlns='" + sc.TargetNamespace + "'><div></div></body>";\r
 385                         XmlTextReader reader = new XmlTextReader (new StringReader (xml));\r
 386                         XmlValidatingReader validator = new XmlValidatingReader (reader);\r
 387                         validator.Schemas.Add (sc);\r
 388                         validator.ValidationType = ValidationType.Schema;\r
 389                         while (!validator.EOF)\r
 390                                 validator.Read ();\r
 391                 }\r
 392 \r
 393 #if NET_2_0\r
 394                 [Test]\r
 395                 public void Bug81460 ()\r
 396                 {\r
 397                         string xsd = "<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'><xs:element name='foo'><xs:complexType><xs:attribute name='a' default='x' /></xs:complexType></xs:element></xs:schema>";\r
 398                         string xml = "<foo/>";\r
 399                         XmlReaderSettings s = new XmlReaderSettings ();\r
 400                         s.ValidationType = ValidationType.Schema;\r
 401                         s.Schemas.Add (XmlSchema.Read (new StringReader (xsd), null));\r
 402                         XmlReader r = XmlReader.Create (new StringReader (xml), s);\r
 403                         r.Read ();\r
 404                         r.MoveToFirstAttribute (); // default attribute\r
 405                         AssertEquals (String.Empty, r.Prefix);\r
 406                 }\r
 407 #endif\r
 408 \r
 409                 [Test]\r
 410 #if NET_2_0\r
 411                 // annoyance\r
 412                 [ExpectedException (typeof (XmlSchemaValidationException))]\r
 413 #else\r
 414                 [ExpectedException (typeof (XmlSchemaException))]\r
 415 #endif\r
 416                 public void Bug82099 ()\r
 417                 {\r
 418                         string xsd = @"\r
 419 <xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'>\r
 420   <xsd:element name='Customer' type='CustomerType' />\r
 421   <xsd:complexType name='CustomerType'>\r
 422     <xsd:attribute name='name' type='xsd:string' />\r
 423   </xsd:complexType>\r
 424 </xsd:schema>";\r
 425                         XmlSchema schema = XmlSchema.Read (new StringReader (xsd), null);\r
 426 \r
 427                         string xml = "<Customer name='Bob'> </Customer>";\r
 428 \r
 429 #if NET_2_0\r
 430                         XmlReaderSettings settings = new XmlReaderSettings ();\r
 431                         settings.Schemas.Add (schema);\r
 432                         settings.ValidationType = ValidationType.Schema;\r
 433 \r
 434                         XmlReader reader = XmlReader.Create (new StringReader (xml), settings);\r
 435                         \r
 436 #else\r
 437                         XmlValidatingReader reader = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 438                         reader.Schemas.Add (schema);\r
 439                         reader.ValidationType = ValidationType.Schema;\r
 440 #endif\r
 441                         reader.Read ();\r
 442                         reader.Read ();\r
 443                         reader.Read ();\r
 444                 }\r
 445 \r
 446                 [Test]\r
 447                 public void Bug82010 ()\r
 448                 {\r
 449                         string xmlfile = "Test/XmlFiles/xsd/82010.xml";\r
 450                         string xsdfile = "Test/XmlFiles/xsd/82010.xsd";\r
 451                         XmlTextReader xr = null, xr2 = null;\r
 452                         try {\r
 453                                 xr = new XmlTextReader (xsdfile);\r
 454                                 xr2 = new XmlTextReader (xmlfile);\r
 455                                 XmlValidatingReader xvr = new XmlValidatingReader (xr2);\r
 456                                 xvr.Schemas.Add (XmlSchema.Read (xr, null));\r
 457                                 while (!xvr.EOF)\r
 458                                         xvr.Read ();\r
 459                         } finally {\r
 460                                 if (xr2 != null)\r
 461                                         xr2.Close ();\r
 462                                 if (xr != null)\r
 463                                         xr.Close ();\r
 464                         }\r
 465                 }\r
 466 \r
 467                 [Test]\r
 468                 public void Bug376395 ()\r
 469                 {\r
 470                         string xmlfile = "Test/XmlFiles/xsd/376395.xml";\r
 471                         string xsdfile = "Test/XmlFiles/xsd/376395.xsd";\r
 472                         XmlTextReader xr = null, xr2 = null;\r
 473                         try {\r
 474                                 xr = new XmlTextReader (xsdfile);\r
 475                                 xr2 = new XmlTextReader (xmlfile);\r
 476                                 XmlValidatingReader xvr = new XmlValidatingReader (xr2);\r
 477                                 xvr.Schemas.Add (XmlSchema.Read (xr, null));\r
 478                                 while (!xvr.EOF)\r
 479                                         xvr.Read ();\r
 480                         } finally {\r
 481                                 if (xr2 != null)\r
 482                                         xr2.Close ();\r
 483                                 if (xr != null)\r
 484                                         xr.Close ();\r
 485                         }\r
 486                 }\r
 487 \r
 488                 [Test]\r
 489                 public void ValidateMixedInsideXsdAny ()\r
 490                 {\r
 491                         string xml = @"<root xmlns='urn:foo'>\r
 492   <X><Z>text</Z></X>\r
 493   <Y><X><Z>text</Z></X></Y>\r
 494 </root>";\r
 495                         string xsd = @"\r
 496 <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'\r
 497   targetNamespace='urn:foo' xmlns='urn:foo'>\r
 498     <xs:complexType name='root-type'>\r
 499       <xs:sequence><xs:element ref='X' /><xs:element ref='Y' /></xs:sequence>\r
 500     </xs:complexType>\r
 501     <xs:complexType name='X-type'>\r
 502       <xs:choice minOccurs='1' maxOccurs='unbounded'>\r
 503         <xs:any processContents='skip'/>\r
 504       </xs:choice>\r
 505     </xs:complexType>\r
 506     <xs:complexType name='Y-type'>\r
 507       <xs:sequence><xs:element ref='X' /></xs:sequence>\r
 508     </xs:complexType>\r
 509   <xs:element name='root' type='root-type' />\r
 510   <xs:element name='X' type='X-type' />\r
 511   <xs:element name='Y' type='Y-type' />\r
 512 </xs:schema>";\r
 513                         XmlTextReader xtr = new XmlTextReader (new StringReader (xml));\r
 514                         XmlValidatingReader xvr = new XmlValidatingReader (xtr);\r
 515                         XmlReader xsr = new XmlTextReader (new StringReader (xsd));\r
 516                         xvr.Schemas.Add (XmlSchema.Read (xsr, null));\r
 517                         while (!xvr.EOF)\r
 518                                 xvr.Read ();\r
 519 #if NET_2_0\r
 520                         xtr = new XmlTextReader (new StringReader (xml));\r
 521                         xsr = new XmlTextReader (new StringReader (xsd));\r
 522                         var s = new XmlReaderSettings ();\r
 523                         s.Schemas.Add (XmlSchema.Read (xsr, null));\r
 524                         s.ValidationType = ValidationType.Schema;\r
 525                         XmlReader xvr2 = XmlReader.Create (xtr, s);\r
 526                         while (!xvr2.EOF)\r
 527                                 xvr2.Read ();\r
 528 #endif\r
 529                 }\r
 530 \r
 531 #if NET_2_0\r
 532                 [Test]\r
 533                 public void WhitespaceAndElementOnly ()\r
 534                 {\r
 535                         string xsd = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
 536   <xs:element name='element_list'>\r
 537     <xs:complexType>\r
 538       <xs:sequence>\r
 539         <xs:element name='element' maxOccurs='unbounded' />\r
 540       </xs:sequence>\r
 541     </xs:complexType>\r
 542   </xs:element>\r
 543 </xs:schema>";\r
 544                         string xml = @"<element_list>\r
 545     <!-- blah blah blah -->\r
 546     <element />\r
 547 \r
 548     <!-- blah blah -->\r
 549     <element />\r
 550 </element_list>";\r
 551                         RunValidation (xml, xsd);\r
 552                 }\r
 553 \r
 554                 [Test]\r
 555                 [ExpectedException (typeof (XmlSchemaValidationException))]\r
 556                 public void EnumerationFacet ()\r
 557                 {\r
 558                         // bug #339934\r
 559                         string xsd = @"<xs:schema id='schema' xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
 560     <xs:simpleType name='ModeType'>\r
 561         <xs:restriction base='xs:string'>\r
 562             <xs:enumeration value='on' />\r
 563             <xs:enumeration value='off' />\r
 564         </xs:restriction>\r
 565     </xs:simpleType>\r
 566     <xs:element name='test'>\r
 567         <xs:complexType>\r
 568             <xs:sequence/>\r
 569             <xs:attribute name='mode' type='ModeType' use='required' />\r
 570         </xs:complexType>\r
 571     </xs:element>\r
 572 </xs:schema>";\r
 573                         string xml = @"<test mode='out of scope'></test>";\r
 574 \r
 575                         RunValidation (xml, xsd);\r
 576                 }\r
 577                 \r
 578                 [Test]\r
 579                 public void Bug501763 ()\r
 580                 {\r
 581                         string xsd1 = @"\r
 582                         <xs:schema id='foo1'\r
 583                                 targetNamespace='foo1'\r
 584                                 elementFormDefault='qualified'\r
 585                                 xmlns='foo1'                      \r
 586                                 xmlns:xs='http://www.w3.org/2001/XMLSchema'\r
 587                                 xmlns:f2='foo2'>\r
 588 \r
 589                                 <xs:import namespace='foo2' />\r
 590                                 <xs:element name='Foo1Element' type='f2:Foo2ExtendedType'/>     \r
 591                         </xs:schema>";\r
 592 \r
 593                         string xsd2 = @"\r
 594                         <xs:schema id='foo2'\r
 595                                 targetNamespace='foo2'\r
 596                                 elementFormDefault='qualified'\r
 597                                 xmlns='foo2'    \r
 598                                 xmlns:xs='http://www.w3.org/2001/XMLSchema' >\r
 599 \r
 600                                 <xs:element name='Foo2Element' type='Foo2Type' />\r
 601         \r
 602                                 <xs:complexType name='Foo2Type'>\r
 603                                         <xs:attribute name='foo2Attr' type='xs:string' use='required'/>\r
 604                                 </xs:complexType>\r
 605         \r
 606                                 <xs:complexType name='Foo2ExtendedType'>\r
 607                                         <xs:complexContent>\r
 608                                                 <xs:extension base='Foo2Type'>\r
 609                                                         <xs:attribute name='foo2ExtAttr' type='xs:string' use='required'/>\r
 610                                                 </xs:extension>\r
 611                                         </xs:complexContent>\r
 612                                 </xs:complexType>\r
 613                         </xs:schema>";\r
 614 \r
 615                         \r
 616                         XmlDocument doc = new XmlDocument ();\r
 617                         \r
 618                         XmlSchema schema1 = XmlSchema.Read (XmlReader.Create (new StringReader (xsd1)), null);\r
 619                         XmlSchema schema2 = XmlSchema.Read (XmlReader.Create (new StringReader (xsd2)), null);\r
 620                         \r
 621                         doc.LoadXml (@"\r
 622                                 <Foo2Element\r
 623                                         foo2Attr='dummyvalue1'\r
 624                                         xmlns='foo2'\r
 625                                 />");\r
 626                         doc.Schemas.Add (schema2);\r
 627                         doc.Validate (null);\r
 628                         \r
 629                         doc = new XmlDocument();\r
 630                         doc.LoadXml(@"\r
 631                                 <Foo1Element\r
 632                                         foo2Attr='dummyvalue1'\r
 633                                         foo2ExtAttr='dummyvalue2'\r
 634                                         xmlns='foo1'\r
 635                                 />");\r
 636                         doc.Schemas.Add (schema2);\r
 637                         doc.Schemas.Add (schema1);\r
 638                         doc.Validate (null);\r
 639                 }\r
 640                 \r
 641                 void RunValidation (string xml, string xsd)\r
 642                 {\r
 643                         XmlReaderSettings s = new XmlReaderSettings ();\r
 644                         s.ValidationType = ValidationType.Schema;\r
 645                         s.Schemas.Add (XmlSchema.Read (XmlReader.Create (new StringReader (xsd)), null));\r
 646 \r
 647                         XmlReader r = XmlReader.Create (new StringReader (xml), s);\r
 648                         while (!r.EOF)\r
 649                                 r.Read ();\r
 650                 }\r
 651 #endif\r
 652         }\r
 653 }\r