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); } }