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

   1 //\r
   2 // System.Xml.Serialization.XmlReflectionImporterTests\r
   3 //\r
   4 // Author:\r
   5 //   Erik LeBel (eriklebel@yahoo.ca)\r
   6 //\r
   7 // (C) 2003 Erik LeBel\r
   8 // \r
   9 // FIXME test some of these with Xml Attributes attached to some members: \r
  10 // do the names get carried over to Element for XmlAttributeAttribute and XmlElementAttribute?\r
  11 // \r
  12 \r
  13 using System;\r
  14 using System.Collections;\r
  15 using System.Xml;\r
  16 using System.Xml.Schema;\r
  17 using System.Xml.Serialization;\r
  18 \r
  19 using NUnit.Framework;\r
  20 \r
  21 using MonoTests.System.Xml.TestClasses;\r
  22 \r
  23 namespace MonoTests.System.XmlSerialization\r
  24 {\r
  25         // debugging class\r
  26         internal class Debug\r
  27         {\r
  28                 public static void Print(XmlTypeMapping tm)\r
  29                 {\r
  30                         Console.WriteLine("/XmlTypeMapping:");\r
  31                         Console.WriteLine("ElementName: {0} ", tm.ElementName);\r
  32                         Console.WriteLine("Namespace: {0} ", tm.Namespace);\r
  33                         Console.WriteLine("TypeName: {0} ", tm.TypeName);\r
  34                         Console.WriteLine("FullTypeName: {0} ", tm.TypeFullName);\r
  35                 }\r
  36 \r
  37                 public static void Print(XmlMemberMapping mm)\r
  38                 {\r
  39                         Console.WriteLine("/XmlMemberMapping:");\r
  40                         Console.WriteLine("Any: {0} ", mm.Any);\r
  41                         Console.WriteLine("ElementName: {0} ", mm.ElementName);\r
  42                         Console.WriteLine("MemberName: {0} ", mm.MemberName);\r
  43                         Console.WriteLine("Namespace: {0} ", mm.Namespace);\r
  44                         Console.WriteLine("TypeFullName: {0} ", mm.TypeFullName);\r
  45                         Console.WriteLine("TypeName: {0} ", mm.TypeName);\r
  46                         Console.WriteLine("TypeNamespace: {0} ", mm.TypeNamespace);\r
  47                 }\r
  48         }\r
  49 \r
  50         [TestFixture]\r
  51         public class XmlReflectionImporterTests\r
  52         {\r
  53                 private const string SomeNamespace = "some:urn";\r
  54                 private const string AnotherNamespace = "another:urn";\r
  55 \r
  56                 // these Map methods re-create the XmlReflectionImporter at every call.\r
  57 \r
  58                 private XmlTypeMapping Map(Type t)\r
  59                 {\r
  60                         XmlReflectionImporter ri = new XmlReflectionImporter();\r
  61                         XmlTypeMapping tm = ri.ImportTypeMapping(t);\r
  62                         //Debug.Print(tm);\r
  63 \r
  64                         return tm;\r
  65                 }\r
  66 \r
  67                 private XmlTypeMapping Map(Type t, XmlRootAttribute root)\r
  68                 {\r
  69                         XmlReflectionImporter ri = new XmlReflectionImporter();\r
  70                         XmlTypeMapping tm = ri.ImportTypeMapping(t, root);\r
  71 \r
  72                         return tm;\r
  73                 }\r
  74 \r
  75                 private XmlTypeMapping Map(Type t, string ns)\r
  76                 {\r
  77                         XmlReflectionImporter ri = new XmlReflectionImporter(ns);\r
  78                         XmlTypeMapping tm = ri.ImportTypeMapping(t);\r
  79                         //Debug.Print(tm);\r
  80 \r
  81                         return tm;\r
  82                 }\r
  83 \r
  84                 private XmlTypeMapping Map (Type t, string ns, XmlRootAttribute root)\r
  85                 {\r
  86                         XmlReflectionImporter ri = new XmlReflectionImporter (ns);\r
  87                         XmlTypeMapping tm = ri.ImportTypeMapping (t, root);\r
  88 \r
  89                         return tm;\r
  90                 }\r
  91 \r
  92                 private XmlTypeMapping Map(Type t, XmlAttributeOverrides overrides)\r
  93                 {\r
  94                         XmlReflectionImporter ri = new XmlReflectionImporter(overrides);\r
  95                         XmlTypeMapping tm = ri.ImportTypeMapping(t);\r
  96                         //Debug.Print(tm);\r
  97 \r
  98                         return tm;\r
  99                 }\r
 100 \r
 101                 private XmlMembersMapping MembersMap(Type t, XmlAttributeOverrides overrides, \r
 102                         XmlReflectionMember [] members, bool inContainer)\r
 103                 {\r
 104                         XmlReflectionImporter ri = new XmlReflectionImporter(overrides);\r
 105                         XmlMembersMapping mm = ri.ImportMembersMapping(null, null, members, inContainer);\r
 106                         \r
 107                         return mm;\r
 108                 }\r
 109                 \r
 110                 [Test]\r
 111                 public void TestIntTypeMapping()\r
 112                 {\r
 113                         XmlTypeMapping tm = Map(typeof(int));\r
 114                         Assert.AreEqual ("int", tm.ElementName, "#1");\r
 115                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 116                         Assert.AreEqual ("Int32", tm.TypeName, "#3");\r
 117                         Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");\r
 118                 }\r
 119 \r
 120                 [Test]\r
 121                 [Category ("NotWorking")]\r
 122                 public void TestIntTypeMapping_Array ()\r
 123                 {\r
 124                         XmlTypeMapping tm = Map(typeof(int[]));\r
 125                         Assert.AreEqual ("ArrayOfInt", tm.ElementName, "#A1");\r
 126                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 127 #if NET_2_0\r
 128                         Assert.AreEqual ("ArrayOfInt32", tm.TypeName, "#A3");\r
 129 #else\r
 130                         Assert.AreEqual ("Int32[]", tm.TypeName, "#A3");\r
 131 #endif\r
 132                         Assert.AreEqual ("System.Int32[]", tm.TypeFullName, "#A4");\r
 133 \r
 134                         tm = Map (typeof (int[][]));\r
 135                         Assert.AreEqual ("ArrayOfArrayOfInt", tm.ElementName, "#B1");\r
 136                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 137 #if NET_2_0\r
 138                         Assert.AreEqual ("ArrayOfArrayOfInt32", tm.TypeName, "#B3");\r
 139 #else\r
 140                         Assert.AreEqual ("Int32[][]", tm.TypeName, "#B3");\r
 141 #endif\r
 142                         Assert.AreEqual ("System.Int32[][]", tm.TypeFullName, "#B4");\r
 143 \r
 144                         tm = Map (typeof (int[][][]));\r
 145                         Assert.AreEqual ("ArrayOfArrayOfArrayOfInt", tm.ElementName, "#C1");\r
 146                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 147 #if NET_2_0\r
 148                         Assert.AreEqual ("ArrayOfArrayOfArrayOfInt32", tm.TypeName, "#C3");\r
 149 #else\r
 150                         Assert.AreEqual ("Int32[][][]", tm.TypeName, "#C3");\r
 151 #endif\r
 152                         Assert.AreEqual ("System.Int32[][][]", tm.TypeFullName, "#C4");\r
 153                 }\r
 154 \r
 155                 [Test]\r
 156                 public void TestStringTypeMapping()\r
 157                 {\r
 158                         XmlTypeMapping tm = Map(typeof(string));\r
 159                         Assert.AreEqual ("string", tm.ElementName, "#1");\r
 160                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 161                         Assert.AreEqual ("String", tm.TypeName, "#3");\r
 162                         Assert.AreEqual ("System.String", tm.TypeFullName, "#4");\r
 163                 }\r
 164 \r
 165                 [Test]\r
 166                 [Category ("NotWorking")]\r
 167                 public void TestStringTypeMapping_Array ()\r
 168                 {\r
 169                         XmlTypeMapping tm = Map (typeof (string[]));\r
 170                         Assert.AreEqual ("ArrayOfString", tm.ElementName, "#A1");\r
 171                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 172 #if NET_2_0\r
 173                         Assert.AreEqual ("ArrayOfString", tm.TypeName, "#A3");\r
 174 #else\r
 175                         Assert.AreEqual ("String[]", tm.TypeName, "#A3");\r
 176 #endif\r
 177                         Assert.AreEqual ("System.String[]", tm.TypeFullName, "#A4");\r
 178 \r
 179                         tm = Map (typeof (string[][]));\r
 180                         Assert.AreEqual ("ArrayOfArrayOfString", tm.ElementName, "#B1");\r
 181                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 182 #if NET_2_0\r
 183                         Assert.AreEqual ("ArrayOfArrayOfString", tm.TypeName, "#B3");\r
 184 #else\r
 185                         Assert.AreEqual ("String[][]", tm.TypeName, "#B3");\r
 186 #endif\r
 187                         Assert.AreEqual ("System.String[][]", tm.TypeFullName, "#B4");\r
 188 \r
 189                         tm = Map (typeof (string[][][]));\r
 190                         Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.ElementName, "#C1");\r
 191                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 192 #if NET_2_0\r
 193                         Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.TypeName, "#C3");\r
 194 #else\r
 195                         Assert.AreEqual ("String[][][]", tm.TypeName, "#C3");\r
 196 #endif\r
 197                         Assert.AreEqual ("System.String[][][]", tm.TypeFullName, "#C4");\r
 198                 }\r
 199 \r
 200                 [Test]\r
 201                 public void TestObjectTypeMapping()\r
 202                 {\r
 203                         XmlTypeMapping tm = Map(typeof(object));\r
 204                         Assert.AreEqual ("anyType", tm.ElementName, "#1");\r
 205                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 206                         Assert.AreEqual ("Object", tm.TypeName, "#3");\r
 207                         Assert.AreEqual ("System.Object", tm.TypeFullName, "#4");\r
 208                 }\r
 209 \r
 210                 [Test]\r
 211                 [Category ("NotWorking")]\r
 212                 public void TestObjectTypeMapping_Array ()\r
 213                 {\r
 214                         XmlTypeMapping tm = Map (typeof (object[]));\r
 215                         Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#A1");\r
 216                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 217 #if NET_2_0\r
 218                         Assert.AreEqual ("ArrayOfObject", tm.TypeName, "#A3");\r
 219 #else\r
 220                         Assert.AreEqual ("Object[]", tm.TypeName, "#A3");\r
 221 #endif\r
 222                         Assert.AreEqual ("System.Object[]", tm.TypeFullName, "#A4");\r
 223 \r
 224                         tm = Map (typeof (object[][]));\r
 225                         Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
 226                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 227 #if NET_2_0\r
 228                         Assert.AreEqual ("ArrayOfArrayOfObject", tm.TypeName, "#B3");\r
 229 #else\r
 230                         Assert.AreEqual ("Object[][]", tm.TypeName, "#B3");\r
 231 #endif\r
 232                         Assert.AreEqual ("System.Object[][]", tm.TypeFullName, "#B4");\r
 233 \r
 234                         tm = Map (typeof (object[][][]));\r
 235                         Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
 236                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 237 #if NET_2_0\r
 238                         Assert.AreEqual ("ArrayOfArrayOfArrayOfObject", tm.TypeName, "#C3");\r
 239 #else\r
 240                         Assert.AreEqual ("Object[][][]", tm.TypeName, "#C3");\r
 241 #endif\r
 242                         Assert.AreEqual ("System.Object[][][]", tm.TypeFullName, "#C4");\r
 243                 }\r
 244 \r
 245                 [Test]\r
 246                 public void TestByteTypeMapping()\r
 247                 {\r
 248                         XmlTypeMapping tm = Map(typeof(byte));\r
 249                         Assert.AreEqual ("unsignedByte", tm.ElementName, "#1");\r
 250                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 251                         Assert.AreEqual ("Byte", tm.TypeName, "#3");\r
 252                         Assert.AreEqual ("System.Byte", tm.TypeFullName, "#4");\r
 253                 }\r
 254 \r
 255                 [Test]\r
 256                 [Category ("NotWorking")]\r
 257                 public void TestByteTypeMapping_Array ()\r
 258                 {\r
 259                         XmlTypeMapping tm = Map(typeof(byte[]));\r
 260                         Assert.AreEqual ("base64Binary", tm.ElementName, "#A1");\r
 261                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 262                         Assert.AreEqual ("Byte[]", tm.TypeName, "#A3");\r
 263                         Assert.AreEqual ("System.Byte[]", tm.TypeFullName, "#A4");\r
 264 \r
 265                         tm = Map (typeof (byte[][]));\r
 266                         Assert.AreEqual ("ArrayOfBase64Binary", tm.ElementName, "#B1");\r
 267                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 268 #if NET_2_0\r
 269                         Assert.AreEqual ("ArrayOfArrayOfByte", tm.TypeName, "#B3");\r
 270 #else\r
 271                         Assert.AreEqual ("Byte[][]", tm.TypeName, "#B3");\r
 272 #endif\r
 273                         Assert.AreEqual ("System.Byte[][]", tm.TypeFullName, "#B4");\r
 274 \r
 275                         tm = Map (typeof (byte[][][]));\r
 276                         Assert.AreEqual ("ArrayOfArrayOfBase64Binary", tm.ElementName, "#C1");\r
 277                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 278 #if NET_2_0\r
 279                         Assert.AreEqual ("ArrayOfArrayOfArrayOfByte", tm.TypeName, "#C3");\r
 280 #else\r
 281                         Assert.AreEqual ("Byte[][][]", tm.TypeName, "#C3");\r
 282 #endif\r
 283                         Assert.AreEqual ("System.Byte[][][]", tm.TypeFullName, "#C4");\r
 284                 }\r
 285 \r
 286                 [Test]\r
 287                 public void TestBoolTypeMapping()\r
 288                 {\r
 289                         XmlTypeMapping tm = Map(typeof(bool));\r
 290                         Assert.AreEqual ("boolean", tm.ElementName, "#1");\r
 291                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 292                         Assert.AreEqual ("Boolean", tm.TypeName, "#3");\r
 293                         Assert.AreEqual ("System.Boolean", tm.TypeFullName, "#4");\r
 294                 }\r
 295 \r
 296                 [Test]\r
 297                 public void TestShortTypeMapping()\r
 298                 {\r
 299                         XmlTypeMapping tm = Map(typeof(short));\r
 300                         Assert.AreEqual ("short", tm.ElementName, "#1");\r
 301                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 302                         Assert.AreEqual ("Int16", tm.TypeName, "#3");\r
 303                         Assert.AreEqual ("System.Int16", tm.TypeFullName, "#4");\r
 304                 }\r
 305 \r
 306                 [Test]\r
 307                 public void TestUnsignedShortTypeMapping()\r
 308                 {\r
 309                         XmlTypeMapping tm = Map(typeof(ushort));\r
 310                         Assert.AreEqual ("unsignedShort", tm.ElementName, "#1");\r
 311                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 312                         Assert.AreEqual ("UInt16", tm.TypeName, "#3");\r
 313                         Assert.AreEqual ("System.UInt16", tm.TypeFullName, "#4");\r
 314                 }\r
 315                 \r
 316                 [Test]\r
 317                 public void TestUIntTypeMapping()\r
 318                 {\r
 319                         XmlTypeMapping tm = Map(typeof(uint));\r
 320                         Assert.AreEqual ("unsignedInt", tm.ElementName, "#1");\r
 321                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 322                         Assert.AreEqual ("UInt32", tm.TypeName, "#3");\r
 323                         Assert.AreEqual ("System.UInt32", tm.TypeFullName, "#4");\r
 324                 }\r
 325                 \r
 326                 [Test]\r
 327                 public void TestLongTypeMapping()\r
 328                 {\r
 329                         XmlTypeMapping tm = Map(typeof(long));\r
 330                         Assert.AreEqual ("long", tm.ElementName, "#1");\r
 331                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 332                         Assert.AreEqual ("Int64", tm.TypeName, "#3");\r
 333                         Assert.AreEqual ("System.Int64", tm.TypeFullName, "#4");\r
 334                 }\r
 335                 \r
 336                 [Test]\r
 337                 public void TestULongTypeMapping()\r
 338                 {\r
 339                         XmlTypeMapping tm = Map(typeof(ulong));\r
 340                         Assert.AreEqual ("unsignedLong", tm.ElementName, "#1");\r
 341                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 342                         Assert.AreEqual ("UInt64", tm.TypeName, "#3");\r
 343                         Assert.AreEqual ("System.UInt64", tm.TypeFullName, "#4");\r
 344                 }\r
 345                 \r
 346                 [Test]\r
 347                 public void TestFloatTypeMapping()\r
 348                 {\r
 349                         XmlTypeMapping tm = Map(typeof(float));\r
 350                         Assert.AreEqual ("float", tm.ElementName, "#1");\r
 351                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 352                         Assert.AreEqual ("Single", tm.TypeName, "#3");\r
 353                         Assert.AreEqual ("System.Single", tm.TypeFullName, "#4");\r
 354                 }\r
 355                 \r
 356                 [Test]\r
 357                 public void TestDoubleTypeMapping()\r
 358                 {\r
 359                         XmlTypeMapping tm = Map(typeof(double));\r
 360                         Assert.AreEqual ("double", tm.ElementName, "#1");\r
 361                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 362                         Assert.AreEqual ("Double", tm.TypeName, "#3");\r
 363                         Assert.AreEqual ("System.Double", tm.TypeFullName, "#4");\r
 364                 }\r
 365                 \r
 366                 [Test]\r
 367                 public void TestDateTimeTypeMapping()\r
 368                 {\r
 369                         XmlTypeMapping tm = Map(typeof(DateTime));\r
 370                         Assert.AreEqual ("dateTime", tm.ElementName, "#1");\r
 371                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 372                         Assert.AreEqual ("DateTime", tm.TypeName, "#3");\r
 373                         Assert.AreEqual ("System.DateTime", tm.TypeFullName, "#4");\r
 374                 }\r
 375 \r
 376                 [Test]\r
 377                 [Category ("NotWorking")]\r
 378                 public void TestDateTimeTypeMapping_Array ()\r
 379                 {\r
 380                         XmlTypeMapping tm = Map (typeof (DateTime[]));\r
 381                         Assert.AreEqual ("ArrayOfDateTime", tm.ElementName, "#A1");\r
 382                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 383 #if NET_2_0\r
 384                         Assert.AreEqual ("ArrayOfDateTime", tm.TypeName, "#A3");\r
 385 #else\r
 386                         Assert.AreEqual ("DateTime[]", tm.TypeName, "#A3");\r
 387 #endif\r
 388                         Assert.AreEqual ("System.DateTime[]", tm.TypeFullName, "#A4");\r
 389 \r
 390                         tm = Map (typeof (DateTime[][]));\r
 391                         Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.ElementName, "#B1");\r
 392                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 393 #if NET_2_0\r
 394                         Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.TypeName, "#B3");\r
 395 #else\r
 396                         Assert.AreEqual ("DateTime[][]", tm.TypeName, "#B3");\r
 397 #endif\r
 398                         Assert.AreEqual ("System.DateTime[][]", tm.TypeFullName, "#B4");\r
 399 \r
 400                         tm = Map (typeof (DateTime[][][]));\r
 401                         Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.ElementName, "#C1");\r
 402                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 403 #if NET_2_0\r
 404                         Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.TypeName, "#C3");\r
 405 #else\r
 406                         Assert.AreEqual ("DateTime[][][]", tm.TypeName, "#C3");\r
 407 #endif\r
 408                         Assert.AreEqual ("System.DateTime[][][]", tm.TypeFullName, "#C4");\r
 409                 }\r
 410 \r
 411                 [Test]\r
 412                 public void TestGuidTypeMapping()\r
 413                 {\r
 414                         XmlTypeMapping tm = Map(typeof(Guid));\r
 415                         Assert.AreEqual ("guid", tm.ElementName, "#1");\r
 416                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 417                         Assert.AreEqual ("Guid", tm.TypeName, "#3");\r
 418                         Assert.AreEqual ("System.Guid", tm.TypeFullName, "#4");\r
 419                 }\r
 420 \r
 421                 [Test]\r
 422                 [Category ("NotWorking")]\r
 423                 public void TestGuidTypeMapping_Array ()\r
 424                 {\r
 425                         XmlTypeMapping tm = Map (typeof (Guid[]));\r
 426                         Assert.AreEqual ("ArrayOfGuid", tm.ElementName, "#A1");\r
 427                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 428 #if NET_2_0\r
 429                         Assert.AreEqual ("ArrayOfGuid", tm.TypeName, "#A3");\r
 430 #else\r
 431                         Assert.AreEqual ("Guid[]", tm.TypeName, "#A3");\r
 432 #endif\r
 433                         Assert.AreEqual ("System.Guid[]", tm.TypeFullName, "#A4");\r
 434 \r
 435                         tm = Map (typeof (Guid[][]));\r
 436                         Assert.AreEqual ("ArrayOfArrayOfGuid", tm.ElementName, "#B1");\r
 437                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 438 #if NET_2_0\r
 439                         Assert.AreEqual ("ArrayOfArrayOfGuid", tm.TypeName, "#B3");\r
 440 #else\r
 441                         Assert.AreEqual ("Guid[][]", tm.TypeName, "#B3");\r
 442 #endif\r
 443                         Assert.AreEqual ("System.Guid[][]", tm.TypeFullName, "#B4");\r
 444 \r
 445                         tm = Map (typeof (Guid[][][]));\r
 446                         Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.ElementName, "#C1");\r
 447                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 448 #if NET_2_0\r
 449                         Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.TypeName, "#C3");\r
 450 #else\r
 451                         Assert.AreEqual ("Guid[][][]", tm.TypeName, "#C3");\r
 452 #endif\r
 453                         Assert.AreEqual ("System.Guid[][][]", tm.TypeFullName, "#C4");\r
 454                 }\r
 455 \r
 456                 [Test]\r
 457                 public void TestDecimalTypeMapping()\r
 458                 {\r
 459                         XmlTypeMapping tm = Map(typeof(decimal));\r
 460                         Assert.AreEqual ("decimal", tm.ElementName, "#1");\r
 461                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 462                         Assert.AreEqual ("Decimal", tm.TypeName, "#3");\r
 463                         Assert.AreEqual ("System.Decimal", tm.TypeFullName, "#4");\r
 464                 }\r
 465                 \r
 466                 [Test]\r
 467                 public void TestXmlQualifiedNameTypeMapping()\r
 468                 {\r
 469                         XmlTypeMapping tm = Map(typeof(XmlQualifiedName));\r
 470                         Assert.AreEqual ("QName", tm.ElementName, "#1");\r
 471                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 472                         Assert.AreEqual ("XmlQualifiedName", tm.TypeName, "#3");\r
 473                         Assert.AreEqual ("System.Xml.XmlQualifiedName", tm.TypeFullName, "#4");\r
 474                 }\r
 475                 \r
 476                 [Test]\r
 477                 public void TestSByteTypeMapping()\r
 478                 {\r
 479                         XmlTypeMapping tm = Map(typeof(sbyte));\r
 480                         Assert.AreEqual ("byte", tm.ElementName, "#1");\r
 481                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 482                         Assert.AreEqual ("SByte", tm.TypeName, "#3");\r
 483                         Assert.AreEqual ("System.SByte", tm.TypeFullName, "#4");\r
 484                 }\r
 485                 \r
 486 \r
 487                 [Test]\r
 488                 public void TestCharTypeMapping()\r
 489                 {\r
 490                         XmlTypeMapping tm = Map(typeof(char));\r
 491                         Assert.AreEqual ("char", tm.ElementName, "#1");\r
 492                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 493                         Assert.AreEqual ("Char", tm.TypeName, "#3");\r
 494                         Assert.AreEqual ("System.Char", tm.TypeFullName, "#4");\r
 495                 }\r
 496 \r
 497                 [Test]\r
 498                 [Category ("NotWorking")]\r
 499                 public void TestCharTypeMapping_Array ()\r
 500                 {\r
 501                         XmlTypeMapping tm = Map (typeof (char[]));\r
 502                         Assert.AreEqual ("ArrayOfChar", tm.ElementName, "#A1");\r
 503                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 504 #if NET_2_0\r
 505                         Assert.AreEqual ("ArrayOfChar", tm.TypeName, "#A3");\r
 506 #else\r
 507                         Assert.AreEqual ("Char[]", tm.TypeName, "#A3");\r
 508 #endif\r
 509                         Assert.AreEqual ("System.Char[]", tm.TypeFullName, "#A4");\r
 510 \r
 511                         tm = Map (typeof (char[][]));\r
 512                         Assert.AreEqual ("ArrayOfArrayOfChar", tm.ElementName, "#B1");\r
 513                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 514 #if NET_2_0\r
 515                         Assert.AreEqual ("ArrayOfArrayOfChar", tm.TypeName, "#B3");\r
 516 #else\r
 517                         Assert.AreEqual ("Char[][]", tm.TypeName, "#B3");\r
 518 #endif\r
 519                         Assert.AreEqual ("System.Char[][]", tm.TypeFullName, "#B4");\r
 520 \r
 521                         tm = Map (typeof (char[][][]));\r
 522                         Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.ElementName, "#C1");\r
 523                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 524 #if NET_2_0\r
 525                         Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.TypeName, "#C3");\r
 526 #else\r
 527                         Assert.AreEqual ("Char[][][]", tm.TypeName, "#C3");\r
 528 #endif\r
 529                         Assert.AreEqual ("System.Char[][][]", tm.TypeFullName, "#C4");\r
 530                 }\r
 531 \r
 532                 [Test]\r
 533                 [Category ("NotWorking")]\r
 534                 public void TestXmlNodeTypeMapping ()\r
 535                 {\r
 536                         Type type = typeof (XmlNode);\r
 537 \r
 538                         XmlTypeMapping tm = Map (type);\r
 539                         Assert.AreEqual (string.Empty, tm.ElementName, "#A1");\r
 540                         Assert.IsNull (tm.Namespace, "#A2");\r
 541                         Assert.AreEqual ("XmlNode", tm.TypeName, "#A3");\r
 542                         Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#A4");\r
 543 \r
 544                         tm = Map (type, AnotherNamespace);\r
 545                         Assert.AreEqual (string.Empty, tm.ElementName, "#B1");\r
 546                         Assert.IsNull (tm.Namespace, "#B2");\r
 547                         Assert.AreEqual ("XmlNode", tm.TypeName, "#B3");\r
 548                         Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#B4");\r
 549 \r
 550                         XmlRootAttribute root = new XmlRootAttribute ("somename");\r
 551                         root.Namespace = SomeNamespace;\r
 552                         tm = Map (type, root);\r
 553                         Assert.AreEqual ("somename", tm.ElementName, "#C1");\r
 554                         Assert.IsNull (tm.Namespace, "#C2");\r
 555                         Assert.AreEqual ("XmlNode", tm.TypeName, "#C3");\r
 556                         Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#C4");\r
 557 \r
 558                         tm = Map (type, AnotherNamespace, root);\r
 559                         Assert.AreEqual ("somename", tm.ElementName, "#D1");\r
 560                         Assert.IsNull (tm.Namespace, "#D2");\r
 561                         Assert.AreEqual ("XmlNode", tm.TypeName, "#D3");\r
 562                         Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#D4");\r
 563 \r
 564                         root.Namespace = null;\r
 565                         tm = Map (type, root);\r
 566                         Assert.AreEqual ("somename", tm.ElementName, "#E1");\r
 567                         Assert.IsNull (tm.Namespace, "#E2");\r
 568                         Assert.AreEqual ("XmlNode", tm.TypeName, "#E3");\r
 569                         Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#E4");\r
 570 \r
 571                         tm = Map (type, AnotherNamespace, root);\r
 572                         Assert.AreEqual ("somename", tm.ElementName, "#F1");\r
 573                         Assert.IsNull (tm.Namespace, "#F2");\r
 574                         Assert.AreEqual ("XmlNode", tm.TypeName, "#F3");\r
 575                         Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#F4");\r
 576                 }\r
 577 \r
 578                 [Test]\r
 579                 [Category ("NotWorking")]\r
 580                 public void TestXmlElementTypeMapping ()\r
 581                 {\r
 582                         Type type = typeof (XmlElement);\r
 583 \r
 584                         XmlTypeMapping tm = Map (type);\r
 585                         Assert.AreEqual (string.Empty, tm.ElementName, "#1");\r
 586                         Assert.IsNull (tm.Namespace, "#2");\r
 587                         Assert.AreEqual ("XmlElement", tm.TypeName, "#3");\r
 588                         Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#4");\r
 589 \r
 590                         tm = Map (type, AnotherNamespace);\r
 591                         Assert.AreEqual (string.Empty, tm.ElementName, "#B1");\r
 592                         Assert.IsNull (tm.Namespace, "#B2");\r
 593                         Assert.AreEqual ("XmlElement", tm.TypeName, "#B3");\r
 594                         Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#B4");\r
 595 \r
 596                         XmlRootAttribute root = new XmlRootAttribute ("somename");\r
 597                         root.Namespace = SomeNamespace;\r
 598                         tm = Map (type, root);\r
 599                         Assert.AreEqual ("somename", tm.ElementName, "#C1");\r
 600                         Assert.IsNull (tm.Namespace, "#C2");\r
 601                         Assert.AreEqual ("XmlElement", tm.TypeName, "#C3");\r
 602                         Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#C4");\r
 603 \r
 604                         tm = Map (type, AnotherNamespace, root);\r
 605                         Assert.AreEqual ("somename", tm.ElementName, "#D1");\r
 606                         Assert.IsNull (tm.Namespace, "#D2");\r
 607                         Assert.AreEqual ("XmlElement", tm.TypeName, "#D3");\r
 608                         Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#D4");\r
 609 \r
 610                         root.Namespace = null;\r
 611                         tm = Map (type, root);\r
 612                         Assert.AreEqual ("somename", tm.ElementName, "#E1");\r
 613                         Assert.IsNull (tm.Namespace, "#E2");\r
 614                         Assert.AreEqual ("XmlElement", tm.TypeName, "#E3");\r
 615                         Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#E4");\r
 616 \r
 617                         tm = Map (type, AnotherNamespace, root);\r
 618                         Assert.AreEqual ("somename", tm.ElementName, "#F1");\r
 619                         Assert.IsNull (tm.Namespace, "#F2");\r
 620                         Assert.AreEqual ("XmlElement", tm.TypeName, "#F3");\r
 621                         Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#F4");\r
 622                 }\r
 623 \r
 624                 [Test]\r
 625                 [Category ("NotWorking")]\r
 626                 public void TestXmlNotationTypeMapping ()\r
 627                 {\r
 628                         Type type = typeof (XmlNotation);\r
 629 \r
 630                         XmlTypeMapping tm = Map (type);\r
 631                         Assert.AreEqual (string.Empty, tm.ElementName, "#1");\r
 632                         Assert.IsNull (tm.Namespace, "#2");\r
 633                         Assert.AreEqual ("XmlNotation", tm.TypeName, "#3");\r
 634                         Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#4");\r
 635 \r
 636                         tm = Map (type, AnotherNamespace);\r
 637                         Assert.AreEqual (string.Empty, tm.ElementName, "#B1");\r
 638                         Assert.IsNull (tm.Namespace, "#B2");\r
 639                         Assert.AreEqual ("XmlNotation", tm.TypeName, "#B3");\r
 640                         Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#B4");\r
 641 \r
 642                         XmlRootAttribute root = new XmlRootAttribute ("somename");\r
 643                         root.Namespace = SomeNamespace;\r
 644                         tm = Map (type, root);\r
 645                         Assert.AreEqual ("somename", tm.ElementName, "#C1");\r
 646                         Assert.IsNull (tm.Namespace, "#C2");\r
 647                         Assert.AreEqual ("XmlNotation", tm.TypeName, "#C3");\r
 648                         Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#C4");\r
 649 \r
 650                         tm = Map (type, AnotherNamespace, root);\r
 651                         Assert.AreEqual ("somename", tm.ElementName, "#D1");\r
 652                         Assert.IsNull (tm.Namespace, "#D2");\r
 653                         Assert.AreEqual ("XmlNotation", tm.TypeName, "#D3");\r
 654                         Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#D4");\r
 655 \r
 656                         root.Namespace = null;\r
 657                         tm = Map (type, root);\r
 658                         Assert.AreEqual ("somename", tm.ElementName, "#E1");\r
 659                         Assert.IsNull (tm.Namespace, "#E2");\r
 660                         Assert.AreEqual ("XmlNotation", tm.TypeName, "#E3");\r
 661                         Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#E4");\r
 662 \r
 663                         tm = Map (type, AnotherNamespace, root);\r
 664                         Assert.AreEqual ("somename", tm.ElementName, "#F1");\r
 665                         Assert.IsNull (tm.Namespace, "#F2");\r
 666                         Assert.AreEqual ("XmlNotation", tm.TypeName, "#F3");\r
 667                         Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#F4");\r
 668                 }\r
 669 \r
 670                 [Test]\r
 671                 [Category ("NotWorking")]\r
 672                 public void TestXmlSerializableTypeMapping ()\r
 673                 {\r
 674                         XmlTypeMapping tm = Map (typeof (Employee));\r
 675                         Assert.AreEqual ("Employee", tm.ElementName, "#1");\r
 676                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 677                         Assert.AreEqual ("Employee", tm.TypeName, "#3");\r
 678                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee", tm.TypeFullName, "#4");\r
 679                 }\r
 680 \r
 681                 [Test]\r
 682                 [Category ("NotWorking")]\r
 683                 public void TestXmlSerializableTypeMapping_Array ()\r
 684                 {\r
 685                         XmlTypeMapping tm = Map (typeof (Employee[]));\r
 686                         Assert.AreEqual ("ArrayOfEmployee", tm.ElementName, "#A1");\r
 687                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 688 #if NET_2_0\r
 689                         Assert.AreEqual ("ArrayOfEmployee", tm.TypeName, "#A3");\r
 690 #else\r
 691                         Assert.AreEqual ("Employee[]", tm.TypeName, "#A3");\r
 692 #endif\r
 693                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[]", tm.TypeFullName, "#A4");\r
 694 \r
 695                         tm = Map (typeof (Employee[][]));\r
 696                         Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.ElementName, "#B1");\r
 697                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 698 #if NET_2_0\r
 699                         Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.TypeName, "#B3");\r
 700 #else\r
 701                         Assert.AreEqual ("Employee[][]", tm.TypeName, "#B3");\r
 702 #endif\r
 703                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[][]", tm.TypeFullName, "#B4");\r
 704 \r
 705                         tm = Map (typeof (Employee[][][]));\r
 706                         Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.ElementName, "#C1");\r
 707                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 708 #if NET_2_0\r
 709                         Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.TypeName, "#C3");\r
 710 #else\r
 711                         Assert.AreEqual ("Employee[][][]", tm.TypeName, "#C3");\r
 712 #endif\r
 713                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[][][]", tm.TypeFullName, "#C4");\r
 714                 }\r
 715 \r
 716                 [Test]\r
 717                 [Category ("NotWorking")]\r
 718                 public void TestClassTypeMapping_NestedStruct ()\r
 719                 {\r
 720                         XmlTypeMapping tm = Map (typeof (NestedStruct));\r
 721                         Assert.AreEqual ("NestedStruct", tm.ElementName, "#1");\r
 722                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 723                         Assert.AreEqual ("NestedStruct", tm.TypeName, "#3");\r
 724                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.NestedStruct", tm.TypeFullName, "#4");\r
 725                 }\r
 726 \r
 727                 [Test]\r
 728                 [ExpectedException (typeof (ArgumentNullException))]\r
 729                 public void TestNullTypeMapping()\r
 730                 {\r
 731                         Map(null);\r
 732                 }\r
 733 \r
 734                 [Test]\r
 735                 public void TestIntTypeMappingWithDefaultNamespaces()\r
 736                 {\r
 737                         XmlTypeMapping tm = Map(typeof(int), SomeNamespace);\r
 738                         Assert.AreEqual ("int", tm.ElementName, "#1");\r
 739                         Assert.AreEqual (SomeNamespace, tm.Namespace, "#2");\r
 740                         Assert.AreEqual ("Int32", tm.TypeName, "#3");\r
 741                         Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");\r
 742                 }\r
 743 \r
 744                 [Test]\r
 745                 [Category ("NotWorking")]\r
 746                 public void TestStructTypeMapping ()\r
 747                 {\r
 748                         XmlTypeMapping tm = Map (typeof (TimeSpan));\r
 749                         Assert.AreEqual ("TimeSpan", tm.ElementName, "#1");\r
 750                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 751                         Assert.AreEqual ("TimeSpan", tm.TypeName, "#3");\r
 752                         Assert.AreEqual ("System.TimeSpan", tm.TypeFullName, "#4");\r
 753                 }\r
 754 \r
 755                 [Test]\r
 756                 [Category ("NotWorking")]\r
 757                 public void TestStructTypeMapping_Array ()\r
 758                 {\r
 759                         XmlTypeMapping tm = Map (typeof (TimeSpan[]));\r
 760                         Assert.AreEqual ("ArrayOfTimeSpan", tm.ElementName, "#A1");\r
 761                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 762 #if NET_2_0\r
 763                         Assert.AreEqual ("ArrayOfTimeSpan", tm.TypeName, "#A3");\r
 764 #else\r
 765                         Assert.AreEqual ("TimeSpan[]", tm.TypeName, "#A3");\r
 766 #endif\r
 767                         Assert.AreEqual ("System.TimeSpan[]", tm.TypeFullName, "#A4");\r
 768 \r
 769                         tm = Map (typeof (TimeSpan[][]));\r
 770                         Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.ElementName, "#B1");\r
 771                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 772 #if NET_2_0\r
 773                         Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.TypeName, "#B3");\r
 774 #else\r
 775                         Assert.AreEqual ("TimeSpan[][]", tm.TypeName, "#B3");\r
 776 #endif\r
 777                         Assert.AreEqual ("System.TimeSpan[][]", tm.TypeFullName, "#B4");\r
 778 \r
 779                         tm = Map (typeof (TimeSpan[][][]));\r
 780                         Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.ElementName, "#C1");\r
 781                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 782 #if NET_2_0\r
 783                         Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.TypeName, "#C3");\r
 784 #else\r
 785                         Assert.AreEqual ("TimeSpan[][][]", tm.TypeName, "#C3");\r
 786 #endif\r
 787                         Assert.AreEqual ("System.TimeSpan[][][]", tm.TypeFullName, "#C4");\r
 788                 }\r
 789 \r
 790                 [Test]\r
 791                 [Category ("NotWorking")]\r
 792                 public void TestEnumTypeMapping ()\r
 793                 {\r
 794                         XmlTypeMapping tm = Map (typeof (AttributeTargets));\r
 795                         Assert.AreEqual ("AttributeTargets", tm.ElementName, "#1");\r
 796                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 797                         Assert.AreEqual ("AttributeTargets", tm.TypeName, "#3");\r
 798                         Assert.AreEqual ("System.AttributeTargets", tm.TypeFullName, "#4");\r
 799                 }\r
 800 \r
 801                 [Test]\r
 802                 [Category ("NotWorking")]\r
 803                 public void TestEnumTypeMapping_Array ()\r
 804                 {\r
 805                         XmlTypeMapping tm = Map (typeof (AttributeTargets[]));\r
 806                         Assert.AreEqual ("ArrayOfAttributeTargets", tm.ElementName, "#A1");\r
 807                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 808 #if NET_2_0\r
 809                         Assert.AreEqual ("ArrayOfAttributeTargets", tm.TypeName, "#A3");\r
 810 #else\r
 811                         Assert.AreEqual ("AttributeTargets[]", tm.TypeName, "#A3");\r
 812 #endif\r
 813                         Assert.AreEqual ("System.AttributeTargets[]", tm.TypeFullName, "#A4");\r
 814 \r
 815                         tm = Map (typeof (AttributeTargets[][]));\r
 816                         Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.ElementName, "#B1");\r
 817                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 818 #if NET_2_0\r
 819                         Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.TypeName, "#B3");\r
 820 #else\r
 821                         Assert.AreEqual ("AttributeTargets[][]", tm.TypeName, "#B3");\r
 822 #endif\r
 823                         Assert.AreEqual ("System.AttributeTargets[][]", tm.TypeFullName, "#B4");\r
 824 \r
 825                         tm = Map (typeof (AttributeTargets[][][]));\r
 826                         Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.ElementName, "#C1");\r
 827                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 828 #if NET_2_0\r
 829                         Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.TypeName, "#C3");\r
 830 #else\r
 831                         Assert.AreEqual ("AttributeTargets[][][]", tm.TypeName, "#C3");\r
 832 #endif\r
 833                         Assert.AreEqual ("System.AttributeTargets[][][]", tm.TypeFullName, "#C4");\r
 834                 }\r
 835 \r
 836                 [Test]\r
 837                 public void TestClassTypeMapping()\r
 838                 {\r
 839                         XmlTypeMapping tm = Map (typeof (SimpleClass));\r
 840                         Assert.AreEqual ("SimpleClass", tm.ElementName, "#1");\r
 841                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 842                         Assert.AreEqual ("SimpleClass", tm.TypeName, "#3");\r
 843                         Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass", tm.TypeFullName, "#4");\r
 844                 }\r
 845 \r
 846                 [Test]\r
 847                 [Category ("NotWorking")]\r
 848                 public void TestClassTypeMapping_Array ()\r
 849                 {\r
 850                         XmlTypeMapping tm = Map (typeof (SimpleClass[]));\r
 851                         Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#A1");\r
 852                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 853 #if NET_2_0\r
 854                         Assert.AreEqual ("ArrayOfSimpleClass", tm.TypeName, "#A3");\r
 855 #else\r
 856                         Assert.AreEqual ("SimpleClass[]", tm.TypeName, "#A3");\r
 857 #endif\r
 858                         Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[]", tm.TypeFullName, "#A4");\r
 859 \r
 860                         tm = Map (typeof (SimpleClass[][]));\r
 861                         Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");\r
 862                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 863 #if NET_2_0\r
 864                         Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.TypeName, "#B3");\r
 865 #else\r
 866                         Assert.AreEqual ("SimpleClass[][]", tm.TypeName, "#B3");\r
 867 #endif\r
 868                         Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[][]", tm.TypeFullName, "#B4");\r
 869 \r
 870                         tm = Map (typeof (SimpleClass[][][]));\r
 871                         Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");\r
 872                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 873 #if NET_2_0\r
 874                         Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.TypeName, "#C3");\r
 875 #else\r
 876                         Assert.AreEqual ("SimpleClass[][][]", tm.TypeName, "#C3");\r
 877 #endif\r
 878                         Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[][][]", tm.TypeFullName, "#C4");\r
 879                 }\r
 880 \r
 881                 [Test]\r
 882                 [Category ("NotWorking")]\r
 883                 public void TypeMapping_IEnumerable_SimpleClass ()\r
 884                 {\r
 885                         XmlTypeMapping tm = Map (typeof (SimpleClassEnumerable));\r
 886                         Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#1");\r
 887                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 888                         Assert.AreEqual ("SimpleClassEnumerable", tm.TypeName, "#3");\r
 889                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable", tm.TypeFullName, "#4");\r
 890 \r
 891                         tm = Map (typeof (SimpleClassEnumerable[]));\r
 892                         Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#A1");\r
 893                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 894 #if NET_2_0\r
 895                         Assert.AreEqual ("ArrayOfSimpleClassEnumerable", tm.TypeName, "#A3");\r
 896 #else\r
 897                         Assert.AreEqual ("SimpleClassEnumerable[]", tm.TypeName, "#A3");\r
 898 #endif\r
 899                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[]", tm.TypeFullName, "#A4");\r
 900 \r
 901                         tm = Map (typeof (SimpleClassEnumerable[][]));\r
 902                         Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");\r
 903                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 904 #if NET_2_0\r
 905                         Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#B3");\r
 906 #else\r
 907                         Assert.AreEqual ("SimpleClassEnumerable[][]", tm.TypeName, "#B3");\r
 908 #endif\r
 909                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][]", tm.TypeFullName, "#B4");\r
 910 \r
 911                         tm = Map (typeof (SimpleClassEnumerable[][][]));\r
 912                         Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");\r
 913                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 914 #if NET_2_0\r
 915                         Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#C3");\r
 916 #else\r
 917                         Assert.AreEqual ("SimpleClassEnumerable[][][]", tm.TypeName, "#C3");\r
 918 #endif\r
 919                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][][]", tm.TypeFullName, "#C4");\r
 920                 }\r
 921 \r
 922                 [Test]\r
 923                 [Category ("NotWorking")]\r
 924                 public void TypeMapping_IEnumerable_Object ()\r
 925                 {\r
 926                         XmlTypeMapping tm = Map (typeof (ObjectEnumerable));\r
 927                         Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");\r
 928                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 929                         Assert.AreEqual ("ObjectEnumerable", tm.TypeName, "#3");\r
 930                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable", tm.TypeFullName, "#4");\r
 931 \r
 932                         tm = Map (typeof (ObjectEnumerable[]));\r
 933                         Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");\r
 934                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 935 #if NET_2_0\r
 936                         Assert.AreEqual ("ArrayOfObjectEnumerable", tm.TypeName, "#A3");\r
 937 #else\r
 938                         Assert.AreEqual ("ObjectEnumerable[]", tm.TypeName, "#A3");\r
 939 #endif\r
 940                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[]", tm.TypeFullName, "#A4");\r
 941 \r
 942                         tm = Map (typeof (ObjectEnumerable[][]));\r
 943                         Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
 944                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
 945 #if NET_2_0\r
 946                         Assert.AreEqual ("ArrayOfArrayOfObjectEnumerable", tm.TypeName, "#B3");\r
 947 #else\r
 948                         Assert.AreEqual ("ObjectEnumerable[][]", tm.TypeName, "#B3");\r
 949 #endif\r
 950                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[][]", tm.TypeFullName, "#B4");\r
 951 \r
 952                         tm = Map (typeof (ObjectEnumerable[][][]));\r
 953                         Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
 954                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
 955 #if NET_2_0\r
 956                         Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectEnumerable", tm.TypeName, "#C3");\r
 957 #else\r
 958                         Assert.AreEqual ("ObjectEnumerable[][][]", tm.TypeName, "#C3");\r
 959 #endif\r
 960                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[][][]", tm.TypeFullName, "#C4");\r
 961                 }\r
 962 \r
 963                 [Test]\r
 964                 [Category ("NotWorking")]\r
 965                 [ExpectedException (typeof (InvalidOperationException))]\r
 966                 public void TypeMapping_IEnumarable_Object_NoMatchingAddMethod ()\r
 967                 {\r
 968                         Map (typeof (ObjectEnumerableNoMatchingAddMethod));\r
 969                 }\r
 970 \r
 971                 [Test]\r
 972                 [Category ("NotWorking")]\r
 973                 [ExpectedException (typeof (InvalidOperationException))]\r
 974                 public void TypeMapping_IEnumarable_Object_NoMatchingAddMethod_Array ()\r
 975                 {\r
 976                         Map (typeof (ObjectEnumerableNoMatchingAddMethod[]));\r
 977                 }\r
 978 \r
 979                 [Test]\r
 980                 [Category ("NotWorking")]\r
 981                 public void TypeMapping_IEnumerable_SimpleClass_PrivateCurrent ()\r
 982                 {\r
 983                         XmlTypeMapping tm = Map (typeof (SimpleClassEnumerablePrivateCurrent));\r
 984                         Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");\r
 985                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
 986                         Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent", tm.TypeName, "#3");\r
 987                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent", tm.TypeFullName, "#4");\r
 988 \r
 989                         tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[]));\r
 990                         Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");\r
 991                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
 992 #if NET_2_0\r
 993                         Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#A3");\r
 994 #else\r
 995                         Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[]", tm.TypeName, "#A3");\r
 996 #endif\r
 997                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[]", tm.TypeFullName, "#A4");\r
 998 \r
 999                         tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[][]));\r
