-//\r
-// System.Xml.Serialization.XmlReflectionImporterTests\r
-//\r
-// Author:\r
-// Erik LeBel (eriklebel@yahoo.ca)\r
-//\r
-// (C) 2003 Erik LeBel\r
-// \r
-// FIXME test some of these with Xml Attributes attached to some members: \r
-// do the names get carried over to Element for XmlAttributeAttribute and XmlElementAttribute?\r
-// \r
-\r
-using System;\r
-using System.Collections;\r
-using System.Xml;\r
-using System.Xml.Schema;\r
-using System.Xml.Serialization;\r
-\r
-using NUnit.Framework;\r
-\r
-using MonoTests.System.Xml.TestClasses;\r
-\r
-namespace MonoTests.System.XmlSerialization\r
-{\r
- // debugging class\r
- internal class Debug\r
- {\r
- public static void Print(XmlTypeMapping tm)\r
- {\r
- Console.WriteLine("/XmlTypeMapping:");\r
- Console.WriteLine("ElementName: {0} ", tm.ElementName);\r
- Console.WriteLine("Namespace: {0} ", tm.Namespace);\r
- Console.WriteLine("TypeName: {0} ", tm.TypeName);\r
- Console.WriteLine("FullTypeName: {0} ", tm.TypeFullName);\r
- }\r
-\r
- public static void Print(XmlMemberMapping mm)\r
- {\r
- Console.WriteLine("/XmlMemberMapping:");\r
- Console.WriteLine("Any: {0} ", mm.Any);\r
- Console.WriteLine("ElementName: {0} ", mm.ElementName);\r
- Console.WriteLine("MemberName: {0} ", mm.MemberName);\r
- Console.WriteLine("Namespace: {0} ", mm.Namespace);\r
- Console.WriteLine("TypeFullName: {0} ", mm.TypeFullName);\r
- Console.WriteLine("TypeName: {0} ", mm.TypeName);\r
- Console.WriteLine("TypeNamespace: {0} ", mm.TypeNamespace);\r
- }\r
- }\r
-\r
- [TestFixture]\r
- public class XmlReflectionImporterTests\r
- {\r
- private const string SomeNamespace = "some:urn";\r
- private const string AnotherNamespace = "another:urn";\r
- private const string XmlSchemaNamespace = "http://www.w3.org/2001/XMLSchema";\r
-\r
- // these Map methods re-create the XmlReflectionImporter at every call.\r
-\r
- private XmlTypeMapping Map(Type t)\r
- {\r
- XmlReflectionImporter ri = new XmlReflectionImporter();\r
- XmlTypeMapping tm = ri.ImportTypeMapping(t);\r
- //Debug.Print(tm);\r
-\r
- return tm;\r
- }\r
-\r
- private XmlTypeMapping Map(Type t, XmlRootAttribute root)\r
- {\r
- XmlReflectionImporter ri = new XmlReflectionImporter();\r
- XmlTypeMapping tm = ri.ImportTypeMapping(t, root);\r
-\r
- return tm;\r
- }\r
-\r
- private XmlTypeMapping Map(Type t, string ns)\r
- {\r
- XmlReflectionImporter ri = new XmlReflectionImporter(ns);\r
- XmlTypeMapping tm = ri.ImportTypeMapping(t);\r
- //Debug.Print(tm);\r
-\r
- return tm;\r
- }\r
-\r
- private XmlTypeMapping Map (Type t, string ns, XmlRootAttribute root)\r
- {\r
- XmlReflectionImporter ri = new XmlReflectionImporter (ns);\r
- XmlTypeMapping tm = ri.ImportTypeMapping (t, root);\r
-\r
- return tm;\r
- }\r
-\r
- private XmlTypeMapping Map(Type t, XmlAttributeOverrides overrides)\r
- {\r
- XmlReflectionImporter ri = new XmlReflectionImporter(overrides);\r
- XmlTypeMapping tm = ri.ImportTypeMapping(t);\r
- //Debug.Print(tm);\r
-\r
- return tm;\r
- }\r
-\r
- private XmlMembersMapping MembersMap(Type t, XmlAttributeOverrides overrides, \r
- XmlReflectionMember [] members, bool inContainer)\r
- {\r
- XmlReflectionImporter ri = new XmlReflectionImporter(overrides);\r
- XmlMembersMapping mm = ri.ImportMembersMapping(null, null, members, inContainer);\r
- \r
- return mm;\r
- }\r
- \r
- [Test]\r
- public void TestIntTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(int));\r
- Assert.AreEqual ("int", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Int32", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestIntTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map(typeof(int[]));\r
- Assert.AreEqual ("ArrayOfInt", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfInt32", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("Int32[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("System.Int32[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (int[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfInt", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfInt32", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("Int32[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.Int32[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (int[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfInt", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfInt32", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("Int32[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.Int32[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestStringTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(string));\r
- Assert.AreEqual ("string", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("String", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.String", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestStringTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (string[]));\r
- Assert.AreEqual ("ArrayOfString", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfString", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("String[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("System.String[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (string[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfString", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfString", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("String[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.String[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (string[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("String[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.String[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestObjectTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(object));\r
- Assert.AreEqual ("anyType", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Object", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Object", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestObjectTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (object[]));\r
- Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfObject", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("Object[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("System.Object[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (object[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfObject", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("Object[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.Object[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (object[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfObject", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("Object[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.Object[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestByteTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(byte));\r
- Assert.AreEqual ("unsignedByte", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Byte", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Byte", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestByteTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map(typeof(byte[]));\r
- Assert.AreEqual ("base64Binary", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
- Assert.AreEqual ("Byte[]", tm.TypeName, "#A3");\r
- Assert.AreEqual ("System.Byte[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (byte[][]));\r
- Assert.AreEqual ("ArrayOfBase64Binary", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfByte", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("Byte[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.Byte[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (byte[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfBase64Binary", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfByte", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("Byte[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.Byte[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestBoolTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(bool));\r
- Assert.AreEqual ("boolean", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Boolean", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Boolean", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
- public void TestShortTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(short));\r
- Assert.AreEqual ("short", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Int16", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Int16", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
- public void TestUnsignedShortTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(ushort));\r
- Assert.AreEqual ("unsignedShort", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("UInt16", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.UInt16", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- public void TestUIntTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(uint));\r
- Assert.AreEqual ("unsignedInt", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("UInt32", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.UInt32", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- public void TestLongTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(long));\r
- Assert.AreEqual ("long", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Int64", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Int64", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- public void TestULongTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(ulong));\r
- Assert.AreEqual ("unsignedLong", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("UInt64", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.UInt64", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- public void TestFloatTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(float));\r
- Assert.AreEqual ("float", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Single", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Single", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- public void TestDoubleTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(double));\r
- Assert.AreEqual ("double", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Double", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Double", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- public void TestDateTimeTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(DateTime));\r
- Assert.AreEqual ("dateTime", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("DateTime", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.DateTime", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestDateTimeTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (DateTime[]));\r
- Assert.AreEqual ("ArrayOfDateTime", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfDateTime", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("DateTime[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("System.DateTime[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (DateTime[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("DateTime[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.DateTime[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (DateTime[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("DateTime[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.DateTime[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestGuidTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(Guid));\r
- Assert.AreEqual ("guid", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Guid", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Guid", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestGuidTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (Guid[]));\r
- Assert.AreEqual ("ArrayOfGuid", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfGuid", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("Guid[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("System.Guid[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (Guid[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfGuid", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfGuid", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("Guid[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.Guid[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (Guid[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("Guid[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.Guid[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestDecimalTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(decimal));\r
- Assert.AreEqual ("decimal", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Decimal", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Decimal", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- public void TestXmlQualifiedNameTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(XmlQualifiedName));\r
- Assert.AreEqual ("QName", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("XmlQualifiedName", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Xml.XmlQualifiedName", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- public void TestSByteTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(sbyte));\r
- Assert.AreEqual ("byte", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("SByte", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.SByte", tm.TypeFullName, "#4");\r
- }\r
- \r
-\r
- [Test]\r
- public void TestCharTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map(typeof(char));\r
- Assert.AreEqual ("char", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Char", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Char", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestCharTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (char[]));\r
- Assert.AreEqual ("ArrayOfChar", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfChar", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("Char[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("System.Char[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (char[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfChar", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfChar", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("Char[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.Char[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (char[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("Char[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.Char[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
- public void TestXmlNodeTypeMapping ()\r
- {\r
- Type type = typeof (XmlNode);\r
-\r
- XmlTypeMapping tm = Map (type);\r
- Assert.AreEqual (string.Empty, tm.ElementName, "#A1");\r
- Assert.IsNull (tm.Namespace, "#A2");\r
- Assert.AreEqual ("XmlNode", tm.TypeName, "#A3");\r
- Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (type, AnotherNamespace);\r
- Assert.AreEqual (string.Empty, tm.ElementName, "#B1");\r
- Assert.IsNull (tm.Namespace, "#B2");\r
- Assert.AreEqual ("XmlNode", tm.TypeName, "#B3");\r
- Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#B4");\r
-\r
- XmlRootAttribute root = new XmlRootAttribute ("somename");\r
- root.Namespace = SomeNamespace;\r
- tm = Map (type, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#C1");\r
- Assert.IsNull (tm.Namespace, "#C2");\r
- Assert.AreEqual ("XmlNode", tm.TypeName, "#C3");\r
- Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#C4");\r
-\r
- tm = Map (type, AnotherNamespace, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#D1");\r
- Assert.IsNull (tm.Namespace, "#D2");\r
- Assert.AreEqual ("XmlNode", tm.TypeName, "#D3");\r
- Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#D4");\r
-\r
- root.Namespace = null;\r
- tm = Map (type, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#E1");\r
- Assert.IsNull (tm.Namespace, "#E2");\r
- Assert.AreEqual ("XmlNode", tm.TypeName, "#E3");\r
- Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#E4");\r
-\r
- tm = Map (type, AnotherNamespace, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#F1");\r
- Assert.IsNull (tm.Namespace, "#F2");\r
- Assert.AreEqual ("XmlNode", tm.TypeName, "#F3");\r
- Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#F4");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
- public void TestXmlElementTypeMapping ()\r
- {\r
- Type type = typeof (XmlElement);\r
-\r
- XmlTypeMapping tm = Map (type);\r
- Assert.AreEqual (string.Empty, tm.ElementName, "#1");\r
- Assert.IsNull (tm.Namespace, "#2");\r
- Assert.AreEqual ("XmlElement", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#4");\r
-\r
- tm = Map (type, AnotherNamespace);\r
- Assert.AreEqual (string.Empty, tm.ElementName, "#B1");\r
- Assert.IsNull (tm.Namespace, "#B2");\r
- Assert.AreEqual ("XmlElement", tm.TypeName, "#B3");\r
- Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#B4");\r
-\r
- XmlRootAttribute root = new XmlRootAttribute ("somename");\r
- root.Namespace = SomeNamespace;\r
- tm = Map (type, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#C1");\r
- Assert.IsNull (tm.Namespace, "#C2");\r
- Assert.AreEqual ("XmlElement", tm.TypeName, "#C3");\r
- Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#C4");\r
-\r
- tm = Map (type, AnotherNamespace, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#D1");\r
- Assert.IsNull (tm.Namespace, "#D2");\r
- Assert.AreEqual ("XmlElement", tm.TypeName, "#D3");\r
- Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#D4");\r
-\r
- root.Namespace = null;\r
- tm = Map (type, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#E1");\r
- Assert.IsNull (tm.Namespace, "#E2");\r
- Assert.AreEqual ("XmlElement", tm.TypeName, "#E3");\r
- Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#E4");\r
-\r
- tm = Map (type, AnotherNamespace, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#F1");\r
- Assert.IsNull (tm.Namespace, "#F2");\r
- Assert.AreEqual ("XmlElement", tm.TypeName, "#F3");\r
- Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#F4");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
- public void TestXmlNotationTypeMapping ()\r
- {\r
- Type type = typeof (XmlNotation);\r
-\r
- XmlTypeMapping tm = Map (type);\r
- Assert.AreEqual (string.Empty, tm.ElementName, "#1");\r
- Assert.IsNull (tm.Namespace, "#2");\r
- Assert.AreEqual ("XmlNotation", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#4");\r
-\r
- tm = Map (type, AnotherNamespace);\r
- Assert.AreEqual (string.Empty, tm.ElementName, "#B1");\r
- Assert.IsNull (tm.Namespace, "#B2");\r
- Assert.AreEqual ("XmlNotation", tm.TypeName, "#B3");\r
- Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#B4");\r
-\r
- XmlRootAttribute root = new XmlRootAttribute ("somename");\r
- root.Namespace = SomeNamespace;\r
- tm = Map (type, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#C1");\r
- Assert.IsNull (tm.Namespace, "#C2");\r
- Assert.AreEqual ("XmlNotation", tm.TypeName, "#C3");\r
- Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#C4");\r
-\r
- tm = Map (type, AnotherNamespace, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#D1");\r
- Assert.IsNull (tm.Namespace, "#D2");\r
- Assert.AreEqual ("XmlNotation", tm.TypeName, "#D3");\r
- Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#D4");\r
-\r
- root.Namespace = null;\r
- tm = Map (type, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#E1");\r
- Assert.IsNull (tm.Namespace, "#E2");\r
- Assert.AreEqual ("XmlNotation", tm.TypeName, "#E3");\r
- Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#E4");\r
-\r
- tm = Map (type, AnotherNamespace, root);\r
- Assert.AreEqual ("somename", tm.ElementName, "#F1");\r
- Assert.IsNull (tm.Namespace, "#F2");\r
- Assert.AreEqual ("XmlNotation", tm.TypeName, "#F3");\r
- Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#F4");\r
- }\r
-\r
- [Test]\r
- public void TestXmlSerializableTypeMapping ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (Employee));\r
- Assert.AreEqual ("Employee", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("Employee", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestXmlSerializableTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (Employee[]));\r
- Assert.AreEqual ("ArrayOfEmployee", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfEmployee", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("Employee[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (Employee[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("Employee[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (Employee[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("Employee[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestClassTypeMapping_NestedStruct ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (NestedStruct));\r
- Assert.AreEqual ("NestedStruct", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("NestedStruct", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.NestedStruct", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentNullException))]\r
- public void TestNullTypeMapping()\r
- {\r
- Map(null);\r
- }\r
-\r
- [Test]\r
- public void TestIntTypeMappingWithDefaultNamespaces()\r
- {\r
- XmlTypeMapping tm = Map(typeof(int), SomeNamespace);\r
- Assert.AreEqual ("int", tm.ElementName, "#1");\r
- Assert.AreEqual (SomeNamespace, tm.Namespace, "#2");\r
- Assert.AreEqual ("Int32", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
- public void TestStructTypeMapping ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (TimeSpan));\r
- Assert.AreEqual ("TimeSpan", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("TimeSpan", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.TimeSpan", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
- public void TestStructTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (TimeSpan[]));\r
- Assert.AreEqual ("ArrayOfTimeSpan", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfTimeSpan", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("TimeSpan[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("System.TimeSpan[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (TimeSpan[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("TimeSpan[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.TimeSpan[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (TimeSpan[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("TimeSpan[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.TimeSpan[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestEnumTypeMapping ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (AttributeTargets));\r
- Assert.AreEqual ("AttributeTargets", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("AttributeTargets", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.AttributeTargets", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestEnumTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (AttributeTargets[]));\r
- Assert.AreEqual ("ArrayOfAttributeTargets", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfAttributeTargets", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("AttributeTargets[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("System.AttributeTargets[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (AttributeTargets[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("AttributeTargets[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("System.AttributeTargets[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (AttributeTargets[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("AttributeTargets[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("System.AttributeTargets[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- public void TestClassTypeMapping()\r
- {\r
- XmlTypeMapping tm = Map (typeof (SimpleClass));\r
- Assert.AreEqual ("SimpleClass", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("SimpleClass", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass", tm.TypeFullName, "#4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TestClassTypeMapping_Array ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (SimpleClass[]));\r
- Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfSimpleClass", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("SimpleClass[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (SimpleClass[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("SimpleClass[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (SimpleClass[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("SimpleClass[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (NotSupportedException))]\r
- public void TypeMapping_IDictionary ()\r
- {\r
- // The type MonoTests.System.Xml.TestClasses.DictionaryWithIndexer \r
- // is not supported because it implements IDictionary.\r
- Map (typeof (DictionaryWithIndexer));\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TypeMapping_IEnumerable_SimpleClass ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (SimpleClassEnumerable));\r
- Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("SimpleClassEnumerable", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable", tm.TypeFullName, "#4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerable[]));\r
- Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfSimpleClassEnumerable", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerable[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerable[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerable[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerable[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerable[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TypeMapping_IEnumerable_Object ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (ObjectEnumerable));\r
- Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("ObjectEnumerable", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable", tm.TypeFullName, "#4");\r
-\r
- tm = Map (typeof (ObjectEnumerable[]));\r
- Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfObjectEnumerable", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("ObjectEnumerable[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (ObjectEnumerable[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfObjectEnumerable", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("ObjectEnumerable[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (ObjectEnumerable[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectEnumerable", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("ObjectEnumerable[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_IEnumerable_Object_NoMatchingAddMethod ()\r
- {\r
- Map (typeof (ObjectEnumerableNoMatchingAddMethod));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_IEnumerable_Object_NoMatchingAddMethod_Array ()\r
- {\r
- Map (typeof (ObjectEnumerableNoMatchingAddMethod[]));\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TypeMapping_IEnumerable_SimpleClass_PrivateCurrent ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (SimpleClassEnumerablePrivateCurrent));\r
- Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent", tm.TypeFullName, "#4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[]));\r
- Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
-#if ONLY_1_1\r
- [Category ("NotDotNet")] // results in NullReferenceException in .NET 1.1 (SP1)\r
-#endif\r
- public void TypeMapping_IEnumerable_SimpleClass_PrivateGetEnumerator ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator));\r
- Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator", tm.TypeFullName, "#4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[]));\r
- Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_ICollection_Object_NoMatchingAddMethod ()\r
- {\r
- Map (typeof (ObjectCollectionNoMatchingAddMethod));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_ICollection_Object_NoMatchingAddMethod_Array ()\r
- {\r
- Map (typeof (ObjectCollectionNoMatchingAddMethod[]));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod ()\r
- {\r
- Map (typeof (SimpleClassCollectionNoMatchingAddMethod));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod_Array ()\r
- {\r
- Map (typeof (SimpleClassCollectionNoMatchingAddMethod[]));\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TypeMapping_ICollection_SimpleClass ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (SimpleClassCollection));\r
- Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("SimpleClassCollection", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection", tm.TypeFullName, "#4");\r
-\r
- tm = Map (typeof (SimpleClassCollection[]));\r
- Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfSimpleClassCollection", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("SimpleClassCollection[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (SimpleClassCollection[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("SimpleClassCollection[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (SimpleClassCollection[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("SimpleClassCollection[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
-#if NET_2_0\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
-#endif\r
- public void TypeMapping_ICollection_Object ()\r
- {\r
- XmlTypeMapping tm = Map (typeof (ObjectCollection));\r
- Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
- Assert.AreEqual ("ObjectCollection", tm.TypeName, "#3");\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection", tm.TypeFullName, "#4");\r
-\r
- tm = Map (typeof (ObjectCollection[]));\r
- Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfObjectCollection", tm.TypeName, "#A3");\r
-#else\r
- Assert.AreEqual ("ObjectCollection[]", tm.TypeName, "#A3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[]", tm.TypeFullName, "#A4");\r
-\r
- tm = Map (typeof (ObjectCollection[][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfObjectCollection", tm.TypeName, "#B3");\r
-#else\r
- Assert.AreEqual ("ObjectCollection[][]", tm.TypeName, "#B3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[][]", tm.TypeFullName, "#B4");\r
-\r
- tm = Map (typeof (ObjectCollection[][][]));\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
- Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
-#if NET_2_0\r
- Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectCollection", tm.TypeName, "#C3");\r
-#else\r
- Assert.AreEqual ("ObjectCollection[][][]", tm.TypeName, "#C3");\r
-#endif\r
- Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[][][]", tm.TypeFullName, "#C4");\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_ICollection_Object_NoIntIndexer ()\r
- {\r
- Map (typeof (ObjectCollectionNoIntIndexer));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_ICollection_Object_NoIntIndexer_Array ()\r
- {\r
- Map (typeof (ObjectCollectionNoIntIndexer[]));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_ICollection_SimpleClass_NoIntIndexer ()\r
- {\r
- Map (typeof (SimpleClassCollectionNoIntIndexer));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TypeMapping_ICollection_SimpleClass_NoIntIndexer_Array ()\r
- {\r
- Map (typeof (SimpleClassCollectionNoIntIndexer[]));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))] \r
- public void TypeMapping_WrongChoices ()\r
- {\r
- // Type MonoTests.System.Xml.TestClasses.ItemChoiceType is missing \r
- // enumeration value 'StrangeOne' for element 'StrangeOne' from\r
- // namespace ''.\r
- Map (typeof (WrongChoices));\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn\r
- public void TestImportMembersMapping()\r
- {\r
- Type type = typeof(SimpleClass);\r
- XmlAttributes attrs = new XmlAttributes();\r
- XmlAttributeOverrides overrides = new XmlAttributeOverrides();\r
- overrides.Add(typeof(SimpleClass), attrs);\r
-\r
- XmlReflectionMember[] members = new XmlReflectionMember[0];\r
- XmlMembersMapping mm;\r
- try\r
- {\r
- mm = MembersMap(type, overrides, members, true);\r
- Assert.Fail("Should not be able to fetch an empty XmlMembersMapping");\r
- }\r
- catch (Exception)\r
- {\r
- }\r
- \r
- XmlReflectionMember rm = new XmlReflectionMember();\r
- rm.IsReturnValue = false;\r
- rm.MemberName = "something";\r
- rm.MemberType = typeof(string);\r
- members = new XmlReflectionMember[1];\r
- members[0] = rm;\r
-\r
- mm = MembersMap(type, overrides, members, false);\r
-\r
- Equals(mm.Count, 1);\r
-\r
- XmlMemberMapping smm = mm[0];\r
- Assert.IsFalse (smm.Any, "#1");\r
- Assert.AreEqual ("something", smm.ElementName, "#2");\r
- Assert.AreEqual ("something", smm.MemberName, "#3");\r
- Assert.IsNull (smm.Namespace, "#4");\r
- Assert.AreEqual ("System.String", smm.TypeFullName, "#5");\r
- Assert.AreEqual ("string", smm.TypeName, "#6");\r
-#if NET_2_0\r
- Assert.AreEqual (XmlSchemaNamespace, smm.TypeNamespace, "#7");\r
-#else\r
- Assert.IsNull (smm.TypeNamespace, "#7");\r
-#endif\r
-\r
- rm = new XmlReflectionMember();\r
- rm.IsReturnValue = false;\r
- rm.MemberName = "nothing";\r
- rm.MemberType = typeof(string);\r
- members = new XmlReflectionMember[1];\r
- members[0] = rm;\r
-\r
- mm = MembersMap(type, overrides, members, false);\r
- Assert.AreEqual (1, mm.Count, "#8");\r
- }\r
-\r
- [Test]\r
- public void TestIntTypeMappingWithXmlRootAttribute()\r
- {\r
- const string TheNamespace = "another:urn";\r
- XmlRootAttribute root = new XmlRootAttribute("price");\r
- root.Namespace = TheNamespace;\r
- \r
- XmlTypeMapping tm = Map(typeof(int), root);\r
- Assert.AreEqual ("price", tm.ElementName, "#1");\r
- Assert.AreEqual (TheNamespace, tm.Namespace, "#2");\r
- Assert.AreEqual ("Int32", tm.TypeName, "#3");\r
- Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");\r
- }\r
- \r
- [Test]\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TestSerializeWrongChoice ()\r
- {\r
- new XmlSerializer (typeof(WrongChoices));\r
- }\r
-\r
- public class Employee : IXmlSerializable\r
- {\r
- private string _firstName;\r
- private string _lastName;\r
- private string _address;\r
-\r
- public XmlSchema GetSchema ()\r
- {\r
- return null;\r
- }\r
-\r
- public void WriteXml (XmlWriter writer)\r
- {\r
- writer.WriteStartElement ("employee", "urn:devx-com");\r
- writer.WriteAttributeString ("firstName", _firstName);\r
- writer.WriteAttributeString ("lastName", _lastName);\r
- writer.WriteAttributeString ("address", _address);\r
- writer.WriteEndElement ();\r
- }\r
-\r
- public void ReadXml (XmlReader reader)\r
- {\r
- XmlNodeType type = reader.MoveToContent ();\r
- if (type == XmlNodeType.Element && reader.LocalName == "employee") {\r
- _firstName = reader["firstName"];\r
- _lastName = reader["lastName"];\r
- _address = reader["address"];\r
- }\r
- }\r
- }\r
-\r
- public class NestedStruct\r
- {\r
- public TimeSpan Period = TimeSpan.MaxValue;\r
- }\r
-\r
- public class ObjectEnumerable : IEnumerable\r
- {\r
- public void Add (int value)\r
- {\r
- }\r
-\r
- public void Add (object value)\r
- {\r
- }\r
-\r
- public IEnumerator GetEnumerator ()\r
- {\r
- return new ArrayList ().GetEnumerator ();\r
- }\r
- }\r
-\r
- public class SimpleClassEnumerable : IEnumerable\r
- {\r
- public void Add (int value)\r
- {\r
- }\r
-\r
- public void Add (object value)\r
- {\r
- }\r
-\r
- IEnumerator IEnumerable.GetEnumerator ()\r
- {\r
- return GetEnumerator ();\r
- }\r
-\r
- public SimpleClassEnumerator GetEnumerator ()\r
- {\r
- return new SimpleClassEnumerator (new ArrayList ());\r
- }\r
- }\r
-\r
- public class SimpleClassEnumerablePrivateGetEnumerator : IEnumerable\r
- {\r
- public void Add (object value)\r
- {\r
- }\r
-\r
- IEnumerator IEnumerable.GetEnumerator ()\r
- {\r
- return new ArrayList ().GetEnumerator ();\r
- }\r
- }\r
-\r
- public class SimpleClassEnumerablePrivateCurrent : IEnumerable\r
- {\r
- public void Add (object value)\r
- {\r
- }\r
-\r
- IEnumerator IEnumerable.GetEnumerator ()\r
- {\r
- return GetEnumerator ();\r
- }\r
-\r
- public NoCurrentEnumerator GetEnumerator ()\r
- {\r
- return new NoCurrentEnumerator (new ArrayList ());\r
- }\r
- }\r
-\r
- // GetEnumerator().Current returns object, but there's no corresponding\r
- // Add (System.Object) method\r
- public class ObjectEnumerableNoMatchingAddMethod : IEnumerable\r
- {\r
- public void Add (int value)\r
- {\r
- }\r
-\r
- public IEnumerator GetEnumerator ()\r
- {\r
- return new ArrayList ().GetEnumerator ();\r
- }\r
- }\r
-\r
- // GetEnumerator().Current returns SimpleClass, but there's no \r
- // corresponding Add (SimpleClass) method\r
- public class SimpleClassCollectionNoMatchingAddMethod : ICollection\r
- {\r
- public SimpleClass this[int index]\r
- {\r
- get\r
- {\r
- return (SimpleClass) _list[index];\r
- }\r
- }\r
-\r
- public int Count\r
- {\r
- get { return _list.Count; }\r
- }\r
-\r
- public bool IsSynchronized\r
- {\r
- get { return _list.IsSynchronized; }\r
- }\r
-\r
- public object SyncRoot\r
- {\r
- get { return _list.SyncRoot; }\r
- }\r
-\r
- public void CopyTo (Array array, int index)\r
- {\r
- _list.CopyTo (array, index);\r
- }\r
-\r
- IEnumerator IEnumerable.GetEnumerator ()\r
- {\r
- return GetEnumerator ();\r
- }\r
-\r
- public SimpleClassEnumerator GetEnumerator ()\r
- {\r
- return new SimpleClassEnumerator (_list);\r
- }\r
-\r
- private ArrayList _list = new ArrayList ();\r
- }\r
-\r
- // GetEnumerator().Current returns object, but there's no corresponding\r
- // Add (System.Object) method\r
- public class ObjectCollectionNoMatchingAddMethod : ICollection\r
- {\r
- public object this[int index]\r
- {\r
- get\r
- {\r
- return _list[index];\r
- }\r
- }\r
-\r
- public int Count\r
- {\r
- get { return _list.Count; }\r
- }\r
-\r
- public bool IsSynchronized\r
- {\r
- get { return _list.IsSynchronized; }\r
- }\r
-\r
- public object SyncRoot\r
- {\r
- get { return _list.SyncRoot; }\r
- }\r
-\r
- public void CopyTo (Array array, int index)\r
- {\r
- _list.CopyTo (array, index);\r
- }\r
-\r
- IEnumerator IEnumerable.GetEnumerator ()\r
- {\r
- return GetEnumerator ();\r
- }\r
-\r
- public IEnumerator GetEnumerator ()\r
- {\r
- return _list.GetEnumerator ();\r
- }\r
-\r
- private ArrayList _list = new ArrayList ();\r
- }\r
-\r
- // Does not have int indexer.\r
- public class SimpleClassCollectionNoIntIndexer : ICollection\r
- {\r
- public SimpleClass this[string name]\r
- {\r
- get\r
- {\r
- return new SimpleClass ();\r
- }\r
- }\r
-\r
- public int Count\r
- {\r
- get { return _list.Count; }\r
- }\r
-\r
- public bool IsSynchronized\r
- {\r
- get { return _list.IsSynchronized; }\r
- }\r
-\r
- public object SyncRoot\r
- {\r
- get { return _list.SyncRoot; }\r
- }\r
-\r
- public void CopyTo (Array array, int index)\r
- {\r
- _list.CopyTo (array, index);\r
- }\r
-\r
- IEnumerator IEnumerable.GetEnumerator ()\r
- {\r
- return GetEnumerator ();\r
- }\r
-\r
- public SimpleClassEnumerator GetEnumerator ()\r
- {\r
- return new SimpleClassEnumerator (_list);\r
- }\r
-\r
- public void Add (SimpleClass value)\r
- {\r
- _list.Add (value);\r
- }\r
-\r
- private ArrayList _list = new ArrayList ();\r
- }\r
-\r
- // Does not have int indexer.\r
- public class ObjectCollectionNoIntIndexer : ICollection\r
- {\r
- public object this[string name]\r
- {\r
- get\r
- {\r
- return new SimpleClass ();\r
- }\r
- }\r
-\r
- public int Count\r
- {\r
- get { return _list.Count; }\r
- }\r
-\r
- public bool IsSynchronized\r
- {\r
- get { return _list.IsSynchronized; }\r
- }\r
-\r
- public object SyncRoot\r
- {\r
- get { return _list.SyncRoot; }\r
- }\r
-\r
- public void CopyTo (Array array, int index)\r
- {\r
- _list.CopyTo (array, index);\r
- }\r
-\r
- public IEnumerator GetEnumerator ()\r
- {\r
- return _list.GetEnumerator ();\r
- }\r
-\r
- public void Add (object value)\r
- {\r
- _list.Add (value);\r
- }\r
-\r
- private ArrayList _list = new ArrayList ();\r
- }\r
-\r
- public class SimpleClassCollection : ICollection\r
- {\r
- public SimpleClass this[int index]\r
- {\r
- get\r
- {\r
- return (SimpleClass) _list[index];\r
- }\r
- }\r
-\r
- public int Count\r
- {\r
- get { return _list.Count; }\r
- }\r
-\r
- public bool IsSynchronized\r
- {\r
- get { return _list.IsSynchronized; }\r
- }\r
-\r
- public object SyncRoot\r
- {\r
- get { return _list.SyncRoot; }\r
- }\r
-\r
- public void CopyTo (Array array, int index)\r
- {\r
- _list.CopyTo (array, index);\r
- }\r
-\r
- IEnumerator IEnumerable.GetEnumerator ()\r
- {\r
- return GetEnumerator ();\r
- }\r
-\r
- public SimpleClassEnumerator GetEnumerator ()\r
- {\r
- return new SimpleClassEnumerator (_list);\r
- }\r
-\r
- public void Add (SimpleClass value)\r
- {\r
- _list.Add (value);\r
- }\r
-\r
- private ArrayList _list = new ArrayList ();\r
- }\r
-\r
- public class ObjectCollection : ICollection\r
- {\r
- public object this[int name]\r
- {\r
- get\r
- {\r
- return new SimpleClass ();\r
- }\r
- }\r
-\r
- public int Count\r
- {\r
- get { return _list.Count; }\r
- }\r
-\r
- public bool IsSynchronized\r
- {\r
- get { return _list.IsSynchronized; }\r
- }\r
-\r
- public object SyncRoot\r
- {\r
- get { return _list.SyncRoot; }\r
- }\r
-\r
- public void CopyTo (Array array, int index)\r
- {\r
- _list.CopyTo (array, index);\r
- }\r
-\r
- public IEnumerator GetEnumerator ()\r
- {\r
- return _list.GetEnumerator ();\r
- }\r
-\r
- public void Add (object value)\r
- {\r
- _list.Add (value);\r
- }\r
-\r
- private ArrayList _list = new ArrayList ();\r
- }\r
-\r
- public class SimpleClassEnumerator : IEnumerator\r
- {\r
- internal SimpleClassEnumerator (ArrayList arguments)\r
- {\r
- IEnumerable temp = (IEnumerable) (arguments);\r
- _baseEnumerator = temp.GetEnumerator ();\r
- }\r
- public SimpleClass Current\r
- {\r
- get { return (SimpleClass) _baseEnumerator.Current; }\r
- }\r
-\r
- object IEnumerator.Current\r
- {\r
- get { return _baseEnumerator.Current; }\r
- }\r
-\r
- public bool MoveNext ()\r
- {\r
- return _baseEnumerator.MoveNext ();\r
- }\r
-\r
- bool IEnumerator.MoveNext ()\r
- {\r
- return _baseEnumerator.MoveNext ();\r
- }\r
-\r
- public void Reset ()\r
- {\r
- _baseEnumerator.Reset ();\r
- }\r
-\r
- void IEnumerator.Reset ()\r
- {\r
- _baseEnumerator.Reset ();\r
- }\r
-\r
- private IEnumerator _baseEnumerator;\r
- }\r
-\r
- public class NoCurrentEnumerator : IEnumerator\r
- {\r
- internal NoCurrentEnumerator (ArrayList arguments)\r
- {\r
- IEnumerable temp = (IEnumerable) (arguments);\r
- _baseEnumerator = temp.GetEnumerator ();\r
- }\r
-\r
- object IEnumerator.Current\r
- {\r
- get { return _baseEnumerator.Current; }\r
- }\r
-\r
- public bool MoveNext ()\r
- {\r
- return _baseEnumerator.MoveNext ();\r
- }\r
-\r
- bool IEnumerator.MoveNext ()\r
- {\r
- return _baseEnumerator.MoveNext ();\r
- }\r
-\r
- public void Reset ()\r
- {\r
- _baseEnumerator.Reset ();\r
- }\r
-\r
- void IEnumerator.Reset ()\r
- {\r
- _baseEnumerator.Reset ();\r
- }\r
-\r
- private IEnumerator _baseEnumerator;\r
- }\r
- }\r
-}\r
-\r
+//
+// System.Xml.Serialization.XmlReflectionImporterTests
+//
+// Author:
+// Erik LeBel (eriklebel@yahoo.ca)
+//
+// (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.Xml;
+using System.Xml.Schema;
+using System.Xml.Serialization;
+
+using NUnit.Framework;
+#if NET_2_0
+using System.Collections.Generic;
+#endif
+
+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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestIntTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map(typeof(int[]));
+ Assert.AreEqual ("ArrayOfInt", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfInt32", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("Int32[]", tm.TypeName, "#A3");
+#endif
+ Assert.AreEqual ("System.Int32[]", tm.TypeFullName, "#A4");
+
+ tm = Map (typeof (int[][]));
+ Assert.AreEqual ("ArrayOfArrayOfInt", tm.ElementName, "#B1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfInt32", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("Int32[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.Int32[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (int[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfInt", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfInt32", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("Int32[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestStringTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map (typeof (string[]));
+ Assert.AreEqual ("ArrayOfString", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfString", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("String[]", tm.TypeName, "#A3");
+#endif
+ Assert.AreEqual ("System.String[]", tm.TypeFullName, "#A4");
+
+ tm = Map (typeof (string[][]));
+ Assert.AreEqual ("ArrayOfArrayOfString", tm.ElementName, "#B1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfString", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("String[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.String[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (string[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("String[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestObjectTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map (typeof (object[]));
+ Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfObject", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("Object[]", tm.TypeName, "#A3");
+#endif
+ Assert.AreEqual ("System.Object[]", tm.TypeFullName, "#A4");
+
+ tm = Map (typeof (object[][]));
+ Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#B1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfObject", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("Object[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.Object[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (object[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfObject", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("Object[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfByte", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("Byte[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.Byte[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (byte[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfBase64Binary", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfByte", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("Byte[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestDateTimeTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map (typeof (DateTime[]));
+ Assert.AreEqual ("ArrayOfDateTime", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfDateTime", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("DateTime[]", tm.TypeName, "#A3");
+#endif
+ Assert.AreEqual ("System.DateTime[]", tm.TypeFullName, "#A4");
+
+ tm = Map (typeof (DateTime[][]));
+ Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.ElementName, "#B1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("DateTime[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.DateTime[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (DateTime[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("DateTime[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestGuidTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map (typeof (Guid[]));
+ Assert.AreEqual ("ArrayOfGuid", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfGuid", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("Guid[]", tm.TypeName, "#A3");
+#endif
+ Assert.AreEqual ("System.Guid[]", tm.TypeFullName, "#A4");
+
+ tm = Map (typeof (Guid[][]));
+ Assert.AreEqual ("ArrayOfArrayOfGuid", tm.ElementName, "#B1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfGuid", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("Guid[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.Guid[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (Guid[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("Guid[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestCharTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map (typeof (char[]));
+ Assert.AreEqual ("ArrayOfChar", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfChar", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("Char[]", tm.TypeName, "#A3");
+#endif
+ Assert.AreEqual ("System.Char[]", tm.TypeFullName, "#A4");
+
+ tm = Map (typeof (char[][]));
+ Assert.AreEqual ("ArrayOfArrayOfChar", tm.ElementName, "#B1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfChar", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("Char[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.Char[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (char[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("Char[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestXmlSerializableTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map (typeof (Employee[]));
+ Assert.AreEqual ("ArrayOfEmployee", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfEmployee", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("Employee[]", tm.TypeName, "#A3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("Employee[][]", tm.TypeName, "#B3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("Employee[][][]", tm.TypeName, "#C3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfTimeSpan", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("TimeSpan[]", tm.TypeName, "#A3");
+#endif
+ Assert.AreEqual ("System.TimeSpan[]", tm.TypeFullName, "#A4");
+
+ tm = Map (typeof (TimeSpan[][]));
+ Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.ElementName, "#B1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("TimeSpan[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.TimeSpan[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (TimeSpan[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("TimeSpan[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestEnumTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map (typeof (AttributeTargets[]));
+ Assert.AreEqual ("ArrayOfAttributeTargets", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfAttributeTargets", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("AttributeTargets[]", tm.TypeName, "#A3");
+#endif
+ Assert.AreEqual ("System.AttributeTargets[]", tm.TypeFullName, "#A4");
+
+ tm = Map (typeof (AttributeTargets[][]));
+ Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.ElementName, "#B1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("AttributeTargets[][]", tm.TypeName, "#B3");
+#endif
+ Assert.AreEqual ("System.AttributeTargets[][]", tm.TypeFullName, "#B4");
+
+ tm = Map (typeof (AttributeTargets[][][]));
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.ElementName, "#C1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("AttributeTargets[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ public void TestClassTypeMapping_Array ()
+ {
+ XmlTypeMapping tm = Map (typeof (SimpleClass[]));
+ Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#A1");
+ Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfSimpleClass", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("SimpleClass[]", tm.TypeName, "#A3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("SimpleClass[][]", tm.TypeName, "#B3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("SimpleClass[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfSimpleClassEnumerable", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerable[]", tm.TypeName, "#A3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerable[][]", tm.TypeName, "#B3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerable[][][]", tm.TypeName, "#C3");
+#endif
+ Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][][]", tm.TypeFullName, "#C4");
+ }
+
+ [Test]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfObjectEnumerable", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("ObjectEnumerable[]", tm.TypeName, "#A3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfObjectEnumerable", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("ObjectEnumerable[][]", tm.TypeName, "#B3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectEnumerable", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("ObjectEnumerable[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[]", tm.TypeName, "#A3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[][]", tm.TypeName, "#B3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeName, "#C3");
+#endif
+ Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeFullName, "#C4");
+ }
+
+ [Test]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+#if ONLY_1_1
+ [Category ("NotDotNet")] // results in NullReferenceException in .NET 1.1 (SP1)
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[]", tm.TypeName, "#A3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[][]", tm.TypeName, "#B3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[][][]", tm.TypeName, "#C3");
+#endif
+ 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]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfSimpleClassCollection", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("SimpleClassCollection[]", tm.TypeName, "#A3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("SimpleClassCollection[][]", tm.TypeName, "#B3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("SimpleClassCollection[][][]", tm.TypeName, "#C3");
+#endif
+ Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][][]", tm.TypeFullName, "#C4");
+ }
+
+ [Test]
+#if NET_2_0
+ [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfObjectCollection", tm.TypeName, "#A3");
+#else
+ Assert.AreEqual ("ObjectCollection[]", tm.TypeName, "#A3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfObjectCollection", tm.TypeName, "#B3");
+#else
+ Assert.AreEqual ("ObjectCollection[][]", tm.TypeName, "#B3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectCollection", tm.TypeName, "#C3");
+#else
+ Assert.AreEqual ("ObjectCollection[][][]", tm.TypeName, "#C3");
+#endif
+ 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");
+#if NET_2_0
+ Assert.AreEqual (XmlSchemaNamespace, smm.TypeNamespace, "#7");
+#else
+ Assert.IsNull (smm.TypeNamespace, "#7");
+#endif
+
+ 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));
+ }
+
+#if NET_2_0
+
+ [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));
+ }
+#endif
+
+ 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;
+ }
+
+#if NET_2_0
+ 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;
+ }
+ }
+#endif
+ }
+}
+
projects / mono.git / blobdiff