public static XmlSchemas MoveSchemaSetToXmlSchemas(XmlSchemaSet set)
{
XmlSchemas schemas = new XmlSchemas();
XmlSchema[] schemaArray = new XmlSchema[set.Count];
set.CopyTo(schemaArray, 0); foreach (XmlSchema xsd in schemaArray)
{
schemas.Add(xsd);
}
return(schemas);
}
//[Variation(Desc = "v7 - Copy all to array of the same size", Priority = 0)]
public void v7()
{
XmlSchemaSet sc = new XmlSchemaSet();
XmlSchema Schema1 = sc.Add("xsdauthor", TestData._XsdAuthor);
XmlSchema Schema2 = sc.Add(null, TestData._XsdNoNs);
XmlSchema[] array = new XmlSchema[2];
sc.CopyTo(array, 0);
Assert.Equal(array[0], Schema1);
Assert.Equal(array[1], Schema2);
return;
}
//[Variation(Desc = "v1 - CopyTo with array = null")]
public void v1()
{
try
{
XmlSchemaSet sc = new XmlSchemaSet();
sc.Add("xsdauthor", TestData._XsdAuthor);
sc.CopyTo(null, 0);
}
catch (ArgumentNullException)
{
// GLOBALIZATION
return;
}
Assert.True(false);
}
//[Variation(Desc = "v8 - 378346: CopyTo throws correct exception for index < 0 but incorrect exception for index > maxLength of array.", Priority = 0)]
public void v8()
{
try
{
XmlSchemaSet ss = new XmlSchemaSet();
ss.CopyTo(new XmlSchema[2], 3);
}
catch (ArgumentOutOfRangeException e)
{
_output.WriteLine(e.Message);
return;
}
Assert.True(false);
}
private static void ReprocessAll(XmlSchemaSet schemas)// and remove duplicate items
{
Hashtable elements = new Hashtable();
Hashtable types = new Hashtable();
XmlSchema[] schemaArray = new XmlSchema[schemas.Count];
schemas.CopyTo(schemaArray, 0);
for (int i = 0; i < schemaArray.Length; i++)
{
XmlSchema schema = schemaArray[i];
XmlSchemaObject[] itemArray = new XmlSchemaObject[schema.Items.Count];
schema.Items.CopyTo(itemArray, 0);
for (int j = 0; j < itemArray.Length; j++)
{
XmlSchemaObject item = itemArray[j];
Hashtable items;
XmlQualifiedName qname;
if (item is XmlSchemaElement)
{
items = elements;
qname = new XmlQualifiedName(((XmlSchemaElement)item).Name, schema.TargetNamespace);
}
else if (item is XmlSchemaType)
{
items = types;
qname = new XmlQualifiedName(((XmlSchemaType)item).Name, schema.TargetNamespace);
}
else
{
continue;
}
object otherItem = items[qname];
if (otherItem != null)
{
schema.Items.Remove(item);
}
else
{
items.Add(qname, item);
}
}
schemas.Reprocess(schema);
}
}
//[Variation(Desc = "v4 - CopyTo with index < 0")]
public void v4()
{
XmlSchemaSet sc = new XmlSchemaSet();
try
{
sc.Add("xsdauthor", TestData._XsdAuthor);
sc.Add(null, TestData._XsdNoNs);
XmlSchema[] array = new XmlSchema[1];
sc.CopyTo(array, -1);
}
catch (ArgumentException)
{
// GLOBALIZATION
return;
}
Assert.True(false);
}
public void v5()
{
XmlSchemaSet sc = new XmlSchemaSet();
XmlSchema Schema1 = sc.Add("xsdauthor", TestData._XsdNoNs);
XmlSchema Schema2 = sc.Add(null, TestData._XsdAuthor);
ICollection Col = sc.Schemas("xsdauthor");
CError.Compare(Col.Count, 2, "Count");
XmlSchema[] Schemas = new XmlSchema[2];
sc.CopyTo(Schemas, 0);
int i = 0;
foreach (XmlSchema Schema in Col)
{
CError.Compare(Schema, Schemas[i], "Count");
i++;
}
return;
}
internal XmlSerializableMapping(XmlRootAttribute root, string elementName, string ns, TypeData typeData, string xmlType, string xmlTypeNamespace)
: base(elementName, ns, typeData, xmlType, xmlTypeNamespace)
{
#if NET_2_0
XmlSchemaProviderAttribute schemaProvider = (XmlSchemaProviderAttribute)Attribute.GetCustomAttribute(typeData.Type, typeof(XmlSchemaProviderAttribute));
if (schemaProvider != null)
{
string method = schemaProvider.MethodName;
MethodInfo mi = typeData.Type.GetMethod(method, BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
if (mi == null)
{
throw new InvalidOperationException(String.Format("Type '{0}' must implement public static method '{1}'", typeData.Type, method));
}
if (!typeof(XmlQualifiedName).IsAssignableFrom(mi.ReturnType) &&
// LAMESPEC: it is undocumented. (We don't have to tell users about it in the error message.)
// Also do not add such a silly compatibility test to assert that it does not raise an error.
!typeof(XmlSchemaComplexType).IsAssignableFrom(mi.ReturnType))
{
throw new InvalidOperationException(String.Format("Method '{0}' indicated by XmlSchemaProviderAttribute must have its return type as XmlQualifiedName", method));
}
XmlSchemaSet xs = new XmlSchemaSet();
object retVal = mi.Invoke(null, new object [] { xs });
_schemaTypeName = XmlQualifiedName.Empty;
if (retVal == null)
{
return;
}
if (retVal is XmlSchemaComplexType)
{
_schemaType = (XmlSchemaComplexType)retVal;
if (!_schemaType.QualifiedName.IsEmpty)
{
_schemaTypeName = _schemaType.QualifiedName;
}
else
{
_schemaTypeName = new XmlQualifiedName(xmlType, xmlTypeNamespace);
}
}
else if (retVal is XmlQualifiedName)
{
_schemaTypeName = (XmlQualifiedName)retVal;
}
else
{
throw new InvalidOperationException(
String.Format("Method {0}.{1}() specified by XmlSchemaProviderAttribute has invalid signature: return type must be compatible with System.Xml.XmlQualifiedName.", typeData.Type.Name, method));
}
// defaultNamespace at XmlReflectionImporter takes precedence for Namespace, but not for XsdTypeNamespace.
UpdateRoot(new XmlQualifiedName(root != null ? root.ElementName : _schemaTypeName.Name, root != null ? root.Namespace : Namespace ?? _schemaTypeName.Namespace));
XmlTypeNamespace = _schemaTypeName.Namespace;
XmlType = _schemaTypeName.Name;
if (!_schemaTypeName.IsEmpty && xs.Count > 0)
{
XmlSchema [] schemas = new XmlSchema [xs.Count];
xs.CopyTo(schemas, 0);
_schema = schemas [0];
}
return;
}
#endif
IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(typeData.Type, true);
#if NET_2_0
try
{
_schema = serializable.GetSchema();
}
catch (Exception)
{
// LAMESPEC: .NET has a bad exception catch and swallows it silently.
}
#else
_schema = serializable.GetSchema();
#endif
if (_schema != null)
{
if (_schema.Id == null || _schema.Id.Length == 0)
{
throw new InvalidOperationException("Schema Id is missing. The schema returned from " + typeData.Type.FullName + ".GetSchema() must have an Id.");
}
}
}
internal XmlSerializableMapping(string elementName, string ns, TypeData typeData, string xmlType, string xmlTypeNamespace) : base(elementName, ns, typeData, xmlType, xmlTypeNamespace)
{
XmlSchemaProviderAttribute xmlSchemaProviderAttribute = (XmlSchemaProviderAttribute)Attribute.GetCustomAttribute(typeData.Type, typeof(XmlSchemaProviderAttribute));
if (xmlSchemaProviderAttribute != null)
{
string methodName = xmlSchemaProviderAttribute.MethodName;
MethodInfo method = typeData.Type.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
if (method == null)
{
throw new InvalidOperationException(string.Format("Type '{0}' must implement public static method '{1}'", typeData.Type, methodName));
}
if (!typeof(XmlQualifiedName).IsAssignableFrom(method.ReturnType) && !typeof(XmlSchemaComplexType).IsAssignableFrom(method.ReturnType))
{
throw new InvalidOperationException(string.Format("Method '{0}' indicated by XmlSchemaProviderAttribute must have its return type as XmlQualifiedName", methodName));
}
XmlSchemaSet xmlSchemaSet = new XmlSchemaSet();
object obj = method.Invoke(null, new object[]
{
xmlSchemaSet
});
this._schemaTypeName = XmlQualifiedName.Empty;
if (obj == null)
{
return;
}
if (obj is XmlSchemaComplexType)
{
this._schemaType = (XmlSchemaComplexType)obj;
if (!this._schemaType.QualifiedName.IsEmpty)
{
this._schemaTypeName = this._schemaType.QualifiedName;
}
else
{
this._schemaTypeName = new XmlQualifiedName(xmlType, xmlTypeNamespace);
}
}
else
{
if (!(obj is XmlQualifiedName))
{
throw new InvalidOperationException(string.Format("Method {0}.{1}() specified by XmlSchemaProviderAttribute has invalid signature: return type must be compatible with System.Xml.XmlQualifiedName.", typeData.Type.Name, methodName));
}
this._schemaTypeName = (XmlQualifiedName)obj;
}
base.UpdateRoot(new XmlQualifiedName(this._schemaTypeName.Name, base.Namespace ?? this._schemaTypeName.Namespace));
base.XmlTypeNamespace = this._schemaTypeName.Namespace;
base.XmlType = this._schemaTypeName.Name;
if (!this._schemaTypeName.IsEmpty && xmlSchemaSet.Count > 0)
{
XmlSchema[] array = new XmlSchema[xmlSchemaSet.Count];
xmlSchemaSet.CopyTo(array, 0);
this._schema = array[0];
}
return;
}
else
{
IXmlSerializable xmlSerializable = (IXmlSerializable)Activator.CreateInstance(typeData.Type, true);
try
{
this._schema = xmlSerializable.GetSchema();
}
catch (Exception)
{
}
if (this._schema != null && (this._schema.Id == null || this._schema.Id.Length == 0))
{
throw new InvalidOperationException("Schema Id is missing. The schema returned from " + typeData.Type.FullName + ".GetSchema() must have an Id.");
}
return;
}
}
public void CopyTo(XmlSchema[] array, int index)
{
lock (schemaSet) {
schemaSet.CopyTo(array, index);
}
}