mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 01:41:17 -10:00
This test is sensitive to the line ending mode used by git. When LF is used by git (which is what Cygwin's git defaults to) this test fails on Windows since CRLF will be used as line ending in the serialized XML. This patch changes the test to use Environment.NewLine explicitly in the expected string.
2111 lines
70 KiB
C#
Executable File
2111 lines
70 KiB
C#
Executable File
//
|
|
// 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.Collections;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using System.Xml.Serialization;
|
|
|
|
using NUnit.Framework;
|
|
using System.Collections.Generic;
|
|
|
|
using MonoTests.System.Xml.TestClasses;
|
|
|
|
namespace MonoTests.System.XmlSerialization
|
|
{
|
|
// 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
|
|
{
|
|
private const string SomeNamespace = "some:urn";
|
|
private const string AnotherNamespace = "another:urn";
|
|
private const string XmlSchemaNamespace = "http://www.w3.org/2001/XMLSchema";
|
|
|
|
// 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, string ns, XmlRootAttribute root)
|
|
{
|
|
XmlReflectionImporter ri = new XmlReflectionImporter (ns);
|
|
XmlTypeMapping tm = ri.ImportTypeMapping (t, root);
|
|
|
|
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));
|
|
Assert.AreEqual ("int", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Int32", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestIntTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(int[]));
|
|
Assert.AreEqual ("ArrayOfInt", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfInt32", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.Int32[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (int[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfInt", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfInt32", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.Int32[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (int[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfInt", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfInt32", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.Int32[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestStringTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(string));
|
|
Assert.AreEqual ("string", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("String", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.String", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestStringTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (string[]));
|
|
Assert.AreEqual ("ArrayOfString", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfString", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.String[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (string[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfString", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfString", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.String[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (string[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.String[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestObjectTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(object));
|
|
Assert.AreEqual ("anyType", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Object", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Object", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestObjectTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (object[]));
|
|
Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfObject", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.Object[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (object[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfObject", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.Object[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (object[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfObject", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.Object[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestByteTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(byte));
|
|
Assert.AreEqual ("unsignedByte", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Byte", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Byte", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestByteTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(byte[]));
|
|
Assert.AreEqual ("base64Binary", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("Byte[]", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.Byte[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (byte[][]));
|
|
Assert.AreEqual ("ArrayOfBase64Binary", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfByte", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.Byte[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (byte[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfBase64Binary", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfByte", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.Byte[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestBoolTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(bool));
|
|
Assert.AreEqual ("boolean", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Boolean", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Boolean", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestShortTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(short));
|
|
Assert.AreEqual ("short", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Int16", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Int16", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestUnsignedShortTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(ushort));
|
|
Assert.AreEqual ("unsignedShort", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("UInt16", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.UInt16", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestUIntTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(uint));
|
|
Assert.AreEqual ("unsignedInt", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("UInt32", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.UInt32", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestLongTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(long));
|
|
Assert.AreEqual ("long", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Int64", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Int64", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestULongTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(ulong));
|
|
Assert.AreEqual ("unsignedLong", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("UInt64", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.UInt64", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestFloatTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(float));
|
|
Assert.AreEqual ("float", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Single", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Single", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestDoubleTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(double));
|
|
Assert.AreEqual ("double", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Double", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Double", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestDateTimeTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(DateTime));
|
|
Assert.AreEqual ("dateTime", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("DateTime", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.DateTime", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestDateTimeTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (DateTime[]));
|
|
Assert.AreEqual ("ArrayOfDateTime", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfDateTime", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.DateTime[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (DateTime[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.DateTime[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (DateTime[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.DateTime[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestGuidTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(Guid));
|
|
Assert.AreEqual ("guid", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Guid", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Guid", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestGuidTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (Guid[]));
|
|
Assert.AreEqual ("ArrayOfGuid", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfGuid", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.Guid[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (Guid[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfGuid", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfGuid", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.Guid[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (Guid[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.Guid[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestDecimalTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(decimal));
|
|
Assert.AreEqual ("decimal", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Decimal", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Decimal", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestXmlQualifiedNameTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(XmlQualifiedName));
|
|
Assert.AreEqual ("QName", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("XmlQualifiedName", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Xml.XmlQualifiedName", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestSByteTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(sbyte));
|
|
Assert.AreEqual ("byte", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("SByte", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.SByte", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void TestCharTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(char));
|
|
Assert.AreEqual ("char", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Char", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Char", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestCharTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (char[]));
|
|
Assert.AreEqual ("ArrayOfChar", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfChar", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.Char[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (char[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfChar", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfChar", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.Char[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (char[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.Char[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestXmlNodeTypeMapping ()
|
|
{
|
|
Type type = typeof (XmlNode);
|
|
|
|
XmlTypeMapping tm = Map (type);
|
|
Assert.AreEqual (string.Empty, tm.ElementName, "#A1");
|
|
Assert.IsNull (tm.Namespace, "#A2");
|
|
Assert.AreEqual ("XmlNode", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (type, AnotherNamespace);
|
|
Assert.AreEqual (string.Empty, tm.ElementName, "#B1");
|
|
Assert.IsNull (tm.Namespace, "#B2");
|
|
Assert.AreEqual ("XmlNode", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#B4");
|
|
|
|
XmlRootAttribute root = new XmlRootAttribute ("somename");
|
|
root.Namespace = SomeNamespace;
|
|
tm = Map (type, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#C1");
|
|
Assert.IsNull (tm.Namespace, "#C2");
|
|
Assert.AreEqual ("XmlNode", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#C4");
|
|
|
|
tm = Map (type, AnotherNamespace, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#D1");
|
|
Assert.IsNull (tm.Namespace, "#D2");
|
|
Assert.AreEqual ("XmlNode", tm.TypeName, "#D3");
|
|
Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#D4");
|
|
|
|
root.Namespace = null;
|
|
tm = Map (type, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#E1");
|
|
Assert.IsNull (tm.Namespace, "#E2");
|
|
Assert.AreEqual ("XmlNode", tm.TypeName, "#E3");
|
|
Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#E4");
|
|
|
|
tm = Map (type, AnotherNamespace, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#F1");
|
|
Assert.IsNull (tm.Namespace, "#F2");
|
|
Assert.AreEqual ("XmlNode", tm.TypeName, "#F3");
|
|
Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#F4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestXmlElementTypeMapping ()
|
|
{
|
|
Type type = typeof (XmlElement);
|
|
|
|
XmlTypeMapping tm = Map (type);
|
|
Assert.AreEqual (string.Empty, tm.ElementName, "#1");
|
|
Assert.IsNull (tm.Namespace, "#2");
|
|
Assert.AreEqual ("XmlElement", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#4");
|
|
|
|
tm = Map (type, AnotherNamespace);
|
|
Assert.AreEqual (string.Empty, tm.ElementName, "#B1");
|
|
Assert.IsNull (tm.Namespace, "#B2");
|
|
Assert.AreEqual ("XmlElement", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#B4");
|
|
|
|
XmlRootAttribute root = new XmlRootAttribute ("somename");
|
|
root.Namespace = SomeNamespace;
|
|
tm = Map (type, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#C1");
|
|
Assert.IsNull (tm.Namespace, "#C2");
|
|
Assert.AreEqual ("XmlElement", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#C4");
|
|
|
|
tm = Map (type, AnotherNamespace, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#D1");
|
|
Assert.IsNull (tm.Namespace, "#D2");
|
|
Assert.AreEqual ("XmlElement", tm.TypeName, "#D3");
|
|
Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#D4");
|
|
|
|
root.Namespace = null;
|
|
tm = Map (type, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#E1");
|
|
Assert.IsNull (tm.Namespace, "#E2");
|
|
Assert.AreEqual ("XmlElement", tm.TypeName, "#E3");
|
|
Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#E4");
|
|
|
|
tm = Map (type, AnotherNamespace, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#F1");
|
|
Assert.IsNull (tm.Namespace, "#F2");
|
|
Assert.AreEqual ("XmlElement", tm.TypeName, "#F3");
|
|
Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#F4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestXmlNotationTypeMapping ()
|
|
{
|
|
Type type = typeof (XmlNotation);
|
|
|
|
XmlTypeMapping tm = Map (type);
|
|
Assert.AreEqual (string.Empty, tm.ElementName, "#1");
|
|
Assert.IsNull (tm.Namespace, "#2");
|
|
Assert.AreEqual ("XmlNotation", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#4");
|
|
|
|
tm = Map (type, AnotherNamespace);
|
|
Assert.AreEqual (string.Empty, tm.ElementName, "#B1");
|
|
Assert.IsNull (tm.Namespace, "#B2");
|
|
Assert.AreEqual ("XmlNotation", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#B4");
|
|
|
|
XmlRootAttribute root = new XmlRootAttribute ("somename");
|
|
root.Namespace = SomeNamespace;
|
|
tm = Map (type, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#C1");
|
|
Assert.IsNull (tm.Namespace, "#C2");
|
|
Assert.AreEqual ("XmlNotation", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#C4");
|
|
|
|
tm = Map (type, AnotherNamespace, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#D1");
|
|
Assert.IsNull (tm.Namespace, "#D2");
|
|
Assert.AreEqual ("XmlNotation", tm.TypeName, "#D3");
|
|
Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#D4");
|
|
|
|
root.Namespace = null;
|
|
tm = Map (type, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#E1");
|
|
Assert.IsNull (tm.Namespace, "#E2");
|
|
Assert.AreEqual ("XmlNotation", tm.TypeName, "#E3");
|
|
Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#E4");
|
|
|
|
tm = Map (type, AnotherNamespace, root);
|
|
Assert.AreEqual ("somename", tm.ElementName, "#F1");
|
|
Assert.IsNull (tm.Namespace, "#F2");
|
|
Assert.AreEqual ("XmlNotation", tm.TypeName, "#F3");
|
|
Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#F4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestXmlSerializableTypeMapping ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (Employee));
|
|
Assert.AreEqual ("Employee", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Employee", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestXmlSerializableTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (Employee[]));
|
|
Assert.AreEqual ("ArrayOfEmployee", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfEmployee", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (Employee[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (Employee[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestClassTypeMapping_NestedStruct ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (NestedStruct));
|
|
Assert.AreEqual ("NestedStruct", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("NestedStruct", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.NestedStruct", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void TestNullTypeMapping()
|
|
{
|
|
Map(null);
|
|
}
|
|
|
|
[Test]
|
|
public void TestIntTypeMappingWithDefaultNamespaces()
|
|
{
|
|
XmlTypeMapping tm = Map(typeof(int), SomeNamespace);
|
|
Assert.AreEqual ("int", tm.ElementName, "#1");
|
|
Assert.AreEqual (SomeNamespace, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Int32", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestStructTypeMapping ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (TimeSpan));
|
|
Assert.AreEqual ("TimeSpan", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("TimeSpan", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.TimeSpan", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestStructTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (TimeSpan[]));
|
|
Assert.AreEqual ("ArrayOfTimeSpan", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfTimeSpan", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.TimeSpan[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (TimeSpan[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.TimeSpan[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (TimeSpan[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.TimeSpan[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestEnumTypeMapping ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (AttributeTargets));
|
|
Assert.AreEqual ("AttributeTargets", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("AttributeTargets", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.AttributeTargets", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestEnumTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (AttributeTargets[]));
|
|
Assert.AreEqual ("ArrayOfAttributeTargets", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfAttributeTargets", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("System.AttributeTargets[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (AttributeTargets[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("System.AttributeTargets[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (AttributeTargets[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("System.AttributeTargets[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
public void TestClassTypeMapping()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (SimpleClass));
|
|
Assert.AreEqual ("SimpleClass", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("SimpleClass", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TestClassTypeMapping_Array ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (SimpleClass[]));
|
|
Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfSimpleClass", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (SimpleClass[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (SimpleClass[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotSupportedException))]
|
|
public void TypeMapping_IDictionary ()
|
|
{
|
|
// The type MonoTests.System.Xml.TestClasses.DictionaryWithIndexer
|
|
// is not supported because it implements IDictionary.
|
|
Map (typeof (DictionaryWithIndexer));
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TypeMapping_IEnumerable_SimpleClass ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (SimpleClassEnumerable));
|
|
Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("SimpleClassEnumerable", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable", tm.TypeFullName, "#4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerable[]));
|
|
Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfSimpleClassEnumerable", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerable[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerable[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TypeMapping_IEnumerable_Object ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (ObjectEnumerable));
|
|
Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("ObjectEnumerable", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable", tm.TypeFullName, "#4");
|
|
|
|
tm = Map (typeof (ObjectEnumerable[]));
|
|
Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfObjectEnumerable", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (ObjectEnumerable[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfObjectEnumerable", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (ObjectEnumerable[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectEnumerable", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_IEnumerable_Object_NoMatchingAddMethod ()
|
|
{
|
|
Map (typeof (ObjectEnumerableNoMatchingAddMethod));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_IEnumerable_Object_NoMatchingAddMethod_Array ()
|
|
{
|
|
Map (typeof (ObjectEnumerableNoMatchingAddMethod[]));
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TypeMapping_IEnumerable_SimpleClass_PrivateCurrent ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (SimpleClassEnumerablePrivateCurrent));
|
|
Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent", tm.TypeFullName, "#4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[]));
|
|
Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TypeMapping_IEnumerable_SimpleClass_PrivateGetEnumerator ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator));
|
|
Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator", tm.TypeFullName, "#4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[]));
|
|
Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_ICollection_Object_NoMatchingAddMethod ()
|
|
{
|
|
Map (typeof (ObjectCollectionNoMatchingAddMethod));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_ICollection_Object_NoMatchingAddMethod_Array ()
|
|
{
|
|
Map (typeof (ObjectCollectionNoMatchingAddMethod[]));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod ()
|
|
{
|
|
Map (typeof (SimpleClassCollectionNoMatchingAddMethod));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod_Array ()
|
|
{
|
|
Map (typeof (SimpleClassCollectionNoMatchingAddMethod[]));
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TypeMapping_ICollection_SimpleClass ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (SimpleClassCollection));
|
|
Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("SimpleClassCollection", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection", tm.TypeFullName, "#4");
|
|
|
|
tm = Map (typeof (SimpleClassCollection[]));
|
|
Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfSimpleClassCollection", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (SimpleClassCollection[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (SimpleClassCollection[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
public void TypeMapping_ICollection_Object ()
|
|
{
|
|
XmlTypeMapping tm = Map (typeof (ObjectCollection));
|
|
Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#2");
|
|
Assert.AreEqual ("ObjectCollection", tm.TypeName, "#3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection", tm.TypeFullName, "#4");
|
|
|
|
tm = Map (typeof (ObjectCollection[]));
|
|
Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
|
|
Assert.AreEqual ("ArrayOfObjectCollection", tm.TypeName, "#A3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[]", tm.TypeFullName, "#A4");
|
|
|
|
tm = Map (typeof (ObjectCollection[][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
|
|
Assert.AreEqual ("ArrayOfArrayOfObjectCollection", tm.TypeName, "#B3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[][]", tm.TypeFullName, "#B4");
|
|
|
|
tm = Map (typeof (ObjectCollection[][][]));
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
|
|
Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
|
|
Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectCollection", tm.TypeName, "#C3");
|
|
Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[][][]", tm.TypeFullName, "#C4");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_ICollection_Object_NoIntIndexer ()
|
|
{
|
|
Map (typeof (ObjectCollectionNoIntIndexer));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_ICollection_Object_NoIntIndexer_Array ()
|
|
{
|
|
Map (typeof (ObjectCollectionNoIntIndexer[]));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_ICollection_SimpleClass_NoIntIndexer ()
|
|
{
|
|
Map (typeof (SimpleClassCollectionNoIntIndexer));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TypeMapping_ICollection_SimpleClass_NoIntIndexer_Array ()
|
|
{
|
|
Map (typeof (SimpleClassCollectionNoIntIndexer[]));
|
|
}
|
|
|
|
[Test]
|
|
public void TypeMapping_InvalidDefault ()
|
|
{
|
|
XmlAttributes attrs = new XmlAttributes (typeof (Field).GetMember ("Modifiers") [0]);
|
|
attrs.XmlDefaultValue = 2; // not a defined enum value
|
|
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
|
|
overrides.Add (typeof (Field), "Modifiers", attrs);
|
|
|
|
try {
|
|
Map (typeof (Field), overrides);
|
|
Assert.Fail ("#A1");
|
|
} catch (InvalidOperationException ex) {
|
|
// There was an error reflecting type MonoTests.System.Xml.TestClasses.Field
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
|
|
Assert.IsNotNull (ex.Message, "#A3");
|
|
Assert.IsTrue (ex.Message.IndexOf (typeof (Field).FullName) != -1, "#A4");
|
|
Assert.IsNotNull (ex.InnerException, "#A5");
|
|
|
|
// There was an error reflecting field 'Modifiers'
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#A6");
|
|
Assert.IsNotNull (ex.InnerException.Message, "#A7");
|
|
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#A8");
|
|
Assert.IsNotNull (ex.InnerException.InnerException, "#A9");
|
|
|
|
// Value '2' cannot be converted to System.Int32
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.InnerException.GetType (), "#A10");
|
|
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#A11");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("'2'") != -1, "#A12");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (int).FullName) != -1, "#A13");
|
|
Assert.IsNull (ex.InnerException.InnerException.InnerException, "#A14");
|
|
}
|
|
|
|
attrs.XmlDefaultValue = "2"; // not of the same type as the underlying enum type (System.Int32)
|
|
|
|
try {
|
|
Map (typeof (Field), overrides);
|
|
Assert.Fail ("#B1");
|
|
} catch (InvalidOperationException ex) {
|
|
// There was an error reflecting type MonoTests.System.Xml.TestClasses.Field
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
|
|
Assert.IsNotNull (ex.Message, "#B3");
|
|
Assert.IsTrue (ex.Message.IndexOf (typeof (Field).FullName) != -1, "#B4");
|
|
Assert.IsNotNull (ex.InnerException, "#B5");
|
|
|
|
// There was an error reflecting field 'Modifiers'
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B6");
|
|
Assert.IsNotNull (ex.InnerException.Message, "#B7");
|
|
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#B8");
|
|
Assert.IsNotNull (ex.InnerException.InnerException, "#B9");
|
|
|
|
// Enum underlying type and the object must be same type or object.
|
|
// Type passed in was 'System.String'; the enum underlying type was
|
|
// 'System.Int32'.
|
|
Assert.AreEqual (typeof (ArgumentException), ex.InnerException.InnerException.GetType (), "#B10");
|
|
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#B11");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (string).FullName) != -1, "#B12");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (int).FullName) != -1, "#B13");
|
|
Assert.IsNull (ex.InnerException.InnerException.InnerException, "#B14");
|
|
}
|
|
|
|
attrs.XmlDefaultValue = EnumDefaultValueNF.e2; // other enum type
|
|
|
|
try {
|
|
Map (typeof (Field), overrides);
|
|
Assert.Fail ("#C1");
|
|
} catch (InvalidOperationException ex) {
|
|
// There was an error reflecting type MonoTests.System.Xml.TestClasses.Field
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
|
|
Assert.IsNotNull (ex.Message, "#C3");
|
|
Assert.IsTrue (ex.Message.IndexOf (typeof (Field).FullName) != -1, "#C4");
|
|
Assert.IsNotNull (ex.InnerException, "#C5");
|
|
|
|
// There was an error reflecting field 'Modifiers'
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C6");
|
|
Assert.IsNotNull (ex.InnerException.Message, "#C7");
|
|
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#C8");
|
|
Assert.IsNotNull (ex.InnerException.InnerException, "#C9");
|
|
|
|
// Object must be the same type as the enum. The type passed in
|
|
// was MonoTests.System.Xml.TestClasses.EnumDefaultValueNF; the
|
|
// enum type was MonoTests.System.Xml.TestClasses.MapModifiers
|
|
Assert.AreEqual (typeof (ArgumentException), ex.InnerException.InnerException.GetType (), "#C10");
|
|
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#C11");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).FullName) != -1, "#C12");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (MapModifiers).FullName) != -1, "#C13");
|
|
Assert.IsNull (ex.InnerException.InnerException.InnerException, "#C14");
|
|
}
|
|
|
|
attrs.XmlDefaultValue = (MapModifiers) 20; // non-existing enum value
|
|
|
|
try {
|
|
Map (typeof (Field), overrides);
|
|
Assert.Fail ("#D1");
|
|
} catch (InvalidOperationException ex) {
|
|
// There was an error reflecting type MonoTests.System.Xml.TestClasses.Field
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
|
|
Assert.IsNotNull (ex.Message, "#D3");
|
|
Assert.IsTrue (ex.Message.IndexOf (typeof (Field).FullName) != -1, "#D4");
|
|
Assert.IsNotNull (ex.InnerException, "#D5");
|
|
|
|
// There was an error reflecting field 'Modifiers'
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D6");
|
|
Assert.IsNotNull (ex.InnerException.Message, "#D7");
|
|
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#D8");
|
|
Assert.IsNotNull (ex.InnerException.InnerException, "#D9");
|
|
|
|
// Value '20' cannot be converted to MonoTests.System.Xml.TestClasses.MapModifiers
|
|
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.InnerException.GetType (), "#D10");
|
|
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#D11");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("'20'") != -1, "#D12");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (MapModifiers).FullName) != -1, "#D13");
|
|
Assert.IsNull (ex.InnerException.InnerException.InnerException, "#D14");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void TypeMapping_Null ()
|
|
{
|
|
Map ((Type) null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotSupportedException))]
|
|
public void TypeMapping_Void ()
|
|
{
|
|
Map (typeof (void));
|
|
}
|
|
|
|
[Test]
|
|
public void TypeMapping_WrongChoices ()
|
|
{
|
|
try {
|
|
Map (typeof (WrongChoices));
|
|
Assert.Fail ("#1");
|
|
} catch (InvalidOperationException ex) {
|
|
// There was an error reflecting type 'MonoTests.System.Xml.TestClasses.WrongChoices'
|
|
Assert.IsNotNull (ex.Message, "#2");
|
|
Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (WrongChoices).FullName + "'") != -1, "#3");
|
|
Assert.IsNotNull (ex.InnerException, "#4");
|
|
|
|
// There was an error reflecting field 'MyChoice'
|
|
Assert.IsNotNull (ex.InnerException.Message, "#5");
|
|
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'MyChoice'") != -1, "#6");
|
|
Assert.IsNotNull (ex.InnerException.InnerException, "#7");
|
|
|
|
// Type MonoTests.System.Xml.TestClasses.ItemChoiceType is missing
|
|
// enumeration value 'StrangeOne' for element 'StrangeOne' from
|
|
// namespace ''.
|
|
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#8");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (ItemChoiceType).FullName) != -1, "#9");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("'StrangeOne'") != -1, "#10");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("''") != -1, "#11");
|
|
}
|
|
}
|
|
|
|
[Test] // bug #77591
|
|
public void TypeMapping_XmlText_PrimitiveTypes ()
|
|
{
|
|
XmlAttributeOverrides overrides = null;
|
|
XmlAttributes attrs = null;
|
|
|
|
overrides = new XmlAttributeOverrides ();
|
|
attrs = new XmlAttributes ();
|
|
attrs.XmlText = new XmlTextAttribute (typeof (int));
|
|
overrides.Add (typeof (Field), "Modifiers", attrs);
|
|
|
|
try {
|
|
Map (typeof (Field), overrides);
|
|
Assert.Fail ("#A1");
|
|
} catch (InvalidOperationException ex) {
|
|
// There was an error reflecting type 'MonoTests.System.Xml.TestClasses.Field'
|
|
Assert.IsNotNull (ex.Message, "#A2");
|
|
Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (Field).FullName + "'") != -1, "#A3");
|
|
Assert.IsNotNull (ex.InnerException, "#A4");
|
|
|
|
// There was an error reflecting field 'Modifiers'
|
|
Assert.IsNotNull (ex.InnerException.Message, "#A5");
|
|
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#A6");
|
|
Assert.IsNotNull (ex.InnerException.InnerException, "#A7");
|
|
|
|
// The type for XmlText may not be specified for primitive types
|
|
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#A8");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("XmlText") != -1, "#A9");
|
|
}
|
|
|
|
overrides = new XmlAttributeOverrides ();
|
|
attrs = new XmlAttributes ();
|
|
attrs.XmlText = new XmlTextAttribute (typeof (int));
|
|
overrides.Add (typeof (Field), "Street", attrs);
|
|
|
|
try {
|
|
Map (typeof (Field), overrides);
|
|
Assert.Fail ("#B1");
|
|
} catch (InvalidOperationException ex) {
|
|
// There was an error reflecting type 'MonoTests.System.Xml.TestClasses.Field'
|
|
Assert.IsNotNull (ex.Message, "#B2");
|
|
Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (Field).FullName + "'") != -1, "#B3");
|
|
Assert.IsNotNull (ex.InnerException, "#B4");
|
|
|
|
// There was an error reflecting field 'Street'
|
|
Assert.IsNotNull (ex.InnerException.Message, "#B5");
|
|
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Street'") != -1, "#B6");
|
|
Assert.IsNotNull (ex.InnerException.InnerException, "#B7");
|
|
|
|
// The type for XmlText may not be specified for primitive types
|
|
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#B8");
|
|
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("XmlText") != -1, "#B9");
|
|
}
|
|
|
|
overrides = new XmlAttributeOverrides ();
|
|
attrs = new XmlAttributes ();
|
|
attrs.XmlText = new XmlTextAttribute (typeof (MapModifiers));
|
|
overrides.Add (typeof (Field), "Modifiers", attrs);
|
|
Map (typeof (Field), overrides);
|
|
|
|
overrides = new XmlAttributeOverrides ();
|
|
attrs = new XmlAttributes ();
|
|
attrs.XmlText = new XmlTextAttribute (typeof (string));
|
|
overrides.Add (typeof (Field), "Street", attrs);
|
|
Map (typeof (Field), overrides);
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
|
|
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);
|
|
Assert.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];
|
|
Assert.IsFalse (smm.Any, "#1");
|
|
Assert.AreEqual ("something", smm.ElementName, "#2");
|
|
Assert.AreEqual ("something", smm.MemberName, "#3");
|
|
Assert.IsNull (smm.Namespace, "#4");
|
|
Assert.AreEqual ("System.String", smm.TypeFullName, "#5");
|
|
Assert.AreEqual ("string", smm.TypeName, "#6");
|
|
Assert.AreEqual (XmlSchemaNamespace, smm.TypeNamespace, "#7");
|
|
|
|
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);
|
|
Assert.AreEqual (1, mm.Count, "#8");
|
|
}
|
|
|
|
[Test]
|
|
public void TestIntTypeMappingWithXmlRootAttribute()
|
|
{
|
|
const string TheNamespace = "another:urn";
|
|
XmlRootAttribute root = new XmlRootAttribute("price");
|
|
root.Namespace = TheNamespace;
|
|
|
|
XmlTypeMapping tm = Map(typeof(int), root);
|
|
Assert.AreEqual ("price", tm.ElementName, "#1");
|
|
Assert.AreEqual (TheNamespace, tm.Namespace, "#2");
|
|
Assert.AreEqual ("Int32", tm.TypeName, "#3");
|
|
Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void TestSerializeWrongChoice ()
|
|
{
|
|
new XmlSerializer (typeof(WrongChoices));
|
|
}
|
|
|
|
[Test]
|
|
public void XmlArrayOnByteArray ()
|
|
{
|
|
new XmlSerializer (typeof (XmlArrayOnByteArrayType));
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void ImportNullableInt ()
|
|
{
|
|
XmlReflectionImporter imp = new XmlReflectionImporter ();
|
|
XmlTypeMapping map = imp.ImportTypeMapping (typeof (int?));
|
|
XmlSchemas schemas = new XmlSchemas ();
|
|
XmlSchemaExporter exp = new XmlSchemaExporter (schemas);
|
|
exp.ExportTypeMapping (map);
|
|
XmlSchema schema = schemas [0];
|
|
XmlSchemaElement el = schema.Items [0] as XmlSchemaElement;
|
|
Assert.AreEqual ("int", el.Name, "#1");
|
|
Assert.AreEqual (new XmlQualifiedName ("int", XmlSchema.Namespace), el.SchemaTypeName, "#2");
|
|
Assert.AreEqual (true, el.IsNillable, "#3");
|
|
}
|
|
|
|
[Test]
|
|
public void ImportNullableContainer ()
|
|
{
|
|
new XmlSerializer (typeof (NullableContainer));
|
|
}
|
|
|
|
[Test]
|
|
public void ImportNullableContainer2 ()
|
|
{
|
|
XmlReflectionImporter imp = new XmlReflectionImporter ();
|
|
XmlTypeMapping map = imp.ImportTypeMapping (typeof (NullableContainer2));
|
|
XmlSchemas schemas = new XmlSchemas ();
|
|
XmlSchemaExporter exp = new XmlSchemaExporter (schemas);
|
|
exp.ExportTypeMapping (map);
|
|
|
|
XmlSchema schema = schemas [0];
|
|
XmlSchemaComplexType el = schema.Items [1] as XmlSchemaComplexType;
|
|
|
|
XmlSchemaSequence s = el.Particle as XmlSchemaSequence;
|
|
XmlSchemaElement el2 = s.Items [0] as XmlSchemaElement;
|
|
Assert.IsTrue (el2.IsNillable);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void ImportGenericTypeDefinition ()
|
|
{
|
|
new XmlSerializer (typeof (List<int>).GetGenericTypeDefinition ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void XmlSchemaProviderMissingMethod ()
|
|
{
|
|
new XmlSerializer (typeof (XmlSchemaProviderMissingMethodType));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void XmlSchemaProviderMethodNonStatic ()
|
|
{
|
|
new XmlSerializer (typeof (XmlSchemaProviderNonStaticType));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void XmlSchemaProviderMethodIncorrectReturn ()
|
|
{
|
|
new XmlSerializer (typeof (XmlSchemaProviderIncorrectReturnType));
|
|
}
|
|
|
|
[Test]
|
|
public void XmlSchemaProviderAndDefaultNamespace ()
|
|
{
|
|
XmlTypeMapping tm = new XmlReflectionImporter ("urn:bar").ImportTypeMapping (typeof (XmlSchemaProviderAndDefaultNamespaceType));
|
|
Assert.AreEqual ("foo", tm.ElementName, "#1");
|
|
Assert.AreEqual ("foo", tm.XsdTypeName, "#2");
|
|
Assert.AreEqual ("urn:bar", tm.Namespace, "#3");
|
|
Assert.AreEqual ("urn:foo", tm.XsdTypeNamespace);
|
|
}
|
|
|
|
[Test]
|
|
public void ImportGenericICollectionWrapped ()
|
|
{
|
|
new XmlSerializer (typeof (MyCollection));
|
|
}
|
|
|
|
[Test]
|
|
public void Bug704813Type ()
|
|
{
|
|
var xs = new XmlSerializer (typeof (Bug704813Type));
|
|
xs.Serialize (TextWriter.Null, new Bug704813Type ());
|
|
}
|
|
|
|
[Test]
|
|
public void Bug708178Type()
|
|
{
|
|
string file = Path.Combine (Path.GetTempPath (), "Bug708178Type.xml");
|
|
XmlSerializer xmlSerializer = new XmlSerializer (typeof(Bug708178Type));
|
|
Bug708178Type bugType = new Bug708178Type ();
|
|
bugType.Foo.Add ("test");
|
|
Assert.AreEqual (1, bugType.Foo.Count);
|
|
|
|
//xml Serialize
|
|
TextWriter WriteFileStream = new StreamWriter (file, false);
|
|
xmlSerializer.Serialize (WriteFileStream, bugType);
|
|
WriteFileStream.Close ();
|
|
|
|
//xml Deserialize
|
|
FileStream ReadFileStream = new FileStream (file, FileMode.Open, FileAccess.Read, FileShare.Read);
|
|
Bug708178Type bugTypeReload = (Bug708178Type)xmlSerializer.Deserialize (ReadFileStream);
|
|
|
|
//should have deserialized the relationship
|
|
Assert.AreEqual(1, bugTypeReload.Foo.Count);
|
|
}
|
|
|
|
public class Employee : IXmlSerializable
|
|
{
|
|
private string _firstName;
|
|
private string _lastName;
|
|
private string _address;
|
|
|
|
public XmlSchema GetSchema ()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public void WriteXml (XmlWriter writer)
|
|
{
|
|
writer.WriteStartElement ("employee", "urn:devx-com");
|
|
writer.WriteAttributeString ("firstName", _firstName);
|
|
writer.WriteAttributeString ("lastName", _lastName);
|
|
writer.WriteAttributeString ("address", _address);
|
|
writer.WriteEndElement ();
|
|
}
|
|
|
|
public void ReadXml (XmlReader reader)
|
|
{
|
|
XmlNodeType type = reader.MoveToContent ();
|
|
if (type == XmlNodeType.Element && reader.LocalName == "employee") {
|
|
_firstName = reader["firstName"];
|
|
_lastName = reader["lastName"];
|
|
_address = reader["address"];
|
|
}
|
|
}
|
|
}
|
|
|
|
public class NestedStruct
|
|
{
|
|
public TimeSpan Period = TimeSpan.MaxValue;
|
|
}
|
|
|
|
public class ObjectEnumerable : IEnumerable
|
|
{
|
|
public void Add (int value)
|
|
{
|
|
}
|
|
|
|
public void Add (object value)
|
|
{
|
|
}
|
|
|
|
public IEnumerator GetEnumerator ()
|
|
{
|
|
return new ArrayList ().GetEnumerator ();
|
|
}
|
|
}
|
|
|
|
public class SimpleClassEnumerable : IEnumerable
|
|
{
|
|
public void Add (int value)
|
|
{
|
|
}
|
|
|
|
public void Add (object value)
|
|
{
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return GetEnumerator ();
|
|
}
|
|
|
|
public SimpleClassEnumerator GetEnumerator ()
|
|
{
|
|
return new SimpleClassEnumerator (new ArrayList ());
|
|
}
|
|
}
|
|
|
|
public class SimpleClassEnumerablePrivateGetEnumerator : IEnumerable
|
|
{
|
|
public void Add (object value)
|
|
{
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return new ArrayList ().GetEnumerator ();
|
|
}
|
|
}
|
|
|
|
public class SimpleClassEnumerablePrivateCurrent : IEnumerable
|
|
{
|
|
public void Add (object value)
|
|
{
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return GetEnumerator ();
|
|
}
|
|
|
|
public NoCurrentEnumerator GetEnumerator ()
|
|
{
|
|
return new NoCurrentEnumerator (new ArrayList ());
|
|
}
|
|
}
|
|
|
|
// GetEnumerator().Current returns object, but there's no corresponding
|
|
// Add (System.Object) method
|
|
public class ObjectEnumerableNoMatchingAddMethod : IEnumerable
|
|
{
|
|
public void Add (int value)
|
|
{
|
|
}
|
|
|
|
public IEnumerator GetEnumerator ()
|
|
{
|
|
return new ArrayList ().GetEnumerator ();
|
|
}
|
|
}
|
|
|
|
// GetEnumerator().Current returns SimpleClass, but there's no
|
|
// corresponding Add (SimpleClass) method
|
|
public class SimpleClassCollectionNoMatchingAddMethod : ICollection
|
|
{
|
|
public SimpleClass this[int index]
|
|
{
|
|
get
|
|
{
|
|
return (SimpleClass) _list[index];
|
|
}
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return _list.Count; }
|
|
}
|
|
|
|
public bool IsSynchronized
|
|
{
|
|
get { return _list.IsSynchronized; }
|
|
}
|
|
|
|
public object SyncRoot
|
|
{
|
|
get { return _list.SyncRoot; }
|
|
}
|
|
|
|
public void CopyTo (Array array, int index)
|
|
{
|
|
_list.CopyTo (array, index);
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return GetEnumerator ();
|
|
}
|
|
|
|
public SimpleClassEnumerator GetEnumerator ()
|
|
{
|
|
return new SimpleClassEnumerator (_list);
|
|
}
|
|
|
|
private ArrayList _list = new ArrayList ();
|
|
}
|
|
|
|
// GetEnumerator().Current returns object, but there's no corresponding
|
|
// Add (System.Object) method
|
|
public class ObjectCollectionNoMatchingAddMethod : ICollection
|
|
{
|
|
public object this[int index]
|
|
{
|
|
get
|
|
{
|
|
return _list[index];
|
|
}
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return _list.Count; }
|
|
}
|
|
|
|
public bool IsSynchronized
|
|
{
|
|
get { return _list.IsSynchronized; }
|
|
}
|
|
|
|
public object SyncRoot
|
|
{
|
|
get { return _list.SyncRoot; }
|
|
}
|
|
|
|
public void CopyTo (Array array, int index)
|
|
{
|
|
_list.CopyTo (array, index);
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return GetEnumerator ();
|
|
}
|
|
|
|
public IEnumerator GetEnumerator ()
|
|
{
|
|
return _list.GetEnumerator ();
|
|
}
|
|
|
|
private ArrayList _list = new ArrayList ();
|
|
}
|
|
|
|
// Does not have int indexer.
|
|
public class SimpleClassCollectionNoIntIndexer : ICollection
|
|
{
|
|
public SimpleClass this[string name]
|
|
{
|
|
get
|
|
{
|
|
return new SimpleClass ();
|
|
}
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return _list.Count; }
|
|
}
|
|
|
|
public bool IsSynchronized
|
|
{
|
|
get { return _list.IsSynchronized; }
|
|
}
|
|
|
|
public object SyncRoot
|
|
{
|
|
get { return _list.SyncRoot; }
|
|
}
|
|
|
|
public void CopyTo (Array array, int index)
|
|
{
|
|
_list.CopyTo (array, index);
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return GetEnumerator ();
|
|
}
|
|
|
|
public SimpleClassEnumerator GetEnumerator ()
|
|
{
|
|
return new SimpleClassEnumerator (_list);
|
|
}
|
|
|
|
public void Add (SimpleClass value)
|
|
{
|
|
_list.Add (value);
|
|
}
|
|
|
|
private ArrayList _list = new ArrayList ();
|
|
}
|
|
|
|
// Does not have int indexer.
|
|
public class ObjectCollectionNoIntIndexer : ICollection
|
|
{
|
|
public object this[string name]
|
|
{
|
|
get
|
|
{
|
|
return new SimpleClass ();
|
|
}
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return _list.Count; }
|
|
}
|
|
|
|
public bool IsSynchronized
|
|
{
|
|
get { return _list.IsSynchronized; }
|
|
}
|
|
|
|
public object SyncRoot
|
|
{
|
|
get { return _list.SyncRoot; }
|
|
}
|
|
|
|
public void CopyTo (Array array, int index)
|
|
{
|
|
_list.CopyTo (array, index);
|
|
}
|
|
|
|
public IEnumerator GetEnumerator ()
|
|
{
|
|
return _list.GetEnumerator ();
|
|
}
|
|
|
|
public void Add (object value)
|
|
{
|
|
_list.Add (value);
|
|
}
|
|
|
|
private ArrayList _list = new ArrayList ();
|
|
}
|
|
|
|
public class SimpleClassCollection : ICollection
|
|
{
|
|
public SimpleClass this[int index]
|
|
{
|
|
get
|
|
{
|
|
return (SimpleClass) _list[index];
|
|
}
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return _list.Count; }
|
|
}
|
|
|
|
public bool IsSynchronized
|
|
{
|
|
get { return _list.IsSynchronized; }
|
|
}
|
|
|
|
public object SyncRoot
|
|
{
|
|
get { return _list.SyncRoot; }
|
|
}
|
|
|
|
public void CopyTo (Array array, int index)
|
|
{
|
|
_list.CopyTo (array, index);
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return GetEnumerator ();
|
|
}
|
|
|
|
public SimpleClassEnumerator GetEnumerator ()
|
|
{
|
|
return new SimpleClassEnumerator (_list);
|
|
}
|
|
|
|
public void Add (SimpleClass value)
|
|
{
|
|
_list.Add (value);
|
|
}
|
|
|
|
private ArrayList _list = new ArrayList ();
|
|
}
|
|
|
|
public class ObjectCollection : ICollection
|
|
{
|
|
public object this[int name]
|
|
{
|
|
get
|
|
{
|
|
return new SimpleClass ();
|
|
}
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return _list.Count; }
|
|
}
|
|
|
|
public bool IsSynchronized
|
|
{
|
|
get { return _list.IsSynchronized; }
|
|
}
|
|
|
|
public object SyncRoot
|
|
{
|
|
get { return _list.SyncRoot; }
|
|
}
|
|
|
|
public void CopyTo (Array array, int index)
|
|
{
|
|
_list.CopyTo (array, index);
|
|
}
|
|
|
|
public IEnumerator GetEnumerator ()
|
|
{
|
|
return _list.GetEnumerator ();
|
|
}
|
|
|
|
public void Add (object value)
|
|
{
|
|
_list.Add (value);
|
|
}
|
|
|
|
private ArrayList _list = new ArrayList ();
|
|
}
|
|
|
|
public class SimpleClassEnumerator : IEnumerator
|
|
{
|
|
internal SimpleClassEnumerator (ArrayList arguments)
|
|
{
|
|
IEnumerable temp = (IEnumerable) (arguments);
|
|
_baseEnumerator = temp.GetEnumerator ();
|
|
}
|
|
public SimpleClass Current
|
|
{
|
|
get { return (SimpleClass) _baseEnumerator.Current; }
|
|
}
|
|
|
|
object IEnumerator.Current
|
|
{
|
|
get { return _baseEnumerator.Current; }
|
|
}
|
|
|
|
public bool MoveNext ()
|
|
{
|
|
return _baseEnumerator.MoveNext ();
|
|
}
|
|
|
|
bool IEnumerator.MoveNext ()
|
|
{
|
|
return _baseEnumerator.MoveNext ();
|
|
}
|
|
|
|
public void Reset ()
|
|
{
|
|
_baseEnumerator.Reset ();
|
|
}
|
|
|
|
void IEnumerator.Reset ()
|
|
{
|
|
_baseEnumerator.Reset ();
|
|
}
|
|
|
|
private IEnumerator _baseEnumerator;
|
|
}
|
|
|
|
public class NoCurrentEnumerator : IEnumerator
|
|
{
|
|
internal NoCurrentEnumerator (ArrayList arguments)
|
|
{
|
|
IEnumerable temp = (IEnumerable) (arguments);
|
|
_baseEnumerator = temp.GetEnumerator ();
|
|
}
|
|
|
|
object IEnumerator.Current
|
|
{
|
|
get { return _baseEnumerator.Current; }
|
|
}
|
|
|
|
public bool MoveNext ()
|
|
{
|
|
return _baseEnumerator.MoveNext ();
|
|
}
|
|
|
|
bool IEnumerator.MoveNext ()
|
|
{
|
|
return _baseEnumerator.MoveNext ();
|
|
}
|
|
|
|
public void Reset ()
|
|
{
|
|
_baseEnumerator.Reset ();
|
|
}
|
|
|
|
void IEnumerator.Reset ()
|
|
{
|
|
_baseEnumerator.Reset ();
|
|
}
|
|
|
|
private IEnumerator _baseEnumerator;
|
|
}
|
|
|
|
public class XmlArrayOnByteArrayType
|
|
{
|
|
[XmlArray]
|
|
[XmlArrayItem ("Byte", IsNullable =false)]
|
|
public byte [] Args;
|
|
}
|
|
|
|
public class NullableContainer
|
|
{
|
|
[XmlElement (IsNullable = true)]
|
|
public int? NilInt;
|
|
}
|
|
|
|
public class NullableContainer2
|
|
{
|
|
int? value;
|
|
|
|
public int? NullableInt {
|
|
get { return value; }
|
|
set { this.value = value; }
|
|
}
|
|
}
|
|
|
|
[XmlSchemaProvider ("GetXsdType")]
|
|
public class XmlSchemaProviderMissingMethodType : IXmlSerializable
|
|
{
|
|
public void ReadXml (XmlReader reader)
|
|
{
|
|
}
|
|
|
|
public void WriteXml (XmlWriter writer)
|
|
{
|
|
}
|
|
|
|
public XmlSchema GetSchema ()
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
[XmlSchemaProvider ("GetXsdType")]
|
|
public class XmlSchemaProviderNonStaticType : IXmlSerializable
|
|
{
|
|
public void ReadXml (XmlReader reader)
|
|
{
|
|
}
|
|
|
|
public void WriteXml (XmlWriter writer)
|
|
{
|
|
}
|
|
|
|
public XmlSchema GetSchema ()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public object GetXsdType ()
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
[XmlSchemaProvider ("GetXsdType")]
|
|
public class XmlSchemaProviderIncorrectReturnType : IXmlSerializable
|
|
{
|
|
public void ReadXml (XmlReader reader)
|
|
{
|
|
}
|
|
|
|
public void WriteXml (XmlWriter writer)
|
|
{
|
|
}
|
|
|
|
public XmlSchema GetSchema ()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public static object GetXsdType ()
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
[XmlSchemaProvider ("GetXsd")]
|
|
public class XmlSchemaProviderAndDefaultNamespaceType : IXmlSerializable
|
|
{
|
|
public static XmlQualifiedName GetXsd (XmlSchemaSet xss)
|
|
{
|
|
XmlSchema xs = new XmlSchema ();
|
|
xs.TargetNamespace = "urn:foo";
|
|
XmlSchemaComplexType ct = new XmlSchemaComplexType ();
|
|
ct.Name = "foo";
|
|
xs.Items.Add (ct);
|
|
xss.Add (xs);
|
|
return new XmlQualifiedName ("foo", "urn:foo");
|
|
}
|
|
|
|
public void WriteXml (XmlWriter write)
|
|
{
|
|
}
|
|
|
|
public void ReadXml (XmlReader reader)
|
|
{
|
|
}
|
|
|
|
public XmlSchema GetSchema ()
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public class MyCollection : ICollection<string>
|
|
{
|
|
public int Count { get { return 0; } }
|
|
|
|
public bool IsReadOnly { get { return false; } }
|
|
|
|
public void Add (string s)
|
|
{
|
|
}
|
|
|
|
public void Clear ()
|
|
{
|
|
}
|
|
|
|
public bool Contains (string item)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public void CopyTo (string [] array, int arrayIndex)
|
|
{
|
|
}
|
|
|
|
public IEnumerator<string> GetEnumerator ()
|
|
{
|
|
throw new Exception ();
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return GetEnumerator ();
|
|
}
|
|
|
|
public bool Remove (string item)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class Bug594490Class
|
|
{
|
|
[XmlAttribute ("xml:lang")]
|
|
public string GroupName;
|
|
}
|
|
|
|
[Test]
|
|
public void Bug594490_SerializationOfXmlLangAttribute ()
|
|
{
|
|
var serializer = new XmlSerializer (typeof(Bug594490Class));
|
|
|
|
using (var writer = new StringWriter ()) {
|
|
var obj = new Bug594490Class ();
|
|
|
|
obj.GroupName = "hello world";
|
|
|
|
serializer.Serialize (writer, obj);
|
|
writer.Close ();
|
|
|
|
Assert.AreEqual (@"<?xml version=""1.0"" encoding=""utf-16""?>" + Environment.NewLine +
|
|
@"<Bug594490Class xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xml:lang=""hello world"" />",
|
|
writer.ToString (),
|
|
"Novell bug #594490 (https://bugzilla.novell.com/show_bug.cgi?id=594490) not fixed.");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The following code was generated from Microsoft's xsd.exe with the /classes switch.
|
|
* It only includes the relevent details but was based on the following namespaces:
|
|
* urn:oasis:names:tc:SAML:2.0:protocol
|
|
* urn:oasis:names:tc:SAML:2.0:assertion
|
|
* http://www.w3.org/2000/09/xmldsig#
|
|
* http://www.w3.org/2001/04/xmlenc
|
|
*/
|
|
|
|
[XmlTypeAttribute (Namespace = "urn:oasis:names:tc:SAML:2.0:protocol")]
|
|
[XmlRootAttribute ("RequestedAuthnContext", Namespace = "urn:oasis:names:tc:SAML:2.0:protocol", IsNullable = false)]
|
|
public class RequestedAuthnContext
|
|
{
|
|
string[] items;
|
|
ItemsChoice7[] itemsElementName;
|
|
|
|
[XmlElementAttribute ("AuthnContextClassRef", typeof (string), Namespace = "urn:oasis:names:tc:SAML:2.0:assertion", DataType = "anyURI")]
|
|
[XmlElementAttribute ("AuthnContextDeclRef", typeof (string), Namespace = "urn:oasis:names:tc:SAML:2.0:assertion", DataType = "anyURI")]
|
|
[XmlChoiceIdentifierAttribute ("ItemsElementName")]
|
|
public string[] Items {
|
|
get { return this.items; }
|
|
set { this.items = value; }
|
|
}
|
|
|
|
[XmlElementAttribute ("ItemsElementName")]
|
|
[XmlIgnoreAttribute ()]
|
|
public ItemsChoice7[] ItemsElementName {
|
|
get { return this.itemsElementName; }
|
|
set { this.itemsElementName = value; }
|
|
}
|
|
}
|
|
|
|
[XmlTypeAttribute (Namespace = "urn:oasis:names:tc:SAML:2.0:protocol", IncludeInSchema = false)]
|
|
public enum ItemsChoice7 {
|
|
[XmlEnumAttribute ("urn:oasis:names:tc:SAML:2.0:assertion:AuthnContextClassRef")]
|
|
AuthnContextClassRef,
|
|
[XmlEnumAttribute ("urn:oasis:names:tc:SAML:2.0:assertion:AuthnContextDeclRef")]
|
|
AuthnContextDeclRef,
|
|
}
|
|
// End snippet from xsd.exe
|
|
|
|
[Test]
|
|
public void FullyQualifiedName_XmlEnumAttribute ()
|
|
{
|
|
var serializer = new XmlSerializer (typeof (RequestedAuthnContext));
|
|
}
|
|
}
|
|
}
|
|
|