mcs/class/System.Runtime.Serialization/Test/System.Runtime.Serialization/XsdDataContractExporterTest.cs

   1 //
   2 // XsdDataContractExporterTest.cs
   3 //
   4 // Author:
   5 //      Ankit Jain  <JAnkit@novell.com>
   6 //
   7 // Copyright (C) 2006 Novell, Inc.  http://www.novell.com
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.Collections.Generic;
  31
  32 using System.IO;
  33 using System.Runtime.Serialization;
  34 using NUnit.Framework;
  35 using System.Xml.Schema;
  36 using System.Collections;
  37 using System.Xml.Serialization;
  38 using System.Reflection;
  39 using System.Xml;
  40
  41 using QName = System.Xml.XmlQualifiedName;
  42
  43 namespace MonoTests.System.Runtime.Serialization
  44 {
  45         [TestFixture]
  46         public class XsdDataContractExporterTest
  47         {
  48                 [Test]
  49                 public void Ctor1 ()
  50                 {
  51                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
  52                         Assert.IsNotNull (xdce.Schemas);
  53                 }
  54
  55                 [Test]
  56                 public void PrimitiveType ()
  57                 {
  58                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
  59                         Assert.AreEqual (1, xdce.Schemas.Count);
  60
  61                         Assert.IsNull (xdce.GetSchemaType (typeof (int)));
  62                         Assert.AreEqual (new QName ("int", XmlSchema.Namespace), xdce.GetSchemaTypeName (typeof (int)));
  63
  64                         xdce.Export (typeof (int));
  65                         Assert.IsNull (xdce.GetSchemaType (typeof (int)));
  66                         Assert.AreEqual (new QName ("int", XmlSchema.Namespace), xdce.GetSchemaTypeName (typeof (int)));
  67                 }
  68
  69                 [Test]
  70                 public void CanExportTest ()
  71                 {
  72                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
  73                         Assert.IsTrue (xdce.CanExport (typeof (int)));
  74                         Assert.IsTrue (xdce.CanExport (typeof (dc)));
  75
  76                         //No DataContract/Serializable etc
  77                         Assert.IsFalse (xdce.CanExport (this.GetType ()));
  78                 }
  79
  80                 [Test]
  81                 public void GetSchemaTypeTest ()
  82                 {
  83                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
  84                         Assert.IsNull (xdce.GetSchemaType (typeof (dc)));
  85                         Assert.AreEqual (new QName ("_dc", "http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"), xdce.GetSchemaTypeName (typeof (dc)));
  86                 }
  87
  88                 [Test]
  89                 public void Test2 ()
  90                 {
  91                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
  92                         xdce.Export (typeof (dc));
  93                         XmlSchemaSet set = xdce.Schemas;
  94
  95                         xdce = new XsdDataContractExporter (set);
  96                         try {
  97                                 xdce.Export (typeof (dc));
  98                         } catch (XmlSchemaException xe) {
  99                                 return;
 100                         } catch (Exception e) {
 101                                 Assert.Fail ("Expected XmlSchemaException, but got " + e.GetType ().ToString ());
 102                         }
 103
 104                         Assert.Fail ("Expected XmlSchemaException");
 105                 }
 106
 107                 [Test]
 108                 public void EnumTest ()
 109                 {
 110                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
 111                         xdce.Export (typeof (XColors));
 112
 113                         CheckEnum (xdce.Schemas, colors_qname, new List<string> (new string [] { "_Red" }));
 114                 }
 115
 116                 [Test]
 117                 public void EnumNoDcTest ()
 118                 {
 119                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
 120                         xdce.Export (typeof (EnumNoDc));
 121
 122                         CheckEnum (xdce.Schemas,
 123                                 new QName ("EnumNoDc",
 124                                         "http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"),
 125                                 new List<string> (new string [] { "Red", "Green", "Blue" }));
 126                 }
 127
 128                 //Test case for class dc
 129                 [Test]
 130                 public void DcTest ()
 131                 {
 132                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
 133                         xdce.Export (typeof (dc));
 134                         CheckDcFull (xdce.Schemas);
 135                 }
 136
 137                 [Test]
 138                 public void Dc3Test ()
 139                 {
 140                         //Check for duplicate dc2 ?
 141                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
 142                         xdce.Export (typeof (dc3));
 143                         CheckDcFull (xdce.Schemas);
 144                 }
 145
 146                 [Test]
 147                 public void Dc3Test2 ()
 148                 {
 149                         //Check for duplicate dc2 ?
 150                         XsdDataContractExporter xdce = new XsdDataContractExporter ();
 151                         xdce.Export (typeof (dc3));
 152                         xdce.Export (typeof (dc3));
 153                         CheckDcFull (xdce.Schemas);
 154                 }
 155
 156                 //Helper methods
 157
 158                 XmlSchemas GetSchemas (XmlSchemaSet set)
 159                 {
 160                         XmlSchemas schemas = new XmlSchemas ();
 161                         foreach (XmlSchema schema in set.Schemas ())
 162                                 schemas.Add (schema);
 163
 164                         return schemas;
 165                 }
 166
 167                 void CheckEnum (XmlSchemaSet schemas, QName qname, List<string> values)
 168                 {
 169                         XmlSchemaSimpleType simple = schemas.GlobalTypes [qname] as XmlSchemaSimpleType;
 170                         Assert.IsNotNull (simple, "#ce1");
 171
 172                         XmlSchemaSimpleTypeRestriction restriction = simple.Content as XmlSchemaSimpleTypeRestriction;
 173                         Assert.IsNotNull (restriction, "#ce2");
 174                         Assert.AreEqual (new QName ("string", XmlSchema.Namespace), restriction.BaseTypeName, "#ce3");
 175
 176                         //Check the values
 177                         Assert.AreEqual (values.Count, restriction.Facets.Count, "#ce4");
 178                         values.Sort ();
 179
 180                         List<string> facets = new List<string> ();
 181                         foreach (XmlSchemaObject obj in restriction.Facets) {
 182                                 XmlSchemaEnumerationFacet facet = obj as XmlSchemaEnumerationFacet;
 183                                 Assert.IsNotNull (facet, "#ce5");
 184                                 facets.Add (facet.Value);
 185                         }
 186
 187                         facets.Sort ();
 188                         for (int i = 0;i < values.Count;i++)
 189                                 Assert.AreEqual (values [i], facets [i], "#ce6");
 190
 191                         //Check the corresponding element
 192                         CheckElement (schemas, qname);
 193                 }
 194
 195                 void CheckElement (XmlSchemaSet schemas, QName qname)
 196                 {
 197                         XmlSchemaElement element = schemas.GlobalElements [qname] as XmlSchemaElement;
 198                         Assert.IsNotNull (element, "#c1");
 199                         Assert.IsTrue (element.IsNillable, "#c2");
 200                         Assert.AreEqual (qname, element.SchemaTypeName, "#c3");
 201                 }
 202
 203                 XmlSchemaComplexType GetSchemaComplexType (XmlSchemaSet schemas, QName qname)
 204                 {
 205                         XmlSchemaComplexType type = schemas.GlobalTypes [qname] as XmlSchemaComplexType;
 206                         Assert.IsNotNull (type, "ComplexType " + qname.ToString () + " not found.");
 207
 208                         return type;
 209                 }
 210
 211                 //Check the <element .. > in a sequence
 212                 void CheckElementReference (XmlSchemaObject obj, string name, QName schema_type, bool nillable)
 213                 {
 214                         XmlSchemaElement element = obj as XmlSchemaElement;
 215                         Assert.IsNotNull (element, "XmlSchemaElement not found for " + schema_type.ToString ());
 216
 217                         Assert.AreEqual (name, element.Name, "#v1, Element name did not match");
 218                         //FIXME: Assert.AreEqual (0, element.MinOccurs, "#v0, MinOccurs should be 0 for element '" + name + "'");
 219                         Assert.AreEqual (schema_type, element.SchemaTypeName, "#v2, SchemaTypeName for element '" + element.Name + "' did not match.");
 220                         Assert.AreEqual (nillable, element.IsNillable, "#v3, Element '" + element.Name + "', schema type = '" + schema_type + "' should have nillable = " + nillable);
 221                 }
 222
 223                 void CheckArray (XmlSchemaSet schemas, QName qname, QName element_qname)
 224                 {
 225                         XmlSchemaComplexType type = GetSchemaComplexType (schemas, qname);
 226                         XmlSchemaSequence sequence = type.Particle as XmlSchemaSequence;
 227                         Assert.IsNotNull (sequence, "#ca1");
 228
 229                         Assert.AreEqual (1, sequence.Items.Count, "#ca2, Sequence.Items.Count");
 230                         CheckElementReference (
 231                                 sequence.Items [0],
 232                                 element_qname.Name,
 233                                 element_qname,
 234                                 element_qname.Namespace != XmlSchema.Namespace);
 235
 236                         XmlSchemaElement element = (XmlSchemaElement) sequence.Items [0];
 237                         Assert.AreEqual ("unbounded", element.MaxOccursString, "#ca3");
 238
 239                         CheckElement (schemas, qname);
 240                 }
 241
 242                 QName colors_qname = new QName ("_XColors", "http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization");
 243                 QName dc_qname = new QName ("_dc", "http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization");
 244                 QName other_qname = new QName ("_other", "http://schemas.datacontract.org/2004/07/OtherNs");
 245
 246
 247                 void CheckDcFull (XmlSchemaSet schemas)
 248                 {
 249                         Assert.IsTrue (schemas.IsCompiled, "#dt0, XmlSchemaSet not compiled");
 250                         XmlSchemaComplexType type = GetSchemaComplexType (schemas, dc_qname);
 251                         XmlSchemaSequence sequence = type.Particle as XmlSchemaSequence;
 252                         Assert.IsNotNull (sequence, "#dt1");
 253
 254                         Assert.AreEqual (5, sequence.Items.Count, "#dt2, Sequence.Items.Count");
 255                         CheckElementReference (sequence.Items [0], "_color",
 256                                 colors_qname, false);
 257                         CheckEnum (schemas, colors_qname, new List<string> (new string [] { "_Red" }));
 258
 259                         CheckElementReference (sequence.Items [1], "_foo",
 260                                 new QName ("string", XmlSchema.Namespace), true);
 261
 262                         CheckElementReference (sequence.Items [2], "_o",
 263                                 new QName ("ArrayOf_other", "http://schemas.datacontract.org/2004/07/OtherNs"), true);
 264                         CheckArray (schemas, new QName ("ArrayOf_other", "http://schemas.datacontract.org/2004/07/OtherNs"), other_qname);
 265
 266                         CheckElementReference (sequence.Items [3], "_single_o",
 267                                 new QName ("_other", "http://schemas.datacontract.org/2004/07/OtherNs"), true);
 268                         CheckOther (schemas);
 269
 270                         CheckElementReference (sequence.Items [4], "i_array",
 271                                 new QName ("ArrayOfint", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"), true);
 272                         CheckArray (schemas, new QName ("ArrayOfint", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"),
 273                                 new QName ("int", XmlSchema.Namespace));
 274
 275                         CheckElement (schemas, dc_qname);
 276                 }
 277
 278                 void CheckOther (XmlSchemaSet schemas)
 279                 {
 280                         XmlSchemaComplexType type = GetSchemaComplexType (schemas, other_qname);
 281                         XmlSchemaSequence sequence = type.Particle as XmlSchemaSequence;
 282                         Assert.IsNotNull (sequence, "#ct0");
 283
 284                         Assert.AreEqual (1, sequence.Items.Count, "#ct1");
 285                         CheckElementReference (sequence.Items [0], "_field_int", new QName ("int", XmlSchema.Namespace), false);
 286                 }
 287
 288         }
 289
 290         [DataContract (Name = "_XColors")]
 291         public enum XColors
 292         {
 293                 [EnumMember (Value = "_Red")]
 294                 Red,
 295                 Green,
 296                 Blue
 297         }
 298
 299         public enum EnumNoDc
 300         {
 301                 Red,
 302                 Green,
 303                 Blue
 304         }
 305
 306         [DataContract (Name = "_dc")]
 307         public class dc
 308         {
 309                 [DataMember (Name = "_foo")]
 310                 public string foo;
 311
 312                 int not_used;
 313
 314                 [DataMember (Name = "_color")]
 315                 XColors color;
 316
 317                 //[DataMember]
 318                 public dc me;
 319
 320                 [DataMember (Name = "_o")]
 321                 public OtherNs.other [] o;
 322
 323                 [DataMember (Name = "_single_o")]
 324                 public OtherNs.other single_o;
 325
 326                 [DataMember]
 327                 public int [] i_array;
 328         }
 329
 330         [DataContract (Name = "_dc2")]
 331         public class dc2 : dc
 332         {
 333                 [DataMember (Name = "_foo2")]
 334                 string foo2;
 335         }
 336
 337         [DataContract]
 338         public abstract class abstract_class
 339         {
 340                 [DataMember]
 341                 public string foo;
 342         }
 343
 344         [Serializable]
 345         public class base_xs
 346         {
 347                 public int base_int;
 348                 private string base_string;
 349         }
 350
 351         [Serializable]
 352         public class xs : base_xs
 353         {
 354                 private string ignore;
 355                 public string useme;
 356         }
 357
 358         [DataContract]
 359         public class dc_with_basexs : base_xs
 360         {
 361                 [DataMember (Name = "_foo")]
 362                 public string foo;
 363         }
 364
 365         [XmlRoot]
 366         public class xa
 367         {
 368                 [XmlElement]
 369                 public string foo;
 370
 371                 [XmlAttribute]
 372                 public int bar;
 373         }
 374
 375         [DataContract (Name = "_dc3")]
 376         public class dc3
 377         {
 378                 [DataMember (Name = "_first")]
 379                 dc2 first;
 380
 381                 [DataMember (Name = "_second")]
 382                 dc2 second;
 383         }
 384
 385 }
 386
 387 namespace OtherNs
 388 {
 389         [DataContract (Name = "_other")]
 390         public class other /*: MonoTests.System.Runtime.Serialization.dc*/
 391         {
 392                 [DataMember (Name = "_field_int")]
 393                 public int field_int;
 394         }
 395 }
 396