* System.Xml_test.dll.sources: Added SoapSchemaExporterTests.cs,

SoapReflectionImporterTests.cs, XmlSchemaImporterTests.cs.
* XmlReflectionImporterTests.cs: Added numerous tests. No longer
derive from Assertion.
* SoapReflectionImporterTests.cs: Added numerous tests.
* XmlSchemaImporterTests.cs: Added numerous tests.
* XmlSchemaExporterTests.cs: Added numerous tests.
* SoapSchemaExporterTests.cs: Added numerous tests.

svn path=/trunk/mcs/; revision=55191

mcs/class/System.XML/ChangeLog

@@ -1,3 +1,8 @@
+2006-01-07  Gert Driesen  <[email protected]>
+
+	* System.Xml_test.dll.sources: Added SoapSchemaExporterTests.cs,
+	SoapReflectionImporterTests.cs, XmlSchemaImporterTests.cs.
+
 2005-12-28  Gert Driesen  <[email protected]>
 
 	* System.Xml_test.dll.sources: Added XmlSchemaExporterTests.cs.

mcs/class/System.XML/System.Xml_test.dll.sources

@@ -53,6 +53,8 @@ System.Xml.Serialization/SoapAttributeAttributeTests.cs
 System.Xml.Serialization/SoapElementAttributeTests.cs
 System.Xml.Serialization/SoapEnumAttributeTests.cs
 System.Xml.Serialization/SoapIncludeAttributeTests.cs
+System.Xml.Serialization/SoapSchemaExporterTests.cs
+System.Xml.Serialization/SoapReflectionImporterTests.cs
 System.Xml.Serialization/SoapSchemaMemberTests.cs
 System.Xml.Serialization/SoapTypeAttributeTests.cs
 System.Xml.Serialization/XmlAnyElementAttributeTests.cs
@@ -67,6 +69,7 @@ System.Xml.Serialization/XmlIncludeAttributeTests.cs
 System.Xml.Serialization/XmlReflectionImporterTests.cs
 System.Xml.Serialization/XmlRootAttributeTests.cs
 System.Xml.Serialization/XmlSchemaExporterTests.cs
+System.Xml.Serialization/XmlSchemaImporterTests.cs
 System.Xml.Serialization/XmlSerializationWriterTests.cs
 System.Xml.Serialization/XmlTextAttributeTests.cs
 System.Xml.Serialization/XmlTypeAttributeTests.cs

mcs/class/System.XML/Test/System.Xml.Serialization/ChangeLog

@@ -1,3 +1,12 @@
+2006-01-07  Gert Driesen  <[email protected]>
+
+	* XmlReflectionImporterTests.cs: Added numerous tests. No longer
+	derive from Assertion.
+	* SoapReflectionImporterTests.cs: Added numerous tests.
+	* XmlSchemaImporterTests.cs: Added numerous tests.
+	* XmlSchemaExporterTests.cs: Added numerous tests.
+	* SoapSchemaExporterTests.cs: Added numerous tests.
+
 2005-12-29  Gert Driesen  <[email protected]>
 
 	* XmlSchemaExporterTests.cs: Added tests for exporting structs, and 

mcs/class/System.XML/Test/System.Xml.Serialization/SoapReflectionImporterTests.cs