1000                         Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
1001                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
1002 #if NET_2_0\r
1003                         Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#B3");\r
1004 #else\r
1005                         Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[][]", tm.TypeName, "#B3");\r
1006 #endif\r
1007                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][]", tm.TypeFullName, "#B4");\r
1008 \r
1009                         tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[][][]));\r
1010                         Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
1011                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
1012 #if NET_2_0\r
1013                         Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#C3");\r
1014 #else\r
1015                         Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeName, "#C3");\r
1016 #endif\r
1017                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeFullName, "#C4");\r
1018                 }\r
1019 \r
1020                 [Test]\r
1021 #if ONLY_1_1\r
1022                 [Category ("NotDotNet")] // results in NullReferenceException in .NET 1.1 (SP1)\r
1023 #endif\r
1024                 [Category ("NotWorking")]\r
1025                 public void TypeMapping_IEnumerable_SimpleClass_PrivateGetEnumerator ()\r
1026                 {\r
1027                         XmlTypeMapping tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator));\r
1028                         Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");\r
1029                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
1030                         Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#3");\r
1031                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator", tm.TypeFullName, "#4");\r
1032 \r
1033                         tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[]));\r
1034                         Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");\r
1035                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
1036 #if NET_2_0\r
1037                         Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#A3");\r
1038 #else\r
1039                         Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[]", tm.TypeName, "#A3");\r
1040 #endif\r
1041                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[]", tm.TypeFullName, "#A4");\r
1042 \r
1043                         tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[][]));\r
1044                         Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
1045                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
1046 #if NET_2_0\r
1047                         Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#B3");\r
1048 #else\r
1049                         Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[][]", tm.TypeName, "#B3");\r
1050 #endif\r
1051                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][]", tm.TypeFullName, "#B4");\r
1052 \r
1053                         tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[][][]));\r
1054                         Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
1055                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
1056 #if NET_2_0\r
1057                         Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#C3");\r
1058 #else\r
1059                         Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator[][][]", tm.TypeName, "#C3");\r
1060 #endif\r
1061                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][][]", tm.TypeFullName, "#C4");\r
1062                 }\r
1063 \r
1064                 [Test]\r
1065                 [Category ("NotWorking")]\r
1066                 [ExpectedException (typeof (InvalidOperationException))]\r
1067                 public void TypeMapping_ICollection_Object_NoMatchingAddMethod ()\r
1068                 {\r
1069                         Map (typeof (ObjectCollectionNoMatchingAddMethod));\r
1070                 }\r
1071 \r
1072                 [Test]\r
1073                 [Category ("NotWorking")]\r
1074                 [ExpectedException (typeof (InvalidOperationException))]\r
1075                 public void TypeMapping_ICollection_Object_NoMatchingAddMethod_Array ()\r
1076                 {\r
1077                         Map (typeof (ObjectCollectionNoMatchingAddMethod[]));\r
1078                 }\r
1079 \r
1080                 [Test]\r
1081                 [Category ("NotWorking")]\r
1082                 [ExpectedException (typeof (InvalidOperationException))]\r
1083                 public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod ()\r
1084                 {\r
1085                         Map (typeof (SimpleClassCollectionNoMatchingAddMethod));\r
1086                 }\r
1087 \r
1088                 [Test]\r
1089                 [Category ("NotWorking")]\r
1090                 [ExpectedException (typeof (InvalidOperationException))]\r
1091                 public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod_Array ()\r
1092                 {\r
1093                         Map (typeof (SimpleClassCollectionNoMatchingAddMethod[]));\r
1094                 }\r
1095 \r
1096                 [Test]\r
1097                 [Category ("NotWorking")]\r
1098                 public void TypeMapping_ICollection_SimpleClass ()\r
1099                 {\r
1100                         XmlTypeMapping tm = Map (typeof (SimpleClassCollection));\r
1101                         Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#1");\r
1102                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
1103                         Assert.AreEqual ("SimpleClassCollection", tm.TypeName, "#3");\r
1104                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection", tm.TypeFullName, "#4");\r
1105 \r
1106                         tm = Map (typeof (SimpleClassCollection[]));\r
1107                         Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#A1");\r
1108                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
1109 #if NET_2_0\r
1110                         Assert.AreEqual ("ArrayOfSimpleClassCollection", tm.TypeName, "#A3");\r
1111 #else\r
1112                         Assert.AreEqual ("SimpleClassCollection[]", tm.TypeName, "#A3");\r
1113 #endif\r
1114                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[]", tm.TypeFullName, "#A4");\r
1115 \r
1116                         tm = Map (typeof (SimpleClassCollection[][]));\r
1117                         Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");\r
1118                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
1119 #if NET_2_0\r
1120                         Assert.AreEqual ("ArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#B3");\r
1121 #else\r
1122                         Assert.AreEqual ("SimpleClassCollection[][]", tm.TypeName, "#B3");\r
1123 #endif\r
1124                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][]", tm.TypeFullName, "#B4");\r
1125 \r
1126                         tm = Map (typeof (SimpleClassCollection[][][]));\r
1127                         Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");\r
1128                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
1129 #if NET_2_0\r
1130                         Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#C3");\r
1131 #else\r
1132                         Assert.AreEqual ("SimpleClassCollection[][][]", tm.TypeName, "#C3");\r
1133 #endif\r
1134                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][][]", tm.TypeFullName, "#C4");\r
1135                 }\r
1136 \r
1137                 [Test]\r
1138                 [Category ("NotWorking")]\r
1139                 public void TypeMapping_ICollection_Object ()\r
1140                 {\r
1141                         XmlTypeMapping tm = Map (typeof (ObjectCollection));\r
1142                         Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");\r
1143                         Assert.AreEqual (string.Empty, tm.Namespace, "#2");\r
1144                         Assert.AreEqual ("ObjectCollection", tm.TypeName, "#3");\r
1145                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection", tm.TypeFullName, "#4");\r
1146 \r
1147                         tm = Map (typeof (ObjectCollection[]));\r
1148                         Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");\r
1149                         Assert.AreEqual (string.Empty, tm.Namespace, "#A2");\r
1150 #if NET_2_0\r
1151                         Assert.AreEqual ("ArrayOfObjectCollection", tm.TypeName, "#A3");\r
1152 #else\r
1153                         Assert.AreEqual ("ObjectCollection[]", tm.TypeName, "#A3");\r
1154 #endif\r
1155                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[]", tm.TypeFullName, "#A4");\r
1156 \r
1157                         tm = Map (typeof (ObjectCollection[][]));\r
1158                         Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");\r
1159                         Assert.AreEqual (string.Empty, tm.Namespace, "#B2");\r
1160 #if NET_2_0\r
1161                         Assert.AreEqual ("ArrayOfArrayOfObjectCollection", tm.TypeName, "#B3");\r
1162 #else\r
1163                         Assert.AreEqual ("ObjectCollection[][]", tm.TypeName, "#B3");\r
1164 #endif\r
1165                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[][]", tm.TypeFullName, "#B4");\r
1166 \r
1167                         tm = Map (typeof (ObjectCollection[][][]));\r
1168                         Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");\r
1169                         Assert.AreEqual (string.Empty, tm.Namespace, "#C2");\r
1170 #if NET_2_0\r
1171                         Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectCollection", tm.TypeName, "#C3");\r
1172 #else\r
1173                         Assert.AreEqual ("ObjectCollection[][][]", tm.TypeName, "#C3");\r
1174 #endif\r
1175                         Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[][][]", tm.TypeFullName, "#C4");\r
1176                 }\r
1177 \r
1178                 [Test]\r
1179                 [Category ("NotWorking")]\r
1180                 [ExpectedException (typeof (InvalidOperationException))]\r
1181                 public void TypeMapping_ICollection_Object_NoIntIndexer ()\r
1182                 {\r
1183                         Map (typeof (ObjectCollectionNoIntIndexer));\r
1184                 }\r
1185 \r
1186                 [Test]\r
1187                 [Category ("NotWorking")]\r
1188                 [ExpectedException (typeof (InvalidOperationException))]\r
1189                 public void TypeMapping_ICollection_Object_NoIntIndexer_Array ()\r
1190                 {\r
1191                         Map (typeof (ObjectCollectionNoIntIndexer[]));\r
1192                 }\r
1193 \r
1194                 [Test]\r
1195                 [Category ("NotWorking")]\r
1196                 [ExpectedException (typeof (InvalidOperationException))]\r
1197                 public void TypeMapping_ICollection_SimpleClass_NoIntIndexer ()\r
1198                 {\r
1199                         Map (typeof (SimpleClassCollectionNoIntIndexer));\r
1200                 }\r
1201 \r
1202                 [Test]\r
1203                 [Category ("NotWorking")]\r
1204                 [ExpectedException (typeof (InvalidOperationException))]\r
1205                 public void TypeMapping_ICollection_SimpleClass_NoIntIndexer_Array ()\r
1206                 {\r
1207                         Map (typeof (SimpleClassCollectionNoIntIndexer[]));\r
1208                 }\r
1209 \r
1210                 [Test]\r
1211                 [Category ("NotWorking")]\r
1212                 public void TestImportMembersMapping()\r
1213                 {\r
1214                         Type type = typeof(SimpleClass);\r
1215                         XmlAttributes attrs = new  XmlAttributes();\r
1216                         XmlAttributeOverrides overrides = new XmlAttributeOverrides();\r
1217                         overrides.Add(typeof(SimpleClass), attrs);\r
1218 \r
1219                         XmlReflectionMember[] members = new XmlReflectionMember[0];\r
1220                         XmlMembersMapping mm;\r
1221                         try\r
1222                         {\r
1223                                 mm = MembersMap(type, overrides, members, true);\r
1224                                 Assert.Fail("Should not be able to fetch an empty XmlMembersMapping");\r
1225                         }\r
1226                         catch (Exception)\r
1227                         {\r
1228                         }\r
1229                         \r
1230                         XmlReflectionMember rm = new XmlReflectionMember();\r
1231                         rm.IsReturnValue = false;\r
1232                         rm.MemberName = "something";\r
1233                         rm.MemberType = typeof(string);\r
1234                         members = new XmlReflectionMember[1];\r
1235                         members[0] = rm;\r
1236 \r
1237                         mm = MembersMap(type, overrides, members, false);\r
1238 \r
1239                         Equals(mm.Count, 1);\r
1240 \r
1241                         XmlMemberMapping smm = mm[0];\r
1242                         Assert.IsFalse (smm.Any, "#1");\r
1243                         Assert.AreEqual ("something", smm.ElementName, "#2");\r
1244                         Assert.AreEqual ("something", smm.MemberName, "#3");\r
1245                         Assert.IsNull (smm.Namespace, "#4");\r
1246                         Assert.AreEqual ("System.String", smm.TypeFullName, "#5");\r
1247                         Assert.AreEqual ("string", smm.TypeName, "#6");\r
1248                         Assert.IsNull (smm.TypeNamespace, "#7");\r
1249 \r
1250                         \r
1251                         rm = new XmlReflectionMember();\r
1252                         rm.IsReturnValue = false;\r
1253                         rm.MemberName = "nothing";\r
1254                         rm.MemberType = typeof(string);\r
1255                         members = new XmlReflectionMember[1];\r
1256                         members[0] = rm;\r
1257 \r
1258                         mm = MembersMap(type, overrides, members, false);\r
1259                         Assert.AreEqual (1, mm.Count, "#8");\r
1260                 }\r
1261 \r
1262                 [Test]\r
1263                 public void TestIntTypeMappingWithXmlRootAttribute()\r
1264                 {\r
1265                         const string TheNamespace = "another:urn";\r
1266                         XmlRootAttribute root = new XmlRootAttribute("price");\r
1267                         root.Namespace = TheNamespace;\r
1268                         \r
1269                         XmlTypeMapping tm = Map(typeof(int), root);\r
1270                         Assert.AreEqual ("price", tm.ElementName, "#1");\r
1271                         Assert.AreEqual (TheNamespace, tm.Namespace, "#2");\r
1272                         Assert.AreEqual ("Int32", tm.TypeName, "#3");\r
1273                         Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");\r
1274                 }\r
1275                 \r
1276                 [Test]\r
1277                 [ExpectedException (typeof (InvalidOperationException))]\r
1278                 public void TestSerializeWrongChoice ()\r
1279                 {\r
1280                         new XmlSerializer (typeof(WrongChoices));\r
1281                 }\r
1282 \r
1283                 public class Employee : IXmlSerializable\r
1284                 {\r
1285                         private string _firstName;\r
1286                         private string _lastName;\r
1287                         private string _address;\r
1288 \r
1289                         public XmlSchema GetSchema ()\r
1290                         {\r
1291                                 return null;\r
1292                         }\r
1293 \r
1294                         public void WriteXml (XmlWriter writer)\r
1295                         {\r
1296                                 writer.WriteStartElement ("employee", "urn:devx-com");\r
1297                                 writer.WriteAttributeString ("firstName", _firstName);\r
1298                                 writer.WriteAttributeString ("lastName", _lastName);\r
1299                                 writer.WriteAttributeString ("address", _address);\r
1300                                 writer.WriteEndElement ();\r
1301                         }\r
1302 \r
1303                         public void ReadXml (XmlReader reader)\r
1304                         {\r
1305                                 XmlNodeType type = reader.MoveToContent ();\r
1306                                 if (type == XmlNodeType.Element && reader.LocalName == "employee") {\r
1307                                         _firstName = reader["firstName"];\r
1308                                         _lastName = reader["lastName"];\r
1309                                         _address = reader["address"];\r
1310                                 }\r
1311                         }\r
1312                 }\r
1313 \r
1314                 public class NestedStruct\r
1315                 {\r
1316                         public TimeSpan Period = TimeSpan.MaxValue;\r
1317                 }\r
1318 \r
1319                 public class ObjectEnumerable : IEnumerable\r
1320                 {\r
1321                         public void Add (int value)\r
1322                         {\r
1323                         }\r
1324 \r
1325                         public void Add (object value)\r
1326                         {\r
1327                         }\r
1328 \r
1329                         public IEnumerator GetEnumerator ()\r
1330                         {\r
1331                                 return new ArrayList ().GetEnumerator ();\r
1332                         }\r
1333                 }\r
1334 \r
1335                 public class SimpleClassEnumerable : IEnumerable\r
1336                 {\r
1337                         public void Add (int value)\r
1338                         {\r
1339                         }\r
1340 \r
1341                         public void Add (object value)\r
1342                         {\r
1343                         }\r
1344 \r
1345                         IEnumerator IEnumerable.GetEnumerator ()\r
1346                         {\r
1347                                 return GetEnumerator ();\r
1348                         }\r
1349 \r
1350                         public SimpleClassEnumerator GetEnumerator ()\r
1351                         {\r
1352                                 return new SimpleClassEnumerator (new ArrayList ());\r
1353                         }\r
1354                 }\r
1355 \r
1356                 public class SimpleClassEnumerablePrivateGetEnumerator : IEnumerable\r
1357                 {\r
1358                         public void Add (object value)\r
1359                         {\r
1360                         }\r
1361 \r
1362                         IEnumerator IEnumerable.GetEnumerator ()\r
1363                         {\r
1364                                 return new ArrayList ().GetEnumerator ();\r
1365                         }\r
1366                 }\r
1367 \r
1368                 public class SimpleClassEnumerablePrivateCurrent : IEnumerable\r
1369                 {\r
1370                         public void Add (object value)\r
1371                         {\r
1372                         }\r
1373 \r
1374                         IEnumerator IEnumerable.GetEnumerator ()\r
1375                         {\r
1376                                 return GetEnumerator ();\r
1377                         }\r
1378 \r
1379                         public NoCurrentEnumerator GetEnumerator ()\r
1380                         {\r
1381                                 return new NoCurrentEnumerator (new ArrayList ());\r
1382                         }\r
1383                 }\r
1384 \r
1385                 // GetEnumerator().Current returns object, but there's no corresponding\r
1386                 // Add (System.Object) method\r
1387                 public class ObjectEnumerableNoMatchingAddMethod : IEnumerable\r
1388                 {\r
1389                         public void Add (int value)\r
1390                         {\r
1391                         }\r
1392 \r
1393                         public IEnumerator GetEnumerator ()\r
1394                         {\r
1395                                 return new ArrayList ().GetEnumerator ();\r
1396                         }\r
1397                 }\r
1398 \r
1399                 // GetEnumerator().Current returns SimpleClass, but there's no \r
1400                 // corresponding Add (SimpleClass) method\r
1401                 public class SimpleClassCollectionNoMatchingAddMethod : ICollection\r
1402                 {\r
1403                         public SimpleClass this[int index]\r
1404                         {\r
1405                                 get\r
1406                                 {\r
1407                                         return (SimpleClass) _list[index];\r
1408                                 }\r
1409                         }\r
1410 \r
1411                         public int Count\r
1412                         {\r
1413                                 get { return _list.Count; }\r
1414                         }\r
1415 \r
1416                         public bool IsSynchronized\r
1417                         {\r
1418                                 get { return _list.IsSynchronized; }\r
1419                         }\r
1420 \r
1421                         public object SyncRoot\r
1422                         {\r
1423                                 get { return _list.SyncRoot; }\r
1424                         }\r
1425 \r
1426                         public void CopyTo (Array array, int index)\r
1427                         {\r
1428                                 _list.CopyTo (array, index);\r
1429                         }\r
1430 \r
1431                         IEnumerator IEnumerable.GetEnumerator ()\r
1432                         {\r
1433                                 return GetEnumerator ();\r
1434                         }\r
1435 \r
1436                         public SimpleClassEnumerator GetEnumerator ()\r
1437                         {\r
1438                                 return new SimpleClassEnumerator (_list);\r
1439                         }\r
1440 \r
1441                         private ArrayList _list = new ArrayList ();\r
1442                 }\r
1443 \r
1444                 // GetEnumerator().Current returns object, but there's no corresponding\r
1445                 // Add (System.Object) method\r
1446                 public class ObjectCollectionNoMatchingAddMethod : ICollection\r
1447                 {\r
1448                         public object this[int index]\r
1449                         {\r
1450                                 get\r
1451                                 {\r
1452                                         return _list[index];\r
1453                                 }\r
1454                         }\r
1455 \r
1456                         public int Count\r
1457                         {\r
1458                                 get { return _list.Count; }\r
1459                         }\r
1460 \r
1461                         public bool IsSynchronized\r
1462                         {\r
1463                                 get { return _list.IsSynchronized; }\r
1464                         }\r
1465 \r
1466                         public object SyncRoot\r
1467                         {\r
1468                                 get { return _list.SyncRoot; }\r
1469                         }\r
1470 \r
1471                         public void CopyTo (Array array, int index)\r
1472                         {\r
1473                                 _list.CopyTo (array, index);\r
1474                         }\r
1475 \r
1476                         IEnumerator IEnumerable.GetEnumerator ()\r
1477                         {\r
1478                                 return GetEnumerator ();\r
1479                         }\r
1480 \r
1481                         public IEnumerator GetEnumerator ()\r
1482                         {\r
1483                                 return _list.GetEnumerator ();\r
1484                         }\r
1485 \r
1486                         private ArrayList _list = new ArrayList ();\r
1487                 }\r
1488 \r
1489                 // Does not have int indexer.\r
1490                 public class SimpleClassCollectionNoIntIndexer : ICollection\r
1491                 {\r
1492                         public SimpleClass this[string name]\r
1493                         {\r
1494                                 get\r
1495                                 {\r
1496                                         return new SimpleClass ();\r
1497                                 }\r
1498                         }\r
1499 \r
1500                         public int Count\r
1501                         {\r
1502                                 get { return _list.Count; }\r
1503                         }\r
1504 \r
1505                         public bool IsSynchronized\r
1506                         {\r
1507                                 get { return _list.IsSynchronized; }\r
1508                         }\r
1509 \r
1510                         public object SyncRoot\r
1511                         {\r
1512                                 get { return _list.SyncRoot; }\r
1513                         }\r
1514 \r
1515                         public void CopyTo (Array array, int index)\r
1516                         {\r
1517                                 _list.CopyTo (array, index);\r
1518                         }\r
1519 \r
1520                         IEnumerator IEnumerable.GetEnumerator ()\r
1521                         {\r
1522                                 return GetEnumerator ();\r
1523                         }\r
1524 \r
1525                         public SimpleClassEnumerator GetEnumerator ()\r
1526                         {\r
1527                                 return new SimpleClassEnumerator (_list);\r
1528                         }\r
1529 \r
1530                         public void Add (SimpleClass value)\r
1531                         {\r
1532                                 _list.Add (value);\r
1533                         }\r
1534 \r
1535                         private ArrayList _list = new ArrayList ();\r
1536                 }\r
1537 \r
1538                 // Does not have int indexer.\r
1539                 public class ObjectCollectionNoIntIndexer : ICollection\r
1540                 {\r
1541                         public object this[string name]\r
1542                         {\r
1543                                 get\r
1544                                 {\r
1545                                         return new SimpleClass ();\r
1546                                 }\r
1547                         }\r
1548 \r
1549                         public int Count\r
1550                         {\r
1551                                 get { return _list.Count; }\r
1552                         }\r
1553 \r
1554                         public bool IsSynchronized\r
1555                         {\r
1556                                 get { return _list.IsSynchronized; }\r
1557                         }\r
1558 \r
1559                         public object SyncRoot\r
1560                         {\r
1561                                 get { return _list.SyncRoot; }\r
1562                         }\r
1563 \r
1564                         public void CopyTo (Array array, int index)\r
1565                         {\r
1566                                 _list.CopyTo (array, index);\r
1567                         }\r
1568 \r
1569                         public IEnumerator GetEnumerator ()\r
1570                         {\r
1571                                 return _list.GetEnumerator ();\r
1572                         }\r
1573 \r
1574                         public void Add (object value)\r
1575                         {\r
1576                                 _list.Add (value);\r
1577                         }\r
1578 \r
1579                         private ArrayList _list = new ArrayList ();\r
1580                 }\r
1581 \r
1582                 public class SimpleClassCollection : ICollection\r
1583                 {\r
1584                         public SimpleClass this[int index]\r
1585                         {\r
1586                                 get\r
1587                                 {\r
1588                                         return (SimpleClass) _list[index];\r
1589                                 }\r
1590                         }\r
1591 \r
1592                         public int Count\r
1593                         {\r
1594                                 get { return _list.Count; }\r
1595                         }\r
1596 \r
1597                         public bool IsSynchronized\r
1598                         {\r
1599                                 get { return _list.IsSynchronized; }\r
1600                         }\r
1601 \r
1602                         public object SyncRoot\r
1603                         {\r
1604                                 get { return _list.SyncRoot; }\r
1605                         }\r
1606 \r
1607                         public void CopyTo (Array array, int index)\r
1608                         {\r
1609                                 _list.CopyTo (array, index);\r
1610                         }\r
1611 \r
1612                         IEnumerator IEnumerable.GetEnumerator ()\r
1613                         {\r
1614                                 return GetEnumerator ();\r
1615                         }\r
1616 \r
1617                         public SimpleClassEnumerator GetEnumerator ()\r
1618                         {\r
1619                                 return new SimpleClassEnumerator (_list);\r
1620                         }\r
1621 \r
1622                         public void Add (SimpleClass value)\r
1623                         {\r
1624                                 _list.Add (value);\r
1625                         }\r
1626 \r
1627                         private ArrayList _list = new ArrayList ();\r
1628                 }\r
1629 \r
1630                 public class ObjectCollection : ICollection\r
1631                 {\r
1632                         public object this[int name]\r
1633                         {\r
1634                                 get\r
1635                                 {\r
1636                                         return new SimpleClass ();\r
1637                                 }\r
1638                         }\r
1639 \r
1640                         public int Count\r
1641                         {\r
1642                                 get { return _list.Count; }\r
1643                         }\r
1644 \r
1645                         public bool IsSynchronized\r
1646                         {\r
1647                                 get { return _list.IsSynchronized; }\r
1648                         }\r
1649 \r
1650                         public object SyncRoot\r
1651                         {\r
1652                                 get { return _list.SyncRoot; }\r
1653                         }\r
1654 \r
1655                         public void CopyTo (Array array, int index)\r
1656                         {\r
1657                                 _list.CopyTo (array, index);\r
1658                         }\r
1659 \r
1660                         public IEnumerator GetEnumerator ()\r
1661                         {\r
1662                                 return _list.GetEnumerator ();\r
1663                         }\r
1664 \r
1665                         public void Add (object value)\r
1666                         {\r
1667                                 _list.Add (value);\r
1668                         }\r
1669 \r
1670                         private ArrayList _list = new ArrayList ();\r
1671                 }\r
1672 \r
1673                 public class SimpleClassEnumerator : IEnumerator\r
1674                 {\r
1675                         internal SimpleClassEnumerator (ArrayList arguments)\r
1676                         {\r
1677                                 IEnumerable temp = (IEnumerable) (arguments);\r
1678                                 _baseEnumerator = temp.GetEnumerator ();\r
1679                         }\r
1680                         public SimpleClass Current\r
1681                         {\r
1682                                 get { return (SimpleClass) _baseEnumerator.Current; }\r
1683                         }\r
1684 \r
1685                         object IEnumerator.Current\r
1686                         {\r
1687                                 get { return _baseEnumerator.Current; }\r
1688                         }\r
1689 \r
1690                         public bool MoveNext ()\r
1691                         {\r
1692                                 return _baseEnumerator.MoveNext ();\r
1693                         }\r
1694 \r
1695                         bool IEnumerator.MoveNext ()\r
1696                         {\r
1697                                 return _baseEnumerator.MoveNext ();\r
1698                         }\r
1699 \r
1700                         public void Reset ()\r
1701                         {\r
1702                                 _baseEnumerator.Reset ();\r
1703                         }\r
1704 \r
1705                         void IEnumerator.Reset ()\r
1706                         {\r
1707                                 _baseEnumerator.Reset ();\r
1708                         }\r
1709 \r
1710                         private IEnumerator _baseEnumerator;\r
1711                 }\r
1712 \r
1713                 public class NoCurrentEnumerator : IEnumerator\r
1714                 {\r
1715                         internal NoCurrentEnumerator (ArrayList arguments)\r
1716                         {\r
1717                                 IEnumerable temp = (IEnumerable) (arguments);\r
1718                                 _baseEnumerator = temp.GetEnumerator ();\r
1719                         }\r
1720 \r
1721                         object IEnumerator.Current\r
1722                         {\r
1723                                 get { return _baseEnumerator.Current; }\r
1724                         }\r
1725 \r
1726                         public bool MoveNext ()\r
1727                         {\r
1728                                 return _baseEnumerator.MoveNext ();\r
1729                         }\r
1730 \r
1731                         bool IEnumerator.MoveNext ()\r
1732                         {\r
1733                                 return _baseEnumerator.MoveNext ();\r
1734                         }\r
1735 \r
1736                         public void Reset ()\r
1737                         {\r
1738                                 _baseEnumerator.Reset ();\r
1739                         }\r
1740 \r
1741                         void IEnumerator.Reset ()\r
1742                         {\r
1743                                 _baseEnumerator.Reset ();\r
1744                         }\r
1745 \r
1746                         private IEnumerator _baseEnumerator;\r
1747                 }\r
1748         }\r
1749 }\r
1750 \r