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 //   Atsushi Enomoto (atsushi@ximian.com)
   7 //
   8 // (C) 2005 Gert Driesen
   9 // Copyright (C) 2006 Novell, Inc.
  10 //
  11
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining
  14 // a copy of this software and associated documentation files (the
  15 // "Software"), to deal in the Software without restriction, including
  16 // without limitation the rights to use, copy, modify, merge, publish,
  17 // distribute, sublicense, and/or sell copies of the Software, and to
  18 // permit persons to whom the Software is furnished to do so, subject to
  19 // the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be
  22 // included in all copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31 //
  32
  33 using System;
  34 using System.CodeDom;
  35 using System.Collections;
  36 using System.Globalization;
  37 using System.IO;
  38 using System.Xml;
  39 using System.Xml.Schema;
  40 using System.Xml.Serialization;
  41
  42 using NUnit.Framework;
  43
  44 using MonoTests.System.Xml.TestClasses;
  45
  46 namespace MonoTests.System.XmlSerialization
  47 {
  48         [TestFixture]
  49         public class XmlSchemaImporterTests
  50         {
  51                 private const string WsdlTypesNamespace = "http://microsoft.com/wsdl/types/";
  52
  53                 [Test]
  54                 [Category ("NotWorking")]
  55                 public void ImportTypeMapping_Struct ()
  56                 {
  57                         XmlSchemas schemas = ExportType (typeof (TimeSpan));
  58                         ArrayList qnames = GetXmlQualifiedNames (schemas);
  59                         Assert.AreEqual (1, qnames.Count, "#1");
  60
  61                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
  62                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
  63
  64                         Assert.IsNotNull (map, "#2");
  65                         Assert.AreEqual ("TimeSpan", map.ElementName, "#3");
  66                         Assert.AreEqual ("NSTimeSpan", map.Namespace, "#4");
  67                         Assert.AreEqual ("TimeSpan", map.TypeFullName, "#5");
  68                         Assert.AreEqual ("TimeSpan", map.TypeName, "#6");
  69                 }
  70
  71                 [Test]
  72                 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
  73                 public void ImportTypeMapping_XsdPrimitive_AnyType ()
  74                 {
  75                         XmlSchemas schemas = ExportType (typeof (object));
  76                         ArrayList qnames = GetXmlQualifiedNames (schemas);
  77                         Assert.AreEqual (1, qnames.Count, "#1");
  78
  79                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
  80                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
  81
  82                         Assert.IsNotNull (map, "#2");
  83                         Assert.AreEqual ("anyType", map.ElementName, "#3");
  84                         Assert.AreEqual ("NSObject", map.Namespace, "#4");
  85                         Assert.AreEqual ("System.Object", map.TypeFullName, "#5");
  86                         Assert.AreEqual ("Object", map.TypeName, "#6");
  87                 }
  88
  89                 [Test]
  90                 public void ImportTypeMapping_XsdPrimitive_AnyURI ()
  91                 {
  92                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
  93                                 "<xs:schema xmlns:tns=\"NSAnyURI\" elementFormDefault=\"qualified\" targetNamespace=\"NSAnyURI\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
  94                                 "  <xs:element name=\"anyURI\" type=\"xs:anyURI\" />" +
  95                                 "</xs:schema>";
  96
  97                         XmlSchemas schemas = new XmlSchemas ();
  98                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
  99
 100                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 101                         Assert.AreEqual (1, qnames.Count, "#1");
 102
 103                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 104
 105                         Assert.AreEqual ("anyURI", qname.Name, "#2");
 106                         Assert.AreEqual ("NSAnyURI", qname.Namespace, "#3");
 107
 108                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 109                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 110
 111                         Assert.IsNotNull (map, "#4");
 112                         Assert.AreEqual ("anyURI", map.ElementName, "#5");
 113                         Assert.AreEqual ("NSAnyURI", map.Namespace, "#6");
 114                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 115                         Assert.AreEqual ("String", map.TypeName, "#8");
 116                 }
 117
 118                 [Test]
 119                 [Category ("NotWorking")]
 120                 public void ImportTypeMapping_XsdPrimitive_Base64 ()
 121                 {
 122                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 123                                 "<xs:schema xmlns:tns=\"NSBase64\" elementFormDefault=\"qualified\" targetNamespace=\"NSBase64\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 124                                 "  <xs:element name=\"base64\" type=\"xs:base64\" />" +
 125                                 "</xs:schema>";
 126
 127                         XmlSchemas schemas = new XmlSchemas ();
 128                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 129                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 130                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("base64", "NSBase64"));
 131
 132                         Assert.IsNotNull (map, "#1");
 133                         Assert.AreEqual ("base64", map.ElementName, "#2");
 134                         Assert.AreEqual ("NSBase64", map.Namespace, "#3");
 135                         Assert.AreEqual ("System.String", map.TypeFullName, "#4");
 136                         Assert.AreEqual ("String", map.TypeName, "#5");
 137                 }
 138
 139                 [Test]
 140                 public void ImportTypeMapping_XsdPrimitive_Base64Binary ()
 141                 {
 142                         XmlSchemas schemas = ExportType (typeof (byte[]));
 143                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 144                         Assert.AreEqual (1, qnames.Count, "#1");
 145
 146                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 147                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 148
 149                         Assert.IsNotNull (map, "#2");
 150                         Assert.AreEqual ("base64Binary", map.ElementName, "#3");
 151                         Assert.AreEqual ("NSByte[]", map.Namespace, "#4");
 152                         Assert.AreEqual ("System.Byte[]", map.TypeFullName, "#5");
 153                         Assert.AreEqual ("Byte[]", map.TypeName, "#6");
 154                 }
 155
 156                 [Test]
 157                 public void ImportTypeMapping_XsdPrimitive_Boolean ()
 158                 {
 159                         XmlSchemas schemas = ExportType (typeof (bool));
 160                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 161                         Assert.AreEqual (1, qnames.Count, "#1");
 162
 163                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 164                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 165
 166                         Assert.IsNotNull (map, "#2");
 167                         Assert.AreEqual ("boolean", map.ElementName, "#3");
 168                         Assert.AreEqual ("NSBoolean", map.Namespace, "#4");
 169                         Assert.AreEqual ("System.Boolean", map.TypeFullName, "#5");
 170                         Assert.AreEqual ("Boolean", map.TypeName, "#6");
 171                 }
 172
 173                 [Test]
 174                 public void ImportTypeMapping_XsdPrimitive_Byte ()
 175                 {
 176                         XmlSchemas schemas = ExportType (typeof (sbyte));
 177                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 178                         Assert.AreEqual (1, qnames.Count, "#1");
 179
 180                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 181                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 182
 183                         Assert.IsNotNull (map, "#2");
 184                         Assert.AreEqual ("byte", map.ElementName, "#3");
 185                         Assert.AreEqual ("NSSByte", map.Namespace, "#4");
 186                         Assert.AreEqual ("System.SByte", map.TypeFullName, "#5");
 187                         Assert.AreEqual ("SByte", map.TypeName, "#6");
 188                 }
 189
 190                 [Test]
 191                 [Category ("NotWorking")]
 192                 public void ImportTypeMapping_XsdPrimitive_Char ()
 193                 {
 194                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 195                                 "<xs:schema xmlns:tns=\"NSChar\" elementFormDefault=\"qualified\" targetNamespace=\"NSChar\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 196                                 "  <xs:element name=\"char\" type=\"xs:char\" />" +
 197                                 "</xs:schema>";
 198
 199                         XmlSchemas schemas = new XmlSchemas ();
 200                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 201                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 202                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("char", "NSChar"));
 203
 204                         Assert.IsNotNull (map, "#A1");
 205                         Assert.AreEqual ("char", map.ElementName, "#A2");
 206                         Assert.AreEqual ("NSChar", map.Namespace, "#A3");
 207                         Assert.AreEqual ("System.String", map.TypeFullName, "#A4");
 208                         Assert.AreEqual ("String", map.TypeName, "#A5");
 209
 210 #if ONLY_1_1
 211                         schemas = ExportType (typeof (char));
 212                         importer = new XmlSchemaImporter (schemas);
 213                         map = importer.ImportTypeMapping (new XmlQualifiedName ("char", "NSChar"));
 214
 215                         Assert.IsNotNull (map, "#B1");
 216                         Assert.AreEqual ("char", map.ElementName, "#B2");
 217                         Assert.AreEqual ("NSChar", map.Namespace, "#B3");
 218                         Assert.AreEqual ("System.Char", map.TypeFullName, "#B4");
 219                         Assert.AreEqual ("Char", map.TypeName, "#B5");
 220 #endif
 221                 }
 222
 223                 [Test]
 224                 public void ImportTypeMapping_XsdPrimitive_Date ()
 225                 {
 226                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 227                                 "<xs:schema xmlns:tns=\"NSDate\" elementFormDefault=\"qualified\" targetNamespace=\"NSDate\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 228                                 "  <xs:element name=\"date\" type=\"xs:date\" />" +
 229                                 "</xs:schema>";
 230
 231                         XmlSchemas schemas = new XmlSchemas ();
 232                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 233
 234                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 235                         Assert.AreEqual (1, qnames.Count, "#1");
 236
 237                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 238
 239                         Assert.AreEqual ("date", qname.Name, "#2");
 240                         Assert.AreEqual ("NSDate", qname.Namespace, "#3");
 241
 242                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 243                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 244
 245                         Assert.IsNotNull (map, "#4");
 246                         Assert.AreEqual ("date", map.ElementName, "#5");
 247                         Assert.AreEqual ("NSDate", map.Namespace, "#6");
 248                         Assert.AreEqual ("System.DateTime", map.TypeFullName, "#7");
 249                         Assert.AreEqual ("DateTime", map.TypeName, "#8");
 250                 }
 251
 252                 [Test]
 253                 public void ImportTypeMapping_XsdPrimitive_DateTime ()
 254                 {
 255                         XmlSchemas schemas = ExportType (typeof (DateTime));
 256                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 257                         Assert.AreEqual (1, qnames.Count, "#1");
 258
 259                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 260                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 261
 262                         Assert.IsNotNull (map, "#2");
 263                         Assert.AreEqual ("dateTime", map.ElementName, "#3");
 264                         Assert.AreEqual ("NSDateTime", map.Namespace, "#4");
 265                         Assert.AreEqual ("System.DateTime", map.TypeFullName, "#5");
 266                         Assert.AreEqual ("DateTime", map.TypeName, "#6");
 267                 }
 268
 269                 [Test]
 270                 public void ImportTypeMapping_XsdPrimitive_Decimal ()
 271                 {
 272                         XmlSchemas schemas = ExportType (typeof (decimal));
 273                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 274                         Assert.AreEqual (1, qnames.Count, "#1");
 275
 276                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 277                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 278
 279                         Assert.IsNotNull (map, "#2");
 280                         Assert.AreEqual ("decimal", map.ElementName, "#3");
 281                         Assert.AreEqual ("NSDecimal", map.Namespace, "#4");
 282                         Assert.AreEqual ("System.Decimal", map.TypeFullName, "#5");
 283                         Assert.AreEqual ("Decimal", map.TypeName, "#6");
 284                 }
 285
 286                 [Test]
 287                 public void ImportTypeMapping_XsdPrimitive_Double ()
 288                 {
 289                         XmlSchemas schemas = ExportType (typeof (double));
 290                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 291                         Assert.AreEqual (1, qnames.Count, "#1");
 292
 293                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 294                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 295
 296                         Assert.IsNotNull (map, "#2");
 297                         Assert.AreEqual ("double", map.ElementName, "#3");
 298                         Assert.AreEqual ("NSDouble", map.Namespace, "#4");
 299                         Assert.AreEqual ("System.Double", map.TypeFullName, "#5");
 300                         Assert.AreEqual ("Double", map.TypeName, "#6");
 301                 }
 302
 303                 [Test]
 304                 [Category ("NotWorking")]
 305                 public void ImportTypeMapping_XsdPrimitive_Duration ()
 306                 {
 307                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 308                                 "<xs:schema xmlns:tns=\"NSDuration\" elementFormDefault=\"qualified\" targetNamespace=\"NSDuration\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 309                                 "  <xs:element name=\"duration\" type=\"xs:duration\" />" +
 310                                 "</xs:schema>";
 311
 312                         XmlSchemas schemas = new XmlSchemas ();
 313                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 314
 315                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 316                         Assert.AreEqual (1, qnames.Count, "#1");
 317
 318                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 319
 320                         Assert.AreEqual ("duration", qname.Name, "#2");
 321                         Assert.AreEqual ("NSDuration", qname.Namespace, "#3");
 322
 323                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 324                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 325
 326                         Assert.IsNotNull (map, "#4");
 327                         Assert.AreEqual ("duration", map.ElementName, "#5");
 328                         Assert.AreEqual ("NSDuration", map.Namespace, "#6");
 329                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 330                         Assert.AreEqual ("String", map.TypeName, "#8");
 331                 }
 332
 333                 [Test]
 334                 public void ImportTypeMapping_XsdPrimitive_ENTITIES ()
 335                 {
 336                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 337                                 "<xs:schema xmlns:tns=\"NSENTITIES\" elementFormDefault=\"qualified\" targetNamespace=\"NSENTITIES\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 338                                 "  <xs:element name=\"ENTITIES\" type=\"xs:ENTITIES\" />" +
 339                                 "</xs:schema>";
 340
 341                         XmlSchemas schemas = new XmlSchemas ();
 342                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 343
 344                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 345                         Assert.AreEqual (1, qnames.Count, "#1");
 346
 347                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 348
 349                         Assert.AreEqual ("ENTITIES", qname.Name, "#2");
 350                         Assert.AreEqual ("NSENTITIES", qname.Namespace, "#3");
 351
 352                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 353                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 354
 355                         Assert.IsNotNull (map, "#4");
 356                         Assert.AreEqual ("ENTITIES", map.ElementName, "#5");
 357                         Assert.AreEqual ("NSENTITIES", map.Namespace, "#6");
 358                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 359                         Assert.AreEqual ("String", map.TypeName, "#8");
 360                 }
 361
 362                 [Test]
 363                 public void ImportTypeMapping_XsdPrimitive_ENTITY ()
 364                 {
 365                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 366                                 "<xs:schema xmlns:tns=\"NSENTITY\" elementFormDefault=\"qualified\" targetNamespace=\"NSENTITY\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 367                                 "  <xs:element name=\"ENTITY\" type=\"xs:ENTITY\" />" +
 368                                 "</xs:schema>";
 369
 370                         XmlSchemas schemas = new XmlSchemas ();
 371                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 372
 373                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 374                         Assert.AreEqual (1, qnames.Count, "#1");
 375
 376                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 377
 378                         Assert.AreEqual ("ENTITY", qname.Name, "#2");
 379                         Assert.AreEqual ("NSENTITY", qname.Namespace, "#3");
 380
 381                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 382                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 383
 384                         Assert.IsNotNull (map, "#4");
 385                         Assert.AreEqual ("ENTITY", map.ElementName, "#5");
 386                         Assert.AreEqual ("NSENTITY", map.Namespace, "#6");
 387                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 388                         Assert.AreEqual ("String", map.TypeName, "#8");
 389                 }
 390
 391                 [Test]
 392                 public void ImportTypeMapping_XsdPrimitive_Float ()
 393                 {
 394                         XmlSchemas schemas = ExportType (typeof (float));
 395                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 396                         Assert.AreEqual (1, qnames.Count, "#1");
 397
 398                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 399                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 400
 401                         Assert.IsNotNull (map, "#2");
 402                         Assert.AreEqual ("float", map.ElementName, "#3");
 403                         Assert.AreEqual ("NSSingle", map.Namespace, "#4");
 404                         Assert.AreEqual ("System.Single", map.TypeFullName, "#5");
 405                         Assert.AreEqual ("Single", map.TypeName, "#6");
 406                 }
 407
 408                 [Test]
 409                 public void ImportTypeMapping_XsdPrimitive_GDay ()
 410                 {
 411                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 412                                 "<xs:schema xmlns:tns=\"NSGDay\" elementFormDefault=\"qualified\" targetNamespace=\"NSGDay\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 413                                 "  <xs:element name=\"gDay\" type=\"xs:gDay\" />" +
 414                                 "</xs:schema>";
 415
 416                         XmlSchemas schemas = new XmlSchemas ();
 417                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 418
 419                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 420                         Assert.AreEqual (1, qnames.Count, "#1");
 421
 422                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 423
 424                         Assert.AreEqual ("gDay", qname.Name, "#2");
 425                         Assert.AreEqual ("NSGDay", qname.Namespace, "#3");
 426
 427                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 428                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 429
 430                         Assert.IsNotNull (map, "#4");
 431                         Assert.AreEqual ("gDay", map.ElementName, "#5");
 432                         Assert.AreEqual ("NSGDay", map.Namespace, "#6");
 433                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 434                         Assert.AreEqual ("String", map.TypeName, "#8");
 435                 }
 436
 437                 [Test]
 438                 public void ImportTypeMapping_XsdPrimitive_GMonthDay ()
 439                 {
 440                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 441                                 "<xs:schema xmlns:tns=\"NSGMonthDay\" elementFormDefault=\"qualified\" targetNamespace=\"NSGMonthDay\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 442                                 "  <xs:element name=\"gMonthDay\" type=\"xs:gMonthDay\" />" +
 443                                 "</xs:schema>";
 444
 445                         XmlSchemas schemas = new XmlSchemas ();
 446                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 447
 448                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 449                         Assert.AreEqual (1, qnames.Count, "#1");
 450
 451                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 452
 453                         Assert.AreEqual ("gMonthDay", qname.Name, "#2");
 454                         Assert.AreEqual ("NSGMonthDay", qname.Namespace, "#3");
 455
 456                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 457                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 458
 459                         Assert.IsNotNull (map, "#4");
 460                         Assert.AreEqual ("gMonthDay", map.ElementName, "#5");
 461                         Assert.AreEqual ("NSGMonthDay", map.Namespace, "#6");
 462                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 463                         Assert.AreEqual ("String", map.TypeName, "#8");
 464                 }
 465
 466                 [Test]
 467                 [Category ("NotWorking")]
 468                 public void ImportTypeMapping_XsdPrimitive_Guid ()
 469                 {
 470                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 471                                 "<xs:schema xmlns:tns=\"NSGuid\" elementFormDefault=\"qualified\" targetNamespace=\"NSGuid\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 472                                 "  <xs:element name=\"guid\" type=\"xs:guid\" />" +
 473                                 "</xs:schema>";
 474
 475                         XmlSchemas schemas = new XmlSchemas ();
 476                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 477                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 478                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("guid", "NSGuid"));
 479
 480                         Assert.IsNotNull (map, "#A1");
 481                         Assert.AreEqual ("guid", map.ElementName, "#A2");
 482                         Assert.AreEqual ("NSGuid", map.Namespace, "#A3");
 483                         Assert.AreEqual ("System.String", map.TypeFullName, "#A4");
 484                         Assert.AreEqual ("String", map.TypeName, "#A5");
 485
 486 #if ONLY_1_1
 487                         schemas = ExportType (typeof (Guid));
 488                         importer = new XmlSchemaImporter (schemas);
 489                         map = importer.ImportTypeMapping (new XmlQualifiedName ("guid", "NSGuid"));
 490
 491                         Assert.IsNotNull (map, "#B1");
 492                         Assert.AreEqual ("guid", map.ElementName, "#B2");
 493                         Assert.AreEqual ("NSGuid", map.Namespace, "#B3");
 494                         Assert.AreEqual ("System.Guid", map.TypeFullName, "#B4");
 495                         Assert.AreEqual ("Guid", map.TypeName, "#B5");
 496 #endif
 497                 }
 498
 499                 [Test]
 500                 public void ImportTypeMapping_XsdPrimitive_GYear ()
 501                 {
 502                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 503                                 "<xs:schema xmlns:tns=\"NSGYear\" elementFormDefault=\"qualified\" targetNamespace=\"NSGYear\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 504                                 "  <xs:element name=\"gYear\" type=\"xs:gYear\" />" +
 505                                 "</xs:schema>";
 506
 507                         XmlSchemas schemas = new XmlSchemas ();
 508                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 509
 510                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 511                         Assert.AreEqual (1, qnames.Count, "#1");
 512
 513                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 514
 515                         Assert.AreEqual ("gYear", qname.Name, "#2");
 516                         Assert.AreEqual ("NSGYear", qname.Namespace, "#3");
 517
 518                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 519                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 520
 521                         Assert.IsNotNull (map, "#4");
 522                         Assert.AreEqual ("gYear", map.ElementName, "#5");
 523                         Assert.AreEqual ("NSGYear", map.Namespace, "#6");
 524                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 525                         Assert.AreEqual ("String", map.TypeName, "#8");
 526                 }
 527
 528                 [Test]
 529                 public void ImportTypeMapping_XsdPrimitive_GYearMonth ()
 530                 {
 531                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 532                                 "<xs:schema xmlns:tns=\"NSGYearMonth\" elementFormDefault=\"qualified\" targetNamespace=\"NSGYearMonth\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 533                                 "  <xs:element name=\"gYearMonth\" type=\"xs:gYearMonth\" />" +
 534                                 "</xs:schema>";
 535
 536                         XmlSchemas schemas = new XmlSchemas ();
 537                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 538
 539                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 540                         Assert.AreEqual (1, qnames.Count, "#1");
 541
 542                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 543
 544                         Assert.AreEqual ("gYearMonth", qname.Name, "#2");
 545                         Assert.AreEqual ("NSGYearMonth", qname.Namespace, "#3");
 546
 547                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 548                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 549
 550                         Assert.IsNotNull (map, "#4");
 551                         Assert.AreEqual ("gYearMonth", map.ElementName, "#5");
 552                         Assert.AreEqual ("NSGYearMonth", map.Namespace, "#6");
 553                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 554                         Assert.AreEqual ("String", map.TypeName, "#8");
 555                 }
 556
 557                 [Test]
 558                 public void ImportTypeMapping_XsdPrimitive_HexBinary ()
 559                 {
 560                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 561                                 "<xs:schema xmlns:tns=\"NSHexBinary\" elementFormDefault=\"qualified\" targetNamespace=\"NSHexBinary\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 562                                 "  <xs:element name=\"hexBinary\" type=\"xs:hexBinary\" />" +
 563                                 "</xs:schema>";
 564
 565                         XmlSchemas schemas = new XmlSchemas ();
 566                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 567
 568                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 569                         Assert.AreEqual (1, qnames.Count, "#1");
 570
 571                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 572
 573                         Assert.AreEqual ("hexBinary", qname.Name, "#2");
 574                         Assert.AreEqual ("NSHexBinary", qname.Namespace, "#3");
 575
 576                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 577                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 578
 579                         Assert.IsNotNull (map, "#4");
 580                         Assert.AreEqual ("hexBinary", map.ElementName, "#5");
 581                         Assert.AreEqual ("NSHexBinary", map.Namespace, "#6");
 582                         Assert.AreEqual ("System.Byte[]", map.TypeFullName, "#7");
 583                         Assert.AreEqual ("Byte[]", map.TypeName, "#8");
 584                 }
 585
 586                 [Test]
 587                 public void ImportTypeMapping_XsdPrimitive_IDREFS ()
 588                 {
 589                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 590                                 "<xs:schema xmlns:tns=\"NSIDREFS\" elementFormDefault=\"qualified\" targetNamespace=\"NSIDREFS\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 591                                 "  <xs:element name=\"IDREFS\" type=\"xs:IDREFS\" />" +
 592                                 "</xs:schema>";
 593
 594                         XmlSchemas schemas = new XmlSchemas ();
 595                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 596
 597                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 598                         Assert.AreEqual (1, qnames.Count, "#1");
 599
 600                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 601
 602                         Assert.AreEqual ("IDREFS", qname.Name, "#2");
 603                         Assert.AreEqual ("NSIDREFS", qname.Namespace, "#3");
 604
 605                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 606                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 607
 608                         Assert.IsNotNull (map, "#4");
 609                         Assert.AreEqual ("IDREFS", map.ElementName, "#5");
 610                         Assert.AreEqual ("NSIDREFS", map.Namespace, "#6");
 611                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 612                         Assert.AreEqual ("String", map.TypeName, "#8");
 613                 }
 614
 615                 [Test]
 616                 public void ImportTypeMapping_XsdPrimitive_Int ()
 617                 {
 618                         XmlSchemas schemas = ExportType (typeof (int));
 619                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 620                         Assert.AreEqual (1, qnames.Count, "#1");
 621
 622                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 623                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 624
 625                         Assert.IsNotNull (map, "#2");
 626                         Assert.AreEqual ("int", map.ElementName, "#3");
 627                         Assert.AreEqual ("NSInt32", map.Namespace, "#4");
 628                         Assert.AreEqual ("System.Int32", map.TypeFullName, "#5");
 629                         Assert.AreEqual ("Int32", map.TypeName, "#6");
 630                 }
 631
 632                 [Test]
 633                 public void ImportTypeMapping_XsdPrimitive_Integer ()
 634                 {
 635                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 636                                 "<xs:schema xmlns:tns=\"NSInteger\" elementFormDefault=\"qualified\" targetNamespace=\"NSInteger\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 637                                 "  <xs:element name=\"integer\" type=\"xs:integer\" />" +
 638                                 "</xs:schema>";
 639
 640                         XmlSchemas schemas = new XmlSchemas ();
 641                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 642
 643                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 644                         Assert.AreEqual (1, qnames.Count, "#1");
 645
 646                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 647
 648                         Assert.AreEqual ("integer", qname.Name, "#2");
 649                         Assert.AreEqual ("NSInteger", qname.Namespace, "#3");
 650
 651                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 652                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 653
 654                         Assert.IsNotNull (map, "#4");
 655                         Assert.AreEqual ("integer", map.ElementName, "#5");
 656                         Assert.AreEqual ("NSInteger", map.Namespace, "#6");
 657                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 658                         Assert.AreEqual ("String", map.TypeName, "#8");
 659                 }
 660
 661                 [Test]
 662                 public void ImportTypeMapping_XsdPrimitive_Long ()
 663                 {
 664                         XmlSchemas schemas = ExportType (typeof (long));
 665                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 666                         Assert.AreEqual (1, qnames.Count, "#1");
 667
 668                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 669                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 670
 671                         Assert.IsNotNull (map, "#2");
 672                         Assert.AreEqual ("long", map.ElementName, "#3");
 673                         Assert.AreEqual ("NSInt64", map.Namespace, "#4");
 674                         Assert.AreEqual ("System.Int64", map.TypeFullName, "#5");
 675                         Assert.AreEqual ("Int64", map.TypeName, "#6");
 676                 }
 677
 678                 [Test]
 679                 [Category ("NotWorking")]
 680                 public void ImportTypeMapping_XsdPrimitive_Month ()
 681                 {
 682                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 683                                 "<xs:schema xmlns:tns=\"NSMonth\" elementFormDefault=\"qualified\" targetNamespace=\"NSMonth\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 684                                 "  <xs:element name=\"month\" type=\"xs:month\" />" +
 685                                 "</xs:schema>";
 686
 687                         XmlSchemas schemas = new XmlSchemas ();
 688                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 689
 690                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 691                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("month", "NSMonth"));
 692
 693                         Assert.IsNotNull (map, "#4");
 694                         Assert.AreEqual ("month", map.ElementName, "#5");
 695                         Assert.AreEqual ("NSMonth", map.Namespace, "#6");
 696                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 697                         Assert.AreEqual ("String", map.TypeName, "#8");
 698                 }
 699
 700                 [Test]
 701                 public void ImportTypeMapping_XsdPrimitive_QName ()
 702                 {
 703                         XmlSchemas schemas = ExportType (typeof (XmlQualifiedName));
 704                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 705                         Assert.AreEqual (1, qnames.Count, "#1");
 706
 707                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 708                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 709
 710                         Assert.IsNotNull (map, "#2");
 711                         Assert.AreEqual ("QName", map.ElementName, "#3");
 712                         Assert.AreEqual ("NSXmlQualifiedName", map.Namespace, "#4");
 713                         Assert.AreEqual ("System.Xml.XmlQualifiedName", map.TypeFullName, "#5");
 714                         Assert.AreEqual ("XmlQualifiedName", map.TypeName, "#6");
 715                 }
 716
 717                 [Test]
 718                 public void ImportTypeMapping_XsdPrimitive_Short ()
 719                 {
 720                         XmlSchemas schemas = ExportType (typeof (short));
 721                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 722                         Assert.AreEqual (1, qnames.Count, "#1");
 723
 724                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 725                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 726
 727                         Assert.IsNotNull (map, "#2");
 728                         Assert.AreEqual ("short", map.ElementName, "#3");
 729                         Assert.AreEqual ("NSInt16", map.Namespace, "#4");
 730                         Assert.AreEqual ("System.Int16", map.TypeFullName, "#5");
 731                         Assert.AreEqual ("Int16", map.TypeName, "#6");
 732                 }
 733
 734                 [Test]
 735                 public void ImportTypeMapping_XsdPrimitive_String ()
 736                 {
 737                         XmlSchemas schemas = ExportType (typeof (string));
 738                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 739                         Assert.AreEqual (1, qnames.Count, "#1");
 740
 741                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 742                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 743
 744                         Assert.IsNotNull (map, "#2");
 745                         Assert.AreEqual ("string", map.ElementName, "#3");
 746                         Assert.AreEqual ("NSString", map.Namespace, "#4");
 747                         Assert.AreEqual ("System.String", map.TypeFullName, "#5");
 748                         Assert.AreEqual ("String", map.TypeName, "#6");
 749                 }
 750
 751                 [Test]
 752                 public void ImportTypeMapping_XsdPrimitive_Time ()
 753                 {
 754                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 755                                 "<xs:schema xmlns:tns=\"NSTime\" elementFormDefault=\"qualified\" targetNamespace=\"NSTime\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 756                                 "  <xs:element name=\"time\" type=\"xs:time\" />" +
 757                                 "</xs:schema>";
 758
 759                         XmlSchemas schemas = new XmlSchemas ();
 760                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 761
 762                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 763                         Assert.AreEqual (1, qnames.Count, "#1");
 764
 765                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 766
 767                         Assert.AreEqual ("time", qname.Name, "#2");
 768                         Assert.AreEqual ("NSTime", qname.Namespace, "#3");
 769
 770                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 771                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 772
 773                         Assert.IsNotNull (map, "#4");
 774                         Assert.AreEqual ("time", map.ElementName, "#5");
 775                         Assert.AreEqual ("NSTime", map.Namespace, "#6");
 776                         Assert.AreEqual ("System.DateTime", map.TypeFullName, "#7");
 777                         Assert.AreEqual ("DateTime", map.TypeName, "#8");
 778                 }
 779
 780                 [Test]
 781                 [Category ("NotWorking")]
 782                 public void ImportTypeMapping_XsdPrimitive_TimeInstant ()
 783                 {
 784                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 785                                 "<xs:schema xmlns:tns=\"NSTimeInstant\" elementFormDefault=\"qualified\" targetNamespace=\"NSTimeInstant\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 786                                 "  <xs:element name=\"timeInstant\" type=\"xs:timeInstant\" />" +
 787                                 "</xs:schema>";
 788
 789                         XmlSchemas schemas = new XmlSchemas ();
 790                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 791
 792                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 793                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("timeInstant", "NSTimeInstant"));
 794
 795                         Assert.IsNotNull (map, "#4");
 796                         Assert.AreEqual ("timeInstant", map.ElementName, "#5");
 797                         Assert.AreEqual ("NSTimeInstant", map.Namespace, "#6");
 798                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 799                         Assert.AreEqual ("String", map.TypeName, "#8");
 800                 }
 801
 802                 [Test]
 803                 [Category ("NotWorking")]
 804                 public void ImportTypeMapping_XsdPrimitive_TimePeriod ()
 805                 {
 806                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 807                                 "<xs:schema xmlns:tns=\"NSTimePeriod\" elementFormDefault=\"qualified\" targetNamespace=\"NSTimePeriod\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" +
 808                                 "  <xs:element name=\"timePeriod\" type=\"xs:timePeriod\" />" +
 809                                 "</xs:schema>";
 810
 811                         XmlSchemas schemas = new XmlSchemas ();
 812                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 813
 814                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 815                         XmlTypeMapping map = importer.ImportTypeMapping (new XmlQualifiedName ("timePeriod", "NSTimePeriod"));
 816
 817                         Assert.IsNotNull (map, "#4");
 818                         Assert.AreEqual ("timePeriod", map.ElementName, "#5");
 819                         Assert.AreEqual ("NSTimePeriod", map.Namespace, "#6");
 820                         Assert.AreEqual ("System.String", map.TypeFullName, "#7");
 821                         Assert.AreEqual ("String", map.TypeName, "#8");
 822                 }
 823
 824                 [Test]
 825                 public void ImportTypeMapping_XsdPrimitive_UnsignedByte ()
 826                 {
 827                         XmlSchemas schemas = ExportType (typeof (byte));
 828                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 829                         Assert.AreEqual (1, qnames.Count, "#1");
 830
 831                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 832                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 833
 834                         Assert.IsNotNull (map, "#2");
 835                         Assert.AreEqual ("unsignedByte", map.ElementName, "#3");
 836                         Assert.AreEqual ("NSByte", map.Namespace, "#4");
 837                         Assert.AreEqual ("System.Byte", map.TypeFullName, "#5");
 838                         Assert.AreEqual ("Byte", map.TypeName, "#6");
 839                 }
 840
 841                 [Test]
 842                 public void ImportTypeMapping_XsdPrimitive_UnsignedInt ()
 843                 {
 844                         XmlSchemas schemas = ExportType (typeof (uint));
 845                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 846                         Assert.AreEqual (1, qnames.Count, "#1");
 847
 848                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 849                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 850
 851                         Assert.IsNotNull (map, "#2");
 852                         Assert.AreEqual ("unsignedInt", map.ElementName, "#3");
 853                         Assert.AreEqual ("NSUInt32", map.Namespace, "#4");
 854                         Assert.AreEqual ("System.UInt32", map.TypeFullName, "#5");
 855                         Assert.AreEqual ("UInt32", map.TypeName, "#6");
 856                 }
 857
 858                 [Test]
 859                 public void ImportTypeMapping_XsdPrimitive_UnsignedLong ()
 860                 {
 861                         XmlSchemas schemas = ExportType (typeof (ulong));
 862                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 863                         Assert.AreEqual (1, qnames.Count, "#1");
 864
 865                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 866                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 867
 868                         Assert.IsNotNull (map, "#2");
 869                         Assert.AreEqual ("unsignedLong", map.ElementName, "#3");
 870                         Assert.AreEqual ("NSUInt64", map.Namespace, "#4");
 871                         Assert.AreEqual ("System.UInt64", map.TypeFullName, "#5");
 872                         Assert.AreEqual ("UInt64", map.TypeName, "#6");
 873                 }
 874
 875                 [Test]
 876                 public void ImportTypeMapping_XsdPrimitive_UnsignedShort ()
 877                 {
 878                         XmlSchemas schemas = ExportType (typeof (ushort));
 879                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 880                         Assert.AreEqual (1, qnames.Count, "#1");
 881
 882                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 883                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 884
 885                         Assert.IsNotNull (map, "#2");
 886                         Assert.AreEqual ("unsignedShort", map.ElementName, "#3");
 887                         Assert.AreEqual ("NSUInt16", map.Namespace, "#4");
 888                         Assert.AreEqual ("System.UInt16", map.TypeFullName, "#5");
 889                         Assert.AreEqual ("UInt16", map.TypeName, "#6");
 890                 }
 891
 892                 [Test]
 893                 public void ImportTypeMapping_EnumSimpleContent ()
 894                 {
 895                         string schemaFragment = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 896                                 "<s:schema xmlns:tns=\"NSDate\" elementFormDefault=\"qualified\" targetNamespace=\"NSDate\" xmlns:s=\"http://www.w3.org/2001/XMLSchema\">" +
 897                                 "      <s:element name=\"trans\" type=\"tns:TranslationStatus\" />" +
 898                                 "      <s:complexType name=\"TranslationStatus\">" +
 899                                 "        <s:simpleContent>" +
 900                                 "          <s:extension base=\"tns:StatusType\">" +
 901                                 "            <s:attribute name=\"Language\" type=\"s:int\" use=\"required\" />" +
 902                                 "          </s:extension>" +
 903                                 "        </s:simpleContent>" +
 904                                 "      </s:complexType>" +
 905                                 "      <s:simpleType name=\"StatusType\">" +
 906                                 "        <s:restriction base=\"s:string\">" +
 907                                 "          <s:enumeration value=\"Untouched\" />" +
 908                                 "          <s:enumeration value=\"Touched\" />" +
 909                                 "          <s:enumeration value=\"Complete\" />" +
 910                                 "          <s:enumeration value=\"None\" />" +
 911                                 "        </s:restriction>" +
 912                                 "      </s:simpleType>" +
 913                                 "</s:schema>";
 914
 915                         XmlSchemas schemas = new XmlSchemas ();
 916                         schemas.Add (XmlSchema.Read (new StringReader (schemaFragment), null));
 917
 918                         ArrayList qnames = GetXmlQualifiedNames (schemas);
 919                         Assert.AreEqual (1, qnames.Count, "#1");
 920
 921                         XmlQualifiedName qname = (XmlQualifiedName) qnames[0];
 922
 923                         Assert.AreEqual ("trans", qname.Name, "#2");
 924                         Assert.AreEqual ("NSDate", qname.Namespace, "#3");
 925
 926                         XmlSchemaImporter importer = new XmlSchemaImporter (schemas);
 927                         XmlTypeMapping map = importer.ImportTypeMapping ((XmlQualifiedName) qnames[0]);
 928
 929                         Assert.IsNotNull (map, "#4");
 930                         Assert.AreEqual ("trans", map.ElementName, "#5");
 931                         Assert.AreEqual ("NSDate", map.Namespace, "#6");
 932                         Assert.AreEqual ("TranslationStatus", map.TypeFullName, "#7");
 933                         Assert.AreEqual ("TranslationStatus", map.TypeName, "#8");
 934
 935                         CodeNamespace codeNamespace = ExportCode (map);
 936                         Assert.IsNotNull (codeNamespace, "#9");
 937
 938                         CodeTypeDeclaration type = FindType (codeNamespace, "TranslationStatus");
 939                         Assert.IsNotNull (type, "#10");
 940
 941 #if NET_2_0
 942                         CodeMemberProperty property = FindMember (type, "Value") as CodeMemberProperty;
 943                         Assert.IsNotNull (property, "#A1");
 944                         Assert.IsTrue (property.HasGet, "#A2");
 945                         Assert.IsTrue (property.HasSet, "#A3");
 946                         Assert.AreEqual ("StatusType", property.Type.BaseType, "#A4");
 947
 948                         CodeMemberField field = FindMember (type, "valueField") as CodeMemberField;
 949                         Assert.IsNotNull (field, "#A5");
 950                         Assert.AreEqual ("StatusType", field.Type.BaseType, "#A6");
 951
 952                         property = FindMember (type, "Language") as CodeMemberProperty;
 953                         Assert.IsNotNull (property, "#B1");
 954                         Assert.IsTrue (property.HasGet, "#B2");
 955                         Assert.IsTrue (property.HasSet, "#B3");
 956                         Assert.AreEqual ("System.Int32", property.Type.BaseType, "#B4");
 957
 958                         field = FindMember (type, "languageField") as CodeMemberField;
 959                         Assert.IsNotNull (field, "#B5");
 960                         Assert.AreEqual ("System.Int32", field.Type.BaseType, "#B6");
 961 #else
 962                         CodeMemberField field = FindMember (type, "Value") as CodeMemberField;
 963                         Assert.IsNotNull (field, "#A1");
 964                         Assert.AreEqual ("StatusType", field.Type.BaseType, "#A2");
 965
 966                         field = FindMember (type, "Language") as CodeMemberField;
 967                         Assert.IsNotNull (field, "#B1");
 968                         Assert.AreEqual ("System.Int32", field.Type.BaseType, "#B2");
 969 #endif
 970                 }
 971
 972                 CodeNamespace ExportCode (XmlTypeMapping map)
 973                 {
 974                         CodeNamespace codeNamespace = new CodeNamespace ();
 975                         XmlCodeExporter exp = new XmlCodeExporter (codeNamespace);
 976                         exp.ExportTypeMapping (map);
 977                         return codeNamespace;
 978                 }
 979
 980                 CodeTypeDeclaration FindType (CodeNamespace codeNamespace, string name)
 981                 {
 982                         foreach (CodeTypeDeclaration t in codeNamespace.Types)
 983                                 if (t.Name == name)
 984                                         return t;
 985                         return null;
 986                 }
 987
 988                 CodeTypeMember FindMember (CodeTypeDeclaration type, string name)
 989                 {
 990                         foreach (CodeTypeMember m in type.Members)
 991                                 if (m.Name == name)
 992                                         return m;
 993                         return null;
 994                 }
 995
 996                 private static XmlSchemas ExportType (Type type)
 997                 {
 998                         XmlReflectionImporter ri = new XmlReflectionImporter ("NS" + type.Name);
 999                         XmlSchemas schemas = new XmlSchemas ();
1000                         XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
1001                         XmlTypeMapping tm = ri.ImportTypeMapping (type);
1002                         sx.ExportTypeMapping (tm);
1003                         return schemas;
1004                 }
1005
1006                 private static ArrayList GetXmlQualifiedNames (XmlSchemas schemas)
1007                 {
1008                         ArrayList qnames = new ArrayList ();
1009
1010                         foreach (XmlSchema schema in schemas) {
1011                                 if (!schema.IsCompiled) schema.Compile (null);
1012                                 foreach (XmlSchemaObject ob in schema.Items)
1013                                         if (ob is XmlSchemaElement)
1014                                                 qnames.Add (((XmlSchemaElement) ob).QualifiedName);
1015                         }
1016
1017                         return qnames;
1018                 }
1019
1020                 [Test]
1021                 [ExpectedException (typeof (InvalidOperationException))]
1022                 public void ImportTypeMappingNonExistent ()
1023                 {
1024                         XmlSchemas xss = new XmlSchemas ();
1025                         xss.Add (new XmlSchema ());
1026                         XmlSchemaImporter imp = new XmlSchemaImporter (xss);
1027                         imp.ImportTypeMapping (new XmlQualifiedName ("foo"));
1028                 }
1029
1030                 [Test]
1031                 public void AnyTypeTopLevelElementImportsAllComplexTypes ()
1032                 {
1033                         string xsd = @"
1034 <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
1035   <xs:element name='Root' type='xs:anyType' />
1036   <xs:complexType name='FooType'>
1037     <xs:sequence>
1038       <xs:element name='Child1' type='xs:string' />
1039       <xs:element name='Child2' type='xs:string' />
1040       <xs:element name='Child3' type='xs:string' />
1041     </xs:sequence>
1042   </xs:complexType>
1043   <xs:complexType name='BarType' />
1044 </xs:schema>";
1045                         XmlSchemas xss = new XmlSchemas ();
1046                         xss.Add (XmlSchema.Read (new XmlTextReader (new StringReader (xsd)), null));
1047                         XmlSchemaImporter imp = new XmlSchemaImporter (xss);
1048                         CodeNamespace cns = new CodeNamespace ();
1049                         XmlCodeExporter exp = new XmlCodeExporter (cns);
1050                         exp.ExportTypeMapping (imp.ImportTypeMapping (new XmlQualifiedName ("Root")));
1051                         bool foo = false, bar = false;
1052                         foreach (CodeTypeDeclaration td in cns.Types) {
1053                                 if (td.Name == "FooType")
1054                                         foo = true;
1055                                 else if (td.Name == "BarType")
1056                                         bar = true;
1057                         }
1058                         Assert.IsTrue (foo, "FooType not found");
1059                         Assert.IsTrue (bar, "BarType not found");
1060                 }
1061
1062                 [Test]
1063                 public void DefaultTypeTopLevelElementImportsAllComplexTypes ()
1064                 {
1065                         string xsd = @"
1066 <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
1067   <xs:element name='Root' />
1068   <xs:complexType name='FooType'>
1069     <xs:sequence>
1070       <xs:element name='Child1' type='xs:string' />
1071       <xs:element name='Child2' type='xs:string' />
1072       <xs:element name='Child3' type='xs:string' />
1073     </xs:sequence>
1074   </xs:complexType>
1075   <xs:complexType name='BarType' />
1076 </xs:schema>";
1077                         XmlSchemas xss = new XmlSchemas ();
1078                         xss.Add (XmlSchema.Read (new XmlTextReader (new StringReader (xsd)), null));
1079                         XmlSchemaImporter imp = new XmlSchemaImporter (xss);
1080                         CodeNamespace cns = new CodeNamespace ();
1081                         XmlCodeExporter exp = new XmlCodeExporter (cns);
1082                         exp.ExportTypeMapping (imp.ImportTypeMapping (new XmlQualifiedName ("Root")));
1083                         bool foo = false, bar = false;
1084                         foreach (CodeTypeDeclaration td in cns.Types) {
1085                                 if (td.Name == "FooType")
1086                                         foo = true;
1087                                 else if (td.Name == "BarType")
1088                                         bar = true;
1089                         }
1090                         Assert.IsTrue (foo, "FooType not found");
1091                         Assert.IsTrue (bar, "BarType not found");
1092                 }
1093
1094                 [Test]
1095                 public void ImportComplexDerivationByExtension ()
1096                 {
1097                         string xsd = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
1098   <xs:element name='Root' type='DerivedType' />
1099   <xs:complexType name='DerivedType'>
1100     <xs:complexContent>
1101       <xs:extension base='BaseType'>
1102         <xs:attribute name='Foo' type='xs:string' />
1103       </xs:extension>
1104     </xs:complexContent>
1105   </xs:complexType>
1106   <xs:complexType name='BaseType'>
1107     <xs:attribute name='Foo' type='xs:string' />
1108   </xs:complexType>
1109 </xs:schema>";
1110                         XmlSchemas xss = new XmlSchemas ();
1111                         xss.Add (XmlSchema.Read (new XmlTextReader (new StringReader (xsd)), null));
1112                         XmlSchemaImporter imp = new XmlSchemaImporter (xss);
1113                         CodeNamespace cns = new CodeNamespace ();
1114                         XmlCodeExporter exp = new XmlCodeExporter (cns);
1115                         exp.ExportTypeMapping (imp.ImportTypeMapping (new XmlQualifiedName ("Root")));
1116                 }
1117         }
1118 }