@@ -0,0 +1,1494 @@
+//
+// System.Xml.Serialization.SoapReflectionImporterTests
+//
+// Author:
+//   Gert Driesen ([email protected])
+//
+// (C) 2005 Novell
+// 
+
+using System;
+using System.Collections;
+using System.Xml;
+using System.Xml.Schema;
+using System.Xml.Serialization;
+
+using NUnit.Framework;
+
+using MonoTests.System.Xml.TestClasses;
+
+namespace MonoTests.System.XmlSerialization
+{
+	[TestFixture]
+	public class SoapReflectionImporterTests
+	{
+		private const string SomeNamespace = "some:urn";
+		private const string AnotherNamespace = "another:urn";
+
+		// these Map methods re-create the SoapReflectionImporter at every call.
+
+		private XmlTypeMapping Map(Type t)
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter();
+			XmlTypeMapping tm = ri.ImportTypeMapping(t);
+
+			return tm;
+		}
+
+		private XmlTypeMapping Map(Type t, string ns)
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter(ns);
+			XmlTypeMapping tm = ri.ImportTypeMapping(t);
+
+			return tm;
+		}
+
+		private XmlTypeMapping Map(Type t, SoapAttributeOverrides overrides)
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter(overrides);
+			XmlTypeMapping tm = ri.ImportTypeMapping(t);
+
+			return tm;
+		}
+
+		private XmlMembersMapping MembersMap (Type t, SoapAttributeOverrides overrides, 
+			XmlReflectionMember [] members, bool inContainer, bool writeAccessors)
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter(overrides);
+			XmlMembersMapping mm = ri.ImportMembersMapping(null, null, members, 
+				inContainer, writeAccessors);
+			
+			return mm;
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestIntTypeMapping()
+		{
+			XmlTypeMapping tm = Map (typeof (int));
+			Assert.AreEqual ("int", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Int32", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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]
+		[Category ("NotWorking")]
+		public void TestStringTypeMapping()
+		{
+			XmlTypeMapping tm = Map (typeof (string));
+			Assert.AreEqual ("string", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("String", tm.TypeName, "#3");
+			Assert.AreEqual ("System.String", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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]
+		[Category ("NotWorking")]
+		public void TestObjectTypeMapping()
+		{
+			XmlTypeMapping tm = Map (typeof (object));
+			Assert.AreEqual ("anyType", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Object", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Object", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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]
+		[Category ("NotWorking")]
+		public void TestByteTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (byte));
+			Assert.AreEqual ("unsignedByte", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Byte", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Byte", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void TestByteTypeMapping_Array ()
+		{
+			XmlTypeMapping tm = Map (typeof (byte[]));
+			Assert.AreEqual ("base64Binary", tm.ElementName, "#A1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", 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]
+		[Category ("NotWorking")]
+		public void TestBoolTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (bool));
+			Assert.AreEqual ("boolean", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Boolean", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Boolean", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void TestShortTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (short));
+			Assert.AreEqual ("short", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Int16", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Int16", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void TestUnsignedShortTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (ushort));
+			Assert.AreEqual ("unsignedShort", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("UInt16", tm.TypeName, "#3");
+			Assert.AreEqual ("System.UInt16", tm.TypeFullName, "#4");
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestUIntTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (uint));
+			Assert.AreEqual ("unsignedInt", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("UInt32", tm.TypeName, "#3");
+			Assert.AreEqual ("System.UInt32", tm.TypeFullName, "#4");
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestLongTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (long));
+			Assert.AreEqual ("long", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Int64", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Int64", tm.TypeFullName, "#4");
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestULongTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (ulong));
+			Assert.AreEqual ("unsignedLong", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("UInt64", tm.TypeName, "#3");
+			Assert.AreEqual ("System.UInt64", tm.TypeFullName, "#4");
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestFloatTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (float));
+			Assert.AreEqual ("float", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Single", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Single", tm.TypeFullName, "#4");
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestDoubleTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (double));
+			Assert.AreEqual ("double", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Double", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Double", tm.TypeFullName, "#4");
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestDateTimeTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (DateTime));
+			Assert.AreEqual ("dateTime", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("DateTime", tm.TypeName, "#3");
+			Assert.AreEqual ("System.DateTime", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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]
+		[Category ("NotWorking")]
+		public void TestGuidTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (Guid));
+			Assert.AreEqual ("guid", tm.ElementName, "#1");
+			Assert.AreEqual ("http://microsoft.com/wsdl/types/", tm.Namespace, "#2");
+			Assert.AreEqual ("Guid", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Guid", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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]
+		[Category ("NotWorking")]
+		public void TestDecimalTypeMapping()
+		{
+			XmlTypeMapping tm = Map (typeof (decimal));
+			Assert.AreEqual ("decimal", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Decimal", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Decimal", tm.TypeFullName, "#4");
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestXmlQualifiedNameTypeMapping()
+		{
+			XmlTypeMapping tm = Map (typeof (XmlQualifiedName));
+			Assert.AreEqual ("QName", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("XmlQualifiedName", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Xml.XmlQualifiedName", tm.TypeFullName, "#4");
+		}
+		
+		[Test]
+		[Category ("NotWorking")]
+		public void TestSByteTypeMapping()
+		{
+			XmlTypeMapping tm = Map (typeof (sbyte));
+			Assert.AreEqual ("byte", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("SByte", tm.TypeName, "#3");
+			Assert.AreEqual ("System.SByte", tm.TypeFullName, "#4");
+		}
+		
+
+		[Test]
+		[Category ("NotWorking")]
+		public void TestCharTypeMapping()
+		{
+			XmlTypeMapping tm = Map (typeof (char));
+			Assert.AreEqual ("char", tm.ElementName, "#1");
+			Assert.AreEqual ("http://microsoft.com/wsdl/types/", tm.Namespace, "#2");
+			Assert.AreEqual ("Char", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Char", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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")]
+		[ExpectedException (typeof (NotSupportedException))] // The type System.Xml.XmlNode may not be serialized with SOAP-encoded messages.
+		public void TestXmlNodeTypeMapping ()
+		{
+			Map (typeof (XmlNode));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (NotSupportedException))] // The type System.Xml.XmlElement may not be serialized with SOAP-encoded messages.
+		public void TestXmlElementTypeMapping ()
+		{
+			Map (typeof (XmlElement));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (NotSupportedException))] // The type System.Xml.XmlNotation may not be serialized with SOAP-encoded messages.
+		public void TestXmlNotationTypeMapping ()
+		{
+			Map (typeof (XmlNotation));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (NotSupportedException))]
+		public void TestXmlSerializableTypeMapping ()
+		{
+			Map (typeof (Employee));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (NotSupportedException))]
+		public void TestClassTypeMapping_NestedStruct ()
+		{
+			Map (typeof (NestedStruct));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void TestNullTypeMapping()
+		{
+			Map(null);
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void TestIntTypeMappingWithDefaultNamespaces()
+		{
+			XmlTypeMapping tm = Map (typeof (int), SomeNamespace);
+			Assert.AreEqual ("int", tm.ElementName, "#1");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", tm.Namespace, "#2");
+			Assert.AreEqual ("Int32", tm.TypeName, "#3");
+			Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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")]
+		[ExpectedException (typeof (NotSupportedException))] // Arrays of structs are not supported with encoded SOAP.
+		public void TestStructTypeMapping_Array ()
+		{
+			Map (typeof (TimeSpan[]));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void TestEnumTypeMapping ()
+		{
+			XmlTypeMapping tm = Map (typeof (AttributeTargets));
+			Assert.AreEqual ("AttributeTargets", tm.ElementName, "#1");
+			Assert.AreEqual (string.Empty, tm.Namespace, "#2");
+			Assert.AreEqual ("AttributeTargets", tm.TypeName, "#3");
+			Assert.AreEqual ("System.AttributeTargets", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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]
+		[Category ("NotWorking")]
+		public void TestClassTypeMapping()
+		{
+			XmlTypeMapping tm = Map (typeof (SimpleClass));
+			Assert.AreEqual ("SimpleClass", tm.ElementName, "#1");
+			Assert.AreEqual (string.Empty, tm.Namespace, "#2");
+			Assert.AreEqual ("SimpleClass", tm.TypeName, "#3");
+			Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass", tm.TypeFullName, "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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]
+		[Category ("NotWorking")]
+		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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.SimpleClassEnumerable[][][]", tm.TypeFullName, "#C4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.ObjectEnumerable[][][]", tm.TypeFullName, "#C4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_IEnumarable_Object_NoMatchingAddMethod ()
+		{
+			Map (typeof (ObjectEnumerableNoMatchingAddMethod));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_IEnumarable_Object_NoMatchingAddMethod_Array ()
+		{
+			Map (typeof (ObjectEnumerableNoMatchingAddMethod[]));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeFullName, "#C4");
+		}
+
+		[Test]
+#if ONLY_1_1
+		[Category ("NotDotNet")] // results in NullReferenceException in .NET 1.1 (SP1)
+#endif
+		[Category ("NotWorking")]
+		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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][][]", tm.TypeFullName, "#C4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_ICollection_Object_NoMatchingAddMethod ()
+		{
+			Map (typeof (ObjectCollectionNoMatchingAddMethod));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_ICollection_Object_NoMatchingAddMethod_Array ()
+		{
+			Map (typeof (ObjectCollectionNoMatchingAddMethod[]));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod ()
+		{
+			Map (typeof (SimpleClassCollectionNoMatchingAddMethod));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod_Array ()
+		{
+			Map (typeof (SimpleClassCollectionNoMatchingAddMethod[]));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.SimpleClassCollection[][][]", tm.TypeFullName, "#C4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.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.SoapReflectionImporterTests.ObjectCollection[][][]", tm.TypeFullName, "#C4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_ICollection_Object_NoIntIndexer ()
+		{
+			Map (typeof (ObjectCollectionNoIntIndexer));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_ICollection_Object_NoIntIndexer_Array ()
+		{
+			Map (typeof (ObjectCollectionNoIntIndexer[]));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_ICollection_SimpleClass_NoIntIndexer ()
+		{
+			Map (typeof (SimpleClassCollectionNoIntIndexer));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void TypeMapping_ICollection_SimpleClass_NoIntIndexer_Array ()
+		{
+			Map (typeof (SimpleClassCollectionNoIntIndexer[]));
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void TestImportMembersMapping()
+		{
+			Type type = typeof (SimpleClass);
+			SoapAttributes attrs = new SoapAttributes ();
+			SoapAttributeOverrides overrides = new SoapAttributeOverrides ();
+			overrides.Add (typeof (SimpleClass), attrs);
+
+			XmlReflectionMember[] members = new XmlReflectionMember[0];
+			XmlMembersMapping mm;
+			try
+			{
+				mm = MembersMap(type, overrides, members, true, 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, false);
+
+			Equals(mm.Count, 1);
+
+			XmlMemberMapping smm = mm[0];
+			Assert.IsFalse (smm.Any, "#1");
+			Assert.AreEqual ("something", smm.ElementName, "#2");
+			Assert.AreEqual ("something", smm.MemberName, "#3");
+			Assert.IsNull (smm.Namespace, "#4");
+			Assert.AreEqual ("System.String", smm.TypeFullName, "#5");
+			Assert.AreEqual ("string", smm.TypeName, "#6");
+			Assert.AreEqual ("http://www.w3.org/2001/XMLSchema", smm.TypeNamespace, "#7");
+
+			
+			rm = new XmlReflectionMember();
+			rm.IsReturnValue = false;
+			rm.MemberName = "nothing";
+			rm.MemberType = typeof(string);
+			members = new XmlReflectionMember[1];
+			members[0] = rm;
+
+			mm = MembersMap(type, overrides, members, false, false);
+			Assert.AreEqual (1 , mm.Count, "#8");
+		}
+
+		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;
+		}
+	}
+}

mcs/class/System.XML/Test/System.Xml.Serialization/SoapSchemaExporterTests.cs

@@ -0,0 +1,480 @@
+//
+// System.Xml.Serialization.SoapSchemaExporterTests
+//
+// Author:
+//   Gert Driesen ([email protected])
+//
+// (C) 2005 Novell
+// 
+
+using System;
+using System.Collections;
+using System.Globalization;
+using System.IO;
+using System.Xml;
+using System.Xml.Schema;
+using System.Xml.Serialization;
+
+using NUnit.Framework;
+
+using MonoTests.System.Xml.TestClasses;
+
+namespace MonoTests.System.XmlSerialization
+{
+	[TestFixture]
+	public class SoapSchemaExporterTests
+	{
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportStruct ()
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter ("NSTimeSpan");
+			XmlSchemas schemas = new XmlSchemas ();
+			SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (TimeSpan));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#1");
+
+			StringWriter sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+#if NET_2_0
+				"<xs:schema xmlns:tns=\"NSTimeSpan\" elementFormDefault=\"qualified\" targetNamespace=\"NSTimeSpan\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#else
+				"<xs:schema xmlns:tns=\"NSTimeSpan\" targetNamespace=\"NSTimeSpan\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#endif
+				"  <xs:complexType name=\"TimeSpan\" />{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+		}
+
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportClass ()
+		{
+			SoapAttributeOverrides overrides = new SoapAttributeOverrides ();
+			SoapAttributes attr = new SoapAttributes ();
+			SoapElementAttribute element = new SoapElementAttribute ();
+			element.ElementName = "saying";
+			element.IsNullable = true;
+			attr.SoapElement = element;
+			overrides.Add (typeof (SimpleClass), "something", attr);
+
+			SoapReflectionImporter ri = new SoapReflectionImporter (overrides, "NSSimpleClass");
+			XmlSchemas schemas = new XmlSchemas ();
+			SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (SimpleClass));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#1");
+
+			StringWriter sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+#if NET_2_0
+				"<xs:schema xmlns:tns=\"NSSimpleClass\" elementFormDefault=\"qualified\" targetNamespace=\"NSSimpleClass\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#else
+				"<xs:schema xmlns:tns=\"NSSimpleClass\" targetNamespace=\"NSSimpleClass\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#endif
+				"  <xs:complexType name=\"SimpleClass\">{0}" +
+				"    <xs:sequence>{0}" +
+#if NET_2_0
+				"      <xs:element minOccurs=\"0\" maxOccurs=\"1\" form=\"unqualified\" name=\"saying\" nillable=\"true\" type=\"xs:string\" />{0}" +
+#else
+				"      <xs:element minOccurs=\"1\" maxOccurs=\"1\" name=\"saying\" type=\"xs:string\" />{0}" +
+#endif
+				"    </xs:sequence>{0}" +
+				"  </xs:complexType>{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))] // Cannot use wildcards at the top level of a schema.
+		public void ExportClass_XmlNode ()
+		{
+			XmlReflectionImporter ri = new XmlReflectionImporter ("NS1");
+			XmlSchemas schemas = new XmlSchemas ();
+			XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (XmlNode));
+			sx.ExportTypeMapping (tm);
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))] // Cannot use wildcards at the top level of a schema.
+		public void ExportClass_XmlElement ()
+		{
+			XmlReflectionImporter ri = new XmlReflectionImporter ("NS1");
+			XmlSchemas schemas = new XmlSchemas ();
+			XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (XmlElement));
+			sx.ExportTypeMapping (tm);
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportClass_Array ()
+		{
+			SoapAttributeOverrides overrides = new SoapAttributeOverrides ();
+			SoapAttributes attr = new SoapAttributes ();
+			SoapElementAttribute element = new SoapElementAttribute ();
+			element.ElementName = "saying";
+			element.IsNullable = true;
+			attr.SoapElement = element;
+			overrides.Add (typeof (SimpleClass), "something", attr);
+
+			SoapReflectionImporter ri = new SoapReflectionImporter (overrides, "NSSimpleClassArray");
+			XmlSchemas schemas = new XmlSchemas ();
+			SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (SimpleClass[]));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#1");
+
+			StringWriter sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+#if NET_2_0
+				"<xs:schema xmlns:tns=\"NSSimpleClassArray\" elementFormDefault=\"qualified\" targetNamespace=\"NSSimpleClassArray\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#else
+				"<xs:schema xmlns:tns=\"NSSimpleClassArray\" targetNamespace=\"NSSimpleClassArray\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#endif
+				"  <xs:import namespace=\"http://schemas.xmlsoap.org/soap/encoding/\" />{0}" +
+				"  <xs:import namespace=\"http://schemas.xmlsoap.org/wsdl/\" />{0}" +
+				"  <xs:complexType name=\"ArrayOfSimpleClass\">{0}" +
+				"    <xs:complexContent mixed=\"false\">{0}" +
+				"      <xs:restriction xmlns:q1=\"http://schemas.xmlsoap.org/soap/encoding/\" base=\"q1:Array\">{0}" +
+				"        <xs:attribute d5p1:arrayType=\"tns:SimpleClass[]\" ref=\"q1:arrayType\" xmlns:d5p1=\"http://schemas.xmlsoap.org/wsdl/\" />{0}" +
+				"      </xs:restriction>{0}" +
+				"    </xs:complexContent>{0}" +
+				"  </xs:complexType>{0}" +
+				"  <xs:complexType name=\"SimpleClass\">{0}" +
+				"    <xs:sequence>{0}" +
+#if NET_2_0
+				"      <xs:element minOccurs=\"0\" maxOccurs=\"1\" form=\"unqualified\" name=\"saying\" nillable=\"true\" type=\"xs:string\" />{0}" +
+#else
+				"      <xs:element minOccurs=\"1\" maxOccurs=\"1\" name=\"saying\" type=\"xs:string\" />{0}" +
+#endif
+				"    </xs:sequence>{0}" +
+				"  </xs:complexType>{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportEnum ()
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter ("NSEnumDefaultValue");
+			XmlSchemas schemas = new XmlSchemas ();
+			SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (EnumDefaultValue));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#1");
+
+			StringWriter sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+#if NET_2_0
+				"<xs:schema xmlns:tns=\"NSEnumDefaultValue\" elementFormDefault=\"qualified\" targetNamespace=\"NSEnumDefaultValue\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#else
+				"<xs:schema xmlns:tns=\"NSEnumDefaultValue\" targetNamespace=\"NSEnumDefaultValue\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#endif
+				"  <xs:simpleType name=\"EnumDefaultValue\">{0}" +
+				"    <xs:list>{0}" +
+				"      <xs:simpleType>{0}" +
+				"        <xs:restriction base=\"xs:string\">{0}" +
+				"          <xs:enumeration value=\"e1\" />{0}" +
+				"          <xs:enumeration value=\"e2\" />{0}" +
+				"          <xs:enumeration value=\"e3\" />{0}" +
+				"        </xs:restriction>{0}" +
+				"      </xs:simpleType>{0}" +
+				"    </xs:list>{0}" +
+				"  </xs:simpleType>{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+
+			ri = new SoapReflectionImporter ("NSEnumDefaultValueNF");
+			schemas = new XmlSchemas ();
+			sx = new SoapSchemaExporter (schemas);
+			tm = ri.ImportTypeMapping (typeof (EnumDefaultValueNF));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#3");
+
+			sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+#if NET_2_0
+				"<xs:schema xmlns:tns=\"NSEnumDefaultValueNF\" elementFormDefault=\"qualified\" targetNamespace=\"NSEnumDefaultValueNF\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#else
+				"<xs:schema xmlns:tns=\"NSEnumDefaultValueNF\" targetNamespace=\"NSEnumDefaultValueNF\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#endif
+				"  <xs:simpleType name=\"EnumDefaultValueNF\">{0}" +
+				"    <xs:restriction base=\"xs:string\">{0}" +
+				"      <xs:enumeration value=\"e1\" />{0}" +
+				"      <xs:enumeration value=\"e2\" />{0}" +
+				"      <xs:enumeration value=\"e3\" />{0}" +
+				"    </xs:restriction>{0}" +
+				"  </xs:simpleType>{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#4");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportXsdPrimitive ()
+		{
+			ArrayList types = new ArrayList ();
+			types.Add (new TypeDescription (typeof (object), true, "anyType", "Object"));
+			types.Add (new TypeDescription (typeof (byte), true, "unsignedByte", "Byte"));
+			types.Add (new TypeDescription (typeof (sbyte), true, "byte", "Byte"));
+			types.Add (new TypeDescription (typeof (bool), true, "boolean", "Boolean"));
+			types.Add (new TypeDescription (typeof (short), true, "short", "Short"));
+			types.Add (new TypeDescription (typeof (int), true, "int", "Int"));
+			types.Add (new TypeDescription (typeof (long), true, "long", "Long"));
+			types.Add (new TypeDescription (typeof (float), true, "float", "Float"));
+			types.Add (new TypeDescription (typeof (double), true, "double", "Double"));
+			types.Add (new TypeDescription (typeof (decimal), true, "decimal", "Decimal"));
+			types.Add (new TypeDescription (typeof (ushort), true, "unsignedShort", "UnsignedShort"));
+			types.Add (new TypeDescription (typeof (uint), true, "unsignedInt", "UnsignedInt"));
+			types.Add (new TypeDescription (typeof (ulong), true, "unsignedLong", "UnsignedLong"));
+			types.Add (new TypeDescription (typeof (DateTime), true, "dateTime", "DateTime"));
+#if NET_2_0
+			types.Add (new TypeDescription (typeof (XmlQualifiedName), true, "QName", "QName", true));
+#else
+			types.Add (new TypeDescription (typeof (XmlQualifiedName), true, "QName", "QName"));
+#endif
+			types.Add (new TypeDescription (typeof (string), true, "string", "String", true));
+
+			foreach (TypeDescription typeDesc in types) {
+				SoapReflectionImporter ri = new SoapReflectionImporter (typeDesc.Type.Name);
+				XmlSchemas schemas = new XmlSchemas ();
+				SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+				XmlTypeMapping tm = ri.ImportTypeMapping (typeDesc.Type);
+				sx.ExportTypeMapping (tm);
+
+				Assert.AreEqual (0, schemas.Count, typeDesc.Type.FullName + "#1");
+			}
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportXsdPrimitive_ByteArray ()
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter ("ByteArray");
+			XmlSchemas schemas = new XmlSchemas ();
+			SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (byte[]));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (0, schemas.Count, "#1");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportXsdPrimitive_Arrays ()
+		{
+			ArrayList types = new ArrayList ();
+			types.Add (new TypeDescription (typeof (object[]), true, "anyType", "AnyType"));
+			types.Add (new TypeDescription (typeof (sbyte[]), true, "byte", "Byte"));
+			types.Add (new TypeDescription (typeof (bool[]), true, "boolean", "Boolean"));
+			types.Add (new TypeDescription (typeof (short[]), true, "short", "Short"));
+			types.Add (new TypeDescription (typeof (int[]), true, "int", "Int"));
+			types.Add (new TypeDescription (typeof (long[]), true, "long", "Long"));
+			types.Add (new TypeDescription (typeof (float[]), true, "float", "Float"));
+			types.Add (new TypeDescription (typeof (double[]), true, "double", "Double"));
+			types.Add (new TypeDescription (typeof (decimal[]), true, "decimal", "Decimal"));
+			types.Add (new TypeDescription (typeof (ushort[]), true, "unsignedShort", "UnsignedShort"));
+			types.Add (new TypeDescription (typeof (uint[]), true, "unsignedInt", "UnsignedInt"));
+			types.Add (new TypeDescription (typeof (ulong[]), true, "unsignedLong", "UnsignedLong"));
+			types.Add (new TypeDescription (typeof (DateTime[]), true, "dateTime", "DateTime"));
+#if NET_2_0
+			types.Add (new TypeDescription (typeof (XmlQualifiedName[]), true, "QName", "QName", true));
+#else
+			types.Add (new TypeDescription (typeof (XmlQualifiedName[]), true, "QName", "QName"));
+#endif
+			types.Add (new TypeDescription (typeof (string[]), true, "string", "String", true));
+
+			foreach (TypeDescription typeDesc in types) {
+				SoapReflectionImporter ri = new SoapReflectionImporter (typeDesc.Type.Name);
+				XmlSchemas schemas = new XmlSchemas ();
+				SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+				XmlTypeMapping tm = ri.ImportTypeMapping (typeDesc.Type);
+				sx.ExportTypeMapping (tm);
+
+				Assert.AreEqual (1, schemas.Count, typeDesc.Type.FullName + "#1");
+
+				StringWriter sw = new StringWriter ();
+				schemas[0].Write (sw);
+
+				Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+					"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+#if NET_2_0
+					"<xs:schema xmlns:tns=\"{1}\" elementFormDefault=\"qualified\" targetNamespace=\"{1}\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#else
+					"<xs:schema xmlns:tns=\"{1}\" targetNamespace=\"{1}\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#endif
+					"  <xs:import namespace=\"http://schemas.xmlsoap.org/soap/encoding/\" />{0}" +
+					"  <xs:import namespace=\"http://schemas.xmlsoap.org/wsdl/\" />{0}" +
+					"  <xs:complexType name=\"ArrayOf{2}\">{0}" +
+					"    <xs:complexContent mixed=\"false\">{0}" +
+					"      <xs:restriction xmlns:q1=\"http://schemas.xmlsoap.org/soap/encoding/\" base=\"q1:Array\">{0}" +
+					"        <xs:attribute d5p1:arrayType=\"xs:{3}[]\" ref=\"q1:arrayType\" xmlns:d5p1=\"http://schemas.xmlsoap.org/wsdl/\" />{0}" +
+					"      </xs:restriction>{0}" +
+					"    </xs:complexContent>{0}" +
+					"  </xs:complexType>{0}" +
+					"</xs:schema>", Environment.NewLine, typeDesc.Type.Name, typeDesc.ArrayType, typeDesc.XmlType, 
+					typeDesc.XsdType ? "xs" : "tns", typeDesc.IsNillable ? "nillable=\"true\" " : ""),
+					sw.ToString (), typeDesc.Type.FullName + "#2");
+			}
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportNonXsdPrimitive_Guid ()
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter ("NSPrimGuid");
+			XmlSchemas schemas = new XmlSchemas ();
+			SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (Guid));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#1");
+
+			StringWriter sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+#if NET_2_0
+				"<xs:schema xmlns:tns=\"http://microsoft.com/wsdl/types/\" elementFormDefault=\"qualified\" targetNamespace=\"http://microsoft.com/wsdl/types/\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#else
+				"<xs:schema xmlns:tns=\"http://microsoft.com/wsdl/types/\" targetNamespace=\"http://microsoft.com/wsdl/types/\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#endif
+				"  <xs:simpleType name=\"guid\">{0}" +
+				"    <xs:restriction base=\"xs:string\">{0}" +
+				"      <xs:pattern value=\"[0-9a-fA-F]{{8}}-[0-9a-fA-F]{{4}}-[0-9a-fA-F]{{4}}-[0-9a-fA-F]{{4}}-[0-9a-fA-F]{{12}}\" />{0}" +
+				"    </xs:restriction>{0}" +
+				"  </xs:simpleType>{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ExportNonXsdPrimitive_Char ()
+		{
+			SoapReflectionImporter ri = new SoapReflectionImporter ("NSPrimChar");
+			XmlSchemas schemas = new XmlSchemas ();
+			SoapSchemaExporter sx = new SoapSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (Char));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#1");
+
+			StringWriter sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+#if NET_2_0
+				"<xs:schema xmlns:tns=\"http://microsoft.com/wsdl/types/\" elementFormDefault=\"qualified\" targetNamespace=\"http://microsoft.com/wsdl/types/\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#else
+				"<xs:schema xmlns:tns=\"http://microsoft.com/wsdl/types/\" targetNamespace=\"http://microsoft.com/wsdl/types/\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+#endif
+				"  <xs:simpleType name=\"char\">{0}" +
+				"    <xs:restriction base=\"xs:unsignedShort\" />{0}" +
+				"  </xs:simpleType>{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+		}
+
+		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"];
+				}
+			}
+		}
+
+		private class TypeDescription
+		{
+			public TypeDescription (Type type, bool xsdType, string xmlType, string arrayType)
+				: this (type, xsdType, xmlType, arrayType, false)
+			{
+			}
+
+			public TypeDescription (Type type, bool xsdType, string xmlType, string arrayType, bool isNillable)
+			{
+				_type = type;
+				_xsdType = xsdType;
+				_xmlType = xmlType;
+				_arrayType = arrayType;
+				_isNillable = isNillable;
+			}
+
+			public Type Type
+			{
+				get { return _type; }
+			}
+
+			public string XmlType
+			{
+				get { return _xmlType; }
+			}
+
+			public string ArrayType
+			{
+				get { return _arrayType; }
+			}
+
+			public bool XsdType
+			{
+				get { return _xsdType; }
+			}
+
+			public bool IsNillable
+			{
+				get { return _isNillable; }
+			}
+
+			private Type _type;
+			private bool _xsdType;
+			private string _xmlType;
+			private string _arrayType;
+			private bool _isNillable;
+		}
+	}
+}

mcs/class/System.XML/Test/System.Xml.Serialization/XmlSchemaExporterTests.cs

@@ -110,6 +110,18 @@ namespace MonoTests.System.XmlSerialization
 				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
 		}
 
+		[Test]
+		[Category ("NotWorking")]
+		[ExpectedException (typeof (InvalidOperationException))] // Cannot use wildcards at the top level of a schema.
+		public void ExportClass_XmlElement ()
+		{
+			XmlReflectionImporter ri = new XmlReflectionImporter ("NS1");
+			XmlSchemas schemas = new XmlSchemas ();
+			XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (XmlElement));
+			sx.ExportTypeMapping (tm);
+		}
+
 		[Test]
 		[Category ("NotWorking")] // on Mono, element is output before type
 		public void ExportClass_Array ()
