private bool CheckExceptions(IXmlSerializable instance)
{
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.GetSchema();
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_GetSchema, Type.Name));
}
catch (NotSupportedException)
{
}
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.ReadXml(null);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_ReadXmlNull, Type.Name));
}
catch (ArgumentNullException)
{
}
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.WriteXml(null);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_WriteXmlNull, Type.Name));
}
catch (ArgumentNullException)
{
}
return true;
}
public void GetSchema_None_IsNull()
{
IXmlSerializable obj = TestStruct;
Assert.IsNull(obj.GetSchema());
}
internal XmlSerializableMapping(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(_schemaTypeName.Name, 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);
_schema = serializable.GetSchema();
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.");
}
}
}
private void RetrieveSerializableSchema()
{
if (_needSchema)
{
_needSchema = false;
if (_getSchemaMethod != null)
{
// get the type info
if (_schemas == null)
{
_schemas = new XmlSchemaSet();
}
object typeInfo = _getSchemaMethod.Invoke(null, new object[] { _schemas });
_xsiType = XmlQualifiedName.Empty;
if (typeInfo != null)
{
if (typeof(XmlSchemaType).IsAssignableFrom(_getSchemaMethod.ReturnType))
{
_xsdType = (XmlSchemaType)typeInfo;
// check if type is named
_xsiType = _xsdType.QualifiedName;
}
else if (typeof(XmlQualifiedName).IsAssignableFrom(_getSchemaMethod.ReturnType))
{
_xsiType = (XmlQualifiedName)typeInfo;
if (_xsiType.IsEmpty)
{
throw new InvalidOperationException(SR.Format(SR.XmlGetSchemaEmptyTypeName, _type.FullName, _getSchemaMethod.Name));
}
}
else
{
throw new InvalidOperationException(SR.Format(SR.XmlGetSchemaMethodReturnType, _type.Name, _getSchemaMethod.Name, typeof(XmlSchemaProviderAttribute).Name, typeof(XmlQualifiedName).FullName));
}
}
else
{
_any = true;
}
// make sure that user-specified schemas are valid
_schemas.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackWithErrorCode);
_schemas.Compile();
// at this point we verified that the information returned by the IXmlSerializable is valid
// Now check to see if the type was referenced before:
// UNDONE check for the duplcate types
if (!_xsiType.IsEmpty)
{
// try to find the type in the schemas collection
if (_xsiType.Namespace != XmlSchema.Namespace)
{
ArrayList srcSchemas = (ArrayList)_schemas.Schemas(_xsiType.Namespace);
if (srcSchemas.Count == 0)
{
throw new InvalidOperationException(SR.Format(SR.XmlMissingSchema, _xsiType.Namespace));
}
if (srcSchemas.Count > 1)
{
throw new InvalidOperationException(SR.Format(SR.XmlGetSchemaInclude, _xsiType.Namespace, _getSchemaMethod.DeclaringType.FullName, _getSchemaMethod.Name));
}
XmlSchema s = (XmlSchema)srcSchemas[0];
if (s == null)
{
throw new InvalidOperationException(SR.Format(SR.XmlMissingSchema, _xsiType.Namespace));
}
_xsdType = (XmlSchemaType)s.SchemaTypes[_xsiType];
if (_xsdType == null)
{
throw new InvalidOperationException(SR.Format(SR.XmlGetSchemaTypeMissing, _getSchemaMethod.DeclaringType.FullName, _getSchemaMethod.Name, _xsiType.Name, _xsiType.Namespace));
}
_xsdType = _xsdType.Redefined != null ? _xsdType.Redefined : _xsdType;
}
}
}
else
{
IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(_type);
_schema = serializable.GetSchema();
if (_schema != null)
{
if (_schema.Id == null || _schema.Id.Length == 0)
{
throw new InvalidOperationException(SR.Format(SR.XmlSerializableNameMissing1, _type.FullName));
}
}
}
}
}
public void GetSchema_ReturnsNull(ITestItem <Day> testItem)
{
IXmlSerializable day = testItem.Create();
Assert.IsNull(day.GetSchema());
}
public void GetSchema_ReturnsNull(ITestItem <HalfHour> testItem)
{
IXmlSerializable halfHour = testItem.Create();
Assert.IsNull(halfHour.GetSchema());
}
public void GetSchema_None_IsNull()
{
IXmlSerializable obj = GetTestInstance();
Assert.IsNull(obj.GetSchema());
}
public void GetSchema_ReturnsNull(ITestItem <QuarterHour> testItem)
{
IXmlSerializable quarterHour = testItem.Create();
Assert.IsNull(quarterHour.GetSchema());
}
