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

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