654 lines
20 KiB
C#
654 lines
20 KiB
C#
//
|
|
// MonoTests.System.Xml.XsdValidatingReaderTests.cs
|
|
//
|
|
// Author:
|
|
// Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
|
|
//
|
|
// (C)2003 Atsushi Enomoto
|
|
// (C)2005-2007 Novell, Inc.
|
|
//
|
|
using System;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.System.Xml
|
|
{
|
|
[TestFixture]
|
|
public class XsdValidatingReaderTests
|
|
{
|
|
public XsdValidatingReaderTests ()
|
|
{
|
|
}
|
|
|
|
XmlReader xtr;
|
|
XmlValidatingReader xvr;
|
|
|
|
private XmlValidatingReader PrepareXmlReader (string xml)
|
|
{
|
|
XmlReader reader = new XmlTextReader (xml, XmlNodeType.Document, null);
|
|
// XmlDocument doc = new XmlDocument ();
|
|
// doc.LoadXml (xml);
|
|
// XmlReader reader = new XmlNodeReader (doc);
|
|
|
|
return new XmlValidatingReader (reader);
|
|
}
|
|
|
|
[Test]
|
|
public void TestEmptySchema ()
|
|
{
|
|
string xml = "<root/>";
|
|
xvr = PrepareXmlReader (xml);
|
|
xvr.ValidationType = ValidationType.Schema;
|
|
xvr.Read (); // Is is missing schema component.
|
|
}
|
|
|
|
[Test]
|
|
public void TestSimpleValidation ()
|
|
{
|
|
string xml = "<root/>";
|
|
xvr = PrepareXmlReader (xml);
|
|
Assert.AreEqual (ValidationType.Auto, xvr.ValidationType);
|
|
XmlSchema schema = new XmlSchema ();
|
|
XmlSchemaElement elem = new XmlSchemaElement ();
|
|
elem.Name = "root";
|
|
schema.Items.Add (elem);
|
|
xvr.Schemas.Add (schema);
|
|
xvr.Read (); // root
|
|
Assert.AreEqual (ValidationType.Auto, xvr.ValidationType);
|
|
xvr.Read (); // EOF
|
|
|
|
xml = "<hoge/>";
|
|
xvr = PrepareXmlReader (xml);
|
|
xvr.Schemas.Add (schema);
|
|
try {
|
|
xvr.Read ();
|
|
Assert.Fail ("element mismatch is incorrectly allowed");
|
|
} catch (XmlSchemaException) {
|
|
}
|
|
|
|
xml = "<hoge xmlns='urn:foo' />";
|
|
xvr = PrepareXmlReader (xml);
|
|
xvr.Schemas.Add (schema);
|
|
try {
|
|
xvr.Read ();
|
|
Assert.Fail ("Element in different namespace is incorrectly allowed.");
|
|
} catch (XmlSchemaException) {
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestReadTypedValueSimple ()
|
|
{
|
|
string xml = "<root>12</root>";
|
|
XmlSchema schema = new XmlSchema ();
|
|
XmlSchemaElement elem = new XmlSchemaElement ();
|
|
elem.Name = "root";
|
|
elem.SchemaTypeName = new XmlQualifiedName ("integer", XmlSchema.Namespace);
|
|
schema.Items.Add (elem);
|
|
|
|
// Lap 1:
|
|
|
|
xvr = PrepareXmlReader (xml);
|
|
xvr.Schemas.Add (schema);
|
|
// Read directly from root.
|
|
object o = xvr.ReadTypedValue ();
|
|
Assert.AreEqual (ReadState.Initial, xvr.ReadState);
|
|
Assert.IsNull (o);
|
|
|
|
xvr.Read (); // element root
|
|
Assert.AreEqual (XmlNodeType.Element, xvr.NodeType);
|
|
Assert.IsNotNull (xvr.SchemaType);
|
|
Assert.IsTrue (xvr.SchemaType is XmlSchemaDatatype);
|
|
o = xvr.ReadTypedValue (); // read "12"
|
|
Assert.AreEqual (XmlNodeType.EndElement, xvr.NodeType);
|
|
Assert.IsNotNull (o);
|
|
Assert.AreEqual (typeof (decimal), o.GetType ());
|
|
decimal n = (decimal) o;
|
|
Assert.AreEqual (12, n);
|
|
Assert.IsTrue (!xvr.EOF);
|
|
Assert.AreEqual ("root", xvr.Name);
|
|
Assert.IsNull (xvr.SchemaType); // EndElement's type
|
|
|
|
// Lap 2:
|
|
|
|
xvr = PrepareXmlReader (xml);
|
|
xvr.Schemas.Add (schema);
|
|
xvr.Read (); // root
|
|
XmlSchemaDatatype dt = xvr.SchemaType as XmlSchemaDatatype;
|
|
Assert.IsNotNull (dt);
|
|
Assert.AreEqual (typeof (decimal), dt.ValueType);
|
|
Assert.AreEqual (XmlTokenizedType.None, dt.TokenizedType);
|
|
xvr.Read (); // text "12"
|
|
Assert.IsNull (xvr.SchemaType);
|
|
o = xvr.ReadTypedValue ();
|
|
// ReadTypedValue is different from ReadString().
|
|
Assert.IsNull (o);
|
|
}
|
|
|
|
[Test]
|
|
[Ignore ("XML Schema validator should not be available for validating non namespace-aware XmlReader that handled colon as a name character")]
|
|
public void TestNamespacesFalse ()
|
|
{
|
|
// This tests if Namespaces=false is specified, then
|
|
// the reader's NamespaceURI should be always string.Empty and
|
|
// validation should be done against such schema that has target ns as "".
|
|
string xml = "<x:root xmlns:x='urn:foo' />";
|
|
xvr = PrepareXmlReader (xml);
|
|
xvr.Namespaces = false;
|
|
Assert.AreEqual (ValidationType.Auto, xvr.ValidationType);
|
|
XmlSchema schema = new XmlSchema ();
|
|
schema.TargetNamespace = "urn:foo";
|
|
XmlSchemaElement elem = new XmlSchemaElement ();
|
|
elem.Name = "root";
|
|
schema.Items.Add (elem);
|
|
xvr.Schemas.Add (schema);
|
|
xvr.Read (); // root
|
|
Assert.IsTrue (!xvr.Namespaces);
|
|
Assert.AreEqual ("x:root", xvr.Name);
|
|
// LocalName may contain colons.
|
|
Assert.AreEqual ("x:root", xvr.LocalName);
|
|
// NamespaceURI is not supplied.
|
|
Assert.AreEqual ("", xvr.NamespaceURI);
|
|
}
|
|
|
|
[Test]
|
|
public void TestReadTypedAttributeValue ()
|
|
{
|
|
string xml = "<root attr='12'></root>";
|
|
XmlSchema schema = new XmlSchema ();
|
|
XmlSchemaElement elem = new XmlSchemaElement ();
|
|
elem.Name = "root";
|
|
XmlSchemaComplexType ct = new XmlSchemaComplexType ();
|
|
XmlSchemaAttribute attr = new XmlSchemaAttribute ();
|
|
attr.Name = "attr";
|
|
attr.SchemaTypeName = new XmlQualifiedName ("int", XmlSchema.Namespace);
|
|
ct.Attributes.Add (attr);
|
|
elem.SchemaType = ct;
|
|
schema.Items.Add (elem);
|
|
|
|
xvr = PrepareXmlReader (xml);
|
|
xvr.Schemas.Add (schema);
|
|
xvr.Read ();
|
|
Assert.AreEqual ("root", xvr.Name);
|
|
Assert.IsTrue (xvr.MoveToNextAttribute ()); // attr
|
|
Assert.AreEqual ("attr", xvr.Name);
|
|
XmlSchemaDatatype dt = xvr.SchemaType as XmlSchemaDatatype;
|
|
Assert.IsNotNull (dt);
|
|
Assert.AreEqual (typeof (int), dt.ValueType);
|
|
Assert.AreEqual (XmlTokenizedType.None, dt.TokenizedType);
|
|
object o = xvr.ReadTypedValue ();
|
|
Assert.AreEqual (XmlNodeType.Attribute, xvr.NodeType);
|
|
Assert.AreEqual (typeof (int), o.GetType ());
|
|
int n = (int) o;
|
|
Assert.AreEqual (12, n);
|
|
Assert.IsTrue (xvr.ReadAttributeValue ()); // can read = seems not proceed.
|
|
}
|
|
|
|
[Test]
|
|
public void DuplicateSchemaAssignment ()
|
|
{
|
|
string xml = @"<data
|
|
xmlns='http://www.test.com/schemas/'
|
|
xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
|
|
xsi:schemaLocation='http://www.test.com/schemas/ /home/user/schema.xsd' />";
|
|
string xsd = @"<xs:schema
|
|
targetNamespace='http://www.test.com/schemas/'
|
|
xmlns:xs='http://www.w3.org/2001/XMLSchema'
|
|
xmlns='http://www.test.com/schemas/' >
|
|
<xs:element name='data' /></xs:schema>";
|
|
|
|
string xmlns = "http://www.test.com/schemas/";
|
|
|
|
XmlValidatingReader xvr = new XmlValidatingReader (
|
|
xml, XmlNodeType.Document, null);
|
|
XmlSchemaCollection schemas = new XmlSchemaCollection ();
|
|
schemas.Add (XmlSchema.Read (new XmlTextReader (
|
|
xsd, XmlNodeType.Document, null), null));
|
|
xvr.Schemas.Add (schemas);
|
|
while (!xvr.EOF)
|
|
xvr.Read ();
|
|
}
|
|
|
|
[Test] // bug #76234
|
|
public void DTDValidatorNamespaceHandling ()
|
|
{
|
|
string xml = "<xml xmlns='urn:a'> <foo> <a:bar xmlns='urn:b' xmlns:a='urn:a' /> <bug /> </foo> </xml>";
|
|
XmlValidatingReader vr = new XmlValidatingReader (
|
|
xml, XmlNodeType.Document, null);
|
|
vr.Read ();
|
|
vr.Read (); // whitespace
|
|
Assert.AreEqual (String.Empty, vr.NamespaceURI, "#1");
|
|
vr.Read (); // foo
|
|
Assert.AreEqual ("urn:a", vr.NamespaceURI, "#2");
|
|
vr.Read (); // whitespace
|
|
vr.Read (); // a:bar
|
|
Assert.AreEqual ("urn:a", vr.NamespaceURI, "#3");
|
|
vr.Read (); // whitespace
|
|
vr.Read (); // bug
|
|
Assert.AreEqual ("urn:a", vr.NamespaceURI, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void MultipleSchemaInSchemaLocation ()
|
|
{
|
|
XmlTextReader xtr = new XmlTextReader ("Test/XmlFiles/xsd/multi-schemaLocation.xml");
|
|
XmlValidatingReader vr = new XmlValidatingReader (xtr);
|
|
while (!vr.EOF)
|
|
vr.Read ();
|
|
}
|
|
|
|
[Test]
|
|
public void ReadTypedValueSimpleTypeRestriction ()
|
|
{
|
|
string xml = "<root>xx</root><!-- after -->";
|
|
string xsd = @"
|
|
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
|
|
<xs:element name='root'>
|
|
<xs:simpleType>
|
|
<xs:restriction base='xs:string'>
|
|
<xs:minLength value='2' />
|
|
</xs:restriction>
|
|
</xs:simpleType>
|
|
</xs:element>
|
|
</xs:schema>";
|
|
XmlTextReader xir =
|
|
new XmlTextReader (xml, XmlNodeType.Document, null);
|
|
XmlTextReader xsr =
|
|
new XmlTextReader (xsd, XmlNodeType.Document, null);
|
|
XmlValidatingReader vr = new XmlValidatingReader (xir);
|
|
vr.Schemas.Add (XmlSchema.Read (xsr, null));
|
|
vr.Read (); // root
|
|
Assert.AreEqual ("xx", vr.ReadTypedValue ());
|
|
Assert.AreEqual (XmlNodeType.EndElement, vr.NodeType);
|
|
}
|
|
|
|
// If we normalize string before validating with facets,
|
|
// this test will fail. It will also fail if ReadTypedValue()
|
|
// ignores whitespace nodes.
|
|
[Test]
|
|
public void ReadTypedValueWhitespaces ()
|
|
{
|
|
string xml = "<root> </root><!-- after -->";
|
|
string xsd = @"
|
|
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
|
|
<xs:element name='root'>
|
|
<xs:simpleType>
|
|
<xs:restriction base='xs:string'>
|
|
<xs:minLength value='2' />
|
|
</xs:restriction>
|
|
</xs:simpleType>
|
|
</xs:element>
|
|
</xs:schema>";
|
|
XmlTextReader xir =
|
|
new XmlTextReader (xml, XmlNodeType.Document, null);
|
|
XmlTextReader xsr =
|
|
new XmlTextReader (xsd, XmlNodeType.Document, null);
|
|
XmlValidatingReader vr = new XmlValidatingReader (xir);
|
|
vr.Schemas.Add (XmlSchema.Read (xsr, null));
|
|
vr.Read (); // root
|
|
Assert.AreEqual (" ", vr.ReadTypedValue ());
|
|
Assert.AreEqual (XmlNodeType.EndElement, vr.NodeType);
|
|
}
|
|
|
|
[Test] // bug #77241
|
|
public void EmptyContentAllowWhitespace ()
|
|
{
|
|
string doc = @"
|
|
<root>
|
|
<!-- some comment -->
|
|
<child/>
|
|
</root>
|
|
";
|
|
string schema = @"
|
|
<xsd:schema xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">
|
|
<xsd:element name=""root"">
|
|
<xsd:complexType>
|
|
<xsd:sequence>
|
|
<xsd:element name=""child"" type=""xsd:string"" />
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
</xsd:element>
|
|
</xsd:schema>
|
|
";
|
|
XmlValidatingReader reader = new XmlValidatingReader (
|
|
new XmlTextReader (new StringReader (doc)));
|
|
reader.Schemas.Add (null,
|
|
new XmlTextReader (new StringReader (schema)));
|
|
while (reader.Read ())
|
|
;
|
|
}
|
|
|
|
[Test] // bug #79650
|
|
#if NET_2_0
|
|
// annoyance
|
|
[ExpectedException (typeof (XmlSchemaValidationException))]
|
|
#else
|
|
[ExpectedException (typeof (XmlSchemaException))]
|
|
#endif
|
|
public void EnumerationFacetOnAttribute ()
|
|
{
|
|
string xml = "<test mode='NOT A ENUMERATION VALUE' />";
|
|
XmlSchema schema = XmlSchema.Read (new XmlTextReader ("Test/XmlFiles/xsd/79650.xsd"), null);
|
|
XmlValidatingReader xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
|
|
xvr.ValidationType = ValidationType.Schema;
|
|
xvr.Schemas.Add (schema);
|
|
while (!xvr.EOF)
|
|
xvr.Read ();
|
|
}
|
|
|
|
class XmlErrorResolver : XmlResolver
|
|
{
|
|
public override ICredentials Credentials {
|
|
set { }
|
|
}
|
|
|
|
public override object GetEntity (Uri uri, string role, Type type)
|
|
{
|
|
throw new Exception ();
|
|
}
|
|
}
|
|
|
|
[Test] // bug #79924
|
|
public void ValidationTypeNoneIgnoreSchemaLocations ()
|
|
{
|
|
string xml = "<project xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:noNamespaceSchemaLocation='nosuchschema.xsd'/>";
|
|
XmlValidatingReader vr = new XmlValidatingReader (
|
|
new XmlTextReader (new StringReader (xml)));
|
|
vr.ValidationType = ValidationType.None;
|
|
vr.XmlResolver = new XmlErrorResolver ();
|
|
while (!vr.EOF)
|
|
vr.Read ();
|
|
}
|
|
|
|
[Test] // bug #336625
|
|
public void ValidationTypeNoneIgnoreLocatedSchemaErrors ()
|
|
{
|
|
string xml = "<test xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:noNamespaceSchemaLocation='Test/XmlFiles/xsd/336625.xsd'/>";
|
|
XmlValidatingReader vr = new XmlValidatingReader (
|
|
new XmlTextReader (new StringReader (xml)));
|
|
vr.ValidationType = ValidationType.None;
|
|
while (!vr.EOF)
|
|
vr.Read ();
|
|
}
|
|
|
|
[Test]
|
|
public void Bug81360 ()
|
|
{
|
|
string schemaFile = "Test/XmlFiles/xsd/81360.xsd";
|
|
XmlTextReader treader = new XmlTextReader (schemaFile);
|
|
XmlSchema sc = XmlSchema.Read (treader, null);
|
|
sc.Compile (null);
|
|
string xml = @"<body xmlns='" + sc.TargetNamespace + "'><div></div></body>";
|
|
XmlTextReader reader = new XmlTextReader (new StringReader (xml));
|
|
XmlValidatingReader validator = new XmlValidatingReader (reader);
|
|
validator.Schemas.Add (sc);
|
|
validator.ValidationType = ValidationType.Schema;
|
|
while (!validator.EOF)
|
|
validator.Read ();
|
|
}
|
|
|
|
#if NET_2_0
|
|
[Test]
|
|
public void Bug81460 ()
|
|
{
|
|
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>";
|
|
string xml = "<foo/>";
|
|
XmlReaderSettings s = new XmlReaderSettings ();
|
|
s.ValidationType = ValidationType.Schema;
|
|
s.Schemas.Add (XmlSchema.Read (new StringReader (xsd), null));
|
|
XmlReader r = XmlReader.Create (new StringReader (xml), s);
|
|
r.Read ();
|
|
r.MoveToFirstAttribute (); // default attribute
|
|
Assert.AreEqual (String.Empty, r.Prefix);
|
|
}
|
|
#endif
|
|
|
|
[Test]
|
|
#if NET_2_0
|
|
// annoyance
|
|
[ExpectedException (typeof (XmlSchemaValidationException))]
|
|
#else
|
|
[ExpectedException (typeof (XmlSchemaException))]
|
|
#endif
|
|
public void Bug82099 ()
|
|
{
|
|
string xsd = @"
|
|
<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'>
|
|
<xsd:element name='Customer' type='CustomerType' />
|
|
<xsd:complexType name='CustomerType'>
|
|
<xsd:attribute name='name' type='xsd:string' />
|
|
</xsd:complexType>
|
|
</xsd:schema>";
|
|
XmlSchema schema = XmlSchema.Read (new StringReader (xsd), null);
|
|
|
|
string xml = "<Customer name='Bob'> </Customer>";
|
|
|
|
#if NET_2_0
|
|
XmlReaderSettings settings = new XmlReaderSettings ();
|
|
settings.Schemas.Add (schema);
|
|
settings.ValidationType = ValidationType.Schema;
|
|
|
|
XmlReader reader = XmlReader.Create (new StringReader (xml), settings);
|
|
|
|
#else
|
|
XmlValidatingReader reader = new XmlValidatingReader (xml, XmlNodeType.Document, null);
|
|
reader.Schemas.Add (schema);
|
|
reader.ValidationType = ValidationType.Schema;
|
|
#endif
|
|
reader.Read ();
|
|
reader.Read ();
|
|
reader.Read ();
|
|
}
|
|
|
|
[Test]
|
|
public void Bug82010 ()
|
|
{
|
|
string xmlfile = "Test/XmlFiles/xsd/82010.xml";
|
|
string xsdfile = "Test/XmlFiles/xsd/82010.xsd";
|
|
XmlTextReader xr = null, xr2 = null;
|
|
try {
|
|
xr = new XmlTextReader (xsdfile);
|
|
xr2 = new XmlTextReader (xmlfile);
|
|
XmlValidatingReader xvr = new XmlValidatingReader (xr2);
|
|
xvr.Schemas.Add (XmlSchema.Read (xr, null));
|
|
while (!xvr.EOF)
|
|
xvr.Read ();
|
|
} finally {
|
|
if (xr2 != null)
|
|
xr2.Close ();
|
|
if (xr != null)
|
|
xr.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Bug376395 ()
|
|
{
|
|
string xmlfile = "Test/XmlFiles/xsd/376395.xml";
|
|
string xsdfile = "Test/XmlFiles/xsd/376395.xsd";
|
|
XmlTextReader xr = null, xr2 = null;
|
|
try {
|
|
xr = new XmlTextReader (xsdfile);
|
|
xr2 = new XmlTextReader (xmlfile);
|
|
XmlValidatingReader xvr = new XmlValidatingReader (xr2);
|
|
xvr.Schemas.Add (XmlSchema.Read (xr, null));
|
|
while (!xvr.EOF)
|
|
xvr.Read ();
|
|
} finally {
|
|
if (xr2 != null)
|
|
xr2.Close ();
|
|
if (xr != null)
|
|
xr.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateMixedInsideXsdAny ()
|
|
{
|
|
string xml = @"<root xmlns='urn:foo'>
|
|
<X><Z>text</Z></X>
|
|
<Y><X><Z>text</Z></X></Y>
|
|
</root>";
|
|
string xsd = @"
|
|
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'
|
|
targetNamespace='urn:foo' xmlns='urn:foo'>
|
|
<xs:complexType name='root-type'>
|
|
<xs:sequence><xs:element ref='X' /><xs:element ref='Y' /></xs:sequence>
|
|
</xs:complexType>
|
|
<xs:complexType name='X-type'>
|
|
<xs:choice minOccurs='1' maxOccurs='unbounded'>
|
|
<xs:any processContents='skip'/>
|
|
</xs:choice>
|
|
</xs:complexType>
|
|
<xs:complexType name='Y-type'>
|
|
<xs:sequence><xs:element ref='X' /></xs:sequence>
|
|
</xs:complexType>
|
|
<xs:element name='root' type='root-type' />
|
|
<xs:element name='X' type='X-type' />
|
|
<xs:element name='Y' type='Y-type' />
|
|
</xs:schema>";
|
|
XmlTextReader xtr = new XmlTextReader (new StringReader (xml));
|
|
XmlValidatingReader xvr = new XmlValidatingReader (xtr);
|
|
XmlReader xsr = new XmlTextReader (new StringReader (xsd));
|
|
xvr.Schemas.Add (XmlSchema.Read (xsr, null));
|
|
while (!xvr.EOF)
|
|
xvr.Read ();
|
|
#if NET_2_0
|
|
xtr = new XmlTextReader (new StringReader (xml));
|
|
xsr = new XmlTextReader (new StringReader (xsd));
|
|
var s = new XmlReaderSettings ();
|
|
s.Schemas.Add (XmlSchema.Read (xsr, null));
|
|
s.ValidationType = ValidationType.Schema;
|
|
XmlReader xvr2 = XmlReader.Create (xtr, s);
|
|
while (!xvr2.EOF)
|
|
xvr2.Read ();
|
|
#endif
|
|
}
|
|
|
|
#if NET_2_0
|
|
[Test]
|
|
public void WhitespaceAndElementOnly ()
|
|
{
|
|
string xsd = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
|
|
<xs:element name='element_list'>
|
|
<xs:complexType>
|
|
<xs:sequence>
|
|
<xs:element name='element' maxOccurs='unbounded' />
|
|
</xs:sequence>
|
|
</xs:complexType>
|
|
</xs:element>
|
|
</xs:schema>";
|
|
string xml = @"<element_list>
|
|
<!-- blah blah blah -->
|
|
<element />
|
|
|
|
<!-- blah blah -->
|
|
<element />
|
|
</element_list>";
|
|
RunValidation (xml, xsd);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (XmlSchemaValidationException))]
|
|
public void EnumerationFacet ()
|
|
{
|
|
// bug #339934
|
|
string xsd = @"<xs:schema id='schema' xmlns:xs='http://www.w3.org/2001/XMLSchema'>
|
|
<xs:simpleType name='ModeType'>
|
|
<xs:restriction base='xs:string'>
|
|
<xs:enumeration value='on' />
|
|
<xs:enumeration value='off' />
|
|
</xs:restriction>
|
|
</xs:simpleType>
|
|
<xs:element name='test'>
|
|
<xs:complexType>
|
|
<xs:sequence/>
|
|
<xs:attribute name='mode' type='ModeType' use='required' />
|
|
</xs:complexType>
|
|
</xs:element>
|
|
</xs:schema>";
|
|
string xml = @"<test mode='out of scope'></test>";
|
|
|
|
RunValidation (xml, xsd);
|
|
}
|
|
|
|
[Test]
|
|
public void Bug501763 ()
|
|
{
|
|
string xsd1 = @"
|
|
<xs:schema id='foo1'
|
|
targetNamespace='foo1'
|
|
elementFormDefault='qualified'
|
|
xmlns='foo1'
|
|
xmlns:xs='http://www.w3.org/2001/XMLSchema'
|
|
xmlns:f2='foo2'>
|
|
|
|
<xs:import namespace='foo2' />
|
|
<xs:element name='Foo1Element' type='f2:Foo2ExtendedType'/>
|
|
</xs:schema>";
|
|
|
|
string xsd2 = @"
|
|
<xs:schema id='foo2'
|
|
targetNamespace='foo2'
|
|
elementFormDefault='qualified'
|
|
xmlns='foo2'
|
|
xmlns:xs='http://www.w3.org/2001/XMLSchema' >
|
|
|
|
<xs:element name='Foo2Element' type='Foo2Type' />
|
|
|
|
<xs:complexType name='Foo2Type'>
|
|
<xs:attribute name='foo2Attr' type='xs:string' use='required'/>
|
|
</xs:complexType>
|
|
|
|
<xs:complexType name='Foo2ExtendedType'>
|
|
<xs:complexContent>
|
|
<xs:extension base='Foo2Type'>
|
|
<xs:attribute name='foo2ExtAttr' type='xs:string' use='required'/>
|
|
</xs:extension>
|
|
</xs:complexContent>
|
|
</xs:complexType>
|
|
</xs:schema>";
|
|
|
|
|
|
XmlDocument doc = new XmlDocument ();
|
|
|
|
XmlSchema schema1 = XmlSchema.Read (XmlReader.Create (new StringReader (xsd1)), null);
|
|
XmlSchema schema2 = XmlSchema.Read (XmlReader.Create (new StringReader (xsd2)), null);
|
|
|
|
doc.LoadXml (@"
|
|
<Foo2Element
|
|
foo2Attr='dummyvalue1'
|
|
xmlns='foo2'
|
|
/>");
|
|
doc.Schemas.Add (schema2);
|
|
doc.Validate (null);
|
|
|
|
doc = new XmlDocument();
|
|
doc.LoadXml(@"
|
|
<Foo1Element
|
|
foo2Attr='dummyvalue1'
|
|
foo2ExtAttr='dummyvalue2'
|
|
xmlns='foo1'
|
|
/>");
|
|
doc.Schemas.Add (schema2);
|
|
doc.Schemas.Add (schema1);
|
|
doc.Validate (null);
|
|
}
|
|
|
|
void RunValidation (string xml, string xsd)
|
|
{
|
|
XmlReaderSettings s = new XmlReaderSettings ();
|
|
s.ValidationType = ValidationType.Schema;
|
|
s.Schemas.Add (XmlSchema.Read (XmlReader.Create (new StringReader (xsd)), null));
|
|
|
|
XmlReader r = XmlReader.Create (new StringReader (xml), s);
|
|
while (!r.EOF)
|
|
r.Read ();
|
|
}
|
|
#endif
|
|
}
|
|
}
|