@@ -154,7 +166,7 @@ namespace MonoTests.System.XmlSerialization
 		[Category ("NotWorking")] // on Mono, element is output before type
 		public void ExportEnum ()
 		{
-			XmlReflectionImporter ri = new XmlReflectionImporter ("NS2");
+			XmlReflectionImporter ri = new XmlReflectionImporter ("NSEnumDefaultValue");
 			XmlSchemas schemas = new XmlSchemas ();
 			XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
 			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (EnumDefaultValue));
@@ -167,7 +179,7 @@ namespace MonoTests.System.XmlSerialization
 
 			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
-				"<xs:schema xmlns:tns=\"NS2\" elementFormDefault=\"qualified\" targetNamespace=\"NS2\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+				"<xs:schema xmlns:tns=\"NSEnumDefaultValue\" elementFormDefault=\"qualified\" targetNamespace=\"NSEnumDefaultValue\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
 				"  <xs:element name=\"EnumDefaultValue\" type=\"tns:EnumDefaultValue\" />{0}" +
 				"  <xs:simpleType name=\"EnumDefaultValue\">{0}" +
 				"    <xs:list>{0}" +
@@ -181,6 +193,30 @@ namespace MonoTests.System.XmlSerialization
 				"    </xs:list>{0}" +
 				"  </xs:simpleType>{0}" +
 				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+
