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

   1 //
   2 // System.Xml.Serialization.XmlSchemaImporterTests
   3 //
   4 // Author:
   5 //   Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (C) 2005 Novell
   8 //
   9
  10 using System;
  11 using System.CodeDom;
  12 using System.Collections;
  13 using System.Globalization;
  14 using System.IO;
  15 using System.Xml;
  16 using System.Xml.Schema;
  17 using System.Xml.Serialization;
  18
  19 using NUnit.Framework;
  20
  21 using MonoTests.System.Xml.TestClasses;
  22
  23 namespace MonoTests.System.XmlSerialization
  24 {
  25         [TestFixture]
  26         public class XmlSchemaImporterTests
  27         {
  28                 private const string WsdlTypesNamespace = "http://microsoft.com/wsdl/types/";
  29
  30                 [Test]
  31                 [Category ("NotWorking")]
  32                 public void ImportTypeMapping_Struct ()
  33                 {
  34                         XmlSchemas schemas = ExportType (typeof (TimeSpan));
  35                         ArrayList qnames = GetXmlQualifiedNames (schemas);
  36                         Assert.AreEqual (1, qnames.Count, "#1");
  37
  38                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
  39                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
  40
  41                         Assert.IsNotNull (map, "#2");
  42                         Assert.AreEqual ("TimeSpan", map.ElementName, "#3");
  43                         Assert.AreEqual ("NSTimeSpan", map.Namespace, "#4");
  44                         Assert.AreEqual ("TimeSpan", map.TypeFullName, "#5");
  45                         Assert.AreEqual ("TimeSpan", map.TypeName, "#6");
  46                 }
  47
  48                 [Test]
  49                 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
  50                 public void ImportTypeMapping_XsdPrimitive_AnyType ()
  51                 {
  52                         XmlSchemas schemas = ExportType (typeof (object));
  53                         ArrayList qnames = GetXmlQualifiedNames (schemas);
  54                         Assert.AreEqual (1, qnames.Count, "#1");
  55
  56                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
  57                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
  58
  59                         Assert.IsNotNull (map, "#2");
  60                         Assert.AreEqual ("anyType", map.ElementName, "#3");
  61                         Assert.AreEqual ("NSObject", map.Namespace, "#4");
  62                         Assert.AreEqual ("System.Object", map.TypeFullName, "#5");
  63                         Assert.AreEqual ("Object", map.TypeName, "#6");
  64                 }
  65
  66                 [Test]
  67                 public void ImportTypeMapping_XsdPrimitive_Boolean ()
  68                 {
  69                         XmlSchemas schemas = ExportType (typeof (bool));
  70                         ArrayList qnames = GetXmlQualifiedNames (schemas);
  71                         Assert.AreEqual (1, qnames.Count, "#1");
  72
  73                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
  74                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
  75
  76                         Assert.IsNotNull (map, "#2");
  77                         Assert.AreEqual ("boolean", map.ElementName, "#3");
  78                         Assert.AreEqual ("NSBoolean", map.Namespace, "#4");
  79                         Assert.AreEqual ("System.Boolean", map.TypeFullName, "#5");
  80                         Assert.AreEqual ("Boolean", map.TypeName, "#6");
  81                 }
  82
  83                 [Test]
  84                 public void ImportTypeMapping_XsdPrimitive_Short ()
  85                 {
  86                         XmlSchemas schemas = ExportType (typeof (short));
  87                         ArrayList qnames = GetXmlQualifiedNames (schemas);
  88                         Assert.AreEqual (1, qnames.Count, "#1");
  89
  90                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
  91                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
  92
  93                         Assert.IsNotNull (map, "#2");
  94                         Assert.AreEqual ("short", map.ElementName, "#3");
  95                         Assert.AreEqual ("NSInt16", map.Namespace, "#4");
  96                         Assert.AreEqual ("System.Int16", map.TypeFullName, "#5");
  97                         Assert.AreEqual ("Int16", map.TypeName, "#6");
  98                 }
  99
 100                 [Test]
 101                 public void ImportTypeMapping_XsdPrimitive_UnsignedShort ()
 102                 {
 103                         XmlSchemas schemas = ExportType (typeof (ushort));
 104                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 105                         Assert.AreEqual (1, qnames.Count, "#1");
 106
 107                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 108                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 109
 110                         Assert.IsNotNull (map, "#2");
 111                         Assert.AreEqual ("unsignedShort", map.ElementName, "#3");
 112                         Assert.AreEqual ("NSUInt16", map.Namespace, "#4");
 113                         Assert.AreEqual ("System.UInt16", map.TypeFullName, "#5");
 114                         Assert.AreEqual ("UInt16", map.TypeName, "#6");
 115                 }
 116
 117                 [Test]
 118                 public void ImportTypeMapping_XsdPrimitive_Int ()
 119                 {
 120                         XmlSchemas schemas = ExportType (typeof (int));
 121                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 122                         Assert.AreEqual (1, qnames.Count, "#1");
 123
 124                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 125                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 126
 127                         Assert.IsNotNull (map, "#2");
 128                         Assert.AreEqual ("int", map.ElementName, "#3");
 129                         Assert.AreEqual ("NSInt32", map.Namespace, "#4");
 130                         Assert.AreEqual ("System.Int32", map.TypeFullName, "#5");
 131                         Assert.AreEqual ("Int32", map.TypeName, "#6");
 132                 }
 133
 134                 [Test]
 135                 public void ImportTypeMapping_XsdPrimitive_UnsignedInt ()
 136                 {
 137                         XmlSchemas schemas = ExportType (typeof (uint));
 138                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 139                         Assert.AreEqual (1, qnames.Count, "#1");
 140
 141                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 142                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 143
 144                         Assert.IsNotNull (map, "#2");
 145                         Assert.AreEqual ("unsignedInt", map.ElementName, "#3");
 146                         Assert.AreEqual ("NSUInt32", map.Namespace, "#4");
 147                         Assert.AreEqual ("System.UInt32", map.TypeFullName, "#5");
 148                         Assert.AreEqual ("UInt32", map.TypeName, "#6");
 149                 }
 150
 151                 [Test]
 152                 public void ImportTypeMapping_XsdPrimitive_Long ()
 153                 {
 154                         XmlSchemas schemas = ExportType (typeof (long));
 155                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 156                         Assert.AreEqual (1, qnames.Count, "#1");
 157
 158                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 159                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 160
 161                         Assert.IsNotNull (map, "#2");
 162                         Assert.AreEqual ("long", map.ElementName, "#3");
 163                         Assert.AreEqual ("NSInt64", map.Namespace, "#4");
 164                         Assert.AreEqual ("System.Int64", map.TypeFullName, "#5");
 165                         Assert.AreEqual ("Int64", map.TypeName, "#6");
 166                 }
 167
 168                 [Test]
 169                 public void ImportTypeMapping_XsdPrimitive_UnsignedLong ()
 170                 {
 171                         XmlSchemas schemas = ExportType (typeof (ulong));
 172                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 173                         Assert.AreEqual (1, qnames.Count, "#1");
 174
 175                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 176                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 177
 178                         Assert.IsNotNull (map, "#2");
 179                         Assert.AreEqual ("unsignedLong", map.ElementName, "#3");
 180                         Assert.AreEqual ("NSUInt64", map.Namespace, "#4");
 181                         Assert.AreEqual ("System.UInt64", map.TypeFullName, "#5");
 182                         Assert.AreEqual ("UInt64", map.TypeName, "#6");
 183                 }
 184
 185                 [Test]
 186                 public void ImportTypeMapping_XsdPrimitive_Float ()
 187                 {
 188                         XmlSchemas schemas = ExportType (typeof (float));
 189                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 190                         Assert.AreEqual (1, qnames.Count, "#1");
 191
 192                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 193                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 194
 195                         Assert.IsNotNull (map, "#2");
 196                         Assert.AreEqual ("float", map.ElementName, "#3");
 197                         Assert.AreEqual ("NSSingle", map.Namespace, "#4");
 198                         Assert.AreEqual ("System.Single", map.TypeFullName, "#5");
 199                         Assert.AreEqual ("Single", map.TypeName, "#6");
 200                 }
 201
 202                 [Test]
 203                 public void ImportTypeMapping_XsdPrimitive_Double ()
 204                 {
 205                         XmlSchemas schemas = ExportType (typeof (double));
 206                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 207                         Assert.AreEqual (1, qnames.Count, "#1");
 208
 209                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 210                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 211
 212                         Assert.IsNotNull (map, "#2");
 213                         Assert.AreEqual ("double", map.ElementName, "#3");
 214                         Assert.AreEqual ("NSDouble", map.Namespace, "#4");
 215                         Assert.AreEqual ("System.Double", map.TypeFullName, "#5");
 216                         Assert.AreEqual ("Double", map.TypeName, "#6");
 217                 }
 218
 219                 [Test]
 220                 public void ImportTypeMapping_XsdPrimitive_DateTime ()
 221                 {
 222                         XmlSchemas schemas = ExportType (typeof (DateTime));
 223                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 224                         Assert.AreEqual (1, qnames.Count, "#1");
 225
 226                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 227                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 228
 229                         Assert.IsNotNull (map, "#2");
 230                         Assert.AreEqual ("dateTime", map.ElementName, "#3");
 231                         Assert.AreEqual ("NSDateTime", map.Namespace, "#4");
 232                         Assert.AreEqual ("System.DateTime", map.TypeFullName, "#5");
 233                         Assert.AreEqual ("DateTime", map.TypeName, "#6");
 234                 }
 235
 236                 [Test]
 237                 public void ImportTypeMapping_XsdPrimitive_Decimal ()
 238                 {
 239                         XmlSchemas schemas = ExportType (typeof (decimal));
 240                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 241                         Assert.AreEqual (1, qnames.Count, "#1");
 242
 243                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 244                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 245
 246                         Assert.IsNotNull (map, "#2");
 247                         Assert.AreEqual ("decimal", map.ElementName, "#3");
 248                         Assert.AreEqual ("NSDecimal", map.Namespace, "#4");
 249                         Assert.AreEqual ("System.Decimal", map.TypeFullName, "#5");
 250                         Assert.AreEqual ("Decimal", map.TypeName, "#6");
 251                 }
 252
 253                 [Test]
 254                 public void ImportTypeMapping_XsdPrimitive_QName ()
 255                 {
 256                         XmlSchemas schemas = ExportType (typeof (XmlQualifiedName));
 257                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 258                         Assert.AreEqual (1, qnames.Count, "#1");
 259
 260                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 261                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 262
 263                         Assert.IsNotNull (map, "#2");
 264                         Assert.AreEqual ("QName", map.ElementName, "#3");
 265                         Assert.AreEqual ("NSXmlQualifiedName", map.Namespace, "#4");
 266                         Assert.AreEqual ("System.Xml.XmlQualifiedName", map.TypeFullName, "#5");
 267                         Assert.AreEqual ("XmlQualifiedName", map.TypeName, "#6");
 268                 }
 269
 270                 [Test]
 271                 public void ImportTypeMapping_XsdPrimitive_String ()
 272                 {
 273                         XmlSchemas schemas = ExportType (typeof (string));
 274                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 275                         Assert.AreEqual (1, qnames.Count, "#1");
 276
 277                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 278                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 279
 280                         Assert.IsNotNull (map, "#2");
 281                         Assert.AreEqual ("string", map.ElementName, "#3");
 282                         Assert.AreEqual ("NSString", map.Namespace, "#4");
 283                         Assert.AreEqual ("System.String", map.TypeFullName, "#5");
 284                         Assert.AreEqual ("String", map.TypeName, "#6");
 285                 }
 286
 287                 [Test]
 288                 [Category ("NotWorking")]
 289                 [ExpectedException (typeof (XmlSchemaException))] // Type 'http://microsoft.com/wsdl/types/:guid' is not declared
 290                 public void ImportTypeMapping_XsdPrimitive_Guid ()
 291                 {
 292                         XmlSchemas schemas = ExportType (typeof (Guid));
 293                         GetXmlQualifiedNames (schemas);
 294                 }
 295
 296                 [Test]
 297                 public void ImportTypeMapping_XsdPrimitive_UnsignedByte ()
 298                 {
 299                         XmlSchemas schemas = ExportType (typeof (byte));
 300                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 301                         Assert.AreEqual (1, qnames.Count, "#1");
 302
 303                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 304                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 305
 306                         Assert.IsNotNull (map, "#2");
 307                         Assert.AreEqual ("unsignedByte", map.ElementName, "#3");
 308                         Assert.AreEqual ("NSByte", map.Namespace, "#4");
 309                         Assert.AreEqual ("System.Byte", map.TypeFullName, "#5");
 310                         Assert.AreEqual ("Byte", map.TypeName, "#6");
 311                 }
 312
 313                 [Test]
 314                 public void ImportTypeMapping_XsdPrimitive_Byte ()
 315                 {
 316                         XmlSchemas schemas = ExportType (typeof (sbyte));
 317                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 318                         Assert.AreEqual (1, qnames.Count, "#1");
 319
 320                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 321                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 322
 323                         Assert.IsNotNull (map, "#2");
 324                         Assert.AreEqual ("byte", map.ElementName, "#3");
 325                         Assert.AreEqual ("NSSByte", map.Namespace, "#4");
 326                         Assert.AreEqual ("System.SByte", map.TypeFullName, "#5");
 327                         Assert.AreEqual ("SByte", map.TypeName, "#6");
 328                 }
 329
 330                 [Test]
 331                 [Category ("NotWorking")]
 332                 [ExpectedException (typeof (XmlSchemaException))] // Type 'http://microsoft.com/wsdl/types/:char' is not declared
 333                 public void ImportTypeMapping_XsdPrimitive_Char ()
 334                 {
 335                         XmlSchemas schemas = ExportType (typeof (char));
 336                         GetXmlQualifiedNames (schemas);
 337                 }
 338
 339                 [Test]
 340                 public void ImportTypeMapping_XsdPrimitive_Base64Binary ()
 341                 {
 342                         XmlSchemas schemas = ExportType (typeof (byte[]));
 343                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 344                         Assert.AreEqual (1, qnames.Count, "#1");
 345
 346                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 347                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 348
 349                         Assert.IsNotNull (map, "#2");
 350                         Assert.AreEqual ("base64Binary", map.ElementName, "#3");
 351                         Assert.AreEqual ("NSByte[]", map.Namespace, "#4");
 352                         Assert.AreEqual ("System.Byte[]", map.TypeFullName, "#5");
 353                         Assert.AreEqual ("Byte[]", map.TypeName, "#6");
 354                 }
 355
 356                 [Test]
 357                 [Category ("NotWorking")]
 358                 public void ImportTypeMapping_XsdPrimitive_Duration ()
 359                 {
 360                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 361                                 "<xs:schema xmlns:tns=\"NSDuration\" elementFormDefault=\"qualified\" targetNamespace=\"NSDuration\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 362                                 "  <xs:element name=\"duration\" type=\"xs:duration\" />" +
 363                                 "</xs:schema>";
 364
 365                         XmlSchemas schemas = new XmlSchemas ();
 366                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 367
 368                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 369                         Assert.AreEqual (1, qnames.Count, "#1");
 370
 371                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 372
 373                         Assert.AreEqual ("duration", qname.Name, "#2");
 374                         Assert.AreEqual ("NSDuration", qname.Namespace, "#3");
 375
 376                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 377                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 378
 379                         Assert.IsNotNull (map, "#4");
 380                         Assert.AreEqual ("duration", map.ElementName, "#5");
 381                         Assert.AreEqual ("NSDuration", map.Namespace, "#6");
 382                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 383                         Assert.AreEqual ("String", map.TypeName, "#8");
 384                 }
 385
 386                 [Test]
 387                 [Category ("NotWorking")]
 388                 public void ImportTypeMapping_XsdPrimitive_Date ()
 389                 {
 390                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 391                                 "<xs:schema xmlns:tns=\"NSDate\" elementFormDefault=\"qualified\" targetNamespace=\"NSDate\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 392                                 "  <xs:element name=\"date\" type=\"xs:date\" />" +
 393                                 "</xs:schema>";
 394
 395                         XmlSchemas schemas = new XmlSchemas ();
 396                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 397
 398                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 399                         Assert.AreEqual (1, qnames.Count, "#1");
 400
 401                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 402
 403                         Assert.AreEqual ("date", qname.Name, "#2");
 404                         Assert.AreEqual ("NSDate", qname.Namespace, "#3");
 405
 406                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 407                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 408
 409                         Assert.IsNotNull (map, "#4");
 410                         Assert.AreEqual ("date", map.ElementName, "#5");
 411                         Assert.AreEqual ("NSDate", map.Namespace, "#6");
 412                         Assert.AreEqual ("System.DateTime", map.TypeFullName, "#7");
 413                         Assert.AreEqual ("DateTime", map.TypeName, "#8");
 414                 }
 415
 416                 [Test]
 417                 public void ImportTypeMapping_EnumSimpleContent ()
 418                 {
 419                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 420                                 "<s:schema xmlns:tns=\"NSDate\" elementFormDefault=\"qualified\" targetNamespace=\"NSDate\" xmlns:s=\"http://www.w3.org/2001/XMLSchema\">";
 421                         schemaFragment += "      <s:element name=\"trans\" type=\"tns:TranslationStatus\" />";
 422                         schemaFragment += "      <s:complexType name=\"TranslationStatus\">";
 423                         schemaFragment += "        <s:simpleContent>";
 424                         schemaFragment += "          <s:extension base=\"tns:StatusType\">";
 425                         schemaFragment += "            <s:attribute name=\"Language\" type=\"s:int\" use=\"required\" />";
 426                         schemaFragment += "          </s:extension>";
 427                         schemaFragment += "        </s:simpleContent>";
 428                         schemaFragment += "      </s:complexType>";
 429                         schemaFragment += "      <s:simpleType name=\"StatusType\">";
 430                         schemaFragment += "        <s:restriction base=\"s:string\">";
 431                         schemaFragment += "          <s:enumeration value=\"Untouched\" />";
 432                         schemaFragment += "          <s:enumeration value=\"Touched\" />";
 433                         schemaFragment += "          <s:enumeration value=\"Complete\" />";
 434                         schemaFragment += "          <s:enumeration value=\"None\" />";
 435                         schemaFragment += "        </s:restriction>";
 436                         schemaFragment += "      </s:simpleType>";
 437                         schemaFragment += "</s:schema>";
 438
 439                         XmlSchemas schemas = new XmlSchemas ();
 440                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 441
 442                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 443                         Assert.AreEqual (1, qnames.Count, "#1");
 444
 445                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 446
 447                         Assert.AreEqual ("trans", qname.Name, "#2");
 448                         Assert.AreEqual ("NSDate", qname.Namespace, "#3");
 449
 450                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 451                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 452
 453                         Assert.IsNotNull (map, "#4");
 454                         Assert.AreEqual ("trans", map.ElementName, "#5");
 455                         Assert.AreEqual ("NSDate", map.Namespace, "#6");
 456                         Assert.AreEqual ("TranslationStatus", map.TypeFullName, "#7");
 457                         Assert.AreEqual ("TranslationStatus", map.TypeName, "#8");
 458
 459                         CodeNamespace codeNamespace = ExportCode (map);
 460                         Assert.IsNotNull (codeNamespace);
 461
 462                         CodeTypeDeclaration type = FindType (codeNamespace, "TranslationStatus");
 463                         Assert.IsNotNull (type, "#9");
 464
 465                         CodeMemberField field = FindMember (type, "Value") as CodeMemberField;
 466                         Assert.IsNotNull (field, "#10");
 467                         Assert.AreEqual ("StatusType", field.Type.BaseType, "#11");
 468
 469                         field = FindMember (type, "Language") as CodeMemberField;
 470                         Assert.IsNotNull (field, "#12");
 471                         Assert.AreEqual ("System.Int32", field.Type.BaseType, "#13");
 472                 }
 473
 474                 CodeNamespace ExportCode (XmlTypeMapping map)
 475                 {
 476                         CodeNamespace codeNamespace = new CodeNamespace ();
 477                         XmlCodeExporter exp = new XmlCodeExporter (codeNamespace);
 478                         exp.ExportTypeMapping (map);
 479                         return codeNamespace;
 480                 }
 481
 482                 CodeTypeDeclaration FindType (CodeNamespace codeNamespace, string name)
 483                 {
 484                         foreach (CodeTypeDeclaration t in codeNamespace.Types)
 485                                 if (t.Name == name)
 486                                         return t;
 487                         return null;
 488                 }
 489
 490                 CodeTypeMember FindMember (CodeTypeDeclaration type, string name)
 491                 {
 492                         foreach (CodeTypeMember m in type.Members)
 493                                 if (m.Name == name)
 494                                         return m;
 495                         return null;
 496                 }
 497
 498                 private static XmlSchemas ExportType (Type type)
 499                 {
 500                         XmlReflectionImporter ri = new XmlReflectionImporter ("NS" + type.Name);
 501                         XmlSchemas schemas = new XmlSchemas ();
 502                         XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
 503                         XmlTypeMapping tm = ri.ImportTypeMapping (type);
 504                         sx.ExportTypeMapping (tm);
 505                         return schemas;
 506                 }
 507
 508                 private static ArrayList GetXmlQualifiedNames (XmlSchemas schemas)
 509                 {
 510                         ArrayList qnames = new ArrayList ();
 511
 512                         foreach (XmlSchema schema in schemas) {
 513                                 if (!schema.IsCompiled) schema.Compile (null);
 514                                 foreach (XmlSchemaObject ob in schema.Items)
 515                                         if (ob is XmlSchemaElement)
 516                                                 qnames.Add (((XmlSchemaElement) ob).QualifiedName);
 517                         }
 518
 519                         return qnames;
 520                 }
 521         }
 522 }