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;
  38 using System.Collections.Generic;
  39 using System.Collections.ObjectModel;
  40 using System.IO;
  41 using System.Net;
  42 using System.Runtime.Serialization;
  43 using System.Text;
  44 using System.Xml;
  45 using NUnit.Framework;
  46 using System.Xml.Serialization;
  47 using System.Xml.Schema;
  48
  49 namespace MonoTests.System.Runtime.Serialization
  50 {
  51         [TestFixture]
  52         public class DataContractSerializerTest
  53         {
  54                 static readonly XmlWriterSettings settings;
  55
  56                 static DataContractSerializerTest ()
  57                 {
  58                         settings = new XmlWriterSettings ();
  59                         settings.OmitXmlDeclaration = true;
  60                 }
  61
  62                 [DataContract]
  63                 class Sample1
  64                 {
  65                         [DataMember]
  66                         public string Member1;
  67                 }
  68
  69                 [Test]
  70                 [ExpectedException (typeof (ArgumentNullException))]
  71                 public void ConstructorTypeNull ()
  72                 {
  73                         new DataContractSerializer (null);
  74                 }
  75
  76                 [Test]
  77                 public void ConstructorKnownTypesNull ()
  78                 {
  79                         // null knownTypes is allowed.
  80                         new DataContractSerializer (typeof (Sample1), null);
  81                         new DataContractSerializer (typeof (Sample1), "Foo", String.Empty, null);
  82                         new DataContractSerializer (typeof (Sample1), new XmlDictionary ().Add ("Foo"), XmlDictionaryString.Empty, null);
  83                 }
  84
  85                 [Test]
  86                 [ExpectedException (typeof (ArgumentNullException))]
  87                 public void ConstructorNameNull ()
  88                 {
  89                         new DataContractSerializer (typeof (Sample1), null, String.Empty);
  90                 }
  91
  92                 [Test]
  93                 [ExpectedException (typeof (ArgumentNullException))]
  94                 public void ConstructorNamespaceNull ()
  95                 {
  96                         new DataContractSerializer (typeof (Sample1), "foo", null);
  97                 }
  98
  99                 [Test]
 100                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 101                 public void ConstructorNegativeMaxObjects ()
 102                 {
 103                         new DataContractSerializer (typeof (Sample1), null,
 104                                 -1, false, false, null);
 105                 }
 106
 107                 [Test]
 108                 public void ConstructorMisc ()
 109                 {
 110                         new DataContractSerializer (typeof (GlobalSample1));
 111                 }
 112
 113                 [Test]
 114                 public void WriteObjectContent ()
 115                 {
 116                         StringWriter sw = new StringWriter ();
 117                         using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
 118                                 DataContractSerializer ser =
 119                                         new DataContractSerializer (typeof (string));
 120                                 xw.WriteStartElement ("my-element");
 121                                 ser.WriteObjectContent (xw, "TEST STRING");
 122                                 xw.WriteEndElement ();
 123                         }
 124                         Assert.AreEqual ("<my-element>TEST STRING</my-element>",
 125                                 sw.ToString ());
 126                 }
 127
 128                 [Test]
 129                 public void WriteObjectToStream ()
 130                 {
 131                         DataContractSerializer ser =
 132                                 new DataContractSerializer (typeof (int));
 133                         MemoryStream sw = new MemoryStream ();
 134                         ser.WriteObject (sw, 1);
 135                         string expected = "<int xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">1</int>";
 136                         byte[] buf = sw.ToArray ();
 137                         Assert.AreEqual (expected, Encoding.UTF8.GetString (buf, 0, buf.Length));
 138                 }
 139
 140                 [Test]
 141                 public void ReadObjectFromStream ()
 142                 {
 143                         DataContractSerializer ser =
 144                                 new DataContractSerializer (typeof (int));
 145                         string expected = "<int xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">1</int>";
 146                         byte[] buf = Encoding.UTF8.GetBytes (expected);
 147                         MemoryStream sw = new MemoryStream (buf);
 148                         object res = ser.ReadObject (sw);
 149                         Assert.AreEqual (1, res);
 150                 }
 151
 152                 // int
 153
 154                 [Test]
 155                 public void SerializeInt ()
 156                 {
 157                         DataContractSerializer ser =
 158                                 new DataContractSerializer (typeof (int));
 159                         SerializeInt (ser, "<int xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">1</int>");
 160                 }
 161
 162
 163                 [Test]
 164                 [Category ("NotWorking")]
 165                 public void NetSerializeInt ()
 166                 {
 167                         NetDataContractSerializer ser =
 168                                 new NetDataContractSerializer ();
 169                         // z:Assembly="0" ???
 170                         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));
 171                 }
 172
 173                 void SerializeInt (XmlObjectSerializer ser, string expected)
 174                 {
 175                         StringWriter sw = new StringWriter ();
 176                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 177                                 ser.WriteObject (w, 1);
 178                         }
 179                         Assert.AreEqual (expected, sw.ToString ());
 180                 }
 181
 182                 // pass typeof(DCEmpty), serialize int
 183
 184                 [Test]
 185                 public void SerializeIntForDCEmpty ()
 186                 {
 187                         DataContractSerializer ser =
 188                                 new DataContractSerializer (typeof (DCEmpty));
 189                         // tricky!
 190                         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>");
 191                 }
 192
 193                 void SerializeIntForDCEmpty (XmlObjectSerializer ser, string expected)
 194                 {
 195                         StringWriter sw = new StringWriter ();
 196                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 197                                 ser.WriteObject (w, 1);
 198                         }
 199                         XmlComparer.AssertAreEqual (expected, sw.ToString ());
 200                 }
 201
 202                 // DCEmpty
 203
 204                 [Test]
 205                 public void SerializeEmptyClass ()
 206                 {
 207                         DataContractSerializer ser =
 208                                 new DataContractSerializer (typeof (DCEmpty));
 209                         SerializeEmptyClass (ser, "<DCEmpty xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\" />");
 210                 }
 211
 212                 [Test]
 213                 [Category ("NotWorking")]
 214                 public void NetSerializeEmptyClass ()
 215                 {
 216                         NetDataContractSerializer ser =
 217                                 new NetDataContractSerializer ();
 218                         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));
 219                 }
 220
 221                 void SerializeEmptyClass (XmlObjectSerializer ser, string expected)
 222                 {
 223                         StringWriter sw = new StringWriter ();
 224                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 225                                 ser.WriteObject (w, new DCEmpty ());
 226                         }
 227                         Assert.AreEqual (expected, sw.ToString ());
 228                 }
 229
 230                 // string (primitive)
 231
 232                 [Test]
 233                 public void SerializePrimitiveString ()
 234                 {
 235                         XmlObjectSerializer ser =
 236                                 new DataContractSerializer (typeof (string));
 237                         SerializePrimitiveString (ser, "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">TEST</string>");
 238                 }
 239
 240                 [Test]
 241                 [Category ("NotWorking")]
 242                 public void NetSerializePrimitiveString ()
 243                 {
 244                         XmlObjectSerializer ser = new NetDataContractSerializer ();
 245                         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>");
 246                 }
 247
 248                 void SerializePrimitiveString (XmlObjectSerializer ser, string expected)
 249                 {
 250                         StringWriter sw = new StringWriter ();
 251                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 252                                 ser.WriteObject (w, "TEST");
 253                         }
 254                         Assert.AreEqual (expected, sw.ToString ());
 255                 }
 256
 257                 // QName (primitive but ...)
 258
 259                 [Test]
 260                 [Ignore ("These tests would not make any sense right now since it's populated prefix is not testable.")]
 261                 public void SerializePrimitiveQName ()
 262                 {
 263                         XmlObjectSerializer ser =
 264                                 new DataContractSerializer (typeof (XmlQualifiedName));
 265                         SerializePrimitiveQName (ser, "<z:QName xmlns:d7=\"urn:foo\" xmlns:z=\"http://schemas.microsoft.com/2003/10/Serialization/\">d7:foo</z:QName>");
 266                 }
 267
 268                 [Test]
 269                 [Ignore ("These tests would not make any sense right now since it's populated prefix is not testable.")]
 270                 public void NetSerializePrimitiveQName ()
 271                 {
 272                         XmlObjectSerializer ser = new NetDataContractSerializer ();
 273                         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>");
 274                 }
 275
 276                 void SerializePrimitiveQName (XmlObjectSerializer ser, string expected)
 277                 {
 278                         StringWriter sw = new StringWriter ();
 279                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 280                                 ser.WriteObject (w, new XmlQualifiedName ("foo", "urn:foo"));
 281                         }
 282                         Assert.AreEqual (expected, sw.ToString ());
 283                 }
 284
 285                 // DCSimple1
 286
 287                 [Test]
 288                 public void SerializeSimpleClass1 ()
 289                 {
 290                         DataContractSerializer ser =
 291                                 new DataContractSerializer (typeof (DCSimple1));
 292                         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>");
 293                 }
 294
 295                 [Test]
 296                 [ExpectedException (typeof (SerializationException))]
 297                 [Category ("NotWorking")] // behavior changed in 3.5/SP1
 298                 public void SerializeSimpleXml ()
 299                 {
 300                         DataContractSerializer ser =
 301                                 new DataContractSerializer (typeof (SimpleXml));
 302                         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>");
 303                 }
 304
 305                 [Test]
 306                 [Category ("NotWorking")]
 307                 public void NetSerializeSimpleClass1 ()
 308                 {
 309                         NetDataContractSerializer ser =
 310                                 new NetDataContractSerializer ();
 311                         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));
 312                 }
 313
 314                 void SerializeSimpleClass1 (XmlObjectSerializer ser, string expected)
 315                 {
 316                         StringWriter sw = new StringWriter ();
 317                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 318                                 ser.WriteObject (w, new DCSimple1 ());
 319                         }
 320                         Console.WriteLine(sw.ToString());
 321                         Assert.AreEqual (expected, sw.ToString ());
 322                 }
 323
 324                 // NonDC (behavior changed in 3.5/SP1; not it's not rejected)
 325
 326                 [Test]
 327                 public void SerializeNonDC ()
 328                 {
 329                         DataContractSerializer ser = new DataContractSerializer (typeof (NonDC));
 330                         var sw = new StringWriter ();
 331                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 332                                 ser.WriteObject (w, new NonDC ());
 333                         }
 334                         Assert.AreEqual ("<NonDC xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization'><Whee>whee!</Whee></NonDC>".Replace ('\'', '"'), sw.ToString ());
 335                 }
 336
 337                 // DCHasNonDC
 338
 339                 [Test]
 340                 public void SerializeDCHasNonDC ()
 341                 {
 342                         DataContractSerializer ser = new DataContractSerializer (typeof (DCHasNonDC));
 343                         var sw = new StringWriter ();
 344                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 345                                 ser.WriteObject (w, new DCHasNonDC ());
 346                         }
 347                         Assert.AreEqual ("<DCHasNonDC xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization'><Hoge><Whee>whee!</Whee></Hoge></DCHasNonDC>".Replace ('\'', '"'), sw.ToString ());
 348                 }
 349
 350                 // DCHasSerializable
 351
 352                 [Test]
 353                 // DCHasSerializable itself is DataContract and has a field
 354                 // whose type is not contract but serializable.
 355                 public void SerializeSimpleSerializable1 ()
 356                 {
 357                         DataContractSerializer ser = new DataContractSerializer (typeof (DCHasSerializable));
 358                         StringWriter sw = new StringWriter ();
 359                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 360                                 ser.WriteObject (w, new DCHasSerializable ());
 361                         }
 362                         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 ());
 363                 }
 364
 365                 [Test]
 366                 public void SerializeDCWithName ()
 367                 {
 368                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithName));
 369                         StringWriter sw = new StringWriter ();
 370                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 371                                 ser.WriteObject (w, new DCWithName ());
 372                         }
 373                         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 ());
 374                 }
 375
 376                 [Test]
 377                 public void SerializeDCWithEmptyName1 ()
 378                 {
 379                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithEmptyName));
 380                         StringWriter sw = new StringWriter ();
 381                         DCWithEmptyName dc = new DCWithEmptyName ();
 382                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 383                                 try {
 384                                         ser.WriteObject (w, dc);
 385                                 } catch (InvalidDataContractException) {
 386                                         return;
 387                                 }
 388                         }
 389                         Assert.Fail ("Expected InvalidDataContractException");
 390                 }
 391
 392                 [Test]
 393                 [Category ("NotWorking")]
 394                 public void SerializeDCWithEmptyName2 ()
 395                 {
 396                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithName));
 397                         StringWriter sw = new StringWriter ();
 398
 399                         /* DataContractAttribute.Name == "", not valid */
 400                         DCWithEmptyName dc = new DCWithEmptyName ();
 401                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 402                                 try {
 403                                         ser.WriteObject (w, dc);
 404                                 } catch (InvalidDataContractException) {
 405                                         return;
 406                                 }
 407                         }
 408                         Assert.Fail ("Expected InvalidDataContractException");
 409                 }
 410
 411                 [Test]
 412                 [Category ("NotWorking")]
 413                 public void SerializeDCWithNullName ()
 414                 {
 415                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithNullName));
 416                         StringWriter sw = new StringWriter ();
 417                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 418                                 try {
 419                                         /* DataContractAttribute.Name == "", not valid */
 420                                         ser.WriteObject (w, new DCWithNullName ());
 421                                 } catch (InvalidDataContractException) {
 422                                         return;
 423                                 }
 424                         }
 425                         Assert.Fail ("Expected InvalidDataContractException");
 426                 }
 427
 428                 [Test]
 429                 public void SerializeDCWithEmptyNamespace1 ()
 430                 {
 431                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithEmptyNamespace));
 432                         StringWriter sw = new StringWriter ();
 433                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 434                                 ser.WriteObject (w, new DCWithEmptyNamespace ());
 435                         }
 436                 }
 437
 438                 // Wrapper.DCWrapped
 439
 440                 [Test]
 441                 public void SerializeWrappedClass ()
 442                 {
 443                         DataContractSerializer ser =
 444                                 new DataContractSerializer (typeof (Wrapper.DCWrapped));
 445                         SerializeWrappedClass (ser, "<Wrapper.DCWrapped xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization\" />");
 446                 }
 447
 448                 [Test]
 449                 [Category ("NotWorking")]
 450                 public void NetSerializeWrappedClass ()
 451                 {
 452                         NetDataContractSerializer ser =
 453                                 new NetDataContractSerializer ();
 454                         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));
 455                 }
 456
 457                 void SerializeWrappedClass (XmlObjectSerializer ser, string expected)
 458                 {
 459                         StringWriter sw = new StringWriter ();
 460                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 461                                 ser.WriteObject (w, new Wrapper.DCWrapped ());
 462                         }
 463                         Assert.AreEqual (expected, sw.ToString ());
 464                 }
 465
 466                 [Test]
 467                 /* old code
 468                 // CollectionContainer : Items must have a setter.
 469                 [ExpectedException (typeof (InvalidDataContractException))]
 470                 [Category ("NotWorking")]
 471                 */
 472                 public void SerializeReadOnlyCollectionMember ()
 473                 {
 474                         DataContractSerializer ser =
 475                                 new DataContractSerializer (typeof (CollectionContainer));
 476
 477                         StringWriter sw = new StringWriter ();
 478                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 479                                 ser.WriteObject (w, null);
 480                         }
 481                         Assert.AreEqual ("<CollectionContainer i:nil='true' xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization' />".Replace ('\'', '"'), sw.ToString (), "#1");
 482
 483                         sw = new StringWriter ();
 484                         var c = new CollectionContainer ();
 485                         c.Items.Add ("foo");
 486                         c.Items.Add ("bar");
 487                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 488                                 ser.WriteObject (w, c);
 489                         }
 490                         Assert.AreEqual ("<CollectionContainer xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization'><Items xmlns:d2p1='http://schemas.microsoft.com/2003/10/Serialization/Arrays'><d2p1:string>foo</d2p1:string><d2p1:string>bar</d2p1:string></Items></CollectionContainer>".Replace ('\'', '"'), sw.ToString (), "#2");
 491                 }
 492
 493                 // DataCollectionContainer : Items must have a setter.
 494                 [Test]
 495                 //[ExpectedException (typeof (InvalidDataContractException))]
 496                 public void SerializeReadOnlyDataCollectionMember ()
 497                 {
 498                         DataContractSerializer ser =
 499                                 new DataContractSerializer (typeof (DataCollectionContainer));
 500                         StringWriter sw = new StringWriter ();
 501                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 502                                 ser.WriteObject (w, null);
 503                         }
 504                         Assert.AreEqual ("<DataCollectionContainer i:nil='true' xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization' />".Replace ('\'', '"'), sw.ToString (), "#1");
 505
 506                         sw = new StringWriter ();
 507                         var c = new DataCollectionContainer ();
 508                         c.Items.Add ("foo");
 509                         c.Items.Add ("bar");
 510                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 511                                 ser.WriteObject (w, c);
 512                         }
 513                         // LAMESPEC: this is bogus behavior. .NET serializes
 514                         // System.String as "string" without overriding its
 515                         // element namespace, but then it must be regarded as
 516                         // in parent's namespace. What if there already is an
 517                         // element definition for "string" with the same
 518                         // namespace?
 519                         Assert.AreEqual ("<DataCollectionContainer xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization'><Items><string>foo</string><string>bar</string></Items></DataCollectionContainer>".Replace ('\'', '"'), sw.ToString (), "#2");
 520                 }
 521
 522                 [Test]
 523                 public void SerializeGuid ()
 524                 {
 525                         DataContractSerializer ser = new DataContractSerializer (typeof (Guid));
 526                         StringWriter sw = new StringWriter ();
 527                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 528                                 ser.WriteObject (w, Guid.Empty);
 529                         }
 530                         Assert.AreEqual (
 531                                 "<guid xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">00000000-0000-0000-0000-000000000000</guid>",
 532                                 sw.ToString ());
 533                 }
 534
 535                 [Test]
 536                 public void SerializeEnum ()
 537                 {
 538                         DataContractSerializer ser = new DataContractSerializer (typeof (Colors));
 539                         StringWriter sw = new StringWriter ();
 540                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 541                                 ser.WriteObject (w, new Colors ());
 542                         }
 543
 544                         Assert.AreEqual (
 545                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">Red</Colors>",
 546                                 sw.ToString ());
 547                 }
 548
 549                 [Test]
 550                 public void SerializeEnum2 ()
 551                 {
 552                         DataContractSerializer ser = new DataContractSerializer (typeof (Colors));
 553                         StringWriter sw = new StringWriter ();
 554                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 555                                 ser.WriteObject (w, 0);
 556                         }
 557
 558                         XmlComparer.AssertAreEqual (
 559                                 @"<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>",
 560                                 sw.ToString ());
 561                 }
 562
 563                 [Test]
 564                 public void SerializeEnumWithDC ()
 565                 {
 566                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsWithDC));
 567                         StringWriter sw = new StringWriter ();
 568                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 569                                 ser.WriteObject (w, new ColorsWithDC ());
 570                         }
 571
 572                         Assert.AreEqual (
 573                                 @"<_ColorsWithDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">_Red</_ColorsWithDC>",
 574                                 sw.ToString ());
 575                 }
 576
 577                 [Test]
 578                 public void SerializeEnumWithNoDC ()
 579                 {
 580                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsEnumMemberNoDC));
 581                         StringWriter sw = new StringWriter ();
 582                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 583                                 ser.WriteObject (w, new ColorsEnumMemberNoDC ());
 584                         }
 585
 586                         Assert.AreEqual (
 587                                 @"<ColorsEnumMemberNoDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">Red</ColorsEnumMemberNoDC>",
 588                                 sw.ToString ());
 589                 }
 590
 591                 [Test]
 592                 public void SerializeEnumWithDC2 ()
 593                 {
 594                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsWithDC));
 595                         StringWriter sw = new StringWriter ();
 596                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 597                                 ser.WriteObject (w, 3);
 598                         }
 599
 600                         XmlComparer.AssertAreEqual (
 601                                 @"<_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>",
 602                                 sw.ToString ());
 603                 }
 604
 605                 [Test]
 606                 [ExpectedException (typeof (SerializationException))]
 607                 public void SerializeEnumWithDCInvalid ()
 608                 {
 609                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsWithDC));
 610                         StringWriter sw = new StringWriter ();
 611                         ColorsWithDC cdc = ColorsWithDC.Blue;
 612                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 613                                 ser.WriteObject (w, cdc);
 614                         }
 615                 }
 616
 617                 [Test]
 618                 public void SerializeDCWithEnum ()
 619                 {
 620                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithEnum));
 621                         StringWriter sw = new StringWriter ();
 622                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 623                                 ser.WriteObject (w, new DCWithEnum ());
 624                         }
 625
 626                         Assert.AreEqual (
 627                                 @"<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>",
 628                                 sw.ToString ());
 629                 }
 630
 631                 [Test]
 632                 public void SerializeDCWithTwoEnums ()
 633                 {
 634                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithTwoEnums));
 635                         StringWriter sw = new StringWriter ();
 636                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 637                                 DCWithTwoEnums e = new DCWithTwoEnums ();
 638                                 e.colors = Colors.Blue;
 639                                 e.colors2 = Colors.Green;
 640                                 ser.WriteObject (w, e);
 641                         }
 642
 643                         Assert.AreEqual (
 644                                 @"<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>",
 645                                 sw.ToString ());
 646                 }
 647
 648                 [Test]
 649                 public void SerializeNestingDC2 ()
 650                 {
 651                         DataContractSerializer ser = new DataContractSerializer (typeof (NestingDC2));
 652                         StringWriter sw = new StringWriter ();
 653                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 654                                 NestingDC2 e = new NestingDC2 ();
 655                                 e.Field = new NestedDC2 ("Something");
 656                                 ser.WriteObject (w, e);
 657                         }
 658
 659                         Assert.AreEqual (
 660                                 @"<NestingDC2 xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""test2""><Field xmlns:d2p1=""test1""><d2p1:Name>Something</d2p1:Name></Field></NestingDC2>",
 661                                 sw.ToString ());
 662                 }
 663
 664                 [Test]
 665                 public void SerializeNestingDC ()
 666                 {
 667                         DataContractSerializer ser = new DataContractSerializer (typeof (NestingDC));
 668                         StringWriter sw = new StringWriter ();
 669                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 670                                 NestingDC e = new NestingDC ();
 671                                 e.Field1 = new NestedDC ("test1");
 672                                 e.Field2 = new NestedDC ("test2");
 673                                 ser.WriteObject (w, e);
 674                         }
 675
 676                         Assert.AreEqual (
 677                                 @"<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>",
 678                                 sw.ToString ());
 679                         sw = new StringWriter ();
 680                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 681                                 NestingDC e = new NestingDC ();
 682                                 ser.WriteObject (w, e);
 683                         }
 684
 685                         Assert.AreEqual (
 686                                 @"<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>",
 687                                 sw.ToString ());
 688                 }
 689
 690                 [Test]
 691                 public void SerializeDerivedDC ()
 692                 {
 693                         DataContractSerializer ser = new DataContractSerializer (typeof (DerivedDC));
 694                         StringWriter sw = new StringWriter ();
 695                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 696                                 DerivedDC e = new DerivedDC ();
 697                                 ser.WriteObject (w, e);
 698                         }
 699
 700                         Assert.AreEqual (
 701                                 @"<DerivedDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""Derived""><baseVal xmlns=""Base"">0</baseVal><derivedVal>0</derivedVal></DerivedDC>",
 702                                 sw.ToString ());
 703                 }
 704
 705                 [Test]
 706                 public void SerializerDCArray ()
 707                 {
 708                         DataContractSerializer ser = new DataContractSerializer (typeof (DCWithEnum []));
 709                         StringWriter sw = new StringWriter ();
 710                         DCWithEnum [] arr = new DCWithEnum [2];
 711                         arr [0] = new DCWithEnum (); arr [0].colors = Colors.Red;
 712                         arr [1] = new DCWithEnum (); arr [1].colors = Colors.Green;
 713                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 714                                 ser.WriteObject (w, arr);
 715                         }
 716
 717                         XmlComparer.AssertAreEqual (
 718                                 @"<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>",
 719                                 sw.ToString ());
 720                 }
 721
 722                 [Test]
 723                 public void SerializerDCArray2 ()
 724                 {
 725                         List<Type> known = new List<Type> ();
 726                         known.Add (typeof (DCWithEnum));
 727                         known.Add (typeof (DCSimple1));
 728                         DataContractSerializer ser = new DataContractSerializer (typeof (object []), known);
 729                         StringWriter sw = new StringWriter ();
 730                         object [] arr = new object [2];
 731                         arr [0] = new DCWithEnum (); ((DCWithEnum)arr [0]).colors = Colors.Red;
 732                         arr [1] = new DCSimple1 (); ((DCSimple1) arr [1]).Foo = "hello";
 733
 734                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 735                                 ser.WriteObject (w, arr);
 736                         }
 737
 738                         XmlComparer.AssertAreEqual (
 739                                 @"<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>",
 740                                 sw.ToString ());
 741                 }
 742
 743                 [Test]
 744                 public void SerializerDCArray3 ()
 745                 {
 746                         DataContractSerializer ser = new DataContractSerializer (typeof (int []));
 747                         StringWriter sw = new StringWriter ();
 748                         int [] arr = new int [2];
 749                         arr [0] = 1; arr [1] = 2;
 750
 751                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {
 752                                 ser.WriteObject (w, arr);
 753                         }
 754
 755                         XmlComparer.AssertAreEqual (
 756                                 @"<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>",
 757                                 sw.ToString ());
 758                 }
 759
 760                 [Test]
 761                 public void SerializeNonDCArray ()
 762                 {
 763                         DataContractSerializer ser = new DataContractSerializer (typeof (SerializeNonDCArrayType));
 764                         StringWriter sw = new StringWriter ();
 765                         using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
 766                                 ser.WriteObject (xw, new SerializeNonDCArrayType ());
 767                         }
 768                         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>",
 769                                 sw.ToString ());
 770                 }
 771
 772                 [Test]
 773                 public void SerializeNonDCArrayItems ()
 774                 {
 775                         DataContractSerializer ser = new DataContractSerializer (typeof (SerializeNonDCArrayType));
 776                         StringWriter sw = new StringWriter ();
 777                         using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
 778                                 SerializeNonDCArrayType obj = new SerializeNonDCArrayType ();
 779                                 obj.IPAddresses = new IPAddress [] {new IPAddress (new byte [] {1, 2, 3, 4})};
 780                                 ser.WriteObject (xw, obj);
 781                         }
 782
 783                         XmlDocument doc = new XmlDocument ();
 784                         doc.LoadXml (sw.ToString ());
 785                         XmlNamespaceManager nsmgr = new XmlNamespaceManager (doc.NameTable);
 786                         nsmgr.AddNamespace ("s", "http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization");
 787                         nsmgr.AddNamespace ("n", "http://schemas.datacontract.org/2004/07/System.Net");
 788                         nsmgr.AddNamespace ("a", "http://schemas.microsoft.com/2003/10/Serialization/Arrays");
 789
 790                         Assert.AreEqual (1, doc.SelectNodes ("/s:SerializeNonDCArrayType/s:IPAddresses/n:IPAddress", nsmgr).Count, "#1");
 791                         Assert.AreEqual ("67305985", doc.SelectSingleNode ("/s:SerializeNonDCArrayType/s:IPAddresses/n:IPAddress/n:m_Address", nsmgr).InnerText, "#2");
 792                         XmlElement el = doc.SelectSingleNode ("/s:SerializeNonDCArrayType/s:IPAddresses/n:IPAddress/n:m_Numbers", nsmgr) as XmlElement;
 793                         Assert.IsNotNull (el, "#3");
 794                         Assert.AreEqual (8, el.SelectNodes ("a:unsignedShort", nsmgr).Count, "#4");
 795                 }
 796
 797                 [Test]
 798                 public void DeserializeEnum ()
 799                 {
 800                         Colors c = Deserialize<Colors> (
 801                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">Red</Colors>");
 802
 803                         Assert.AreEqual (Colors.Red, c, "#de2");
 804                 }
 805
 806                 [Test]
 807                 public void DeserializeEnum2 ()
 808                 {
 809                         Colors c = Deserialize<Colors> (
 810                                 @"<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>",
 811                                 typeof (int));
 812
 813                         Assert.AreEqual (Colors.Green, c, "#de4");
 814                 }
 815
 816                 [Test]
 817                 [ExpectedException (typeof (SerializationException))]
 818                 public void DeserializeEnumInvalid1 ()
 819                 {
 820                         Deserialize<Colors> (
 821                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""></Colors>");
 822                 }
 823
 824                 [Test]
 825                 [ExpectedException (typeof (SerializationException))]
 826                 public void DeserializeEnumInvalid2 ()
 827                 {
 828                         Deserialize<Colors> (
 829                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""/>");
 830                 }
 831
 832                 [Test]
 833                 [ExpectedException (typeof (SerializationException))]
 834                 public void DeserializeEnumInvalid3 ()
 835                 {
 836                         //"red" instead of "Red"
 837                         Deserialize<Colors> (
 838                                 @"<Colors xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">red</Colors>");
 839                 }
 840
 841                 [Test]
 842                 public void DeserializeEnumWithDC ()
 843                 {
 844                         ColorsWithDC cdc = Deserialize<ColorsWithDC> (
 845                                 @"<_ColorsWithDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">_Red</_ColorsWithDC>");
 846
 847                         Assert.AreEqual (ColorsWithDC.Red, cdc, "#de6");
 848                 }
 849
 850                 [Test]
 851                 [ExpectedException (typeof (SerializationException))]
 852                 public void DeserializeEnumWithDCInvalid ()
 853                 {
 854                         Deserialize<ColorsWithDC> (
 855                                 @"<_ColorsWithDC xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">NonExistant</_ColorsWithDC>");
 856                 }
 857
 858                 [Test]
 859                 public void DeserializeDCWithEnum ()
 860                 {
 861                         DCWithEnum dc = Deserialize<DCWithEnum> (
 862                                 @"<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>");
 863
 864                         Assert.AreEqual (Colors.Red, dc.colors, "#de8");
 865                 }
 866
 867                 [Test]
 868                 public void DeserializeNestingDC ()
 869                 {
 870                         NestingDC dc = Deserialize<NestingDC> (
 871                                 @"<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>");
 872
 873                         Assert.IsNotNull (dc.Field1, "#N1: Field1 should not be null.");
 874                         Assert.IsNotNull (dc.Field2, "#N2: Field2 should not be null.");
 875                         Assert.AreEqual ("test1", dc.Field1.Name, "#1");
 876                         Assert.AreEqual ("test2", dc.Field2.Name, "#2");
 877                 }
 878
 879                 [Test]
 880                 public void DeserializeNestingDC2 ()
 881                 {
 882                         NestingDC2 dc = Deserialize<NestingDC2> (
 883                                 @"<NestingDC2 xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""test2""><Field xmlns:d2p1=""test1""><d2p1:Name>Something</d2p1:Name></Field></NestingDC2>");
 884
 885                         Assert.IsNotNull (dc.Field, "#N1: Field should not be null.");
 886                         Assert.AreEqual ("Something", dc.Field.Name, "#N2");
 887                 }
 888
 889                 [Test]
 890                 public void DeserializeDerivedDC ()
 891                 {
 892                         DerivedDC dc = Deserialize<DerivedDC> (
 893                                 @"<DerivedDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""Derived""><baseVal xmlns=""Base"">1</baseVal><derivedVal>2</derivedVal></DerivedDC>");
 894
 895                         Assert.AreEqual (1, dc.baseVal, "#N1");
 896                         Assert.AreEqual (2, dc.derivedVal, "#N2");
 897                 }
 898
 899                 [Test]
 900                 public void DeserializeTwice ()
 901                 {
 902                         string xml =
 903                                 @"<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>";
 904                         DataContractSerializer ser = new DataContractSerializer (typeof (ColorsWithDC));
 905                         XmlReader xr = XmlReader.Create (new StringReader (xml), new XmlReaderSettings ());
 906                         xr.ReadStartElement ();
 907                         object o = ser.ReadObject (xr);
 908                         Assert.AreEqual (typeof (ColorsWithDC), o.GetType (), "#de5");
 909                         ColorsWithDC cdc = (ColorsWithDC) o;
 910                         Assert.AreEqual (ColorsWithDC.Red, o, "#de6");
 911
 912                         o = ser.ReadObject (xr);
 913                         Assert.AreEqual (typeof (ColorsWithDC), o.GetType (), "#de5");
 914                         cdc = (ColorsWithDC) o;
 915                         Assert.AreEqual (ColorsWithDC.Red, o, "#de6");
 916                         Assert.AreEqual (XmlNodeType.EndElement, xr.NodeType, "#de6");
 917                         Assert.AreEqual ("any", xr.LocalName, "#de6");
 918                         xr.ReadEndElement ();
 919                 }
 920
 921
 922                 [Test]
 923                 public void DeserializeEmptyNestingDC ()
 924                 {
 925                         NestingDC dc = Deserialize<NestingDC> (
 926                                 @"<NestingDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""></NestingDC>");
 927
 928                         Assert.IsNotNull (dc, "#A0: The object should not be null.");
 929                         Assert.IsNull (dc.Field1, "#A1: Field1 should be null.");
 930                         Assert.IsNull (dc.Field2, "#A2: Field2 should be null.");
 931
 932                         dc = Deserialize<NestingDC> (
 933                                 @"<NestingDC xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""/>");
 934
 935                         Assert.IsNotNull (dc, "#B0: The object should not be null.");
 936                         Assert.IsNull (dc.Field1, "#B1: Field1 should be null.");
 937                         Assert.IsNull (dc.Field2, "#B2: Field2 should be null.");
 938
 939                         dc = Deserialize<NestingDC> (
 940                                 @"<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>");
 941
 942                         Assert.IsNotNull (dc, "#B0: The object should not be null.");
 943                         Assert.IsNull (dc.Field1, "#B1: Field1 should be null.");
 944                         Assert.IsNull (dc.Field2, "#B2: Field2 should be null.");
 945                 }
 946
 947                 [Test]
 948                 [ExpectedException (typeof (SerializationException))]
 949                 public void DeserializeEmptyDCWithTwoEnums ()
 950                 {
 951                         Deserialize<DCWithTwoEnums> (
 952                                 @"<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>");
 953                 }
 954
 955                 [Test]
 956                 [Category ("NotWorking")]
 957                 public void DeserializeDCWithNullableEnum ()
 958                 {
 959                         DCWithNullableEnum dc = Deserialize<DCWithNullableEnum> (
 960                                 @"<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>");
 961
 962                         Assert.IsNull (dc.colors, "#B1: Field should be null.");
 963                 }
 964
 965                 [Test]
 966                 public void DeserializeDCWithTwoEnums ()
 967                 {
 968                         DCWithTwoEnums dc = Deserialize<DCWithTwoEnums> (
 969                                 @"<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>");
 970
 971                         Assert.AreEqual (Colors.Blue, dc.colors, "#0");
 972                         Assert.AreEqual (Colors.Green, dc.colors2, "#1");
 973                 }
 974
 975                 [Test]
 976                 public void DeserializerDCArray ()
 977                 {
 978                         DCWithEnum [] dcArray = Deserialize<DCWithEnum []> (
 979                                 @"<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>");
 980
 981                         Assert.AreEqual (2, dcArray.Length, "#N1");
 982                         Assert.AreEqual (Colors.Red, dcArray [0].colors, "#N2");
 983                         Assert.AreEqual (Colors.Green, dcArray [1].colors, "#N3");
 984                 }
 985
 986                 [Test]
 987                 public void DeserializerDCArray2 ()
 988                 {
 989                         string xml =
 990                                 @"<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>";
 991
 992                         List<Type> known = new List<Type> ();
 993                         known.Add (typeof (DCWithEnum));
 994                         known.Add (typeof (DCSimple1));
 995                         DataContractSerializer ser = new DataContractSerializer (typeof (object []), known);
 996                         XmlReader xr = XmlReader.Create (new StringReader (xml));
 997
 998                         object [] dc = (object []) ser.ReadObject (xr);
 999                         Assert.AreEqual (2, dc.Length, "#N1");
1000                         Assert.AreEqual (typeof (DCWithEnum), dc [0].GetType (), "#N2");
1001                         DCWithEnum dc0 = (DCWithEnum) dc [0];
1002                         Assert.AreEqual (Colors.Red, dc0.colors, "#N3");
1003                         Assert.AreEqual (typeof (DCSimple1), dc [1].GetType (), "#N4");
1004                         DCSimple1 dc1 = (DCSimple1) dc [1];
1005                         Assert.AreEqual ("hello", dc1.Foo, "#N4");
1006                 }
1007
1008                 [Test]
1009                 public void DeserializerDCArray3 ()
1010                 {
1011                         int [] intArray = Deserialize<int []> (
1012                                 @"<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>");
1013
1014                         Assert.AreEqual (2, intArray.Length, "#N0");
1015                         Assert.AreEqual (1, intArray [0], "#N1");
1016                         Assert.AreEqual (2, intArray [1], "#N2");
1017                 }
1018
1019                 [Test]
1020                 public void ReadObjectNoVerifyObjectName ()
1021                 {
1022                         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>";
1023                         VerifyObjectNameTestData res = (VerifyObjectNameTestData)new DataContractSerializer (typeof (VerifyObjectNameTestData))
1024                                 .ReadObject (XmlReader.Create (new StringReader (xml)), false);
1025                         Assert.AreEqual ("bar", res.GetMember());
1026                 }
1027
1028                 [Test]
1029                 public void ReadObjectVerifyObjectName ()
1030                 {
1031                         string xml = @"<VerifyObjectNameTestData xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization""><Member1>bar</Member1></VerifyObjectNameTestData>";
1032                         VerifyObjectNameTestData res = (VerifyObjectNameTestData)new DataContractSerializer (typeof (VerifyObjectNameTestData))
1033                                 .ReadObject (XmlReader.Create (new StringReader (xml)));
1034                         Assert.AreEqual ("bar", res.GetMember());
1035                 }
1036
1037                 [Test]
1038                 [ExpectedException (typeof (SerializationException))]
1039                 public void ReadObjectWrongNamespace ()
1040                 {
1041                         string xml = @"<VerifyObjectNameTestData xmlns=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization2""><Member1>bar</Member1></VerifyObjectNameTestData>";
1042                         new DataContractSerializer (typeof (VerifyObjectNameTestData))
1043                                 .ReadObject (XmlReader.Create (new StringReader (xml)));
1044                 }
1045
1046                 [Test]
1047                 public void ReferenceSerialization ()
1048                 {
1049                         var dc = new DataContractSerializer (typeof (ReferenceWrapper));
1050                         var t = new ReferenceType ();
1051                         StringWriter sw = new StringWriter ();
1052                         using (var xw = XmlWriter.Create (sw)) {
1053                                 xw.WriteStartElement ("z", "root", "http://schemas.microsoft.com/2003/10/Serialization/");
1054                                 dc.WriteObject (xw, new ReferenceWrapper () {T = t, T2 = t});
1055                                 xw.WriteEndElement ();
1056                         }
1057                         string xml = @"<?xml version='1.0' encoding='utf-16'?><z:root xmlns:z='http://schemas.microsoft.com/2003/10/Serialization/'><ReferenceWrapper xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization'><T z:Id='i1'><F>x</F></T><T2 z:Ref='i1' /></ReferenceWrapper></z:root>";
1058                         Assert.AreEqual (xml.Replace ('\'', '"'), sw.ToString (), "#1");
1059
1060                         ReferenceWrapper w;
1061                         using (XmlReader r = XmlReader.Create (new StringReader (xml)))
1062         {
1063                                 r.ReadStartElement ();
1064                                 w = (ReferenceWrapper) dc.ReadObject (r);
1065                                 r.ReadEndElement ();
1066                         }
1067                         Assert.AreEqual (w.T, w.T2, "#2");
1068                 }
1069
1070                 [Test]
1071                 public void GenericSerialization ()
1072                 {
1073                         var sw = new StringWriter ();
1074                         var ser  = new DataContractSerializer (typeof (Foo<string,int,int>));
1075                         using (var xw = XmlWriter.Create (sw))
1076                                 ser.WriteObject (xw, new Foo<string,int,int> () {Field = "f"
1077                         });
1078                         var s = sw.ToString ();
1079
1080                         var ret = (Foo<string,int,int>) ser.ReadObject (XmlReader.Create (new StringReader (s)));
1081                         Assert.AreEqual ("f", ret.Field);
1082                 }
1083
1084                 [Test]
1085                 public void GenericCollectionSerialization ()
1086                 {
1087                         var l = new MyList ();
1088                         l.Add ("foo");
1089                         l.Add ("bar");
1090                         var ds = new DataContractSerializer (typeof (MyList));
1091                         var sw = new StringWriter ();
1092                         using (var xw = XmlWriter.Create (sw))
1093                                 ds.WriteObject (xw, l);
1094                         l = (MyList) ds.ReadObject (XmlReader.Create (new StringReader (sw.ToString ())));
1095                         Assert.AreEqual (2, l.Count);
1096                 }
1097
1098                 [Test]
1099                 public void GenericListOfKeyValuePairSerialization ()
1100                 {
1101                         string xml = @"<?xml version='1.0' encoding='utf-16'?><ArrayOfKeyValuePairOfstringstring xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/System.Collections.Generic'><KeyValuePairOfstringstring><key>foo</key><value>bar</value></KeyValuePairOfstringstring></ArrayOfKeyValuePairOfstringstring>".Replace ('\'', '"');
1102
1103                         var ds = new DataContractSerializer (typeof (List<KeyValuePair<string,string>>));
1104                         var d = new List<KeyValuePair<string,string>> ();
1105                         //d ["foo"] = "bar";
1106                         //d.Add (new DictionaryEntry ("foo", "bar"));
1107                         d.Add (new KeyValuePair<string,string> ("foo", "bar"));
1108                         var sw = new StringWriter ();
1109                         using (var xw = XmlWriter.Create (sw))
1110                                 ds.WriteObject (xw, d);
1111                         Assert.AreEqual (xml, sw.ToString (), "#1");
1112                         d = (List<KeyValuePair<string,string>>) ds.ReadObject (XmlReader.Create (new StringReader (xml)));
1113                         //Console.WriteLine ("{0}: {1}", d.Count, d ["foo"]);
1114                         Console.WriteLine ("{0}: {1}", d.Count, d [0].Value);
1115                         Assert.AreEqual (1, d.Count, "#2");
1116                         Assert.AreEqual ("bar", d [0].Value);
1117                 }
1118
1119                 [Test]
1120                 public void GenericListOfDictionaryEntrySerialization ()
1121                 {
1122                         string xml = @"<?xml version='1.0' encoding='utf-16'?><ArrayOfDictionaryEntry xmlns:i='http://www.w3.org/2001/XMLSchema-instance' xmlns='http://schemas.datacontract.org/2004/07/System.Collections'><DictionaryEntry><_key xmlns:d3p1='http://www.w3.org/2001/XMLSchema' i:type='d3p1:string'>foo</_key><_value xmlns:d3p1='http://www.w3.org/2001/XMLSchema' i:type='d3p1:string'>bar</_value></DictionaryEntry></ArrayOfDictionaryEntry>".Replace ('\'', '"');
1123
1124                         var ds = new DataContractSerializer (typeof (List<DictionaryEntry>));
1125                         var d = new List<DictionaryEntry> ();
1126                         d.Add (new DictionaryEntry ("foo", "bar"));
1127                         var sw = new StringWriter ();
1128                         using (var xw = XmlWriter.Create (sw))
1129                                 ds.WriteObject (xw, d);
1130                         Assert.AreEqual (xml, sw.ToString (), "#1");
1131                         Assert.IsTrue (sw.ToString ().IndexOf ("i:type") >= 0);
1132                         d = (List<DictionaryEntry>) ds.ReadObject (XmlReader.Create (new StringReader (xml)));
1133                         Assert.AreEqual (1, d.Count, "#2");
1134                         Assert.AreEqual ("bar", d [0].Value);
1135                 }
1136
1137                 private T Deserialize<T> (string xml)
1138                 {
1139                         return Deserialize<T> (xml, typeof (T));
1140                 }
1141
1142                 private T Deserialize<T> (string xml, Type runtimeType)
1143                 {
1144                         DataContractSerializer ser = new DataContractSerializer (typeof (T));
1145                         XmlReader xr = XmlReader.Create (new StringReader (xml), new XmlReaderSettings ());
1146                         object o = ser.ReadObject (xr);
1147                         Assert.AreEqual (runtimeType, o.GetType (), "#DS0");
1148                         return (T)o;
1149                 }
1150         }
1151
1152         public enum Colors {
1153                 Red, Green, Blue
1154         }
1155
1156         [DataContract (Name = "_ColorsWithDC")]
1157         public enum ColorsWithDC {
1158
1159                 [EnumMember (Value = "_Red")]
1160                 Red,
1161                 [EnumMember]
1162                 Green,
1163                 Blue
1164         }
1165
1166
1167         public enum ColorsEnumMemberNoDC {
1168                 [EnumMember (Value = "_Red")]
1169                 Red,
1170                 [EnumMember]
1171                 Green,
1172                 Blue
1173         }
1174
1175         [DataContract]
1176         public class DCWithEnum {
1177                 [DataMember (Name = "_colors")]
1178                 public Colors colors;
1179         }
1180
1181         [DataContract]
1182         public class DCWithTwoEnums {
1183                 [DataMember]
1184                 public Colors colors;
1185                 [DataMember]
1186                 public Colors colors2;
1187         }
1188
1189         [DataContract]
1190         public class DCWithNullableEnum {
1191                 [DataMember]
1192                 public Colors? colors;
1193         }
1194
1195
1196         [DataContract (Namespace = "Base")]
1197         public class BaseDC {
1198                 [DataMember]
1199                 public int baseVal;
1200         }
1201
1202         [DataContract (Namespace = "Derived")]
1203         public class DerivedDC : BaseDC {
1204                 [DataMember]
1205                 public int derivedVal;
1206         }
1207
1208         [DataContract]
1209         public class NestedDC {
1210                 public NestedDC (string name) { this.Name = name; }
1211
1212                 [DataMember]
1213                 public string Name;
1214         }
1215
1216         [DataContract]
1217         public class NestingDC {
1218                 [DataMember]
1219                 public NestedDC Field1;
1220                 [DataMember]
1221                 public NestedDC Field2;
1222         }
1223
1224         [DataContract (Namespace = "test1")]
1225         public class NestedDC2 {
1226                 public NestedDC2 (string name) { this.Name = name; }
1227
1228                 [DataMember]
1229                 public string Name;
1230         }
1231
1232         [DataContract (Namespace = "test2")]
1233         public class NestingDC2 {
1234                 [DataMember]
1235                 public NestedDC2 Field;
1236         }
1237
1238         [DataContract]
1239         public class DCEmpty
1240         {
1241                 // serializer doesn't touch it.
1242                 public string Foo = "TEST";
1243         }
1244
1245         [DataContract]
1246         public class DCSimple1
1247         {
1248                 [DataMember]
1249                 public string Foo = "TEST";
1250         }
1251
1252         [DataContract]
1253         public class DCHasNonDC
1254         {
1255                 [DataMember]
1256                 public NonDC Hoge= new NonDC ();
1257         }
1258
1259         public class NonDC
1260         {
1261                 public string Whee = "whee!";
1262         }
1263
1264         [DataContract]
1265         public class DCHasSerializable
1266         {
1267                 [DataMember]
1268                 public SimpleSer1 Ser = new SimpleSer1 ();
1269         }
1270
1271         [DataContract (Name = "Foo")]
1272         public class DCWithName
1273         {
1274                 [DataMember (Name = "FooMember")]
1275                 public string DMWithName = "value";
1276         }
1277
1278         [DataContract (Name = "")]
1279         public class DCWithEmptyName
1280         {
1281         }
1282
1283         [DataContract (Name = null)]
1284         public class DCWithNullName
1285         {
1286         }
1287
1288         [DataContract (Namespace = "")]
1289         public class DCWithEmptyNamespace
1290         {
1291         }
1292
1293         [Serializable]
1294         public class SimpleSer1
1295         {
1296                 public string Doh = "doh!";
1297                 [NonSerialized]
1298                 public string Bah = "bah!";
1299         }
1300
1301         public class Wrapper
1302         {
1303                 [DataContract]
1304                 public class DCWrapped
1305                 {
1306                 }
1307         }
1308
1309         [DataContract]
1310         public class CollectionContainer
1311         {
1312                 Collection<string> items = new Collection<string> ();
1313
1314                 [DataMember]
1315                 public Collection<string> Items {
1316                         get { return items; }
1317                 }
1318         }
1319
1320         [CollectionDataContract]
1321         public class DataCollection<T> : Collection<T>
1322         {
1323         }
1324
1325         [DataContract]
1326         public class DataCollectionContainer
1327         {
1328                 DataCollection<string> items = new DataCollection<string> ();
1329
1330                 [DataMember]
1331                 public DataCollection<string> Items {
1332                         get { return items; }
1333                 }
1334         }
1335
1336         [DataContract]
1337         class SerializeNonDCArrayType
1338         {
1339                 [DataMember]
1340                 public IPAddress [] IPAddresses = new IPAddress [0];
1341         }
1342
1343         [DataContract]
1344         public class VerifyObjectNameTestData
1345         {
1346                 [DataMember]
1347                 string Member1 = "foo";
1348
1349                 public string GetMember() { return Member1; }
1350         }
1351
1352         [XmlRoot(ElementName = "simple", Namespace = "")]
1353         public class SimpleXml : IXmlSerializable
1354         {
1355                 void IXmlSerializable.ReadXml (XmlReader reader)
1356                 {
1357                 }
1358
1359                 void IXmlSerializable.WriteXml (XmlWriter writer)
1360                 {
1361                 }
1362
1363                 XmlSchema IXmlSerializable.GetSchema ()
1364                 {
1365                         return null;
1366                 }
1367
1368         }
1369
1370         [DataContract]
1371         public class ReferenceWrapper
1372         {
1373                 [DataMember (Order = 1)]
1374                 public ReferenceType T;
1375
1376                 [DataMember (Order = 2)]
1377                 public ReferenceType T2;
1378         }
1379
1380         [DataContract (IsReference = true)]
1381         public class ReferenceType
1382         {
1383                 [DataMember]
1384                 public string F = "x";
1385         }
1386
1387         public class MyList : IList<string>
1388         {
1389                 List<string> l = new List<string> ();
1390                 public void Clear () { l.Clear (); }
1391                 public void Add(string s) { l.Add (s);}
1392                 public void Insert(int idx, string s) { l.Insert(idx,s);}
1393                 public bool Contains(string s) { return l.Contains(s); }
1394                 public IEnumerator<string> GetEnumerator () { return l.GetEnumerator (); }
1395                 IEnumerator IEnumerable.GetEnumerator () { return l.GetEnumerator (); }
1396                 public bool Remove(string s) { return l.Remove(s); }
1397                 public void RemoveAt(int i) { l.RemoveAt (i);}
1398                 public void CopyTo (string [] arr, int index) { l.CopyTo (arr, index);}
1399                 public int IndexOf (string s) { return l.IndexOf (s); }
1400
1401                 public int Count { get { return l.Count; } }
1402                 public bool IsReadOnly { get { return ((IList<string>) l).IsReadOnly; } }
1403                 public string this [int index] { get { return l [index]; } set { l [index] = value; } }
1404         }
1405
1406 }
1407
1408 [DataContract]
1409 class GlobalSample1
1410 {
1411 }
1412
1413 [DataContract]
1414 class Foo<X,Y,Z>
1415 {
1416         [DataMember]
1417         public X Field;
1418 }