+			ri = new XmlReflectionImporter ("NSEnumDefaultValueNF");
+			schemas = new XmlSchemas ();
+			sx = new XmlSchemaExporter (schemas);
+			tm = ri.ImportTypeMapping (typeof (EnumDefaultValueNF));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#3");
+
+			sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+				"<xs:schema xmlns:tns=\"NSEnumDefaultValueNF\" elementFormDefault=\"qualified\" targetNamespace=\"NSEnumDefaultValueNF\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+				"  <xs:element name=\"EnumDefaultValueNF\" type=\"tns:EnumDefaultValueNF\" />{0}" +
+				"  <xs:simpleType name=\"EnumDefaultValueNF\">{0}" +
+				"    <xs:restriction base=\"xs:string\">{0}" +
+				"      <xs:enumeration value=\"e1\" />{0}" +
+				"      <xs:enumeration value=\"e2\" />{0}" +
+				"      <xs:enumeration value=\"e3\" />{0}" +
+				"    </xs:restriction>{0}" +
+				"  </xs:simpleType>{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#4");
 		}
 
 		[Test]
@@ -290,6 +326,28 @@ namespace MonoTests.System.XmlSerialization
 			}
 		}
 
+		[Test]
+		[Category ("NotWorking")] // bug #77117
+		public void ExportXsdPrimitive_Object ()
+		{
+			XmlReflectionImporter ri = new XmlReflectionImporter ("NSAnyType");
+			XmlSchemas schemas = new XmlSchemas ();
+			XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (object));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#1");
+
+			StringWriter sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+				"<xs:schema xmlns:tns=\"NSAnyType\" elementFormDefault=\"qualified\" targetNamespace=\"NSAnyType\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+				"  <xs:element name=\"anyType\" nillable=\"true\" />{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+		}
+
 		[Test]
 		[Category ("NotWorking")] // bug #77117
 		public void ExportXsdPrimitive_ByteArray ()
