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_AnyURI ()
  68                 {
  69                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
  70                                 "<xs:schema xmlns:tns=\"NSAnyURI\" elementFormDefault=\"qualified\" targetNamespace=\"NSAnyURI\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
  71                                 "  <xs:element name=\"anyURI\" type=\"xs:anyURI\" />" +
  72                                 "</xs:schema>";
  73
  74                         XmlSchemas schemas = new XmlSchemas ();
  75                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
  76
  77                         ArrayList qnames = GetXmlQualifiedNames (schemas);
  78                         Assert.AreEqual (1, qnames.Count, "#1");
  79
  80                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
  81
  82                         Assert.AreEqual ("anyURI", qname.Name, "#2");
  83                         Assert.AreEqual ("NSAnyURI", qname.Namespace, "#3");
  84
  85                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
  86                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
  87
  88                         Assert.IsNotNull (map, "#4");
  89                         Assert.AreEqual ("anyURI", map.ElementName, "#5");
  90                         Assert.AreEqual ("NSAnyURI", map.Namespace, "#6");
  91                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
  92                         Assert.AreEqual ("String", map.TypeName, "#8");
  93                 }
  94
  95                 [Test]
  96                 [Category ("NotWorking")]
  97                 public void ImportTypeMapping_XsdPrimitive_Base64 ()
  98                 {
  99                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 100                                 "<xs:schema xmlns:tns=\"NSBase64\" elementFormDefault=\"qualified\" targetNamespace=\"NSBase64\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 101                                 "  <xs:element name=\"base64\" type=\"xs:base64\" />" +
 102                                 "</xs:schema>";
 103
 104                         XmlSchemas schemas = new XmlSchemas ();
 105                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 106                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 107                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("base64", "NSBase64"));
 108
 109                         Assert.IsNotNull (map, "#1");
 110                         Assert.AreEqual ("base64", map.ElementName, "#2");
 111                         Assert.AreEqual ("NSBase64", map.Namespace, "#3");
 112                         Assert.AreEqual ("System.String", map.TypeFullName, "#4");
 113                         Assert.AreEqual ("String", map.TypeName, "#5");
 114                 }
 115
 116                 [Test]
 117                 public void ImportTypeMapping_XsdPrimitive_Base64Binary ()
 118                 {
 119                         XmlSchemas schemas = ExportType (typeof (byte[]));
 120                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 121                         Assert.AreEqual (1, qnames.Count, "#1");
 122
 123                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 124                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 125
 126                         Assert.IsNotNull (map, "#2");
 127                         Assert.AreEqual ("base64Binary", map.ElementName, "#3");
 128                         Assert.AreEqual ("NSByte[]", map.Namespace, "#4");
 129                         Assert.AreEqual ("System.Byte[]", map.TypeFullName, "#5");
 130                         Assert.AreEqual ("Byte[]", map.TypeName, "#6");
 131                 }
 132
 133                 [Test]
 134                 public void ImportTypeMapping_XsdPrimitive_Boolean ()
 135                 {
 136                         XmlSchemas schemas = ExportType (typeof (bool));
 137                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 138                         Assert.AreEqual (1, qnames.Count, "#1");
 139
 140                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 141                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 142
 143                         Assert.IsNotNull (map, "#2");
 144                         Assert.AreEqual ("boolean", map.ElementName, "#3");
 145                         Assert.AreEqual ("NSBoolean", map.Namespace, "#4");
 146                         Assert.AreEqual ("System.Boolean", map.TypeFullName, "#5");
 147                         Assert.AreEqual ("Boolean", map.TypeName, "#6");
 148                 }
 149
 150                 [Test]
 151                 public void ImportTypeMapping_XsdPrimitive_Byte ()
 152                 {
 153                         XmlSchemas schemas = ExportType (typeof (sbyte));
 154                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 155                         Assert.AreEqual (1, qnames.Count, "#1");
 156
 157                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 158                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 159
 160                         Assert.IsNotNull (map, "#2");
 161                         Assert.AreEqual ("byte", map.ElementName, "#3");
 162                         Assert.AreEqual ("NSSByte", map.Namespace, "#4");
 163                         Assert.AreEqual ("System.SByte", map.TypeFullName, "#5");
 164                         Assert.AreEqual ("SByte", map.TypeName, "#6");
 165                 }
 166
 167                 [Test]
 168                 [Category ("NotWorking")]
 169                 public void ImportTypeMapping_XsdPrimitive_Char ()
 170                 {
 171                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 172                                 "<xs:schema xmlns:tns=\"NSChar\" elementFormDefault=\"qualified\" targetNamespace=\"NSChar\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 173                                 "  <xs:element name=\"char\" type=\"xs:char\" />" +
 174                                 "</xs:schema>";
 175
 176                         XmlSchemas schemas = new XmlSchemas ();
 177                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 178                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 179                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("char", "NSChar"));
 180
 181                         Assert.IsNotNull (map, "#A1");
 182                         Assert.AreEqual ("char", map.ElementName, "#A2");
 183                         Assert.AreEqual ("NSChar", map.Namespace, "#A3");
 184                         Assert.AreEqual ("System.String", map.TypeFullName, "#A4");
 185                         Assert.AreEqual ("String", map.TypeName, "#A5");
 186
 187 #if ONLY_1_1
 188                         schemas = ExportType (typeof (char));
 189                         importer = new XmlSchemaImporter (schemas);
 190                         map = importer.ImportTypeMapping (new XmlQualifiedName ("char", "NSChar"));
 191
 192                         Assert.IsNotNull (map, "#B1");
 193                         Assert.AreEqual ("char", map.ElementName, "#B2");
 194                         Assert.AreEqual ("NSChar", map.Namespace, "#B3");
 195                         Assert.AreEqual ("System.Char", map.TypeFullName, "#B4");
 196                         Assert.AreEqual ("Char", map.TypeName, "#B5");
 197 #endif
 198                 }
 199
 200                 [Test]
 201                 public void ImportTypeMapping_XsdPrimitive_Date ()
 202                 {
 203                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 204                                 "<xs:schema xmlns:tns=\"NSDate\" elementFormDefault=\"qualified\" targetNamespace=\"NSDate\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 205                                 "  <xs:element name=\"date\" type=\"xs:date\" />" +
 206                                 "</xs:schema>";
 207
 208                         XmlSchemas schemas = new XmlSchemas ();
 209                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 210
 211                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 212                         Assert.AreEqual (1, qnames.Count, "#1");
 213
 214                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 215
 216                         Assert.AreEqual ("date", qname.Name, "#2");
 217                         Assert.AreEqual ("NSDate", qname.Namespace, "#3");
 218
 219                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 220                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 221
 222                         Assert.IsNotNull (map, "#4");
 223                         Assert.AreEqual ("date", map.ElementName, "#5");
 224                         Assert.AreEqual ("NSDate", map.Namespace, "#6");
 225                         Assert.AreEqual ("System.DateTime", map.TypeFullName, "#7");
 226                         Assert.AreEqual ("DateTime", map.TypeName, "#8");
 227                 }
 228
 229                 [Test]
 230                 public void ImportTypeMapping_XsdPrimitive_DateTime ()
 231                 {
 232                         XmlSchemas schemas = ExportType (typeof (DateTime));
 233                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 234                         Assert.AreEqual (1, qnames.Count, "#1");
 235
 236                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 237                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 238
 239                         Assert.IsNotNull (map, "#2");
 240                         Assert.AreEqual ("dateTime", map.ElementName, "#3");
 241                         Assert.AreEqual ("NSDateTime", map.Namespace, "#4");
 242                         Assert.AreEqual ("System.DateTime", map.TypeFullName, "#5");
 243                         Assert.AreEqual ("DateTime", map.TypeName, "#6");
 244                 }
 245
 246                 [Test]
 247                 public void ImportTypeMapping_XsdPrimitive_Decimal ()
 248                 {
 249                         XmlSchemas schemas = ExportType (typeof (decimal));
 250                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 251                         Assert.AreEqual (1, qnames.Count, "#1");
 252
 253                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 254                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 255
 256                         Assert.IsNotNull (map, "#2");
 257                         Assert.AreEqual ("decimal", map.ElementName, "#3");
 258                         Assert.AreEqual ("NSDecimal", map.Namespace, "#4");
 259                         Assert.AreEqual ("System.Decimal", map.TypeFullName, "#5");
 260                         Assert.AreEqual ("Decimal", map.TypeName, "#6");
 261                 }
 262
 263                 [Test]
 264                 public void ImportTypeMapping_XsdPrimitive_Double ()
 265                 {
 266                         XmlSchemas schemas = ExportType (typeof (double));
 267                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 268                         Assert.AreEqual (1, qnames.Count, "#1");
 269
 270                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 271                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 272
 273                         Assert.IsNotNull (map, "#2");
 274                         Assert.AreEqual ("double", map.ElementName, "#3");
 275                         Assert.AreEqual ("NSDouble", map.Namespace, "#4");
 276                         Assert.AreEqual ("System.Double", map.TypeFullName, "#5");
 277                         Assert.AreEqual ("Double", map.TypeName, "#6");
 278                 }
 279
 280                 [Test]
 281                 [Category ("NotWorking")]
 282                 public void ImportTypeMapping_XsdPrimitive_Duration ()
 283                 {
 284                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 285                                 "<xs:schema xmlns:tns=\"NSDuration\" elementFormDefault=\"qualified\" targetNamespace=\"NSDuration\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 286                                 "  <xs:element name=\"duration\" type=\"xs:duration\" />" +
 287                                 "</xs:schema>";
 288
 289                         XmlSchemas schemas = new XmlSchemas ();
 290                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 291
 292                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 293                         Assert.AreEqual (1, qnames.Count, "#1");
 294
 295                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 296
 297                         Assert.AreEqual ("duration", qname.Name, "#2");
 298                         Assert.AreEqual ("NSDuration", qname.Namespace, "#3");
 299
 300                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 301                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 302
 303                         Assert.IsNotNull (map, "#4");
 304                         Assert.AreEqual ("duration", map.ElementName, "#5");
 305                         Assert.AreEqual ("NSDuration", map.Namespace, "#6");
 306                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 307                         Assert.AreEqual ("String", map.TypeName, "#8");
 308                 }
 309
 310                 [Test]
 311                 public void ImportTypeMapping_XsdPrimitive_ENTITIES ()
 312                 {
 313                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 314                                 "<xs:schema xmlns:tns=\"NSENTITIES\" elementFormDefault=\"qualified\" targetNamespace=\"NSENTITIES\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 315                                 "  <xs:element name=\"ENTITIES\" type=\"xs:ENTITIES\" />" +
 316                                 "</xs:schema>";
 317
 318                         XmlSchemas schemas = new XmlSchemas ();
 319                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 320
 321                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 322                         Assert.AreEqual (1, qnames.Count, "#1");
 323
 324                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 325
 326                         Assert.AreEqual ("ENTITIES", qname.Name, "#2");
 327                         Assert.AreEqual ("NSENTITIES", qname.Namespace, "#3");
 328
 329                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 330                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 331
 332                         Assert.IsNotNull (map, "#4");
 333                         Assert.AreEqual ("ENTITIES", map.ElementName, "#5");
 334                         Assert.AreEqual ("NSENTITIES", map.Namespace, "#6");
 335                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 336                         Assert.AreEqual ("String", map.TypeName, "#8");
 337                 }
 338
 339                 [Test]
 340                 public void ImportTypeMapping_XsdPrimitive_ENTITY ()
 341                 {
 342                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 343                                 "<xs:schema xmlns:tns=\"NSENTITY\" elementFormDefault=\"qualified\" targetNamespace=\"NSENTITY\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 344                                 "  <xs:element name=\"ENTITY\" type=\"xs:ENTITY\" />" +
 345                                 "</xs:schema>";
 346
 347                         XmlSchemas schemas = new XmlSchemas ();
 348                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 349
 350                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 351                         Assert.AreEqual (1, qnames.Count, "#1");
 352
 353                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 354
 355                         Assert.AreEqual ("ENTITY", qname.Name, "#2");
 356                         Assert.AreEqual ("NSENTITY", qname.Namespace, "#3");
 357
 358                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 359                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 360
 361                         Assert.IsNotNull (map, "#4");
 362                         Assert.AreEqual ("ENTITY", map.ElementName, "#5");
 363                         Assert.AreEqual ("NSENTITY", map.Namespace, "#6");
 364                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 365                         Assert.AreEqual ("String", map.TypeName, "#8");
 366                 }
 367
 368                 [Test]
 369                 public void ImportTypeMapping_XsdPrimitive_Float ()
 370                 {
 371                         XmlSchemas schemas = ExportType (typeof (float));
 372                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 373                         Assert.AreEqual (1, qnames.Count, "#1");
 374
 375                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 376                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 377
 378                         Assert.IsNotNull (map, "#2");
 379                         Assert.AreEqual ("float", map.ElementName, "#3");
 380                         Assert.AreEqual ("NSSingle", map.Namespace, "#4");
 381                         Assert.AreEqual ("System.Single", map.TypeFullName, "#5");
 382                         Assert.AreEqual ("Single", map.TypeName, "#6");
 383                 }
 384
 385                 [Test]
 386                 public void ImportTypeMapping_XsdPrimitive_GDay ()
 387                 {
 388                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 389                                 "<xs:schema xmlns:tns=\"NSGDay\" elementFormDefault=\"qualified\" targetNamespace=\"NSGDay\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 390                                 "  <xs:element name=\"gDay\" type=\"xs:gDay\" />" +
 391                                 "</xs:schema>";
 392
 393                         XmlSchemas schemas = new XmlSchemas ();
 394                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 395
 396                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 397                         Assert.AreEqual (1, qnames.Count, "#1");
 398
 399                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 400
 401                         Assert.AreEqual ("gDay", qname.Name, "#2");
 402                         Assert.AreEqual ("NSGDay", qname.Namespace, "#3");
 403
 404                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 405                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 406
 407                         Assert.IsNotNull (map, "#4");
 408                         Assert.AreEqual ("gDay", map.ElementName, "#5");
 409                         Assert.AreEqual ("NSGDay", map.Namespace, "#6");
 410                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 411                         Assert.AreEqual ("String", map.TypeName, "#8");
 412                 }
 413
 414                 [Test]
 415                 public void ImportTypeMapping_XsdPrimitive_GMonthDay ()
 416                 {
 417                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 418                                 "<xs:schema xmlns:tns=\"NSGMonthDay\" elementFormDefault=\"qualified\" targetNamespace=\"NSGMonthDay\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 419                                 "  <xs:element name=\"gMonthDay\" type=\"xs:gMonthDay\" />" +
 420                                 "</xs:schema>";
 421
 422                         XmlSchemas schemas = new XmlSchemas ();
 423                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 424
 425                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 426                         Assert.AreEqual (1, qnames.Count, "#1");
 427
 428                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 429
 430                         Assert.AreEqual ("gMonthDay", qname.Name, "#2");
 431                         Assert.AreEqual ("NSGMonthDay", qname.Namespace, "#3");
 432
 433                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 434                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 435
 436                         Assert.IsNotNull (map, "#4");
 437                         Assert.AreEqual ("gMonthDay", map.ElementName, "#5");
 438                         Assert.AreEqual ("NSGMonthDay", map.Namespace, "#6");
 439                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 440                         Assert.AreEqual ("String", map.TypeName, "#8");
 441                 }
 442
 443                 [Test]
 444                 [Category ("NotWorking")]
 445                 public void ImportTypeMapping_XsdPrimitive_Guid ()
 446                 {
 447                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 448                                 "<xs:schema xmlns:tns=\"NSGuid\" elementFormDefault=\"qualified\" targetNamespace=\"NSGuid\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 449                                 "  <xs:element name=\"guid\" type=\"xs:guid\" />" +
 450                                 "</xs:schema>";
 451
 452                         XmlSchemas schemas = new XmlSchemas ();
 453                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 454                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 455                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("guid", "NSGuid"));
 456
 457                         Assert.IsNotNull (map, "#A1");
 458                         Assert.AreEqual ("guid", map.ElementName, "#A2");
 459                         Assert.AreEqual ("NSGuid", map.Namespace, "#A3");
 460                         Assert.AreEqual ("System.String", map.TypeFullName, "#A4");
 461                         Assert.AreEqual ("String", map.TypeName, "#A5");
 462
 463 #if ONLY_1_1
 464                         schemas = ExportType (typeof (Guid));
 465                         importer = new XmlSchemaImporter (schemas);
 466                         map = importer.ImportTypeMapping (new XmlQualifiedName ("guid", "NSGuid"));
 467
 468                         Assert.IsNotNull (map, "#B1");
 469                         Assert.AreEqual ("guid", map.ElementName, "#B2");
 470                         Assert.AreEqual ("NSGuid", map.Namespace, "#B3");
 471                         Assert.AreEqual ("System.Guid", map.TypeFullName, "#B4");
 472                         Assert.AreEqual ("Guid", map.TypeName, "#B5");
 473 #endif
 474                 }
 475
 476                 [Test]
 477                 public void ImportTypeMapping_XsdPrimitive_GYear ()
 478                 {
 479                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 480                                 "<xs:schema xmlns:tns=\"NSGYear\" elementFormDefault=\"qualified\" targetNamespace=\"NSGYear\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 481                                 "  <xs:element name=\"gYear\" type=\"xs:gYear\" />" +
 482                                 "</xs:schema>";
 483
 484                         XmlSchemas schemas = new XmlSchemas ();
 485                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 486
 487                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 488                         Assert.AreEqual (1, qnames.Count, "#1");
 489
 490                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 491
 492                         Assert.AreEqual ("gYear", qname.Name, "#2");
 493                         Assert.AreEqual ("NSGYear", qname.Namespace, "#3");
 494
 495                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 496                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 497
 498                         Assert.IsNotNull (map, "#4");
 499                         Assert.AreEqual ("gYear", map.ElementName, "#5");
 500                         Assert.AreEqual ("NSGYear", map.Namespace, "#6");
 501                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 502                         Assert.AreEqual ("String", map.TypeName, "#8");
 503                 }
 504
 505                 [Test]
 506                 public void ImportTypeMapping_XsdPrimitive_GYearMonth ()
 507                 {
 508                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 509                                 "<xs:schema xmlns:tns=\"NSGYearMonth\" elementFormDefault=\"qualified\" targetNamespace=\"NSGYearMonth\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 510                                 "  <xs:element name=\"gYearMonth\" type=\"xs:gYearMonth\" />" +
 511                                 "</xs:schema>";
 512
 513                         XmlSchemas schemas = new XmlSchemas ();
 514                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 515
 516                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 517                         Assert.AreEqual (1, qnames.Count, "#1");
 518
 519                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 520
 521                         Assert.AreEqual ("gYearMonth", qname.Name, "#2");
 522                         Assert.AreEqual ("NSGYearMonth", qname.Namespace, "#3");
 523
 524                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 525                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 526
 527                         Assert.IsNotNull (map, "#4");
 528                         Assert.AreEqual ("gYearMonth", map.ElementName, "#5");
 529                         Assert.AreEqual ("NSGYearMonth", map.Namespace, "#6");
 530                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 531                         Assert.AreEqual ("String", map.TypeName, "#8");
 532                 }
 533
 534                 [Test]
 535                 public void ImportTypeMapping_XsdPrimitive_HexBinary ()
 536                 {
 537                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 538                                 "<xs:schema xmlns:tns=\"NSHexBinary\" elementFormDefault=\"qualified\" targetNamespace=\"NSHexBinary\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 539                                 "  <xs:element name=\"hexBinary\" type=\"xs:hexBinary\" />" +
 540                                 "</xs:schema>";
 541
 542                         XmlSchemas schemas = new XmlSchemas ();
 543                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 544
 545                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 546                         Assert.AreEqual (1, qnames.Count, "#1");
 547
 548                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 549
 550                         Assert.AreEqual ("hexBinary", qname.Name, "#2");
 551                         Assert.AreEqual ("NSHexBinary", qname.Namespace, "#3");
 552
 553                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 554                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 555
 556                         Assert.IsNotNull (map, "#4");
 557                         Assert.AreEqual ("hexBinary", map.ElementName, "#5");
 558                         Assert.AreEqual ("NSHexBinary", map.Namespace, "#6");
 559                         Assert.AreEqual ("System.Byte[]", map.TypeFullName, "#7");
 560                         Assert.AreEqual ("Byte[]", map.TypeName, "#8");
 561                 }
 562
 563                 [Test]
 564                 public void ImportTypeMapping_XsdPrimitive_IDREFS ()
 565                 {
 566                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 567                                 "<xs:schema xmlns:tns=\"NSIDREFS\" elementFormDefault=\"qualified\" targetNamespace=\"NSIDREFS\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 568                                 "  <xs:element name=\"IDREFS\" type=\"xs:IDREFS\" />" +
 569                                 "</xs:schema>";
 570
 571                         XmlSchemas schemas = new XmlSchemas ();
 572                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 573
 574                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 575                         Assert.AreEqual (1, qnames.Count, "#1");
 576
 577                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 578
 579                         Assert.AreEqual ("IDREFS", qname.Name, "#2");
 580                         Assert.AreEqual ("NSIDREFS", qname.Namespace, "#3");
 581
 582                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 583                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 584
 585                         Assert.IsNotNull (map, "#4");
 586                         Assert.AreEqual ("IDREFS", map.ElementName, "#5");
 587                         Assert.AreEqual ("NSIDREFS", map.Namespace, "#6");
 588                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 589                         Assert.AreEqual ("String", map.TypeName, "#8");
 590                 }
 591
 592                 [Test]
 593                 public void ImportTypeMapping_XsdPrimitive_Int ()
 594                 {
 595                         XmlSchemas schemas = ExportType (typeof (int));
 596                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 597                         Assert.AreEqual (1, qnames.Count, "#1");
 598
 599                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 600                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 601
 602                         Assert.IsNotNull (map, "#2");
 603                         Assert.AreEqual ("int", map.ElementName, "#3");
 604                         Assert.AreEqual ("NSInt32", map.Namespace, "#4");
 605                         Assert.AreEqual ("System.Int32", map.TypeFullName, "#5");
 606                         Assert.AreEqual ("Int32", map.TypeName, "#6");
 607                 }
 608
 609                 [Test]
 610                 public void ImportTypeMapping_XsdPrimitive_Integer ()
 611                 {
 612                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 613                                 "<xs:schema xmlns:tns=\"NSInteger\" elementFormDefault=\"qualified\" targetNamespace=\"NSInteger\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 614                                 "  <xs:element name=\"integer\" type=\"xs:integer\" />" +
 615                                 "</xs:schema>";
 616
 617                         XmlSchemas schemas = new XmlSchemas ();
 618                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 619
 620                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 621                         Assert.AreEqual (1, qnames.Count, "#1");
 622
 623                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 624
 625                         Assert.AreEqual ("integer", qname.Name, "#2");
 626                         Assert.AreEqual ("NSInteger", qname.Namespace, "#3");
 627
 628                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 629                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 630
 631                         Assert.IsNotNull (map, "#4");
 632                         Assert.AreEqual ("integer", map.ElementName, "#5");
 633                         Assert.AreEqual ("NSInteger", map.Namespace, "#6");
 634                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 635                         Assert.AreEqual ("String", map.TypeName, "#8");
 636                 }
 637
 638                 [Test]
 639                 public void ImportTypeMapping_XsdPrimitive_Long ()
 640                 {
 641                         XmlSchemas schemas = ExportType (typeof (long));
 642                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 643                         Assert.AreEqual (1, qnames.Count, "#1");
 644
 645                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 646                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 647
 648                         Assert.IsNotNull (map, "#2");
 649                         Assert.AreEqual ("long", map.ElementName, "#3");
 650                         Assert.AreEqual ("NSInt64", map.Namespace, "#4");
 651                         Assert.AreEqual ("System.Int64", map.TypeFullName, "#5");
 652                         Assert.AreEqual ("Int64", map.TypeName, "#6");
 653                 }
 654
 655                 [Test]
 656                 [Category ("NotWorking")]
 657                 public void ImportTypeMapping_XsdPrimitive_Month ()
 658                 {
 659                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 660                                 "<xs:schema xmlns:tns=\"NSMonth\" elementFormDefault=\"qualified\" targetNamespace=\"NSMonth\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 661                                 "  <xs:element name=\"month\" type=\"xs:month\" />" +
 662                                 "</xs:schema>";
 663
 664                         XmlSchemas schemas = new XmlSchemas ();
 665                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 666
 667                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 668                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("month", "NSMonth"));
 669
 670                         Assert.IsNotNull (map, "#4");
 671                         Assert.AreEqual ("month", map.ElementName, "#5");
 672                         Assert.AreEqual ("NSMonth", map.Namespace, "#6");
 673                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 674                         Assert.AreEqual ("String", map.TypeName, "#8");
 675                 }
 676
 677                 [Test]
 678                 public void ImportTypeMapping_XsdPrimitive_QName ()
 679                 {
 680                         XmlSchemas schemas = ExportType (typeof (XmlQualifiedName));
 681                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 682                         Assert.AreEqual (1, qnames.Count, "#1");
 683
 684                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 685                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 686
 687                         Assert.IsNotNull (map, "#2");
 688                         Assert.AreEqual ("QName", map.ElementName, "#3");
 689                         Assert.AreEqual ("NSXmlQualifiedName", map.Namespace, "#4");
 690                         Assert.AreEqual ("System.Xml.XmlQualifiedName", map.TypeFullName, "#5");
 691                         Assert.AreEqual ("XmlQualifiedName", map.TypeName, "#6");
 692                 }
 693
 694                 [Test]
 695                 public void ImportTypeMapping_XsdPrimitive_Short ()
 696                 {
 697                         XmlSchemas schemas = ExportType (typeof (short));
 698                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 699                         Assert.AreEqual (1, qnames.Count, "#1");
 700
 701                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 702                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 703
 704                         Assert.IsNotNull (map, "#2");
 705                         Assert.AreEqual ("short", map.ElementName, "#3");
 706                         Assert.AreEqual ("NSInt16", map.Namespace, "#4");
 707                         Assert.AreEqual ("System.Int16", map.TypeFullName, "#5");
 708                         Assert.AreEqual ("Int16", map.TypeName, "#6");
 709                 }
 710
 711                 [Test]
 712                 public void ImportTypeMapping_XsdPrimitive_String ()
 713                 {
 714                         XmlSchemas schemas = ExportType (typeof (string));
 715                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 716                         Assert.AreEqual (1, qnames.Count, "#1");
 717
 718                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 719                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 720
 721                         Assert.IsNotNull (map, "#2");
 722                         Assert.AreEqual ("string", map.ElementName, "#3");
 723                         Assert.AreEqual ("NSString", map.Namespace, "#4");
 724                         Assert.AreEqual ("System.String", map.TypeFullName, "#5");
 725                         Assert.AreEqual ("String", map.TypeName, "#6");
 726                 }
 727
 728                 [Test]
 729                 public void ImportTypeMapping_XsdPrimitive_Time ()
 730                 {
 731                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 732                                 "<xs:schema xmlns:tns=\"NSTime\" elementFormDefault=\"qualified\" targetNamespace=\"NSTime\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 733                                 "  <xs:element name=\"time\" type=\"xs:time\" />" +
 734                                 "</xs:schema>";
 735
 736                         XmlSchemas schemas = new XmlSchemas ();
 737                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 738
 739                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 740                         Assert.AreEqual (1, qnames.Count, "#1");
 741
 742                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 743
 744                         Assert.AreEqual ("time", qname.Name, "#2");
 745                         Assert.AreEqual ("NSTime", qname.Namespace, "#3");
 746
 747                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 748                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 749
 750                         Assert.IsNotNull (map, "#4");
 751                         Assert.AreEqual ("time", map.ElementName, "#5");
 752                         Assert.AreEqual ("NSTime", map.Namespace, "#6");
 753                         Assert.AreEqual ("System.DateTime", map.TypeFullName, "#7");
 754                         Assert.AreEqual ("DateTime", map.TypeName, "#8");
 755                 }
 756
 757                 [Test]
 758                 [Category ("NotWorking")]
 759                 public void ImportTypeMapping_XsdPrimitive_TimeInstant ()
 760                 {
 761                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 762                                 "<xs:schema xmlns:tns=\"NSTimeInstant\" elementFormDefault=\"qualified\" targetNamespace=\"NSTimeInstant\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 763                                 "  <xs:element name=\"timeInstant\" type=\"xs:timeInstant\" />" +
 764                                 "</xs:schema>";
 765
 766                         XmlSchemas schemas = new XmlSchemas ();
 767                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 768
 769                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 770                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("timeInstant", "NSTimeInstant"));
 771
 772                         Assert.IsNotNull (map, "#4");
 773                         Assert.AreEqual ("timeInstant", map.ElementName, "#5");
 774                         Assert.AreEqual ("NSTimeInstant", map.Namespace, "#6");
 775                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 776                         Assert.AreEqual ("String", map.TypeName, "#8");
 777                 }
 778
 779                 [Test]
 780                 [Category ("NotWorking")]
 781                 public void ImportTypeMapping_XsdPrimitive_TimePeriod ()
 782                 {
 783                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 784                                 "<xs:schema xmlns:tns=\"NSTimePeriod\" elementFormDefault=\"qualified\" targetNamespace=\"NSTimePeriod\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 785                                 "  <xs:element name=\"timePeriod\" type=\"xs:timePeriod\" />" +
 786                                 "</xs:schema>";
 787
 788                         XmlSchemas schemas = new XmlSchemas ();
 789                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 790
 791                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 792                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("timePeriod", "NSTimePeriod"));
 793
 794                         Assert.IsNotNull (map, "#4");
 795                         Assert.AreEqual ("timePeriod", map.ElementName, "#5");
 796                         Assert.AreEqual ("NSTimePeriod", map.Namespace, "#6");
 797                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 798                         Assert.AreEqual ("String", map.TypeName, "#8");
 799                 }
 800
 801                 [Test]
 802                 public void ImportTypeMapping_XsdPrimitive_UnsignedByte ()
 803                 {
 804                         XmlSchemas schemas = ExportType (typeof (byte));
 805                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 806                         Assert.AreEqual (1, qnames.Count, "#1");
 807
 808                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 809                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 810
 811                         Assert.IsNotNull (map, "#2");
 812                         Assert.AreEqual ("unsignedByte", map.ElementName, "#3");
 813                         Assert.AreEqual ("NSByte", map.Namespace, "#4");
 814                         Assert.AreEqual ("System.Byte", map.TypeFullName, "#5");
 815                         Assert.AreEqual ("Byte", map.TypeName, "#6");
 816                 }
 817
 818                 [Test]
 819                 public void ImportTypeMapping_XsdPrimitive_UnsignedInt ()
 820                 {
 821                         XmlSchemas schemas = ExportType (typeof (uint));
 822                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 823                         Assert.AreEqual (1, qnames.Count, "#1");
 824
 825                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 826                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 827
 828                         Assert.IsNotNull (map, "#2");
 829                         Assert.AreEqual ("unsignedInt", map.ElementName, "#3");
 830                         Assert.AreEqual ("NSUInt32", map.Namespace, "#4");
 831                         Assert.AreEqual ("System.UInt32", map.TypeFullName, "#5");
 832                         Assert.AreEqual ("UInt32", map.TypeName, "#6");
 833                 }
 834
 835                 [Test]
 836                 public void ImportTypeMapping_XsdPrimitive_UnsignedLong ()
 837                 {
 838                         XmlSchemas schemas = ExportType (typeof (ulong));
 839                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 840                         Assert.AreEqual (1, qnames.Count, "#1");
 841
 842                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 843                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 844
 845                         Assert.IsNotNull (map, "#2");
 846                         Assert.AreEqual ("unsignedLong", map.ElementName, "#3");
 847                         Assert.AreEqual ("NSUInt64", map.Namespace, "#4");
 848                         Assert.AreEqual ("System.UInt64", map.TypeFullName, "#5");
 849                         Assert.AreEqual ("UInt64", map.TypeName, "#6");
 850                 }
 851
 852                 [Test]
 853                 public void ImportTypeMapping_XsdPrimitive_UnsignedShort ()
 854                 {
 855                         XmlSchemas schemas = ExportType (typeof (ushort));
 856                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 857                         Assert.AreEqual (1, qnames.Count, "#1");
 858
 859                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 860                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 861
 862                         Assert.IsNotNull (map, "#2");
 863                         Assert.AreEqual ("unsignedShort", map.ElementName, "#3");
 864                         Assert.AreEqual ("NSUInt16", map.Namespace, "#4");
 865                         Assert.AreEqual ("System.UInt16", map.TypeFullName, "#5");
 866                         Assert.AreEqual ("UInt16", map.TypeName, "#6");
 867                 }
 868
 869                 [Test]
 870                 public void ImportTypeMapping_EnumSimpleContent ()
 871                 {
 872                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 873                                 "<s:schema xmlns:tns=\"NSDate\" elementFormDefault=\"qualified\" targetNamespace=\"NSDate\" xmlns:s=\"http://www.w3.org/2001/XMLSchema\">" +
 874                                 "      <s:element name=\"trans\" type=\"tns:TranslationStatus\" />" +
 875                                 "      <s:complexType name=\"TranslationStatus\">" +
 876                                 "        <s:simpleContent>" +
 877                                 "          <s:extension base=\"tns:StatusType\">" +
 878                                 "            <s:attribute name=\"Language\" type=\"s:int\" use=\"required\" />" +
 879                                 "          </s:extension>" +
 880                                 "        </s:simpleContent>" +
 881                                 "      </s:complexType>" +
 882                                 "      <s:simpleType name=\"StatusType\">" +
 883                                 "        <s:restriction base=\"s:string\">" +
 884                                 "          <s:enumeration value=\"Untouched\" />" +
 885                                 "          <s:enumeration value=\"Touched\" />" +
 886                                 "          <s:enumeration value=\"Complete\" />" +
 887                                 "          <s:enumeration value=\"None\" />" +
 888                                 "        </s:restriction>" +
 889                                 "      </s:simpleType>" +
 890                                 "</s:schema>";
 891
 892                         XmlSchemas schemas = new XmlSchemas ();
 893                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 894
 895                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 896                         Assert.AreEqual (1, qnames.Count, "#1");
 897
 898                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 899
 900                         Assert.AreEqual ("trans", qname.Name, "#2");
 901                         Assert.AreEqual ("NSDate", qname.Namespace, "#3");
 902
 903                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 904                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 905
 906                         Assert.IsNotNull (map, "#4");
 907                         Assert.AreEqual ("trans", map.ElementName, "#5");
 908                         Assert.AreEqual ("NSDate", map.Namespace, "#6");
 909                         Assert.AreEqual ("TranslationStatus", map.TypeFullName, "#7");
 910                         Assert.AreEqual ("TranslationStatus", map.TypeName, "#8");
 911
 912                         CodeNamespace codeNamespace = ExportCode (map);
 913                         Assert.IsNotNull (codeNamespace, "#9");
 914
 915                         CodeTypeDeclaration type = FindType (codeNamespace, "TranslationStatus");
 916                         Assert.IsNotNull (type, "#10");
 917
 918 #if NET_2_0
 919                         CodeMemberProperty property = FindMember (type, "Value") as CodeMemberProperty;
 920                         Assert.IsNotNull (property, "#A1");
 921                         Assert.IsTrue (property.HasGet, "#A2");
 922                         Assert.IsTrue (property.HasSet, "#A3");
 923                         Assert.AreEqual ("StatusType", property.Type.BaseType, "#A4");
 924
 925                         CodeMemberField field = FindMember (type, "valueField") as CodeMemberField;
 926                         Assert.IsNotNull (field, "#A5");
 927                         Assert.AreEqual ("StatusType", field.Type.BaseType, "#A6");
 928
 929                         property = FindMember (type, "Language") as CodeMemberProperty;
 930                         Assert.IsNotNull (property, "#B1");
 931                         Assert.IsTrue (property.HasGet, "#B2");
 932                         Assert.IsTrue (property.HasSet, "#B3");
 933                         Assert.AreEqual ("System.Int32", property.Type.BaseType, "#B4");
 934
 935                         field = FindMember (type, "languageField") as CodeMemberField;
 936                         Assert.IsNotNull (field, "#B5");
 937                         Assert.AreEqual ("System.Int32", field.Type.BaseType, "#B6");
 938 #else
 939                         CodeMemberField field = FindMember (type, "Value") as CodeMemberField;
 940                         Assert.IsNotNull (field, "#A1");
 941                         Assert.AreEqual ("StatusType", field.Type.BaseType, "#A2");
 942
 943                         field = FindMember (type, "Language") as CodeMemberField;
 944                         Assert.IsNotNull (field, "#B1");
 945                         Assert.AreEqual ("System.Int32", field.Type.BaseType, "#B2");
 946 #endif
 947                 }
 948
 949                 CodeNamespace ExportCode (XmlTypeMapping map)
 950                 {
 951                         CodeNamespace codeNamespace = new CodeNamespace ();
 952                         XmlCodeExporter exp = new XmlCodeExporter (codeNamespace);
 953                         exp.ExportTypeMapping (map);
 954                         return codeNamespace;
 955                 }
 956
 957                 CodeTypeDeclaration FindType (CodeNamespace codeNamespace, string name)
 958                 {
 959                         foreach (CodeTypeDeclaration t in codeNamespace.Types)
 960                                 if (t.Name == name)
 961                                         return t;
 962                         return null;
 963                 }
 964
 965                 CodeTypeMember FindMember (CodeTypeDeclaration type, string name)
 966                 {
 967                         foreach (CodeTypeMember m in type.Members)
 968                                 if (m.Name == name)
 969                                         return m;
 970                         return null;
 971                 }
 972
 973                 private static XmlSchemas ExportType (Type type)
 974                 {
 975                         XmlReflectionImporter ri = new XmlReflectionImporter ("NS" + type.Name);
 976                         XmlSchemas schemas = new XmlSchemas ();
 977                         XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
 978                         XmlTypeMapping tm = ri.ImportTypeMapping (type);
 979                         sx.ExportTypeMapping (tm);
 980                         return schemas;
 981                 }
 982
 983                 private static ArrayList GetXmlQualifiedNames (XmlSchemas schemas)
 984                 {
 985                         ArrayList qnames = new ArrayList ();
 986
 987                         foreach (XmlSchema schema in schemas) {
 988                                 if (!schema.IsCompiled) schema.Compile (null);
 989                                 foreach (XmlSchemaObject ob in schema.Items)
 990                                         if (ob is XmlSchemaElement)
 991                                                 qnames.Add (((XmlSchemaElement) ob).QualifiedName);
 992                         }
 993
 994                         return qnames;
 995                 }
 996         }
 997 }