| private Compile ( ValidationEventHandler, validationEventHandler ) : void | ||
| validationEventHandler | ValidationEventHandler, | |
| return | void | |
public void TestAdd()
{
XmlSchemaCollection col = new XmlSchemaCollection();
XmlSchema schema = new XmlSchema();
XmlSchemaElement elem = new XmlSchemaElement();
elem.Name = "foo";
schema.Items.Add(elem);
schema.TargetNamespace = "urn:foo";
col.Add(schema);
col.Add(schema); // No problem !?
XmlSchema schema2 = new XmlSchema();
schema2.Items.Add(elem);
schema2.TargetNamespace = "urn:foo";
col.Add(schema2); // No problem !!
schema.Compile(null);
col.Add(schema);
col.Add(schema); // Still no problem !!!
schema2.Compile(null);
col.Add(schema2);
schema = GetSchema("Test/XmlFiles/xsd/3.xsd");
schema.Compile(null);
col.Add(schema);
schema2 = GetSchema("Test/XmlFiles/xsd/3.xsd");
schema2.Compile(null);
col.Add(schema2);
}
[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) {
}
}
/* Takes a type name, and a valid example of that type,
* Creates a schema consisting of a single element of that
* type, and validates a bit of xml containing the valid
* value, with whitespace against that schema.
*
* FIXME: Really we want to test the value of whitespace more
* directly that by creating a schema then parsing a string.
*
*/
public void WhiteSpaceTest(string type, string valid)
{
passed = true;
XmlSchema schema = new XmlSchema();
schema.TargetNamespace = "http://example.com/testCase";
XmlSchemaElement element = new XmlSchemaElement();
element.Name = "a";
element.SchemaTypeName = new XmlQualifiedName(type, "http://www.w3.org/2001/XMLSchema");
schema.Items.Add(element);
schema.Compile(new ValidationEventHandler(ValidationCallbackOne));
XmlValidatingReader vr = new XmlValidatingReader(new XmlTextReader(new StringReader("<a xmlns='http://example.com/testCase'>\n\n" + valid + "\n\n</a>")));
vr.Schemas.Add(schema);
vr.ValidationType = ValidationType.Schema;
// vr.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
while (vr.Read())
{
}
;
vr.Close();
Assert.IsTrue(passed, type + " doesn't collapse whitespace: " + (errorInfo != null ? errorInfo.Message : null));
}
void GenerateXmlSchema(String[] formats, String fileFormatType)
{
StreamWriter writer = File.CreateText(xmlSchemaFile + "_" + fileFormatType + ".xml");
XmlSchema schema;
XmlSchemaElement element;
XmlSchemaComplexType complexType;
XmlSchemaSequence sequence;
schema = new XmlSchema();
element = new XmlSchemaElement();
schema.Items.Add(element);
element.Name = "Table";
complexType = new XmlSchemaComplexType();
element.SchemaType = complexType;
sequence = new XmlSchemaSequence();
complexType.Particle = sequence;
element = new XmlSchemaElement();
element.Name = "Number";
element.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
sequence.Items.Add(element);
for (int i = 0; i < formats.Length; i++)
{
element = new XmlSchemaElement();
element.Name = formats[i];
element.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
sequence.Items.Add(element);
}
schema.Compile(new ValidationEventHandler(ValidationCallbackOne));
schema.Write(writer);
writer.Close();
}
private void LoadSchemes()
{
string schemaDir = Path.GetFullPath(".\\schemas\\");
if (Directory.Exists(schemaDir))
{
string[] schemas = Directory.GetFiles(schemaDir, "*.xsd", SearchOption.TopDirectoryOnly);
foreach (var schemaPath in schemas)
{
//Load
try
{
using (TextReader reader = File.OpenText(schemaPath))
{
XmlSchema schema = XmlSchema.Read(reader, XmppSchemeValidationEventHandler);
if (!schemaSet.ContainsKey(schema.TargetNamespace))
{
#pragma warning disable 618,612
schema.Compile(XmppSchemeValidationEventHandler);
#pragma warning restore 618,612
schemaSet.Add(schema.TargetNamespace, schema);
}
}
}
catch (Exception)
{
log.ErrorFormat("error loading scheme {0}", schemaPath);
}
}
}
}
[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())
{
;
}
}
/// <summary>
/// Generates strongly typed serialization classes for the given schema document
/// under the given namespace and generates a code compile unit.
/// </summary>
/// <param name="xmlSchema">Schema document to generate classes for.</param>
/// <param name="generateNamespace">Namespace to be used for the generated code.</param>
/// <returns>A fully populated CodeCompileUnit, which can be serialized in the language of choice.</returns>
public static CodeCompileUnit Generate(XmlSchema xmlSchema, string generateNamespace)
{
if (xmlSchema == null)
{
throw new ArgumentNullException("xmlSchema");
}
if (generateNamespace == null)
{
throw new ArgumentNullException("generateNamespace");
}
simpleTypeNamesToClrTypeNames = new Hashtable();
typeNamesToEnumDeclarations = new Hashtable();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace(generateNamespace);
codeCompileUnit.Namespaces.Add(codeNamespace);
codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Xml"));
simpleTypeNamesToClrTypeNames.Add("dateTime", "DateTime");
simpleTypeNamesToClrTypeNames.Add("uint", "uint");
simpleTypeNamesToClrTypeNames.Add("int", "int");
simpleTypeNamesToClrTypeNames.Add("integer", "int");
simpleTypeNamesToClrTypeNames.Add("NMTOKEN", "string");
simpleTypeNamesToClrTypeNames.Add("nonNegativeInteger", "uint");
simpleTypeNamesToClrTypeNames.Add("string", "string");
xmlSchema.Compile(null);
foreach (XmlSchemaObject schemaObject in xmlSchema.SchemaTypes.Values)
{
XmlSchemaComplexType schemaComplexType = schemaObject as XmlSchemaComplexType;
if (schemaComplexType != null)
{
ProcessComplexType(schemaComplexType, codeNamespace);
}
XmlSchemaSimpleType schemaSimpleType = schemaObject as XmlSchemaSimpleType;
if (schemaSimpleType != null)
{
ProcessSimpleType(schemaSimpleType, codeNamespace);
}
}
foreach (XmlSchemaObject schemaObject in xmlSchema.Elements.Values)
{
XmlSchemaElement schemaElement = schemaObject as XmlSchemaElement;
if (schemaElement != null)
{
ProcessElement(schemaElement, codeNamespace);
}
}
return(codeCompileUnit);
}
public void VerifyThatReferencedSchemaCanBeLoaded()
{
var a = Assembly.GetExecutingAssembly();
var stream = a.GetManifestResourceStream("ReqIFSharp.Tests.driver.xsd");
XmlSchema schema = XmlSchema.Read(stream, this.ValidationEventHandler);
schema.Compile(this.ValidationEventHandler, new ReqIfSchemaResolver());
}
public void DumpSchema (XmlSchema schema)
{
schema.Compile (null);
SortedList sl = new SortedList ();
IndentLine ("**XmlSchema**");
IndentLine ("TargetNamespace: " + schema.TargetNamespace);
IndentLine ("AttributeGroups:");
foreach (DictionaryEntry entry in schema.AttributeGroups)
sl.Add (entry.Key.ToString (), entry.Value);
foreach (DictionaryEntry entry in sl)
DumpAttributeGroup ((XmlSchemaAttributeGroup) entry.Value);
sl.Clear ();
IndentLine ("Attributes:");
foreach (DictionaryEntry entry in schema.Attributes)
sl.Add (entry.Key.ToString (), entry.Value);
foreach (DictionaryEntry entry in sl)
DumpAttribute ((XmlSchemaAttribute) entry.Value);
sl.Clear ();
IndentLine ("Elements:");
foreach (DictionaryEntry entry in schema.Elements)
sl.Add (entry.Key.ToString (), entry.Value);
foreach (DictionaryEntry entry in sl)
DumpElement ((XmlSchemaElement) entry.Value);
sl.Clear ();
IndentLine ("Groups");
foreach (DictionaryEntry entry in schema.Groups)
sl.Add (entry.Key.ToString (), entry.Value);
foreach (DictionaryEntry entry in sl)
DumpGroup ((XmlSchemaGroup) entry.Value);
sl.Clear ();
IndentLine ("IsCompiled: " + schema.IsCompiled);
IndentLine ("Notations");
foreach (DictionaryEntry entry in schema.Notations)
sl.Add (entry.Key.ToString (), entry.Value);
foreach (DictionaryEntry entry in sl)
DumpNotation ((XmlSchemaNotation) entry.Value);
sl.Clear ();
IndentLine ("SchemaTypes:");
foreach (DictionaryEntry entry in schema.Notations)
sl.Add (entry.Key.ToString (), entry.Value);
foreach (DictionaryEntry entry in sl)
if (entry.Value is XmlSchemaSimpleType)
DumpSimpleType ((XmlSchemaSimpleType) entry.Value);
else
DumpComplexType ((XmlSchemaComplexType) entry.Value);
sl.Clear ();
}
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);
}
private void LoadSchemas(out XmlSchema xsd, out XmlSchemas schemas)
{
using (FileStream fs = File.OpenRead(base.InputFilePath))
{
xsd = XmlSchema.Read(fs, null);
xsd.Compile(null);
}
schemas = new XmlSchemas();
schemas.Add(xsd);
}
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();
}
}
/// <summary>
/// Writes a schema for each type in the assembly
/// </summary>
public void WriteSchema(string assembly, string lookup_type, string output_dir)
{
Assembly a;
try {
a = Assembly.LoadFrom(assembly);
} catch (Exception e) {
Console.WriteLine("Cannot use {0}, {1}", assembly, e.Message);
return;
}
generatedSchemaTypes = new Hashtable();
XmlSchemaType schemaType;
foreach (Type t in a.GetTypes())
{
if (lookup_type != null && t.Name != lookup_type)
{
continue;
}
try {
schemaType = WriteSchemaType(t);
} catch (ArgumentException e) {
throw new ArgumentException(String.Format("Error: We cannot process {0}\n{1}", assembly, e.Message));
}
if (schemaType == null)
{
continue; // skip
}
XmlSchemaElement schemaElement = WriteSchemaElement(t, schemaType);
schema.Items.Add(schemaElement);
schema.Items.Add(schemaType);
}
schema.ElementFormDefault = XmlSchemaForm.Qualified;
schema.Compile(new ValidationEventHandler(OnSchemaValidation));
string output = String.Format("schema{0}.xsd", fileCount);
if (output_dir != null)
{
output = Path.Combine(output_dir, output);
}
XmlTextWriter writer = new XmlTextWriter(output, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
schema.Write(writer);
Console.WriteLine("\nWriting {0}.", output);
}
// 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);
}
private static XmlSchema LoadSchema()
{
var schema = new XmlSchema();
using (var stream = typeof(XmlCompletionDataProvider).Assembly.GetManifestResourceStream("Aras.Tools.InnovatorAdmin.Editor.xslt.xsd"))
{
using (var reader = XmlReader.Create(stream))
{
schema = XmlSchema.Read(reader, new ValidationEventHandler(SchemaValidation));
schema.Compile(new ValidationEventHandler(SchemaValidation));
}
}
return(schema);
}
// Note that it could also apply to BaseTypeName (since if
// it is xs:anyType and BaseType is empty, BaseTypeName
// should be xs:anyType).
public void TestAnyType()
{
XmlSchema schema = GetSchema("Test/XmlFiles/xsd/datatypesTest.xsd");
schema.Compile(null);
XmlSchemaElement any = schema.Elements [QName("e00", "urn:bar")] as XmlSchemaElement;
XmlSchemaComplexType cType = any.ElementType as XmlSchemaComplexType;
Assert.AreEqual(typeof(XmlSchemaComplexType), cType.GetType(), "#1");
Assert.IsNotNull(cType, "#2");
Assert.AreEqual(XmlQualifiedName.Empty, cType.QualifiedName, "#3");
Assert.IsNull(cType.BaseSchemaType, "#4"); // In MS.NET 2.0 its null. In 1.1 it is not null.
Assert.IsNotNull(cType.ContentTypeParticle, "#5");
}
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;
Assert.IsNotNull(el);
XmlSchemaComplexType ct = el.ElementType as XmlSchemaComplexType;
XmlSchemaSequence seq = ct.ContentTypeParticle as XmlSchemaSequence;
XmlSchemaElement elp = seq.Items [0] as XmlSchemaElement;
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;
Assert.IsNotNull(el);
ct = el.ElementType as XmlSchemaComplexType;
seq = ct.ContentTypeParticle as XmlSchemaSequence;
elp = seq.Items [0] as XmlSchemaElement;
Assert.AreEqual(QName("Bar", "urn:bar"), elp.QualifiedName);
}
public void TestReadFlags()
{
XmlSchema schema = GetSchema("Test/XmlFiles/xsd/2.xsd");
schema.Compile(null);
XmlSchemaElement el = schema.Items [0] as XmlSchemaElement;
Assert.IsNotNull(el);
Assert.AreEqual(XmlSchemaDerivationMethod.Extension, el.Block);
el = schema.Items [1] as XmlSchemaElement;
Assert.IsNotNull(el);
Assert.AreEqual(XmlSchemaDerivationMethod.Extension |
XmlSchemaDerivationMethod.Restriction, el.Block);
}
/// <summary>
/// Gets the apispec schema information.
/// </summary>
/// <returns>The XmlSchema instance containing the apispec schema information.</returns>
public static XmlSchema GetApispecSchema()
{
if (apiSpecXsd == null)
{
//Load schema from resource file
string[] ress = Assembly.GetExecutingAssembly().GetManifestResourceNames();
if (ress == null || ress.Length != 1)
{
throw new ApplicationException("Assembly must be built with the apispec.xsd as embedded resource.");
}
Stream schemaStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(ress[0]);
apiSpecXsd = XmlSchema.Read(schemaStream, null);
apiSpecXsd.Compile(null);
}
return(apiSpecXsd);
}
public void TestSimpleImport()
{
XmlSchema schema = XmlSchema.Read(new XmlTextReader("Test/XmlFiles/xsd/3.xsd"), null);
Assert.AreEqual("urn:foo", schema.TargetNamespace);
XmlSchemaImport import = schema.Includes [0] as XmlSchemaImport;
Assert.IsNotNull(import);
schema.Compile(null);
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")]);
}
public static void Main(string[] args)
{
if (args.Length < 2)
{
PrintUsage();
}
Stream s = null;
switch (args[0])
{
case "ecma":
s = Assembly.GetExecutingAssembly().GetManifestResourceStream("monodoc-ecma.xsd");
break;
default:
Console.WriteLine("Unknown provider: {0}", args[0]);
Environment.Exit(0);
break;
}
if (s == null)
{
Console.WriteLine("ERROR: schema for {0} was not found", args[0]);
Environment.Exit(1);
}
schema = XmlSchema.Read(s, null);
schema.Compile(null);
// skip args[0] because it is the provider name
for (int i = 1; i < args.Length; i++)
{
string arg = args[i];
if (IsMonodocFile(arg))
{
ValidateFile(arg);
}
if (Directory.Exists(arg))
{
RecurseDirectory(arg);
}
}
Console.WriteLine("Total validation errors: {0}", errors);
}
public void TestAll()
{
XmlSchema schema = GetSchema("Test/XmlFiles/xsd/datatypesTest.xsd");
schema.Compile(null);
AssertDatatype(schema, 1, XmlTokenizedType.CDATA, typeof(string), " f o o ", " f o o ");
AssertDatatype(schema, 2, XmlTokenizedType.CDATA, typeof(string), " f o o ", " f o o ");
// token shouldn't allow " f o o "
AssertDatatype(schema, 3, XmlTokenizedType.CDATA, typeof(string), "f o o", "f o o");
// language seems to be checked strictly
AssertDatatype(schema, 4, XmlTokenizedType.CDATA, typeof(string), "x-foo", "x-foo");
// NMTOKEN shouldn't allow " f o o "
// AssertDatatype (schema, 5, XmlTokenizedType.NMTOKEN, typeof (string), "foo", "foo");
// AssertDatatype (schema, 6, XmlTokenizedType.NMTOKEN, typeof (string []), "f o o", new string [] {"f", "o", "o"});
}
object Find(XmlSchema schema, XmlQualifiedName name, Type type)
{
if (!schema.IsCompiled)
{
schema.Compile(null);
}
XmlSchemaObjectTable tbl = null;
if (type == typeof(XmlSchemaSimpleType) || type == typeof(XmlSchemaComplexType))
{
tbl = schema.SchemaTypes;
}
else if (type == typeof(XmlSchemaAttribute))
{
tbl = schema.Attributes;
}
else if (type == typeof(XmlSchemaAttributeGroup))
{
tbl = schema.AttributeGroups;
}
else if (type == typeof(XmlSchemaElement))
{
tbl = schema.Elements;
}
else if (type == typeof(XmlSchemaGroup))
{
tbl = schema.Groups;
}
else if (type == typeof(XmlSchemaNotation))
{
tbl = schema.Notations;
}
object res = (tbl != null) ? tbl [name] : null;
if (res != null && res.GetType() != type)
{
return(null);
}
else
{
return(res);
}
}
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();
}
}
public void v7(object param0)
{
Initialize();
try
{
XmlSchema schema = XmlSchema.Read(CreateReader(Path.Combine(TestData._Root, param0.ToString())), ValidationCallback);
#pragma warning disable 0618
schema.Compile(ValidationCallback);
#pragma warning restore 0618
}
catch (XmlException e)
{
CError.Compare(e.Message.Contains("DTD"), true, "Some other error thrown");
return;
}
Assert.True(false);
}
public void v8(object param0)
{
Initialize();
try
{
XmlSchema schema = XmlSchema.Read(CreateReader(Path.Combine(TestData._Root, param0.ToString())), ValidationCallback);
#pragma warning disable 0618
schema.Compile(ValidationCallback);
#pragma warning restore 0618
}
catch (XmlException)
{
Assert.True(false); //exepect a validation warning for unresolvable schema location
}
CError.Compare(warningCount, 0, "Warning Count mismatch");
return;
}
private void CreateSimpletypeLength(string length, string minLength, string maxLength, bool expected)
{
passed = true;
XmlSchema schema = new XmlSchema();
XmlSchemaSimpleType testType = new XmlSchemaSimpleType();
testType.Name = "TestType";
XmlSchemaSimpleTypeRestriction testTypeRestriction = new XmlSchemaSimpleTypeRestriction();
testTypeRestriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
if (length != "-")
{
XmlSchemaLengthFacet _length = new XmlSchemaLengthFacet();
_length.Value = length;
testTypeRestriction.Facets.Add(_length);
}
if (minLength != "-")
{
XmlSchemaMinLengthFacet _minLength = new XmlSchemaMinLengthFacet();
_minLength.Value = minLength;
testTypeRestriction.Facets.Add(_minLength);
}
if (maxLength != "-")
{
XmlSchemaMaxLengthFacet _maxLength = new XmlSchemaMaxLengthFacet();
_maxLength.Value = maxLength;
testTypeRestriction.Facets.Add(_maxLength);
}
testType.Content = testTypeRestriction;
schema.Items.Add(testType);
schema.Compile(new ValidationEventHandler(ValidationCallbackOne));
Assert(
(passed ? "Test passed, should have failed" : "Test failed, should have passed") +
": " + length + " " + minLength + " " + maxLength,
expected == passed);
}
public void v11(object param0)
{
Initialize();
try
{
XmlSchema schema = XmlSchema.Read(CreateReader(TestData._Root + param0.ToString(), false), ValidationCallback);
#pragma warning disable 0618
schema.Compile(ValidationCallback);
#pragma warning restore 0618
}
catch (XmlException)
{
Assert.True(false);
}
CError.Compare(warningCount, 0, "Warning Count mismatch");
CError.Compare(errorCount, 0, "Warning Count mismatch");
return;
}
private static bool NormalizeXmlSchema(String url, TextWriter writer)
{
try
{
XmlTextReader txtRead = new XmlTextReader(url);
XmlSchema sch = XmlSchema.Read(txtRead, null);
// Compiling Schema
sch.Compile(null);
var outSch = XmlSchemaIncludeNormalizer.BuildIncludeFreeXmlSchema(sch);
outSch.Write(writer);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return(false);
}
return(true);
}
public void v6(object param0)
{
Initialize();
XmlSchemaSet xss = new XmlSchemaSet();
xss.XmlResolver = new XmlUrlResolver();
xss.ValidationEventHandler += ValidationCallback;
var reader = new XmlTextReader(Path.Combine(TestData._Root, param0.ToString()));
reader.XmlResolver = new XmlUrlResolver();
XmlSchema schema = XmlSchema.Read(reader, ValidationCallback);
#pragma warning disable 0618
schema.Compile(ValidationCallback);
#pragma warning restore 0618
xss.Add(schema);
// expect a validation warning for unresolvable schema location
CError.Compare(warningCount, 0, "Warning Count mismatch");
CError.Compare(errorCount, 0, "Error Count mismatch");
}
void GenerateXmlSchema(String[] formats, String fileFormatType)
{
StreamWriter writer = File.CreateText(xmlSchemaFile + "_" + fileFormatType + ".xml");
XmlSchema schema;
XmlSchemaElement element;
XmlSchemaComplexType complexType;
XmlSchemaSequence sequence;
schema = new XmlSchema();
element = new XmlSchemaElement();
schema.Items.Add(element);
element.Name = "Table";
complexType = new XmlSchemaComplexType();
element.SchemaType = complexType;
sequence = new XmlSchemaSequence();
complexType.Particle = sequence;
element = new XmlSchemaElement();
element.Name = "Number";
element.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
sequence.Items.Add(element);
for(int i=0; i<formats.Length; i++){
element = new XmlSchemaElement();
element.Name = formats[i];
element.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
sequence.Items.Add(element);
}
schema.Compile(new ValidationEventHandler(ValidationCallbackOne));
schema.Write(writer);
writer.Close();
}
private void WriteXMLForCultures(CultureInfo[] cultures)
{
StreamWriter writer = File.CreateText("CultureSchema.xml");
XmlSchema schema;
XmlSchemaElement element;
XmlSchemaComplexType complexType;
XmlSchemaSequence sequence;
schema = new XmlSchema();
element = new XmlSchemaElement();
schema.Items.Add(element);
element.Name = "Table";
complexType = new XmlSchemaComplexType();
element.SchemaType = complexType;
sequence = new XmlSchemaSequence();
complexType.Particle = sequence;
element = new XmlSchemaElement();
element.Name = "CultureName";
element.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
sequence.Items.Add(element);
schema.Compile(new ValidationEventHandler(ValidationCallbackOne));
schema.Write(writer);
writer.Close();
writer = File.CreateText("CultureData.xml");
XmlTextWriter myXmlTextWriter = new XmlTextWriter(writer);
myXmlTextWriter.Formatting = Formatting.Indented;
myXmlTextWriter.WriteStartElement("NewDataSet");
for(int j=0; j<cultures.Length; j++)
{
myXmlTextWriter.WriteStartElement("Table");
myXmlTextWriter.WriteElementString("CultureName", cultures[j].LCID.ToString());
myXmlTextWriter.WriteEndElement();
}
myXmlTextWriter.WriteEndElement();
myXmlTextWriter.Flush();
myXmlTextWriter.Close();
}
