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