Files
mono/mcs/class/System.XML/Test/System.Xml.Serialization/XmlReflectionImporterTests.cs
T
2003-05-13 20:41:56 +00:00

435 lines
12 KiB
C#

//
// System.Xml.Serialization.XmlReflectionImporterTests
//
// Author:
// Erik LeBel ([email protected])
//
// (C) 2003 Erik LeBel
//
// FIXME test some of these with Xml Attributes attached to some members:
// do the names get carried over to Element for XmlAttributeAttribute and XmlElementAttribute?
//
using System;
using System.Xml;
using System.Xml.Serialization;
using NUnit.Framework;
using MonoTests.System.Xml.TestClasses;
namespace MonoTests.System.Xml.Serialization
{
// debugging class
internal class Debug
{
public static void Print(XmlTypeMapping tm)
{
Console.WriteLine("/XmlTypeMapping:");
Console.WriteLine("ElementName: {0} ", tm.ElementName);
Console.WriteLine("Namespace: {0} ", tm.Namespace);
Console.WriteLine("TypeName: {0} ", tm.TypeName);
Console.WriteLine("FullTypeName: {0} ", tm.TypeFullName);
}
public static void Print(XmlMemberMapping mm)
{
Console.WriteLine("/XmlMemberMapping:");
Console.WriteLine("Any: {0} ", mm.Any);
Console.WriteLine("ElementName: {0} ", mm.ElementName);
Console.WriteLine("MemberName: {0} ", mm.MemberName);
Console.WriteLine("Namespace: {0} ", mm.Namespace);
Console.WriteLine("TypeFullName: {0} ", mm.TypeFullName);
Console.WriteLine("TypeName: {0} ", mm.TypeName);
Console.WriteLine("TypeNamespace: {0} ", mm.TypeNamespace);
}
}
[TestFixture]
public class XmlReflectionImporterTests : Assertion
{
private const string SomeNamespace = "some:urn";
private const string AnotherNamespace = "another:urn";
// these Map methods re-create the XmlReflectionImporter at every call.
private XmlTypeMapping Map(Type t)
{
XmlReflectionImporter ri = new XmlReflectionImporter();
XmlTypeMapping tm = ri.ImportTypeMapping(t);
//Debug.Print(tm);
return tm;
}
private XmlTypeMapping Map(Type t, XmlRootAttribute root)
{
XmlReflectionImporter ri = new XmlReflectionImporter();
XmlTypeMapping tm = ri.ImportTypeMapping(t, root);
return tm;
}
private XmlTypeMapping Map(Type t, string ns)
{
XmlReflectionImporter ri = new XmlReflectionImporter(ns);
XmlTypeMapping tm = ri.ImportTypeMapping(t);
//Debug.Print(tm);
return tm;
}
private XmlTypeMapping Map(Type t, XmlAttributeOverrides overrides)
{
XmlReflectionImporter ri = new XmlReflectionImporter(overrides);
XmlTypeMapping tm = ri.ImportTypeMapping(t);
//Debug.Print(tm);
return tm;
}
private XmlMembersMapping MembersMap(Type t, XmlAttributeOverrides overrides,
XmlReflectionMember [] members, bool inContainer)
{
XmlReflectionImporter ri = new XmlReflectionImporter(overrides);
XmlMembersMapping mm = ri.ImportMembersMapping(null, null, members, inContainer);
return mm;
}
[Test]
public void TestIntTypeMapping()
{
XmlTypeMapping tm = Map(typeof(int));
AssertEquals(tm.ElementName, "int");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Int32");
AssertEquals(tm.TypeFullName, "System.Int32");
}
[Test]
public void TestIntArrayTypeMapping()
{
XmlTypeMapping tm = Map(typeof(int[]));
AssertEquals(tm.ElementName, "ArrayOfInt");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Int32[]");
AssertEquals(tm.TypeFullName, "System.Int32[]");
}
[Test]
public void TestStringTypeMapping()
{
XmlTypeMapping tm = Map(typeof(string));
AssertEquals(tm.ElementName, "string");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "String");
AssertEquals(tm.TypeFullName, "System.String");
}
[Test]
public void TestObjectTypeMapping()
{
XmlTypeMapping tm = Map(typeof(object));
AssertEquals(tm.ElementName, "anyType");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Object");
AssertEquals(tm.TypeFullName, "System.Object");
}
[Test]
public void TestByteTypeMapping()
{
XmlTypeMapping tm = Map(typeof(byte));
AssertEquals(tm.ElementName, "unsignedByte");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Byte");
AssertEquals(tm.TypeFullName, "System.Byte");
}
[Test]
public void TestByteArrayTypeMapping()
{
XmlTypeMapping tm = Map(typeof(byte[]));
AssertEquals(tm.ElementName, "base64Binary");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Byte[]");
AssertEquals(tm.TypeFullName, "System.Byte[]");
}
[Test]
public void TestBoolTypeMapping()
{
XmlTypeMapping tm = Map(typeof(bool));
AssertEquals(tm.ElementName, "boolean");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Boolean");
AssertEquals(tm.TypeFullName, "System.Boolean");
}
[Test]
public void TestShortTypeMapping()
{
XmlTypeMapping tm = Map(typeof(short));
AssertEquals(tm.ElementName, "short");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Int16");
AssertEquals(tm.TypeFullName, "System.Int16");
}
[Test]
public void TestUnsignedShortTypeMapping()
{
XmlTypeMapping tm = Map(typeof(ushort));
AssertEquals(tm.ElementName, "unsignedShort");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "UInt16");
AssertEquals(tm.TypeFullName, "System.UInt16");
}
[Test]
public void TestUIntTypeMapping()
{
XmlTypeMapping tm = Map(typeof(uint));
AssertEquals(tm.ElementName, "unsignedInt");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "UInt32");
AssertEquals(tm.TypeFullName, "System.UInt32");
}
[Test]
public void TestLongTypeMapping()
{
XmlTypeMapping tm = Map(typeof(long));
AssertEquals(tm.ElementName, "long");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Int64");
AssertEquals(tm.TypeFullName, "System.Int64");
}
[Test]
public void TestULongTypeMapping()
{
XmlTypeMapping tm = Map(typeof(ulong));
AssertEquals(tm.ElementName, "unsignedLong");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "UInt64");
AssertEquals(tm.TypeFullName, "System.UInt64");
}
[Test]
public void TestFloatTypeMapping()
{
XmlTypeMapping tm = Map(typeof(float));
AssertEquals(tm.ElementName, "float");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Single");
AssertEquals(tm.TypeFullName, "System.Single");
}
[Test]
public void TestDoubleTypeMapping()
{
XmlTypeMapping tm = Map(typeof(double));
AssertEquals(tm.ElementName, "double");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Double");
AssertEquals(tm.TypeFullName, "System.Double");
}
[Test]
public void TestDateTimeTypeMapping()
{
XmlTypeMapping tm = Map(typeof(DateTime));
AssertEquals(tm.ElementName, "dateTime");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "DateTime");
AssertEquals(tm.TypeFullName, "System.DateTime");
}
[Test]
public void TestGuidTypeMapping()
{
XmlTypeMapping tm = Map(typeof(Guid));
AssertEquals(tm.ElementName, "guid");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Guid");
AssertEquals(tm.TypeFullName, "System.Guid");
}
[Test]
public void TestDecimalTypeMapping()
{
XmlTypeMapping tm = Map(typeof(decimal));
AssertEquals(tm.ElementName, "decimal");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Decimal");
AssertEquals(tm.TypeFullName, "System.Decimal");
}
[Test]
public void TestXmlQualifiedNameTypeMapping()
{
XmlTypeMapping tm = Map(typeof(XmlQualifiedName));
AssertEquals(tm.ElementName, "QName");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "XmlQualifiedName");
AssertEquals(tm.TypeFullName, "System.Xml.XmlQualifiedName");
}
[Test]
public void TestSByteTypeMapping()
{
XmlTypeMapping tm = Map(typeof(sbyte));
AssertEquals(tm.ElementName, "byte");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "SByte");
AssertEquals(tm.TypeFullName, "System.SByte");
}
[Test]
public void TestCharTypeMapping()
{
XmlTypeMapping tm = Map(typeof(char));
AssertEquals(tm.ElementName, "char");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "Char");
AssertEquals(tm.TypeFullName, "System.Char");
}
[Test]
public void TestNullTypeMapping()
{
try
{
XmlTypeMapping tm = Map(null);
Fail("Should not be able to map a null type");
}
catch (Exception)
{
}
}
[Test]
public void TestInvalidClassTypeMapping()
{
try
{
// this can use any class
XmlTypeMapping tm = Map(typeof(SimpleClass));
Fail("Should not be able to this type");
}
catch (Exception)
{
}
}
/*
[Test]
public void TestTypeMapping()
{
XmlTypeMapping tm = Map(typeof());
AssertEquals(tm.ElementName, "");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "");
AssertEquals(tm.TypeFullName, "System.");
}
*/
[Test]
public void TestIntTypeMappingWithDefaultNamespaces()
{
XmlTypeMapping tm = Map(typeof(int), SomeNamespace);
AssertEquals(tm.ElementName, "int");
AssertEquals(tm.Namespace, SomeNamespace);
AssertEquals(tm.TypeName, "Int32");
AssertEquals(tm.TypeFullName, "System.Int32");
}
[Test]
public void TestValidClassTypeMapping()
{
Type type = typeof(SimpleClass);
XmlAttributes attrs = new XmlAttributes();
XmlAttributeOverrides overrides = new XmlAttributeOverrides();
overrides.Add(typeof(SimpleClass), attrs);
XmlTypeMapping tm = Map(type, overrides);
AssertEquals(tm.ElementName, "SimpleClass");
AssertEquals(tm.Namespace, "");
AssertEquals(tm.TypeName, "SimpleClass");
AssertEquals(tm.TypeFullName, "MonoTests.System.Xml.TestClasses.SimpleClass");
}
[Test]
public void TestImportMembersMapping()
{
Type type = typeof(SimpleClass);
XmlAttributes attrs = new XmlAttributes();
XmlAttributeOverrides overrides = new XmlAttributeOverrides();
overrides.Add(typeof(SimpleClass), attrs);
XmlReflectionMember[] members = new XmlReflectionMember[0];
XmlMembersMapping mm;
try
{
mm = MembersMap(type, overrides, members, true);
Fail("Should not be able to fetch an empty XmlMembersMapping");
}
catch (Exception)
{
}
XmlReflectionMember rm = new XmlReflectionMember();
rm.IsReturnValue = false;
rm.MemberName = "something";
rm.MemberType = typeof(string);
members = new XmlReflectionMember[1];
members[0] = rm;
mm = MembersMap(type, overrides, members, false);
Equals(mm.Count, 1);
XmlMemberMapping smm = mm[0];
AssertEquals(smm.Any, false);
AssertEquals(smm.ElementName, "something");
AssertEquals(smm.MemberName, "something");
AssertEquals(smm.Namespace, null);
AssertEquals(smm.TypeFullName, "System.String");
AssertEquals(smm.TypeName, "string");
AssertEquals(smm.TypeNamespace, null);
rm = new XmlReflectionMember();
rm.IsReturnValue = false;
rm.MemberName = "nothing";
rm.MemberType = typeof(string);
members = new XmlReflectionMember[1];
members[0] = rm;
mm = MembersMap(type, overrides, members, false);
Equals(mm.Count, 0);
}
[Test]
public void TestIntTypeMappingWithXmlRootAttribute()
{
const string TheNamespace = "another:urn";
XmlRootAttribute root = new XmlRootAttribute("price");
root.Namespace = TheNamespace;
XmlTypeMapping tm = Map(typeof(int), root);
AssertEquals(tm.ElementName, "price");
AssertEquals(tm.Namespace, TheNamespace);
AssertEquals(tm.TypeName, "Int32");
AssertEquals(tm.TypeFullName, "System.Int32");
}
}
}