@@ -363,6 +421,33 @@ namespace MonoTests.System.XmlSerialization
 			}
 		}
 
+		[Test]
+		[Category ("NotWorking")] // bug #77117
+		public void ExportXsdPrimitive_Object_Arrays ()
+		{
+			XmlReflectionImporter ri = new XmlReflectionImporter ("NSArrayOfAnyType");
+			XmlSchemas schemas = new XmlSchemas ();
+			XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (typeof (object[]));
+			sx.ExportTypeMapping (tm);
+
+			Assert.AreEqual (1, schemas.Count, "#1");
+
+			StringWriter sw = new StringWriter ();
+			schemas[0].Write (sw);
+
+			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+				"<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
+				"<xs:schema xmlns:tns=\"NSArrayOfAnyType\" elementFormDefault=\"qualified\" targetNamespace=\"NSArrayOfAnyType\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{0}" +
+				"  <xs:element name=\"ArrayOfAnyType\" nillable=\"true\" type=\"tns:ArrayOfAnyType\" />{0}" +
+				"  <xs:complexType name=\"ArrayOfAnyType\">{0}" +
+				"    <xs:sequence>{0}" +
+				"      <xs:element minOccurs=\"0\" maxOccurs=\"unbounded\" name=\"anyType\" nillable=\"true\" />{0}" +
+				"    </xs:sequence>{0}" +
+				"  </xs:complexType>{0}" +
+				"</xs:schema>", Environment.NewLine), sw.ToString (), "#2");
+		}
+
 		[Test]
 		[Category ("NotWorking")] // bug #77117
 		public void ExportNonXsdPrimitive_Guid ()

