mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
435 lines
12 KiB
C#
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");
|
|
}
|
|
|
|
}
|
|
}
|
|
|