using System;
using System.IO;
+using System.Net;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using NUnit.Framework;
namespace MonoTests.System.Xml
-{
+{
[TestFixture]
public class XmlSchemaTests : XmlSchemaAssertion
{
+ static readonly bool StrictMsCompliant = Environment.GetEnvironmentVariable ("MONO_STRICT_MS_COMPLIANT") == "yes";
+
[Test]
public void TestRead ()
{
XmlSchema schema = GetSchema ("Test/XmlFiles/xsd/1.xsd");
- AssertEquals (6, schema.Items.Count);
+ Assert.AreEqual (6, schema.Items.Count);
bool fooValidated = false;
bool barValidated = false;
barValidated = true;
}
}
- Assert (fooValidated);
- Assert (barValidated);
+ Assert.IsTrue (fooValidated);
+ Assert.IsTrue (barValidated);
}
[Test]
XmlSchema schema = GetSchema ("Test/XmlFiles/xsd/2.xsd");
schema.Compile (null);
XmlSchemaElement el = schema.Items [0] as XmlSchemaElement;
- AssertNotNull (el);
- AssertEquals (XmlSchemaDerivationMethod.Extension, el.Block);
+ Assert.IsNotNull (el);
+ Assert.AreEqual (XmlSchemaDerivationMethod.Extension, el.Block);
el = schema.Items [1] as XmlSchemaElement;
- AssertNotNull (el);
- AssertEquals (XmlSchemaDerivationMethod.Extension |
+ Assert.IsNotNull (el);
+ Assert.AreEqual (XmlSchemaDerivationMethod.Extension |
XmlSchemaDerivationMethod.Restriction, el.Block);
}
XmlSchemaSequence seq;
XmlSchema schema = GetSchema ("Test/XmlFiles/xsd/1.xsd");
-// Assert (!schema.IsCompiled);
+// Assert.IsTrue (!schema.IsCompiled);
schema.Compile (null);
- Assert (schema.IsCompiled);
+ Assert.IsTrue (schema.IsCompiled);
string ns = "urn:bar";
XmlSchemaElement foo = (XmlSchemaElement) schema.Elements [QName ("Foo", ns)];
- AssertNotNull (foo);
+ Assert.IsNotNull (foo);
XmlSchemaDatatype stringDatatype = foo.ElementType as XmlSchemaDatatype;
- AssertNotNull (stringDatatype);
+ Assert.IsNotNull (stringDatatype);
// HogeType
qname = QName ("HogeType", ns);
cType = schema.SchemaTypes [qname] as XmlSchemaComplexType;
- AssertNotNull (cType);
- AssertNull (cType.ContentModel);
+ Assert.IsNotNull (cType);
+ Assert.IsNull (cType.ContentModel);
AssertCompiledComplexType (cType, qname, 0, 0,
false, null, true, XmlSchemaContentType.ElementOnly);
seq = cType.ContentTypeParticle as XmlSchemaSequence;
- AssertNotNull (seq);
- AssertEquals (2, seq.Items.Count);
+ Assert.IsNotNull (seq);
+ Assert.AreEqual (2, seq.Items.Count);
XmlSchemaElement refFoo = seq.Items [0] as XmlSchemaElement;
AssertCompiledElement (refFoo, QName ("Foo", ns), stringDatatype);
// FugaType
qname = QName ("FugaType", ns);
cType = schema.SchemaTypes [qname] as XmlSchemaComplexType;
- AssertNotNull (cType);
+ Assert.IsNotNull (cType);
xccx = cType.ContentModel.Content as XmlSchemaComplexContentExtension;
AssertCompiledComplexContentExtension (
xccx, 0, false, QName ("HogeType", ns));
AssertCompiledComplexType (cType, qname, 0, 0,
false, typeof (XmlSchemaComplexContent),
true, XmlSchemaContentType.ElementOnly);
- AssertNotNull (cType.BaseSchemaType);
+ Assert.IsNotNull (cType.BaseSchemaType);
seq = xccx.Particle as XmlSchemaSequence;
- AssertNotNull (seq);
- AssertEquals (1, seq.Items.Count);
+ Assert.IsNotNull (seq);
+ Assert.AreEqual (1, seq.Items.Count);
XmlSchemaElement refBaz = seq.Items [0] as XmlSchemaElement;
- AssertNotNull (refBaz);
+ Assert.IsNotNull (refBaz);
AssertCompiledElement (refBaz, QName ("Baz", ""), stringDatatype);
qname = QName ("Bar", ns);
AssertCompiledElement (element, qname, cType);
}
+ [Test]
+ [ExpectedException (typeof (XmlSchemaException))]
+ public void TestCompile_ZeroLength_TargetNamespace ()
+ {
+ XmlSchema schema = new XmlSchema ();
+ schema.TargetNamespace = string.Empty;
+ Assert.IsTrue (!schema.IsCompiled);
+
+ // MS.NET 1.x: The Namespace '' is an invalid URI.
+ // MS.NET 2.0: The targetNamespace attribute cannot have empty string as its value.
+ schema.Compile (null);
+ }
+
[Test]
[ExpectedException (typeof (XmlSchemaException))]
public void TestCompileNonSchema ()
{
XmlTextReader xtr = new XmlTextReader ("<root/>", XmlNodeType.Document, null);
XmlSchema schema = XmlSchema.Read (xtr, null);
- xtr.Close ();\r
+ xtr.Close ();
}
[Test]
public void TestSimpleImport ()
{
XmlSchema schema = XmlSchema.Read (new XmlTextReader ("Test/XmlFiles/xsd/3.xsd"), null);
- AssertEquals ("urn:foo", schema.TargetNamespace);
+ Assert.AreEqual ("urn:foo", schema.TargetNamespace);
XmlSchemaImport import = schema.Includes [0] as XmlSchemaImport;
- AssertNotNull (import);
+ Assert.IsNotNull (import);
schema.Compile (null);
- AssertEquals (4, schema.Elements.Count);
- AssertNotNull (schema.Elements [QName ("Foo", "urn:foo")]);
- AssertNotNull (schema.Elements [QName ("Bar", "urn:foo")]);
- AssertNotNull (schema.Elements [QName ("Foo", "urn:bar")]);
- AssertNotNull (schema.Elements [QName ("Bar", "urn:bar")]);
+ Assert.AreEqual (4, schema.Elements.Count);
+ Assert.IsNotNull (schema.Elements [QName ("Foo", "urn:foo")]);
+ Assert.IsNotNull (schema.Elements [QName ("Bar", "urn:foo")]);
+ Assert.IsNotNull (schema.Elements [QName ("Foo", "urn:bar")]);
+ Assert.IsNotNull (schema.Elements [QName ("Bar", "urn:bar")]);
}
+ [Test]
+ [Category ("MobileNotWorking")]
+ public void TestSimpleMutualImport ()
+ {
+ XmlReader r = new XmlTextReader ("Test/XmlFiles/xsd/inter-inc-1.xsd");
+ try {
+ XmlSchema.Read (r, null).Compile (null);
+ } finally {
+ r.Close ();
+ }
+ }
+
[Test]
public void TestQualification ()
{
XmlSchema schema = XmlSchema.Read (new XmlTextReader ("Test/XmlFiles/xsd/5.xsd"), null);
schema.Compile (null);
XmlSchemaElement el = schema.Elements [QName ("Foo", "urn:bar")] as XmlSchemaElement;
- AssertNotNull (el);
+ Assert.IsNotNull (el);
XmlSchemaComplexType ct = el.ElementType as XmlSchemaComplexType;
XmlSchemaSequence seq = ct.ContentTypeParticle as XmlSchemaSequence;
XmlSchemaElement elp = seq.Items [0] as XmlSchemaElement;
- AssertEquals (QName ("Bar", ""), elp.QualifiedName);
+ Assert.AreEqual (QName ("Bar", ""), elp.QualifiedName);
schema = XmlSchema.Read (new XmlTextReader ("Test/XmlFiles/xsd/6.xsd"), null);
schema.Compile (null);
el = schema.Elements [QName ("Foo", "urn:bar")] as XmlSchemaElement;
- AssertNotNull (el);
+ Assert.IsNotNull (el);
ct = el.ElementType as XmlSchemaComplexType;
seq = ct.ContentTypeParticle as XmlSchemaSequence;
elp = seq.Items [0] as XmlSchemaElement;
- AssertEquals (QName ("Bar", "urn:bar"), elp.QualifiedName);
+ Assert.AreEqual (QName ("Bar", "urn:bar"), elp.QualifiedName);
}
[Test]
xw = new XmlTextWriter (sw);
xs.Write (xw);
doc.LoadXml (sw.ToString ());
- AssertEquals ("#1", "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml);
+ Assert.AreEqual ("<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml, "#1");
// TargetNamespace
xs = new XmlSchema ();
xw = new XmlTextWriter (sw);
xs.TargetNamespace = "urn:foo";
xs.Write (xw);
- Console.WriteLine ("#2", "<xs:schema xmlns:tns=\"urn:foo\" targetNamespace=\"urn:foo\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml);
+ doc.LoadXml (sw.ToString ());
+ Assert.AreEqual ("<xs:schema xmlns:tns=\"urn:foo\" targetNamespace=\"urn:foo\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml, "#2");
+
+ // Zero-length TargetNamespace
+ xs = new XmlSchema ();
+ sw = new StringWriter ();
+ xw = new XmlTextWriter (sw);
+ xs.TargetNamespace = string.Empty;
+ xs.Write (xw);
+ doc.LoadXml (sw.ToString ());
+ Assert.AreEqual ("<xs:schema targetNamespace=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml, "#2b");
// XmlSerializerNamespaces
xs = new XmlSchema ();
xs.Write (xw);
doc.LoadXml (sw.ToString ());
// commenting out. .NET 2.0 outputs xs:schema instead of schema, that also makes sense.
- // AssertEquals ("#3", "<schema xmlns:hoge=\"urn:hoge\" xmlns=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml);
+ // Assert.AreEqual ("<schema xmlns:hoge=\"urn:hoge\" xmlns=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml, "#3");
// TargetNamespace + XmlSerializerNamespaces
xs = new XmlSchema ();
xs.Write (xw);
doc.LoadXml (sw.ToString ());
// commenting out. .NET 2.0 outputs xs:schema instead of schema, that also makes sense.
- // AssertEquals ("#4", "<schema xmlns:hoge=\"urn:hoge\" targetNamespace=\"urn:foo\" xmlns=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml);
+ // Assert.AreEqual ("<schema xmlns:hoge=\"urn:hoge\" targetNamespace=\"urn:foo\" xmlns=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml, "#4");
// Add XmlSchema.Namespace to XmlSerializerNamespaces
xs = new XmlSchema ();
xs.Namespaces.Add ("a", XmlSchema.Namespace);
xs.Write (xw);
doc.LoadXml (sw.ToString ());
- AssertEquals ("#5", "<a:schema xmlns:a=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml);
+ Assert.AreEqual ("<a:schema xmlns:a=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml, "#5");
// UnhandledAttributes + XmlSerializerNamespaces
xs = new XmlSchema ();
xs.Write (xw);
doc.LoadXml (sw.ToString ());
// commenting out. .NET 2.0 outputs xs:schema instead of schema, that also makes sense.
- // AssertEquals ("#6", "<schema xmlns:hoge=\"urn:hoge\" hoge=\"\" xmlns=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml);
+ // Assert.AreEqual ("<schema xmlns:hoge=\"urn:hoge\" hoge=\"\" xmlns=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml, "#6");
// Adding xmlns to UnhandledAttributes -> no output
xs = new XmlSchema ();
xs.UnhandledAttributes = new XmlAttribute [] {attr};
xs.Write (xw);
doc.LoadXml (sw.ToString ());
- AssertEquals ("#7", "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml);
+ Assert.AreEqual ("<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", doc.DocumentElement.OuterXml, "#7");
}
[Category ("NotWorking")]
StringWriter sw;
sw = new StringWriter ();
xs.Write (new XmlTextWriter (sw));
- AssertEquals ("#1", xmldecl + "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString ());
+ Assert.AreEqual (xmldecl + "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString (), "#1");
xs.Namespaces = nss;
sw = new StringWriter ();
xs.Write (new XmlTextWriter (sw));
- AssertEquals ("#2", xmldecl + "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString ());
+ Assert.AreEqual (xmldecl + "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString (), "#2");
nss.Add ("foo", "urn:foo");
sw = new StringWriter ();
xs.Write (new XmlTextWriter (sw));
// commenting out. .NET 2.0 outputs xs:schema instead of schema, that also makes sense.
- // AssertEquals ("#3", xmldecl + "<schema xmlns:foo=\"urn:foo\" xmlns=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString ());
+ // Assert.AreEqual (xmldecl + "<schema xmlns:foo=\"urn:foo\" xmlns=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString (), "#3");
nss.Add ("", "urn:foo");
sw = new StringWriter ();
xs.Write (new XmlTextWriter (sw));
// commenting out. .NET 2.0 outputs xs:schema instead of q1:schema, that also makes sense.
- // AssertEquals ("#4", xmldecl + "<q1:schema xmlns:foo=\"urn:foo\" xmlns=\"urn:foo\" xmlns:q1=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString ());
+ // Assert.AreEqual (xmldecl + "<q1:schema xmlns:foo=\"urn:foo\" xmlns=\"urn:foo\" xmlns:q1=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString (), "#4");
nss.Add ("q1", "urn:q1");
sw = new StringWriter ();
xs.Write (new XmlTextWriter (sw));
//Not sure if testing for exact order of these name spaces is
// relevent, so using less strict test that passes on MS.NET
- //AssertEquals (xmldecl + "<q2:schema xmlns:foo=\"urn:foo\" xmlns:q1=\"urn:q1\" xmlns=\"urn:foo\" xmlns:q2=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString ());
- Assert("q1", sw.ToString ().IndexOf ("xmlns:q1=\"urn:q1\"") != -1);
+ //Assert.AreEqual (xmldecl + "<q2:schema xmlns:foo=\"urn:foo\" xmlns:q1=\"urn:q1\" xmlns=\"urn:foo\" xmlns:q2=\"http://www.w3.org/2001/XMLSchema\" />", sw.ToString ());
+ Assert.IsTrue (sw.ToString ().IndexOf ("xmlns:q1=\"urn:q1\"") != -1, "q1");
}
[Test]
XmlTextReader xtr = new XmlTextReader (xsd, XmlNodeType.Document, null);
xtr.Read ();
XmlSchema xs = XmlSchema.Read (xtr, null);
- AssertEquals (XmlNodeType.EndElement, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType);
+ }
+
+ [Test]
+ // bug #76865
+ public void AmbiguityDetectionOnChameleonAnyOther ()
+ {
+ string xsd = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
+<xs:complexType name='TestType'>
+ <xs:sequence>
+ <xs:any namespace='##other' minOccurs='0' />
+ <xs:element name='Item' />
+ <xs:any namespace='##other' minOccurs='0' />
+ </xs:sequence>
+</xs:complexType>
+</xs:schema>";
+ XmlSchema.Read (new XmlTextReader (xsd, XmlNodeType.Document, null), null);
+ }
+
+ [Test]
+ // bug #77685
+ public void ReadDoesNotIgnoreDocumentationEmptyElement ()
+ {
+ string schemaxml = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
+ <xs:element name='choice'>
+ <xs:annotation><xs:documentation /></xs:annotation>
+ </xs:element>
+</xs:schema>";
+ XmlTextReader tr = new XmlTextReader (
+ schemaxml, XmlNodeType.Document, null);
+ XmlSchema schema = XmlSchema.Read (tr, null);
+ XmlSchemaElement element =
+ schema.Items [0] as XmlSchemaElement;
+ XmlSchemaAnnotation annotation = element.Annotation;
+ XmlSchemaDocumentation doc =
+ annotation.Items [0] as XmlSchemaDocumentation;
+ Assert.AreEqual (0, doc.Markup.Length);
+ }
+
+
+ [Test]
+ // bug #77687
+ public void CompileFillsSchemaPropertyInExternal ()
+ {
+ string schemaFileName = "Test/XmlFiles/xsd/77687.xsd";
+ XmlTextReader tr = new XmlTextReader (schemaFileName);
+
+ XmlSchema schema = XmlSchema.Read (tr, null);
+ XmlSchemaInclude inc = (XmlSchemaInclude) schema.Includes [0];
+ Assert.IsNull (inc.Schema);
+ schema.Compile (null);
+ tr.Close ();
+ Assert.IsNotNull (inc.Schema);
+ }
+
+ [Test]
+ // bug #78985 (contains two identical field path "@key" in
+ // two different keys where one is in scope within another)
+ public void DuplicateKeyFieldAttributePath ()
+ {
+ string schemaFileName = "Test/XmlFiles/xsd/78985.xsd";
+ string xmlFileName = "Test/XmlFiles/xsd/78985.xml";
+ XmlTextReader tr = new XmlTextReader (schemaFileName);
+
+ XmlValidatingReader vr = new XmlValidatingReader (
+ new XmlTextReader (xmlFileName));
+ vr.Schemas.Add (XmlSchema.Read (tr, null));
+ while (!vr.EOF)
+ vr.Read ();
+ }
+
+ [Test]
+ public void ThreeLevelNestedInclusion ()
+ {
+ XmlTextReader r = new XmlTextReader ("Test/XmlFiles/xsd/361818.xsd");
+ try {
+ XmlSchema xs = XmlSchema.Read (r, null);
+ xs.Compile (null);
+ } finally {
+ r.Close ();
+ }
+ }
+
+ [Test] // bug #502115
+ public void ExtensionRedefineAttribute1 ()
+ {
+ const string xml = "<Bar xmlns='foo'/>";
+
+ XmlSchema schema = GetSchema ("Test/XmlFiles/xsd/extension-attr-redefine-1.xsd");
+
+#if NET_2_0
+ XmlSchemaSet xss = new XmlSchemaSet ();
+ xss.Add (schema);
+ if (StrictMsCompliant) {
+ xss.Compile ();
+ } else {
+ try {
+ xss.Compile ();
+ Assert.Fail ();
+ } catch (XmlSchemaException) {
+ }
+ return;
+ }
+
+ StringReader sr = new StringReader (xml);
+
+ XmlReaderSettings settings = new XmlReaderSettings ();
+ settings.ValidationType = ValidationType.Schema;
+ settings.Schemas = xss;
+ XmlReader vr = XmlReader.Create (sr, settings);
+#else
+ if (StrictMsCompliant) {
+ schema.Compile (null);
+ } else {
+ try {
+ schema.Compile (null);
+ Assert.Fail ();
+ } catch (XmlSchemaException) {
+ }
+ return;
+ }
+
+ XmlValidatingReader vr = new XmlValidatingReader (xml,
+ XmlNodeType.Document, null);
+ vr.Schemas.Add (schema);
+ vr.ValidationType = ValidationType.Schema;
+#endif
+
+ try {
+ vr.Read ();
+ Assert.Fail ();
+ } catch (XmlSchemaException) {
+ }
+ }
+
+ [Test] // bug #502115
+ public void ExtensionRedefineAttribute2 ()
+ {
+ const string xml = "<Bar xmlns='foo'/>";
+
+ XmlSchema schema = GetSchema ("Test/XmlFiles/xsd/extension-attr-redefine-2.xsd");
+
+#if NET_2_0
+ XmlSchemaSet xss = new XmlSchemaSet ();
+ xss.Add (schema);
+ xss.Compile ();
+
+ StringReader sr = new StringReader (xml);
+
+ XmlReaderSettings settings = new XmlReaderSettings ();
+ settings.ValidationType = ValidationType.Schema;
+ settings.Schemas = xss;
+ XmlReader vr = XmlReader.Create (sr, settings);
+#else
+ schema.Compile (null);
+
+ XmlValidatingReader vr = new XmlValidatingReader (xml,
+ XmlNodeType.Document, null);
+ vr.Schemas.Add (schema);
+ vr.ValidationType = ValidationType.Schema;
+#endif
+
+ while (vr.Read ()) ;
+ }
+
+ [Test] // bug #502115
+ public void ExtensionRedefineAttribute3 ()
+ {
+ const string xml = "<Bar xmlns='foo'/>";
+
+ XmlSchema schema = GetSchema ("Test/XmlFiles/xsd/extension-attr-redefine-3.xsd");
+
+#if NET_2_0
+ XmlSchemaSet xss = new XmlSchemaSet ();
+ xss.Add (schema);
+ if (StrictMsCompliant) {
+ xss.Compile ();
+ } else {
+ try {
+ xss.Compile ();
+ Assert.Fail ();
+ } catch (XmlSchemaException) {
+ }
+ return;
+ }
+
+ StringReader sr = new StringReader ("<Bar xmlns='foo'/>");
+
+ XmlReaderSettings settings = new XmlReaderSettings ();
+ settings.ValidationType = ValidationType.Schema;
+ settings.Schemas = xss;
+ XmlReader vr = XmlReader.Create (sr, settings);
+#else
+ if (StrictMsCompliant) {
+ schema.Compile (null);
+ } else {
+ try {
+ schema.Compile (null);
+ Assert.Fail ();
+ } catch (XmlSchemaException) {
+ }
+ return;
+ }
+
+ XmlValidatingReader vr = new XmlValidatingReader (xml,
+ XmlNodeType.Document, null);
+ vr.Schemas.Add (schema);
+ vr.ValidationType = ValidationType.Schema;
+#endif
+
+ while (vr.Read ()) ;
+ }
+
+#if NET_2_0
+
+ internal class XmlTestResolver : XmlResolver
+ {
+ Uri receivedUri;
+
+ public override ICredentials Credentials
+ {
+ set { throw new NotSupportedException (); }
+ }
+
+ public override Uri ResolveUri (Uri baseUri, string relativeUri)
+ {
+ return new Uri (relativeUri);
+ }
+
+ public Uri ReceivedUri
+ {
+ get { return receivedUri; }
+ }
+
+ public override object GetEntity (Uri absoluteUri, string role, Type ofObjectToReturn)
+ {
+ receivedUri = absoluteUri;
+
+ return null;
+ }
+ }
+
+ [Test]
+ public void TestResolveUri ()
+ {
+ XmlSchemaSet schemaSet = new XmlSchemaSet ();
+ FileStream stream = new FileStream ("Test/XmlFiles/xsd/resolveUriSchema.xsd", FileMode.Open);
+ schemaSet.Add ("http://tempuri.org/resolveUriSchema.xsd", new XmlTextReader (stream));
+
+ XmlTestResolver resolver = new XmlTestResolver ();
+
+ XmlReaderSettings settings = new XmlReaderSettings ();
+ settings.Schemas.XmlResolver = resolver;
+ settings.Schemas.Add (schemaSet);
+ settings.ValidationType = ValidationType.Schema;
+ settings.ValidationFlags = XmlSchemaValidationFlags.ProcessInlineSchema | XmlSchemaValidationFlags.ProcessSchemaLocation;
+ XmlReader reader = XmlReader.Create (stream, settings);
+
+ try
+ {
+ reader.Read ();
+ }
+ catch (XmlException)
+ {
+ // do nothing - we are expecting this exception because the test xmlresolver returns null from its
+ // GetEntity method.
+ }
+
+ Assert.AreEqual ("assembly://MyAssembly.Name/MyProjectNameSpace/objects.xsd", resolver.ReceivedUri.OriginalString);
+ }
+
+ [Test]
+ public void TestImportNoSchemaLocation()
+ {
+ XmlSchemaSet schemaSet = new XmlSchemaSet ();
+ schemaSet.Add (GetSchema ("Test/XmlFiles/xsd/importNamespaceTest.xsd"));
+ schemaSet.Add (GetSchema ("Test/XmlFiles/xsd/importedNamespace.xsd"));
+
+ XmlReaderSettings settings = new XmlReaderSettings ();
+ settings.Schemas.Add (schemaSet);
+ settings.ValidationType = ValidationType.Schema;
+
+ XmlReader reader = XmlReader.Create ("Test/XmlFiles/xsd/xsdimporttest.xml", settings);
+
+ // Parse the file.
+ while (reader.Read()) {}
+ }
+#endif
+
+ [Test]
+ public void TestImportSchemaThatIncludesAnother ()
+ {
+ XmlSchema xs = GetSchema ("Test/XmlFiles/xsd/importNamespaceTest2.xsd");
+ xs.Compile (null);
}
}
}
projects / mono.git / blobdiff