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