mcs/class/System.XML/Test/System.Xml.Serialization/XmlSchemaImporterTests.cs

@@ -0,0 +1,455 @@
+//
+// System.Xml.Serialization.XmlSchemaImporterTests
+//
+// Author:
+//   Gert Driesen ([email protected])
+//
+// (C) 2005 Novell
+// 
+
+using System;
+using System.Collections;
+using System.Globalization;
+using System.IO;
+using System.Xml;
+using System.Xml.Schema;
+using System.Xml.Serialization;
+
+using NUnit.Framework;
+
+using MonoTests.System.Xml.TestClasses;
+
+namespace MonoTests.System.XmlSerialization
+{
+	[TestFixture]
+	public class XmlSchemaImporterTests
+	{
+		[Test]
+		[Category ("NotWorking")]
+		public void ImportTypeMapping_Struct ()
+		{
+			XmlSchemas schemas = ExportType (typeof (TimeSpan));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("TimeSpan", map.ElementName, "#3");
+			Assert.AreEqual ("NSTimeSpan", map.Namespace, "#4");
+			Assert.AreEqual ("TimeSpan", map.TypeFullName, "#5");
+			Assert.AreEqual ("TimeSpan", map.TypeName, "#6");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ImportTypeMapping_XsdPrimitive_AnyType ()
+		{
+			XmlSchemas schemas = ExportType (typeof (object));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("anyType", map.ElementName, "#3");
+			Assert.AreEqual ("NSObject", map.Namespace, "#4");
+			Assert.AreEqual ("System.Object", map.TypeFullName, "#5");
+			Assert.AreEqual ("Object", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Boolean ()
+		{
+			XmlSchemas schemas = ExportType (typeof (bool));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("boolean", map.ElementName, "#3");
+			Assert.AreEqual ("NSBoolean", map.Namespace, "#4");
+			Assert.AreEqual ("System.Boolean", map.TypeFullName, "#5");
+			Assert.AreEqual ("Boolean", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Short ()
+		{
+			XmlSchemas schemas = ExportType (typeof (short));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("short", map.ElementName, "#3");
+			Assert.AreEqual ("NSInt16", map.Namespace, "#4");
+			Assert.AreEqual ("System.Int16", map.TypeFullName, "#5");
+			Assert.AreEqual ("Int16", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_UnsignedShort ()
+		{
+			XmlSchemas schemas = ExportType (typeof (ushort));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("unsignedShort", map.ElementName, "#3");
+			Assert.AreEqual ("NSUInt16", map.Namespace, "#4");
+			Assert.AreEqual ("System.UInt16", map.TypeFullName, "#5");
+			Assert.AreEqual ("UInt16", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Int ()
+		{
+			XmlSchemas schemas = ExportType (typeof (int));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("int", map.ElementName, "#3");
+			Assert.AreEqual ("NSInt32", map.Namespace, "#4");
+			Assert.AreEqual ("System.Int32", map.TypeFullName, "#5");
+			Assert.AreEqual ("Int32", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_UnsignedInt ()
+		{
+			XmlSchemas schemas = ExportType (typeof (uint));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("unsignedInt", map.ElementName, "#3");
+			Assert.AreEqual ("NSUInt32", map.Namespace, "#4");
+			Assert.AreEqual ("System.UInt32", map.TypeFullName, "#5");
+			Assert.AreEqual ("UInt32", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Long ()
+		{
+			XmlSchemas schemas = ExportType (typeof (long));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("long", map.ElementName, "#3");
+			Assert.AreEqual ("NSInt64", map.Namespace, "#4");
+			Assert.AreEqual ("System.Int64", map.TypeFullName, "#5");
+			Assert.AreEqual ("Int64", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_UnsignedLong ()
+		{
+			XmlSchemas schemas = ExportType (typeof (ulong));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("unsignedLong", map.ElementName, "#3");
+			Assert.AreEqual ("NSUInt64", map.Namespace, "#4");
+			Assert.AreEqual ("System.UInt64", map.TypeFullName, "#5");
+			Assert.AreEqual ("UInt64", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Float ()
+		{
+			XmlSchemas schemas = ExportType (typeof (float));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("float", map.ElementName, "#3");
+			Assert.AreEqual ("NSSingle", map.Namespace, "#4");
+			Assert.AreEqual ("System.Single", map.TypeFullName, "#5");
+			Assert.AreEqual ("Single", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Double ()
+		{
+			XmlSchemas schemas = ExportType (typeof (double));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("double", map.ElementName, "#3");
+			Assert.AreEqual ("NSDouble", map.Namespace, "#4");
+			Assert.AreEqual ("System.Double", map.TypeFullName, "#5");
+			Assert.AreEqual ("Double", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_DateTime ()
+		{
+			XmlSchemas schemas = ExportType (typeof (DateTime));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("dateTime", map.ElementName, "#3");
+			Assert.AreEqual ("NSDateTime", map.Namespace, "#4");
+			Assert.AreEqual ("System.DateTime", map.TypeFullName, "#5");
+			Assert.AreEqual ("DateTime", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Decimal ()
+		{
+			XmlSchemas schemas = ExportType (typeof (decimal));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("decimal", map.ElementName, "#3");
+			Assert.AreEqual ("NSDecimal", map.Namespace, "#4");
+			Assert.AreEqual ("System.Decimal", map.TypeFullName, "#5");
+			Assert.AreEqual ("Decimal", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_QName ()
+		{
+			XmlSchemas schemas = ExportType (typeof (XmlQualifiedName));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("QName", map.ElementName, "#3");
+			Assert.AreEqual ("NSXmlQualifiedName", map.Namespace, "#4");
+			Assert.AreEqual ("System.Xml.XmlQualifiedName", map.TypeFullName, "#5");
+			Assert.AreEqual ("XmlQualifiedName", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_String ()
+		{
+			XmlSchemas schemas = ExportType (typeof (string));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("string", map.ElementName, "#3");
+			Assert.AreEqual ("NSString", map.Namespace, "#4");
+			Assert.AreEqual ("System.String", map.TypeFullName, "#5");
+			Assert.AreEqual ("String", map.TypeName, "#6");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ImportTypeMapping_XsdPrimitive_Guid ()
+		{
+			XmlSchemas schemas = ExportType (typeof (Guid));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("int", map.ElementName, "#3");
+			Assert.AreEqual ("NSInt32", map.Namespace, "#4");
+			Assert.AreEqual ("System.Int32", map.TypeFullName, "#5");
+			Assert.AreEqual ("Int32", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_UnsignedByte ()
+		{
+			XmlSchemas schemas = ExportType (typeof (byte));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("unsignedByte", map.ElementName, "#3");
+			Assert.AreEqual ("NSByte", map.Namespace, "#4");
+			Assert.AreEqual ("System.Byte", map.TypeFullName, "#5");
+			Assert.AreEqual ("Byte", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Byte ()
+		{
+			XmlSchemas schemas = ExportType (typeof (sbyte));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("byte", map.ElementName, "#3");
+			Assert.AreEqual ("NSSByte", map.Namespace, "#4");
+			Assert.AreEqual ("System.SByte", map.TypeFullName, "#5");
+			Assert.AreEqual ("SByte", map.TypeName, "#6");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ImportTypeMapping_XsdPrimitive_Char ()
+		{
+			XmlSchemas schemas = ExportType (typeof (char));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("int", map.ElementName, "#3");
+			Assert.AreEqual ("NSChar", map.Namespace, "#4");
+			Assert.AreEqual ("System.Int32", map.TypeFullName, "#5");
+			Assert.AreEqual ("Int32", map.TypeName, "#6");
+		}
+
+		[Test]
+		public void ImportTypeMapping_XsdPrimitive_Base64Binary ()
+		{
+			XmlSchemas schemas = ExportType (typeof (byte[]));
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#2");
+			Assert.AreEqual ("base64Binary", map.ElementName, "#3");
+			Assert.AreEqual ("NSByte[]", map.Namespace, "#4");
+			Assert.AreEqual ("System.Byte[]", map.TypeFullName, "#5");
+			Assert.AreEqual ("Byte[]", map.TypeName, "#6");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ImportTypeMapping_XsdPrimitive_Duration ()
+		{
+			string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
+				"<xs:schema xmlns:tns=\"NSDuration\" elementFormDefault=\"qualified\" targetNamespace=\"NSDuration\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
+				"  <xs:element name=\"duration\" type=\"xs:duration\" />" +
+				"</xs:schema>";
+
+			XmlSchemas schemas = new XmlSchemas ();
+			schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
+
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
+
+			Assert.AreEqual ("duration", qname.Name, "#2");
+			Assert.AreEqual ("NSDuration", qname.Namespace, "#3");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#4");
+			Assert.AreEqual ("duration", map.ElementName, "#5");
+			Assert.AreEqual ("NSDuration", map.Namespace, "#6");
+			Assert.AreEqual ("System.String", map.TypeFullName, "#7");
+			Assert.AreEqual ("String", map.TypeName, "#8");
+		}
+
+		[Test]
+		[Category ("NotWorking")]
+		public void ImportTypeMapping_XsdPrimitive_Date ()
+		{
+			string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
+				"<xs:schema xmlns:tns=\"NSDate\" elementFormDefault=\"qualified\" targetNamespace=\"NSDate\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
+				"  <xs:element name=\"date\" type=\"xs:date\" />" +
+				"</xs:schema>";
+
+			XmlSchemas schemas = new XmlSchemas ();
+			schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
+
+			ArrayList qnames = GetXmlQualifiedNames (schemas);
+			Assert.AreEqual (1, qnames.Count, "#1");
+
+			XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
+
+			Assert.AreEqual ("date", qname.Name, "#2");
+			Assert.AreEqual ("NSDate", qname.Namespace, "#3");
+
+			XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
+			XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
+
+			Assert.IsNotNull (map, "#4");
+			Assert.AreEqual ("date", map.ElementName, "#5");
+			Assert.AreEqual ("NSDate", map.Namespace, "#6");
+			Assert.AreEqual ("System.DateTime", map.TypeFullName, "#7");
+			Assert.AreEqual ("DateTime", map.TypeName, "#8");
+		}
+
+		private static XmlSchemas ExportType (Type type)
+		{
+			XmlReflectionImporter ri = new XmlReflectionImporter ("NS" + type.Name);
+			XmlSchemas schemas = new XmlSchemas ();
+			XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
+			XmlTypeMapping tm = ri.ImportTypeMapping (type);
+			sx.ExportTypeMapping (tm);
+			return schemas;
+		}
+
+		private static ArrayList GetXmlQualifiedNames (XmlSchemas schemas)
+		{
+			ArrayList qnames = new ArrayList ();
+
+			foreach (XmlSchema schema in schemas) {
+				if (!schema.IsCompiled) schema.Compile (null);
+				foreach (XmlSchemaObject ob in schema.Items)
+					if (ob is XmlSchemaElement)
+						qnames.Add (((XmlSchemaElement) ob).QualifiedName);
+			}
+
+			return qnames;
+		}
+	}
+}