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

   1 //
   2 // XmlObjectSerializerTest.cs
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //      Ankit Jain <JAnkit@novell.com>
   7 //
   8 // Copyright (C) 2005 Novell, Inc.  http://www.novell.com
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 //
  32 // This test code contains tests for both DataContractSerializer and
  33 // NetDataContractSerializer. The code could be mostly common.
  34 //
  35
  36 using System;
  37 using System.Collections.Generic;
  38 using System.Collections.ObjectModel;
  39 using System.IO;
  40 using System.Net;
  41 using System.Runtime.Serialization;
  42 using System.Text;
  43 using System.Xml;
  44 using NUnit.Framework;
  45 using System.Xml.Serialization;
  46 using System.Xml.Schema;
  47
  48 namespace MonoTests.System.Runtime.Serialization
  49 {
  50         [TestFixture]
  51         public class DataContractSerializerTest
  52         {
  53                 static readonly XmlWriterSettings settings;
  54
  55                 static DataContractSerializerTest ()
  56                 {
  57                         settings = new XmlWriterSettings ();
  58                         settings.OmitXmlDeclaration = true;
  59                 }
  60
  61                 [DataContract]
  62                 class Sample1
  63                 {
  64                         [DataMember]
  65                         public string Member1;
  66                 }
  67
  68                 [Test]
  69                 [ExpectedException (typeof (ArgumentNullException))]
  70                 public void ConstructorTypeNull ()
  71                 {
  72                         new DataContractSerializer (null);
  73                 }
  74
  75                 [Test]
  76                 public void ConstructorKnownTypesNull ()
  77                 {
  78                         // null knownTypes is allowed.
  79                         new DataContractSerializer (typeof (Sample1), null);
  80                         new DataContractSerializer (typeof (Sample1), "Foo", String.Empty, null);
  81                         new DataContractSerializer (typeof (Sample1), new XmlDictionary ().Add ("Foo"), XmlDictionaryString.Empty, null);
  82                 }
  83
  84                 [Test]
  85                 [ExpectedException (typeof (ArgumentNullException))]
  86                 public void ConstructorNameNull ()
  87                 {
  88                         new DataContractSerializer (typeof (Sample1), null, String.Empty);
  89                 }
  90
  91                 [Test]
  92                 [ExpectedException (typeof (ArgumentNullException))]
  93                 public void ConstructorNamespaceNull ()
  94                 {
  95                         new DataContractSerializer (typeof (Sample1), "foo", null);
  96                 }
  97
  98                 [Test]
  99                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 100                 public void ConstructorNegativeMaxObjects ()
 101                 {
 102                         new DataContractSerializer (typeof (Sample1), null,
 103                                 -1, false, false, null);
 104                 }
 105
 106                 [Test]
 107                 public void ConstructorMisc ()
 108                 {
 109                         new DataContractSerializer (typeof (GlobalSample1));
 110                 }
 111
 112                 [Test]
 113                 public void WriteObjectContent ()
 114                 {
 115                         StringWriter sw = new StringWriter ();
 116                         using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
 117                                 DataContractSerializer ser =
 118                                         new DataContractSerializer (typeof (string));
 119                                 xw.WriteStartElement ("my-element");
 120                                 ser.WriteObjectContent (xw, "TEST STRING");
 121                                 xw.WriteEndElement ();
 122                         }
 123                         Assert.AreEqual ("<my-element>TEST STRING</my-element>",
 124                                 sw.ToString ());
 125                 }
 126
 127                 [Test]
 128                 public void WriteObjectToStream ()
 129                 {
 130                         DataContractSerializer ser =
 131                                 new DataContractSerializer (typeof (int));
 132                         MemoryStream sw = new MemoryStream ();
 133                         ser.WriteObject (sw, 1);
 134                         string expected = "<int xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">1</int>";
 135                         byte[] buf = sw.ToArray ();
 136                         Assert.AreEqual (expected, Encoding.UTF8.GetString (buf, 0, buf.Length));
 137                 }
 138
 139                 [Test]
 140                 public void ReadObjectFromStream ()
 141                 {
 142                         DataContractSerializer ser =
 143                                 new DataContractSerializer (typeof (int));
 144                         string expected = "<int xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">1</int>";
 145                         byte[] buf = Encoding.UTF8.GetBytes (expected);
 146                         MemoryStream sw = new MemoryStream (buf);
 147                         object res = ser.ReadObject (sw);
 148                         Assert.AreEqual (1, res);
 149                 }
 150
 151                 // int
 152
 153                 [Test]
 154                 public void SerializeInt ()
 155                 {
 156                         DataContractSerializer ser =
 157                                 new DataContractSerializer (typeof (int));
 158                         SerializeInt (ser, "<int xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">1</int>");
 159                 }
 160
 161
 162                 [Test]
 163                 [Category ("NotWorking")]
 164                 public void NetSerializeInt ()
 165                 {
 166                         NetDataContractSerializer ser =
 167                                 new NetDataContractSerializer ();
 168                         // z:Assembly="0" ???
 169                         SerializeInt (ser, String.Format ("<int z:Type=\"System.Int32\" z:Assembly=\"0\" xmlns:z=\"http://schemas.microsoft.com/2003/10/Serialization/\" xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">1</int>", typeof (int).Assembly.FullName));
 170                 }
 171
 172                 void SerializeInt (XmlObjectSerializer ser, string expected)
 173                 {
 174                         StringWriter sw = new StringWriter ();
 175                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 176                                 ser.WriteObject (w, 1);
 177                         }
 178                         Assert.AreEqual (expected, sw.ToString ());
 179                 }
 180
 181                 // pass typeof(DCEmpty), serialize int
 182
 183                 [Test]
 184                 public void SerializeIntForDCEmpty ()
 185                 {
 186                         DataContractSerializer ser =
 187                                 new DataContractSerializer (typeof (DCEmpty));
 188                         // tricky!
 189                         SerializeIntForDCEmpty (ser, "<DCEmpty xmlns:d1p1=\"http://www.w3.org/2001/XMLSchema\" i:type=\"d1p1:int\" xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\">1</DCEmpty>");
 190                 }
 191
 192                 void SerializeIntForDCEmpty (XmlObjectSerializer ser, string expected)
 193                 {
 194                         StringWriter sw = new StringWriter ();
 195                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 196                                 ser.WriteObject (w, 1);
 197                         }
 198                         XmlComparer.AssertAreEqual (expected, sw.ToString ());
 199                 }
 200
 201                 // DCEmpty
 202
 203                 [Test]
 204                 public void SerializeEmptyClass ()
 205                 {
 206                         DataContractSerializer ser =
 207                                 new DataContractSerializer (typeof (DCEmpty));
 208                         SerializeEmptyClass (ser, "<DCEmpty xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\" />");
 209                 }
 210
 211                 [Test]
 212                 [Category ("NotWorking")]
 213                 public void NetSerializeEmptyClass ()
 214                 {
 215                         NetDataContractSerializer ser =
 216                                 new NetDataContractSerializer ();
 217                         SerializeEmptyClass (ser, String.Format ("<DCEmpty xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" z:Id=\"1\" z:Type=\"MonoTests.System.Runtime.Serialization.DCEmpty\" z:Assembly=\"{0}\" xmlns:z=\"http://schemas.microsoft.com/2003/10/Serialization/\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\" />", this.GetType ().Assembly.FullName));
 218                 }
 219
 220                 void SerializeEmptyClass (XmlObjectSerializer ser, string expected)
 221                 {
 222                         StringWriter sw = new StringWriter ();
 223                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 224                                 ser.WriteObject (w, new DCEmpty ());
 225                         }
 226                         Assert.AreEqual (expected, sw.ToString ());
 227                 }
 228
 229                 // string (primitive)
 230
 231                 [Test]
 232                 public void SerializePrimitiveString ()
 233                 {
 234                         XmlObjectSerializer ser =
 235                                 new DataContractSerializer (typeof (string));
 236                         SerializePrimitiveString (ser, "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">TEST</string>");
 237                 }
 238
 239                 [Test]
 240                 [Category ("NotWorking")]
 241                 public void NetSerializePrimitiveString ()
 242                 {
 243                         XmlObjectSerializer ser = new NetDataContractSerializer ();
 244                         SerializePrimitiveString (ser, "<string z:Type=\"System.String\" z:Assembly=\"0\" xmlns:z=\"http://schemas.microsoft.com/2003/10/Serialization/\" xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">TEST</string>");
 245                 }
 246
 247                 void SerializePrimitiveString (XmlObjectSerializer ser, string expected)
 248                 {
 249                         StringWriter sw = new StringWriter ();
 250                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 251                                 ser.WriteObject (w, "TEST");
 252                         }
 253                         Assert.AreEqual (expected, sw.ToString ());
 254                 }
 255
 256                 // QName (primitive but ...)
 257
 258                 [Test]
 259                 [Ignore ("These tests would not make any sense right now since it's populated prefix is not testable.")]
 260                 public void SerializePrimitiveQName ()
 261                 {
 262                         XmlObjectSerializer ser =
 263                                 new DataContractSerializer (typeof (XmlQualifiedName));
 264                         SerializePrimitiveQName (ser, "<z:QName xmlns:d7=\"urn:foo\" xmlns:z=\"http://schemas.microsoft.com/2003/10/Serialization/\">d7:foo</z:QName>");
 265                 }
 266
 267                 [Test]
 268                 [Ignore ("These tests would not make any sense right now since it's populated prefix is not testable.")]
 269                 public void NetSerializePrimitiveQName ()
 270                 {
 271                         XmlObjectSerializer ser = new NetDataContractSerializer ();
 272                         SerializePrimitiveQName (ser, "<z:QName z:Type=\"System.Xml.XmlQualifiedName\" z:Assembly=\"System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\" xmlns:d7=\"urn:foo\" xmlns:z=\"http://schemas.microsoft.com/2003/10/Serialization/\">d7:foo</z:QName>");
 273                 }
 274
 275                 void SerializePrimitiveQName (XmlObjectSerializer ser, string expected)
 276                 {
 277                         StringWriter sw = new StringWriter ();
 278                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 279                                 ser.WriteObject (w, new XmlQualifiedName ("foo", "urn:foo"));
 280                         }
 281                         Assert.AreEqual (expected, sw.ToString ());
 282                 }
 283
 284                 // DCSimple1
 285
 286                 [Test]
 287                 public void SerializeSimpleClass1 ()
 288                 {
 289                         DataContractSerializer ser =
 290                                 new DataContractSerializer (typeof (DCSimple1));
 291                         SerializeSimpleClass1 (ser, "<DCSimple1 xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\"><Foo>TEST</Foo></DCSimple1>");
 292                 }
 293
 294                 [Test]
 295                 public void SerializeSimpleXml ()
 296                 {
 297                         DataContractSerializer ser =
 298                                 new DataContractSerializer (typeof (SimpleXml));
 299                         SerializeSimpleClass1 (ser, @"<simple i:type=""d1p1:DCSimple1"" xmlns:d1p1=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""><d1p1:Foo>TEST</d1p1:Foo></simple>");
 300                 }
 301
 302                 [Test]
 303                 [Category ("NotWorking")]
 304                 public void NetSerializeSimpleClass1 ()
 305                 {
 306                         NetDataContractSerializer ser =
 307                                 new NetDataContractSerializer ();
 308                         SerializeSimpleClass1 (ser, String.Format ("<DCSimple1 xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" z:Id=\"1\" z:Type=\"MonoTests.System.Runtime.Serialization.DCSimple1\" z:Assembly=\"{0}\" xmlns:z=\"http://schemas.microsoft.com/2003/10/Serialization/\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\"><Foo z:Id=\"2\">TEST</Foo></DCSimple1>", this.GetType ().Assembly.FullName));
 309                 }
 310
 311                 void SerializeSimpleClass1 (XmlObjectSerializer ser, string expected)
 312                 {
 313                         StringWriter sw = new StringWriter ();
 314                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 315                                 ser.WriteObject (w, new DCSimple1 ());
 316                         }
 317                         Console.WriteLine(sw.ToString());
 318                         Assert.AreEqual (expected, sw.ToString ());
 319                 }
 320
 321                 // NonDC
 322
 323                 [Test]
 324                 // NonDC is not a DataContract type.
 325                 public void SerializeNonDCOnlyCtor ()
 326                 {
 327                         DataContractSerializer ser = new DataContractSerializer (typeof (NonDC));
 328                 }
 329
 330                 [Test]
 331                 [ExpectedException (typeof (InvalidDataContractException))]
 332                 // NonDC is not a DataContract type.
 333                 public void SerializeNonDC ()
 334                 {
 335                         DataContractSerializer ser = new DataContractSerializer (typeof (NonDC));
 336                         using (XmlWriter w = XmlWriter.Create (TextWriter.Null, settings)) {
 337                                 ser.WriteObject (w, new NonDC ());
 338                         }
 339                 }
 340
 341                 // DCHasNonDC
 342
 343                 [Test]
 344                 [ExpectedException (typeof (InvalidDataContractException))]
 345                 // DCHasNonDC itself is a DataContract type whose field is
 346                 // marked as DataMember but its type is not DataContract.
 347                 public void SerializeDCHasNonDC ()
 348                 {
 349                         DataContractSerializer ser = new DataContractSerializer (typeof (DCHasNonDC));
 350                         using (XmlWriter w = XmlWriter.Create (TextWriter.Null, settings)) {
 351                                 ser.WriteObject (w, new DCHasNonDC ());
 352                         }
 353                 }
 354
 355                 // DCHasSerializable
 356
 357                 [Test]
 358                 // DCHasSerializable itself is DataContract and has a field
 359                 // whose type is not contract but serializable.
 360                 public void SerializeSimpleSerializable1 ()
 361                 {
 362                         DataContractSerializer ser = new DataContractSerializer (typeof (DCHasSerializable));
 363                         StringWriter sw = new StringWriter ();
 364                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 365                                 ser.WriteObject (w, new DCHasSerializable ());
 366                         }
 367                         Assert.AreEqual ("<DCHasSerializable xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\"><Ser><Doh>doh!</Doh></Ser></DCHasSerializable>", sw.ToString ());
 368                 }
 369
 370                 [Test]
 371                 public void SerializeDCWithName ()
 372                 {
 373                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithName));
 374                         StringWriter sw = new StringWriter ();
 375                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 376                                 ser.WriteObject (w, new DCWithName ());
 377                         }
 378                         Assert.AreEqual ("<Foo xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\"><FooMember>value</FooMember></Foo>", sw.ToString ());
 379                 }
 380
 381                 [Test]
 382                 public void SerializeDCWithEmptyName1 ()
 383                 {
 384                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithEmptyName));
 385                         StringWriter sw = new StringWriter ();
 386                         DCWithEmptyName dc = new DCWithEmptyName ();
 387                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 388                                 try {
 389                                         ser.WriteObject (w, dc);
 390                                 } catch (InvalidDataContractException) {
 391                                         return;
 392                                 }
 393                         }
 394                         Assert.Fail ("Expected InvalidDataContractException");
 395                 }
 396
 397                 [Test]
 398                 [Category ("NotWorking")]
 399                 public void SerializeDCWithEmptyName2 ()
 400                 {
 401                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithName));
 402                         StringWriter sw = new StringWriter ();
 403
 404                         /* DataContractAttribute.Name == "", not valid */
 405                         DCWithEmptyName dc = new DCWithEmptyName ();
 406                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 407                                 try {
 408                                         ser.WriteObject (w, dc);
 409                                 } catch (InvalidDataContractException) {
 410                                         return;
 411                                 }
 412                         }
 413                         Assert.Fail ("Expected InvalidDataContractException");
 414                 }
 415
 416                 [Test]
 417                 [Category ("NotWorking")]
 418                 public void SerializeDCWithNullName ()
 419                 {
 420                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithNullName));
 421                         StringWriter sw = new StringWriter ();
 422                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 423                                 try {
 424                                         /* DataContractAttribute.Name == "", not valid */
 425                                         ser.WriteObject (w, new DCWithNullName ());
 426                                 } catch (InvalidDataContractException) {
 427                                         return;
 428                                 }
 429                         }
 430                         Assert.Fail ("Expected InvalidDataContractException");
 431                 }
 432
 433                 [Test]
 434                 public void SerializeDCWithEmptyNamespace1 ()
 435                 {
 436                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithEmptyNamespace));
 437                         StringWriter sw = new StringWriter ();
 438                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 439                                 ser.WriteObject (w, new DCWithEmptyNamespace ());
 440                         }
 441                 }
 442
 443                 // Wrapper.DCWrapped
 444
 445                 [Test]
 446                 public void SerializeWrappedClass ()
 447                 {
 448                         DataContractSerializer ser =
 449                                 new DataContractSerializer (typeof (Wrapper.DCWrapped));
 450                         SerializeWrappedClass (ser, "<Wrapper.DCWrapped xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\" />");
 451                 }
 452
 453                 [Test]
 454                 [Category ("NotWorking")]
 455                 public void NetSerializeWrappedClass ()
 456                 {
 457                         NetDataContractSerializer ser =
 458                                 new NetDataContractSerializer ();
 459                         SerializeWrappedClass (ser, String.Format ("<Wrapper.DCWrapped xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" z:Id=\"1\" z:Type=\"MonoTests.System.Runtime.Serialization.Wrapper+DCWrapped\" z:Assembly=\"{0}\" xmlns:z=\"http://schemas.microsoft.com/2003/10/Serialization/\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\" />", this.GetType ().Assembly.FullName));
 460                 }
 461
 462                 void SerializeWrappedClass (XmlObjectSerializer ser, string expected)
 463                 {
 464                         StringWriter sw = new StringWriter ();
 465                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 466                                 ser.WriteObject (w, new Wrapper.DCWrapped ());
 467                         }
 468                         Assert.AreEqual (expected, sw.ToString ());
 469                 }
 470
 471                 // CollectionContainer : Items must have a setter.
 472                 [Test]
 473                 [ExpectedException (typeof (InvalidDataContractException))]
 474                 [Category ("NotWorking")]
 475                 public void SerializeReadOnlyCollectionMember ()
 476                 {
 477                         DataContractSerializer ser =
 478                                 new DataContractSerializer (typeof (CollectionContainer));
 479                         StringWriter sw = new StringWriter ();
 480                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 481                                 ser.WriteObject (w, null);
 482                         }
 483                 }
 484
 485                 // DataCollectionContainer : Items must have a setter.
 486                 [Test]
 487                 [ExpectedException (typeof (InvalidDataContractException))]
 488                 [Category ("NotWorking")]
 489                 public void SerializeReadOnlyDataCollectionMember ()
 490                 {
 491                         DataContractSerializer ser =
 492                                 new DataContractSerializer (typeof (DataCollectionContainer));
 493                         StringWriter sw = new StringWriter ();
 494                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 495                                 ser.WriteObject (w, null);
 496                         }
 497                 }
 498
 499                 [Test]
 500                 public void SerializeGuid ()
 501                 {
 502                         DataContractSerializer ser = new DataContractSerializer (typeof (Guid));
 503                         StringWriter sw = new StringWriter ();
 504                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 505                                 ser.WriteObject (w, Guid.Empty);
 506                         }
 507                         Assert.AreEqual (
 508                                 "<guid xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">00000000-0000-0000-0000-000000000000</guid>",
 509                                 sw.ToString ());
 510                 }
 511
 512                 [Test]
 513                 public void SerializeEnum ()
 514                 {
 515                         DataContractSerializer ser = new DataContractSerializer (typeof (Colors));
 516                         StringWriter sw = new StringWriter ();
 517                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 518                                 ser.WriteObject (w, new Colors ());
 519                         }
 520
 521                         Assert.AreEqual (
 522                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">Red</Colors>",
 523                                 sw.ToString ());
 524                 }
 525
 526                 [Test]
 527                 public void SerializeEnum2 ()
 528                 {
 529                         DataContractSerializer ser = new DataContractSerializer (typeof (Colors));
 530                         StringWriter sw = new StringWriter ();
 531                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 532                                 ser.WriteObject (w, 0);
 533                         }
 534
 535                         XmlComparer.AssertAreEqual (
 536                                 @"<Colors xmlns:d1p1=""http://www.w3.org/2001/XMLSchema"" i:type=""d1p1:int"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">0</Colors>",
 537                                 sw.ToString ());
 538                 }
 539
 540                 [Test]
 541                 public void SerializeEnumWithDC ()
 542                 {
 543                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsWithDC));
 544                         StringWriter sw = new StringWriter ();
 545                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 546                                 ser.WriteObject (w, new ColorsWithDC ());
 547                         }
 548
 549                         Assert.AreEqual (
 550                                 @"<_ColorsWithDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">_Red</_ColorsWithDC>",
 551                                 sw.ToString ());
 552                 }
 553
 554                 [Test]
 555                 public void SerializeEnumWithNoDC ()
 556                 {
 557                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsEnumMemberNoDC));
 558                         StringWriter sw = new StringWriter ();
 559                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 560                                 ser.WriteObject (w, new ColorsEnumMemberNoDC ());
 561                         }
 562
 563                         Assert.AreEqual (
 564                                 @"<ColorsEnumMemberNoDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">Red</ColorsEnumMemberNoDC>",
 565                                 sw.ToString ());
 566                 }
 567
 568                 [Test]
 569                 public void SerializeEnumWithDC2 ()
 570                 {
 571                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsWithDC));
 572                         StringWriter sw = new StringWriter ();
 573                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 574                                 ser.WriteObject (w, 3);
 575                         }
 576
 577                         XmlComparer.AssertAreEqual (
 578                                 @"<_ColorsWithDC xmlns:d1p1=""http://www.w3.org/2001/XMLSchema"" i:type=""d1p1:int"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">3</_ColorsWithDC>",
 579                                 sw.ToString ());
 580                 }
 581
 582                 [Test]
 583                 [ExpectedException (typeof (SerializationException))]
 584                 public void SerializeEnumWithDCInvalid ()
 585                 {
 586                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsWithDC));
 587                         StringWriter sw = new StringWriter ();
 588                         ColorsWithDC cdc = ColorsWithDC.Blue;
 589                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 590                                 ser.WriteObject (w, cdc);
 591                         }
 592                 }
 593
 594                 [Test]
 595                 public void SerializeDCWithEnum ()
 596                 {
 597                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithEnum));
 598                         StringWriter sw = new StringWriter ();
 599                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 600                                 ser.WriteObject (w, new DCWithEnum ());
 601                         }
 602
 603                         Assert.AreEqual (
 604                                 @"<DCWithEnum xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><_colors>Red</_colors></DCWithEnum>",
 605                                 sw.ToString ());
 606                 }
 607
 608                 [Test]
 609                 public void SerializeDCWithTwoEnums ()
 610                 {
 611                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithTwoEnums));
 612                         StringWriter sw = new StringWriter ();
 613                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 614                                 DCWithTwoEnums e = new DCWithTwoEnums ();
 615                                 e.colors = Colors.Blue;
 616                                 e.colors2 = Colors.Green;
 617                                 ser.WriteObject (w, e);
 618                         }
 619
 620                         Assert.AreEqual (
 621                                 @"<DCWithTwoEnums xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><colors>Blue</colors><colors2>Green</colors2></DCWithTwoEnums>",
 622                                 sw.ToString ());
 623                 }
 624
 625                 [Test]
 626                 public void SerializeNestingDC2 ()
 627                 {
 628                         DataContractSerializer ser = new DataContractSerializer (typeof (NestingDC2));
 629                         StringWriter sw = new StringWriter ();
 630                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 631                                 NestingDC2 e = new NestingDC2 ();
 632                                 e.Field = new NestedDC2 ("Something");
 633                                 ser.WriteObject (w, e);
 634                         }
 635
 636                         Assert.AreEqual (
 637                                 @"<NestingDC2 xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""test2""><Field xmlns:d2p1=""test1""><d2p1:Name>Something</d2p1:Name></Field></NestingDC2>",
 638                                 sw.ToString ());
 639                 }
 640
 641                 [Test]
 642                 public void SerializeNestingDC ()
 643                 {
 644                         DataContractSerializer ser = new DataContractSerializer (typeof (NestingDC));
 645                         StringWriter sw = new StringWriter ();
 646                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 647                                 NestingDC e = new NestingDC ();
 648                                 e.Field1 = new NestedDC ("test1");
 649                                 e.Field2 = new NestedDC ("test2");
 650                                 ser.WriteObject (w, e);
 651                         }
 652
 653                         Assert.AreEqual (
 654                                 @"<NestingDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><Field1><Name>test1</Name></Field1><Field2><Name>test2</Name></Field2></NestingDC>",
 655                                 sw.ToString ());
 656                         sw = new StringWriter ();
 657                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 658                                 NestingDC e = new NestingDC ();
 659                                 ser.WriteObject (w, e);
 660                         }
 661
 662                         Assert.AreEqual (
 663                                 @"<NestingDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><Field1 i:nil=""true"" /><Field2 i:nil=""true"" /></NestingDC>",
 664                                 sw.ToString ());
 665                 }
 666
 667                 [Test]
 668                 public void SerializeDerivedDC ()
 669                 {
 670                         DataContractSerializer ser = new DataContractSerializer (typeof (DerivedDC));
 671                         StringWriter sw = new StringWriter ();
 672                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 673                                 DerivedDC e = new DerivedDC ();
 674                                 ser.WriteObject (w, e);
 675                         }
 676
 677                         Assert.AreEqual (
 678                                 @"<DerivedDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""Derived""><baseVal xmlns=""Base"">0</baseVal><derivedVal>0</derivedVal></DerivedDC>",
 679                                 sw.ToString ());
 680                 }
 681
 682                 [Test]
 683                 public void SerializerDCArray ()
 684                 {
 685                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithEnum []));
 686                         StringWriter sw = new StringWriter ();
 687                         DCWithEnum [] arr = new DCWithEnum [2];
 688                         arr [0] = new DCWithEnum (); arr [0].colors = Colors.Red;
 689                         arr [1] = new DCWithEnum (); arr [1].colors = Colors.Green;
 690                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 691                                 ser.WriteObject (w, arr);
 692                         }
 693
 694                         XmlComparer.AssertAreEqual (
 695                                 @"<ArrayOfDCWithEnum xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><DCWithEnum><_colors>Red</_colors></DCWithEnum><DCWithEnum><_colors>Green</_colors></DCWithEnum></ArrayOfDCWithEnum>",
 696                                 sw.ToString ());
 697                 }
 698
 699                 [Test]
 700                 public void SerializerDCArray2 ()
 701                 {
 702                         List<Type> known = new List<Type> ();
 703                         known.Add (typeof (DCWithEnum));
 704                         known.Add (typeof (DCSimple1));
 705                         DataContractSerializer ser = new DataContractSerializer (typeof (object []), known);
 706                         StringWriter sw = new StringWriter ();
 707                         object [] arr = new object [2];
 708                         arr [0] = new DCWithEnum (); ((DCWithEnum)arr [0]).colors = Colors.Red;
 709                         arr [1] = new DCSimple1 (); ((DCSimple1) arr [1]).Foo = "hello";
 710
 711                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 712                                 ser.WriteObject (w, arr);
 713                         }
 714
 715                         XmlComparer.AssertAreEqual (
 716                                 @"<ArrayOfanyType xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><anyType xmlns:d2p1=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"" i:type=""d2p1:DCWithEnum""><d2p1:_colors>Red</d2p1:_colors></anyType><anyType xmlns:d2p1=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"" i:type=""d2p1:DCSimple1""><d2p1:Foo>hello</d2p1:Foo></anyType></ArrayOfanyType>",
 717                                 sw.ToString ());
 718                 }
 719
 720                 [Test]
 721                 public void SerializerDCArray3 ()
 722                 {
 723                         DataContractSerializer ser = new DataContractSerializer (typeof (int []));
 724                         StringWriter sw = new StringWriter ();
 725                         int [] arr = new int [2];
 726                         arr [0] = 1; arr [1] = 2;
 727
 728                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 729                                 ser.WriteObject (w, arr);
 730                         }
 731
 732                         XmlComparer.AssertAreEqual (
 733                                 @"<ArrayOfint xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><int>1</int><int>2</int></ArrayOfint>",
 734                                 sw.ToString ());
 735                 }
 736
 737                 [Test]
 738                 public void SerializeNonDCArray ()
 739                 {
 740                         DataContractSerializer ser = new DataContractSerializer (typeof (SerializeNonDCArrayType));
 741                         StringWriter sw = new StringWriter ();
 742                         using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
 743                                 ser.WriteObject (xw, new SerializeNonDCArrayType ());
 744                         }
 745                         Assert.AreEqual (@"<SerializeNonDCArrayType xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><IPAddresses xmlns:d2p1=""http://schemas.datacontract.org/2004/07/System.Net"" /></SerializeNonDCArrayType>",
 746                                 sw.ToString ());
 747                 }
 748
 749                 [Test]
 750                 public void SerializeNonDCArrayItems ()
 751                 {
 752                         DataContractSerializer ser = new DataContractSerializer (typeof (SerializeNonDCArrayType));
 753                         StringWriter sw = new StringWriter ();
 754                         using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
 755                                 SerializeNonDCArrayType obj = new SerializeNonDCArrayType ();
 756                                 obj.IPAddresses = new IPAddress [] {new IPAddress (new byte [] {1, 2, 3, 4})};
 757                                 ser.WriteObject (xw, obj);
 758                         }
 759
 760                         XmlDocument doc = new XmlDocument ();
 761                         doc.LoadXml (sw.ToString ());
 762                         XmlNamespaceManager nsmgr = new XmlNamespaceManager (doc.NameTable);
 763                         nsmgr.AddNamespace ("s", "http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization");
 764                         nsmgr.AddNamespace ("n", "http://schemas.datacontract.org/2004/07/System.Net");
 765                         nsmgr.AddNamespace ("a", "http://schemas.microsoft.com/2003/10/Serialization/Arrays");
 766
 767                         Assert.AreEqual (1, doc.SelectNodes ("/s:SerializeNonDCArrayType/s:IPAddresses/n:IPAddress", nsmgr).Count, "#1");
 768                         Assert.AreEqual ("67305985", doc.SelectSingleNode ("/s:SerializeNonDCArrayType/s:IPAddresses/n:IPAddress/n:m_Address", nsmgr).InnerText, "#2");
 769                         XmlElement el = doc.SelectSingleNode ("/s:SerializeNonDCArrayType/s:IPAddresses/n:IPAddress/n:m_Numbers", nsmgr) as XmlElement;
 770                         Assert.IsNotNull (el, "#3");
 771                         Assert.AreEqual (8, el.SelectNodes ("a:unsignedShort", nsmgr).Count, "#4");
 772                 }
 773
 774                 [Test]
 775                 public void DeserializeEnum ()
 776                 {
 777                         Colors c = Deserialize<Colors> (
 778                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">Red</Colors>");
 779
 780                         Assert.AreEqual (Colors.Red, c, "#de2");
 781                 }
 782
 783                 [Test]
 784                 public void DeserializeEnum2 ()
 785                 {
 786                         Colors c = Deserialize<Colors> (
 787                                 @"<Colors xmlns:d1p1=""http://www.w3.org/2001/XMLSchema"" i:type=""d1p1:int"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">1</Colors>",
 788                                 typeof (int));
 789
 790                         Assert.AreEqual (Colors.Green, c, "#de4");
 791                 }
 792
 793                 [Test]
 794                 [ExpectedException (typeof (SerializationException))]
 795                 public void DeserializeEnumInvalid1 ()
 796                 {
 797                         Deserialize<Colors> (
 798                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""></Colors>");
 799                 }
 800
 801                 [Test]
 802                 [ExpectedException (typeof (SerializationException))]
 803                 public void DeserializeEnumInvalid2 ()
 804                 {
 805                         Deserialize<Colors> (
 806                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""/>");
 807                 }
 808
 809                 [Test]
 810                 [ExpectedException (typeof (SerializationException))]
 811                 public void DeserializeEnumInvalid3 ()
 812                 {
 813                         //"red" instead of "Red"
 814                         Deserialize<Colors> (
 815                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">red</Colors>");
 816                 }
 817
 818                 [Test]
 819                 public void DeserializeEnumWithDC ()
 820                 {
 821                         ColorsWithDC cdc = Deserialize<ColorsWithDC> (
 822                                 @"<_ColorsWithDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">_Red</_ColorsWithDC>");
 823
 824                         Assert.AreEqual (ColorsWithDC.Red, cdc, "#de6");
 825                 }
 826
 827                 [Test]
 828                 [ExpectedException (typeof (SerializationException))]
 829                 public void DeserializeEnumWithDCInvalid ()
 830                 {
 831                         Deserialize<ColorsWithDC> (
 832                                 @"<_ColorsWithDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">NonExistant</_ColorsWithDC>");
 833                 }
 834
 835                 [Test]
 836                 public void DeserializeDCWithEnum ()
 837                 {
 838                         DCWithEnum dc = Deserialize<DCWithEnum> (
 839                                 @"<DCWithEnum xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><_colors>Red</_colors></DCWithEnum>");
 840
 841                         Assert.AreEqual (Colors.Red, dc.colors, "#de8");
 842                 }
 843
 844                 [Test]
 845                 public void DeserializeNestingDC ()
 846                 {
 847                         NestingDC dc = Deserialize<NestingDC> (
 848                                 @"<NestingDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><Field1><Name>test1</Name></Field1><Field2><Name>test2</Name></Field2></NestingDC>");
 849
 850                         Assert.IsNotNull (dc.Field1, "#N1: Field1 should not be null.");
 851                         Assert.IsNotNull (dc.Field2, "#N2: Field2 should not be null.");
 852                         Assert.AreEqual ("test1", dc.Field1.Name, "#1");
 853                         Assert.AreEqual ("test2", dc.Field2.Name, "#2");
 854                 }
 855
 856                 [Test]
 857                 public void DeserializeNestingDC2 ()
 858                 {
 859                         NestingDC2 dc = Deserialize<NestingDC2> (
 860                                 @"<NestingDC2 xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""test2""><Field xmlns:d2p1=""test1""><d2p1:Name>Something</d2p1:Name></Field></NestingDC2>");
 861
 862                         Assert.IsNotNull (dc.Field, "#N1: Field should not be null.");
 863                         Assert.AreEqual ("Something", dc.Field.Name, "#N2");
 864                 }
 865
 866                 [Test]
 867                 public void DeserializeDerivedDC ()
 868                 {
 869                         DerivedDC dc = Deserialize<DerivedDC> (
 870                                 @"<DerivedDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""Derived""><baseVal xmlns=""Base"">1</baseVal><derivedVal>2</derivedVal></DerivedDC>");
 871
 872                         Assert.AreEqual (1, dc.baseVal, "#N1");
 873                         Assert.AreEqual (2, dc.derivedVal, "#N2");
 874                 }
 875
 876                 [Test]
 877                 public void DeserializeTwice ()
 878                 {
 879                         string xml =
 880                                 @"<any><_ColorsWithDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">_Red</_ColorsWithDC> <_ColorsWithDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">_Red</_ColorsWithDC></any>";
 881                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsWithDC));
 882                         XmlReader xr = XmlReader.Create (new StringReader (xml), new XmlReaderSettings ());
 883                         xr.ReadStartElement ();
 884                         object o = ser.ReadObject (xr);
 885                         Assert.AreEqual (typeof (ColorsWithDC), o.GetType (), "#de5");
 886                         ColorsWithDC cdc = (ColorsWithDC) o;
 887                         Assert.AreEqual (ColorsWithDC.Red, o, "#de6");
 888
 889                         o = ser.ReadObject (xr);
 890                         Assert.AreEqual (typeof (ColorsWithDC), o.GetType (), "#de5");
 891                         cdc = (ColorsWithDC) o;
 892                         Assert.AreEqual (ColorsWithDC.Red, o, "#de6");
 893                         Assert.AreEqual (XmlNodeType.EndElement, xr.NodeType, "#de6");
 894                         Assert.AreEqual ("any", xr.LocalName, "#de6");
 895                         xr.ReadEndElement ();
 896                 }
 897
 898
 899                 [Test]
 900                 public void DeserializeEmptyNestingDC ()
 901                 {
 902                         NestingDC dc = Deserialize<NestingDC> (
 903                                 @"<NestingDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""></NestingDC>");
 904
 905                         Assert.IsNotNull (dc, "#A0: The object should not be null.");
 906                         Assert.IsNull (dc.Field1, "#A1: Field1 should be null.");
 907                         Assert.IsNull (dc.Field2, "#A2: Field2 should be null.");
 908
 909                         dc = Deserialize<NestingDC> (
 910                                 @"<NestingDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""/>");
 911
 912                         Assert.IsNotNull (dc, "#B0: The object should not be null.");
 913                         Assert.IsNull (dc.Field1, "#B1: Field1 should be null.");
 914                         Assert.IsNull (dc.Field2, "#B2: Field2 should be null.");
 915
 916                         dc = Deserialize<NestingDC> (
 917                                 @"<NestingDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><Field1 i:nil=""true"" /><Field2 i:nil=""true"" /></NestingDC>");
 918
 919                         Assert.IsNotNull (dc, "#B0: The object should not be null.");
 920                         Assert.IsNull (dc.Field1, "#B1: Field1 should be null.");
 921                         Assert.IsNull (dc.Field2, "#B2: Field2 should be null.");
 922                 }
 923
 924                 [Test]
 925                 [ExpectedException (typeof (SerializationException))]
 926                 public void DeserializeEmptyDCWithTwoEnums ()
 927                 {
 928                         Deserialize<DCWithTwoEnums> (
 929                                 @"<DCWithTwoEnums xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><colors i:nil=""true""/><colors2 i:nil=""true""/></DCWithTwoEnums>");
 930                 }
 931
 932                 [Test]
 933                 [Category ("NotWorking")]
 934                 public void DeserializeDCWithNullableEnum ()
 935                 {
 936                         DCWithNullableEnum dc = Deserialize<DCWithNullableEnum> (
 937                                 @"<DCWithNullableEnum xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><colors i:nil=""true""/></DCWithNullableEnum>");
 938
 939                         Assert.IsNull (dc.colors, "#B1: Field should be null.");
 940                 }
 941
 942                 [Test]
 943                 public void DeserializeDCWithTwoEnums ()
 944                 {
 945                         DCWithTwoEnums dc = Deserialize<DCWithTwoEnums> (
 946                                 @"<DCWithTwoEnums xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><colors>Blue</colors><colors2>Green</colors2></DCWithTwoEnums>");
 947
 948                         Assert.AreEqual (Colors.Blue, dc.colors, "#0");
 949                         Assert.AreEqual (Colors.Green, dc.colors2, "#1");
 950                 }
 951
 952                 [Test]
 953                 public void DeserializerDCArray ()
 954                 {
 955                         DCWithEnum [] dcArray = Deserialize<DCWithEnum []> (
 956                                 @"<ArrayOfDCWithEnum xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><DCWithEnum><_colors>Red</_colors></DCWithEnum><DCWithEnum><_colors>Green</_colors></DCWithEnum></ArrayOfDCWithEnum>");
 957
 958                         Assert.AreEqual (2, dcArray.Length, "#N1");
 959                         Assert.AreEqual (Colors.Red, dcArray [0].colors, "#N2");
 960                         Assert.AreEqual (Colors.Green, dcArray [1].colors, "#N3");
 961                 }
 962
 963                 [Test]
 964                 public void DeserializerDCArray2 ()
 965                 {
 966                         string xml =
 967                                 @"<ArrayOfanyType xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><anyType xmlns:d2p1=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"" i:type=""d2p1:DCWithEnum""><d2p1:_colors>Red</d2p1:_colors></anyType><anyType xmlns:d2p1=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"" i:type=""d2p1:DCSimple1""><d2p1:Foo>hello</d2p1:Foo></anyType></ArrayOfanyType>";
 968
 969                         List<Type> known = new List<Type> ();
 970                         known.Add (typeof (DCWithEnum));
 971                         known.Add (typeof (DCSimple1));
 972                         DataContractSerializer ser = new DataContractSerializer (typeof (object []), known);
 973                         XmlReader xr = XmlReader.Create (new StringReader (xml));
 974
 975                         object [] dc = (object []) ser.ReadObject (xr);
 976                         Assert.AreEqual (2, dc.Length, "#N1");
 977                         Assert.AreEqual (typeof (DCWithEnum), dc [0].GetType (), "#N2");
 978                         DCWithEnum dc0 = (DCWithEnum) dc [0];
 979                         Assert.AreEqual (Colors.Red, dc0.colors, "#N3");
 980                         Assert.AreEqual (typeof (DCSimple1), dc [1].GetType (), "#N4");
 981                         DCSimple1 dc1 = (DCSimple1) dc [1];
 982                         Assert.AreEqual ("hello", dc1.Foo, "#N4");
 983                 }
 984
 985                 [Test]
 986                 public void DeserializerDCArray3 ()
 987                 {
 988                         int [] intArray = Deserialize<int []> (
 989                                 @"<ArrayOfint xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><int>1</int><int>2</int></ArrayOfint>");
 990
 991                         Assert.AreEqual (2, intArray.Length, "#N0");
 992                         Assert.AreEqual (1, intArray [0], "#N1");
 993                         Assert.AreEqual (2, intArray [1], "#N2");
 994                 }
 995
 996                 [Test]
 997                 public void ReadObjectNoVerifyObjectName ()
 998                 {
 999                         string xml = @"<any><Member1 xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization1"">bar1</Member1><Member1 xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization2"">bar2</Member1><Member1 xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">bar</Member1></any>";
1000                         VerifyObjectNameTestData res = (VerifyObjectNameTestData)new DataContractSerializer (typeof (VerifyObjectNameTestData))
1001                                 .ReadObject (XmlReader.Create (new StringReader (xml)), false);
1002                         Assert.AreEqual ("bar", res.GetMember());
1003                 }
1004
1005                 [Test]
1006                 public void ReadObjectVerifyObjectName ()
1007                 {
1008                         string xml = @"<VerifyObjectNameTestData xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><Member1>bar</Member1></VerifyObjectNameTestData>";
1009                         VerifyObjectNameTestData res = (VerifyObjectNameTestData)new DataContractSerializer (typeof (VerifyObjectNameTestData))
1010                                 .ReadObject (XmlReader.Create (new StringReader (xml)));
1011                         Assert.AreEqual ("bar", res.GetMember());
1012                 }
1013
1014                 [Test]
1015                 [ExpectedException (typeof (SerializationException))]
1016                 public void ReadObjectWrongNamespace ()
1017                 {
1018                         string xml = @"<VerifyObjectNameTestData xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization2""><Member1>bar</Member1></VerifyObjectNameTestData>";
1019                         new DataContractSerializer (typeof (VerifyObjectNameTestData))
1020                                 .ReadObject (XmlReader.Create (new StringReader (xml)));
1021                 }
1022
1023                 private T Deserialize<T> (string xml)
1024                 {
1025                         return Deserialize<T> (xml, typeof (T));
1026                 }
1027
1028                 private T Deserialize<T> (string xml, Type runtimeType)
1029                 {
1030                         DataContractSerializer ser = new DataContractSerializer (typeof (T));
1031                         XmlReader xr = XmlReader.Create (new StringReader (xml), new XmlReaderSettings ());
1032                         object o = ser.ReadObject (xr);
1033                         Assert.AreEqual (runtimeType, o.GetType (), "#DS0");
1034                         return (T)o;
1035                 }
1036         }
1037
1038         public enum Colors {
1039                 Red, Green, Blue
1040         }
1041
1042         [DataContract (Name = "_ColorsWithDC")]
1043         public enum ColorsWithDC {
1044
1045                 [EnumMember (Value = "_Red")]
1046                 Red,
1047                 [EnumMember]
1048                 Green,
1049                 Blue
1050         }
1051
1052
1053         public enum ColorsEnumMemberNoDC {
1054                 [EnumMember (Value = "_Red")]
1055                 Red,
1056                 [EnumMember]
1057                 Green,
1058                 Blue
1059         }
1060
1061         [DataContract]
1062         public class DCWithEnum {
1063                 [DataMember (Name = "_colors")]
1064                 public Colors colors;
1065         }
1066
1067         [DataContract]
1068         public class DCWithTwoEnums {
1069                 [DataMember]
1070                 public Colors colors;
1071                 [DataMember]
1072                 public Colors colors2;
1073         }
1074
1075         [DataContract]
1076         public class DCWithNullableEnum {
1077                 [DataMember]
1078                 public Colors? colors;
1079         }
1080
1081
1082         [DataContract (Namespace = "Base")]
1083         public class BaseDC {
1084                 [DataMember]
1085                 public int baseVal;
1086         }
1087
1088         [DataContract (Namespace = "Derived")]
1089         public class DerivedDC : BaseDC {
1090                 [DataMember]
1091                 public int derivedVal;
1092         }
1093
1094         [DataContract]
1095         public class NestedDC {
1096                 public NestedDC (string name) { this.Name = name; }
1097
1098                 [DataMember]
1099                 public string Name;
1100         }
1101
1102         [DataContract]
1103         public class NestingDC {
1104                 [DataMember]
1105                 public NestedDC Field1;
1106                 [DataMember]
1107                 public NestedDC Field2;
1108         }
1109
1110         [DataContract (Namespace = "test1")]
1111         public class NestedDC2 {
1112                 public NestedDC2 (string name) { this.Name = name; }
1113
1114                 [DataMember]
1115                 public string Name;
1116         }
1117
1118         [DataContract (Namespace = "test2")]
1119         public class NestingDC2 {
1120                 [DataMember]
1121                 public NestedDC2 Field;
1122         }
1123
1124         [DataContract]
1125         public class DCEmpty
1126         {
1127                 // serializer doesn't touch it.
1128                 public string Foo = "TEST";
1129         }
1130
1131         [DataContract]
1132         public class DCSimple1
1133         {
1134                 [DataMember]
1135                 public string Foo = "TEST";
1136         }
1137
1138         [DataContract]
1139         public class DCHasNonDC
1140         {
1141                 [DataMember]
1142                 public NonDC Hoge= new NonDC ();
1143         }
1144
1145         public class NonDC
1146         {
1147                 public string Whee = "whee!";
1148         }
1149
1150         [DataContract]
1151         public class DCHasSerializable
1152         {
1153                 [DataMember]
1154                 public SimpleSer1 Ser = new SimpleSer1 ();
1155         }
1156
1157         [DataContract (Name = "Foo")]
1158         public class DCWithName
1159         {
1160                 [DataMember (Name = "FooMember")]
1161                 public string DMWithName = "value";
1162         }
1163
1164         [DataContract (Name = "")]
1165         public class DCWithEmptyName
1166         {
1167         }
1168
1169         [DataContract (Name = null)]
1170         public class DCWithNullName
1171         {
1172         }
1173
1174         [DataContract (Namespace = "")]
1175         public class DCWithEmptyNamespace
1176         {
1177         }
1178
1179         [Serializable]
1180         public class SimpleSer1
1181         {
1182                 public string Doh = "doh!";
1183         }
1184
1185         public class Wrapper
1186         {
1187                 [DataContract]
1188                 public class DCWrapped
1189                 {
1190                 }
1191         }
1192
1193         [DataContract]
1194         public class CollectionContainer
1195         {
1196                 Collection<string> items = new Collection<string> ();
1197
1198                 [DataMember]
1199                 public Collection<string> Items {
1200                         get { return items; }
1201                 }
1202         }
1203
1204         [CollectionDataContract]
1205         public class DataCollection<T> : Collection<T>
1206         {
1207         }
1208
1209         [DataContract]
1210         public class DataCollectionContainer
1211         {
1212                 DataCollection<string> items = new DataCollection<string> ();
1213
1214                 [DataMember]
1215                 public DataCollection<string> Items {
1216                         get { return items; }
1217                 }
1218         }
1219
1220         [DataContract]
1221         class SerializeNonDCArrayType
1222         {
1223                 [DataMember]
1224                 public IPAddress [] IPAddresses = new IPAddress [0];
1225         }
1226
1227         [DataContract]
1228         public class VerifyObjectNameTestData
1229         {
1230                 [DataMember]
1231                 string Member1 = "foo";
1232
1233                 public string GetMember() { return Member1; }
1234         }
1235
1236         [XmlRoot(ElementName = "simple", Namespace = "")]
1237         public class SimpleXml : IXmlSerializable
1238         {
1239                 void IXmlSerializable.ReadXml (XmlReader reader)
1240                 {
1241                 }
1242
1243                 void IXmlSerializable.WriteXml (XmlWriter writer)
1244                 {
1245                 }
1246
1247                 XmlSchema IXmlSerializable.GetSchema ()
1248                 {
1249                         return null;
1250                 }
1251
1252         }
1253
1254 }
1255
1256 [DataContract]
1257 class GlobalSample1
1258 {
1259 }