[S.R.Serialization] fix default value comparison.

[mono-project.git] / mcs / class / System.ServiceModel.Web / Test / System.Runtime.Serialization.Json / DataContractJsonSerializerTest.cs

//
// DataContractJsonSerializerTest.cs
//
// Author:
//      Atsushi Enomoto <atsushi@ximian.com>
//      Ankit Jain <JAnkit@novell.com>
//      Antoine Cailliau <antoinecailliau@gmail.com>
//
// Copyright (C) 2005-2007 Novell, Inc.  http://www.novell.com

//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

//
// This test code contains tests for DataContractJsonSerializer, which is
// imported from DataContractSerializerTest.cs.
//

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Net;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Xml;
using NUnit.Framework;

namespace MonoTests.System.Runtime.Serialization.Json
{
        [TestFixture]
        public class DataContractJsonSerializerTest
        {
                static readonly XmlWriterSettings settings;

                static DataContractJsonSerializerTest ()
                {
                        settings = new XmlWriterSettings ();
                        settings.OmitXmlDeclaration = true;
                }

                [DataContract]
                class Sample1
                {
                        [DataMember]
                        public string Member1;
                }

                [Test]
                [ExpectedException (typeof (ArgumentNullException))]
                public void ConstructorTypeNull ()
                {
                        new DataContractJsonSerializer (null);
                }

                [Test]
                public void ConstructorKnownTypesNull ()
                {
                        // null knownTypes is allowed.
                        new DataContractJsonSerializer (typeof (Sample1), (IEnumerable<Type>) null);
                        new DataContractJsonSerializer (typeof (Sample1), "Foo", null);
                }

                [Test]
                [ExpectedException (typeof (ArgumentNullException))]
                public void ConstructorNameNull ()
                {
                        new DataContractJsonSerializer (typeof (Sample1), (string) null);
                }

                [Test]
                [ExpectedException (typeof (ArgumentOutOfRangeException))]
                public void ConstructorNegativeMaxObjects ()
                {
                        new DataContractJsonSerializer (typeof (Sample1), "Sample1",
                                null, -1, false, null, false);
                }

                [Test]
                public void ConstructorMisc ()
                {
                        new DataContractJsonSerializer (typeof (GlobalSample1)).WriteObject (new MemoryStream (), new GlobalSample1 ());
                }

                [Test]
                public void WriteObjectContent ()
                {
                        StringWriter sw = new StringWriter ();
                        using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
                                DataContractJsonSerializer ser =
                                        new DataContractJsonSerializer (typeof (string));
                                xw.WriteStartElement ("my-element");
                                ser.WriteObjectContent (xw, "TEST STRING");
                                xw.WriteEndElement ();
                        }
                        Assert.AreEqual ("<my-element>TEST STRING</my-element>",
                                sw.ToString ());
                }

                // int

                [Test]
                public void SerializeIntXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeInt (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""number"">1</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeIntJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeInt (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "1",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeInt (XmlWriter writer)
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (int));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, 1);
                        }
                }

                // int, with rootName

                [Test]
                public void SerializeIntXmlWithRootName ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeIntWithRootName (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<myroot type=""number"">1</myroot>",
                                sw.ToString ());
                }

                [Test]
                // since JsonWriter supports only "root" as the root name, using
                // XmlWriter from JsonReaderWriterFactory will always fail with
                // an explicit rootName.
                [ExpectedException (typeof (SerializationException))]
                public void SerializeIntJsonWithRootName ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeIntWithRootName (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "1",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeIntWithRootName (XmlWriter writer)
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (int), "myroot");
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, 1);
                        }
                }

                // pass typeof(DCEmpty), serialize int

                [Test]
                public void SerializeIntForDCEmptyXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeIntForDCEmpty (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""number"">1</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeIntForDCEmptyJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeIntForDCEmpty (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "1",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeIntForDCEmpty (XmlWriter writer)
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (DCEmpty));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, 1);
                        }
                }

                // DCEmpty

                [Test]
                public void SerializeEmptyClassXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeEmptyClass (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""object"" />",
                                sw.ToString ());
                }

                [Test]
                public void SerializeEmptyClassJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeEmptyClass (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "{}",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeEmptyClass (XmlWriter writer)
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (DCEmpty));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new DCEmpty ());
                        }
                }

                // string (primitive)

                [Test]
                public void SerializePrimitiveStringXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializePrimitiveString (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                "<root>TEST</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializePrimitiveStringJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializePrimitiveString (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"""TEST""",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializePrimitiveString (XmlWriter writer)
                {
                        XmlObjectSerializer ser =
                                new DataContractJsonSerializer (typeof (string));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, "TEST");
                        }
                }

                // QName (primitive but ...)

                [Test]
                public void SerializePrimitiveQNameXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializePrimitiveQName (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                "<root>foo:urn:foo</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializePrimitiveQNameJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializePrimitiveQName (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"""foo:urn:foo""",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializePrimitiveQName (XmlWriter writer)
                {
                        XmlObjectSerializer ser =
                                new DataContractJsonSerializer (typeof (XmlQualifiedName));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new XmlQualifiedName ("foo", "urn:foo"));
                        }
                }

                // DBNull (primitive)

                [Test]
                public void SerializeDBNullXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeDBNull (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""object"" />",
                                sw.ToString ());
                }

                [Test]
                public void SerializeDBNullJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeDBNull (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "{}",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeDBNull (XmlWriter writer)
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (DBNull));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, DBNull.Value);
                        }
                }

                // DCSimple1

                [Test]
                public void SerializeSimpleClass1Xml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeSimpleClass1 (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""object""><Foo>TEST</Foo></root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeSimpleClass1Json ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeSimpleClass1 (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"{""Foo"":""TEST""}",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeSimpleClass1 (XmlWriter writer)
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (DCSimple1));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new DCSimple1 ());
                        }
                }

                // NonDC

                [Test]
                // NonDC is not a DataContract type.
                public void SerializeNonDCOnlyCtor ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (NonDC));
                }

                [Test]
                //[ExpectedException (typeof (InvalidDataContractException))]
                // NonDC is not a DataContract type.
                // UPDATE: non-DataContract types are became valid in RTM.
                public void SerializeNonDC ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (NonDC));
                        using (XmlWriter w = XmlWriter.Create (TextWriter.Null, settings)) {
                                ser.WriteObject (w, new NonDC ());
                        }
                }

                // DCHasNonDC

                [Test]
                //[ExpectedException (typeof (InvalidDataContractException))]
                // DCHasNonDC itself is a DataContract type whose field is
                // marked as DataMember but its type is not DataContract.
                // UPDATE: non-DataContract types are became valid in RTM.
                public void SerializeDCHasNonDC ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCHasNonDC));
                        using (XmlWriter w = XmlWriter.Create (TextWriter.Null, settings)) {
                                ser.WriteObject (w, new DCHasNonDC ());
                        }
                }

                // DCHasSerializable

                [Test]
                public void SerializeSimpleSerializable1Xml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeSimpleSerializable1 (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""object""><Ser type=""object""><Doh>doh!</Doh></Ser></root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeSimpleSerializable1Json ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeSimpleSerializable1 (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"{""Ser"":{""Doh"":""doh!""}}",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                // DCHasSerializable itself is DataContract and has a field
                // whose type is not contract but serializable.
                void SerializeSimpleSerializable1 (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCHasSerializable));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new DCHasSerializable ());
                        }
                }

                [Test]
                public void SerializeDCWithNameXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeDCWithName (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""object""><FooMember>value</FooMember></root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeDCWithNameJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeDCWithName (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"{""FooMember"":""value""}",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeDCWithName (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCWithName));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new DCWithName ());
                        }
                }

                [Test]
                public void SerializeDCWithEmptyName1 ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCWithEmptyName));
                        StringWriter sw = new StringWriter ();
                        DCWithEmptyName dc = new DCWithEmptyName ();
                        using (XmlWriter w = XmlWriter.Create (sw, settings)) {
                                try {
                                        ser.WriteObject (w, dc);
                                } catch (InvalidDataContractException) {
                                        return;
                                }
                        }
                        Assert.Fail ("Expected InvalidDataContractException");
                }

                [Test]
                public void SerializeDCWithEmptyName2 ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCWithName));
                        StringWriter sw = new StringWriter ();

                        /* DataContractAttribute.Name == "", not valid */
                        DCWithEmptyName dc = new DCWithEmptyName ();
                        using (XmlWriter w = XmlWriter.Create (sw, settings)) {
                                try {
                                        ser.WriteObject (w, dc);
                                } catch (InvalidDataContractException) {
                                        return;
                                }
                        }
                        Assert.Fail ("Expected InvalidDataContractException");
                }

                [Test]
                [Category("NotWorking")]
                public void SerializeDCWithNullName ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCWithNullName));
                        StringWriter sw = new StringWriter ();
                        using (XmlWriter w = XmlWriter.Create (sw, settings)) {
                                try {
                                        /* DataContractAttribute.Name == "", not valid */
                                        ser.WriteObject (w, new DCWithNullName ());
                                } catch (InvalidDataContractException) {
                                        return;
                                }
                        }
                        Assert.Fail ("Expected InvalidDataContractException");
                }

                [Test]
                public void SerializeDCWithEmptyNamespace1 ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCWithEmptyNamespace));
                        StringWriter sw = new StringWriter ();
                        using (XmlWriter w = XmlWriter.Create (sw, settings)) {
                                ser.WriteObject (w, new DCWithEmptyNamespace ());
                        }
                }

                [Test]
                public void SerializeWrappedClassXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeWrappedClass (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""object"" />",
                                sw.ToString ());
                }

                [Test]
                public void SerializeWrappedClassJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeWrappedClass (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "{}",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeWrappedClass (XmlWriter writer)
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (Wrapper.DCWrapped));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new Wrapper.DCWrapped ());
                        }
                }

                // CollectionContainer : Items must have a setter. (but became valid in RTM).
                [Test]
                public void SerializeReadOnlyCollectionMember ()
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (CollectionContainer));
                        StringWriter sw = new StringWriter ();
                        using (XmlWriter w = XmlWriter.Create (sw, settings)) {
                                ser.WriteObject (w, null);
                        }
                }

                // DataCollectionContainer : Items must have a setter. (but became valid in RTM).
                [Test]
                public void SerializeReadOnlyDataCollectionMember ()
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (DataCollectionContainer));
                        StringWriter sw = new StringWriter ();
                        using (XmlWriter w = XmlWriter.Create (sw, settings)) {
                                ser.WriteObject (w, null);
                        }
                }

                [Test]
                [Ignore ("https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=409970")]
                [ExpectedException (typeof (SerializationException))]
                public void DeserializeReadOnlyDataCollection_NullCollection ()
                {
                        DataContractJsonSerializer ser =
                                new DataContractJsonSerializer (typeof (CollectionContainer));
                        StringWriter sw = new StringWriter ();
                        var c = new CollectionContainer ();
                        c.Items.Add ("foo");
                        c.Items.Add ("bar");
                        using (XmlWriter w = XmlWriter.Create (sw, settings))
                                ser.WriteObject (w, c);
                        // CollectionContainer.Items is null, so it cannot deserialize non-null collection.
                        using (XmlReader r = XmlReader.Create (new StringReader (sw.ToString ())))
                                c = (CollectionContainer) ser.ReadObject (r);
                }

                [Test]
                public void SerializeGuidXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeGuid (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root>00000000-0000-0000-0000-000000000000</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeGuidJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeGuid (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"""00000000-0000-0000-0000-000000000000""",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeGuid (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (Guid));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, Guid.Empty);
                        }
                }

                [Test]
                public void SerializeEnumXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeEnum (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""number"">0</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeEnumJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeEnum (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "0",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeEnum (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (Colors));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new Colors ());
                        }
                }

                [Test]
                public void SerializeEnum2Xml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeEnum2 (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""number"">0</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeEnum2Json ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeEnum2 (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "0",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeEnum2 (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (Colors));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, 0);
                        }
                }

                [Test] // so, DataContract does not affect here.
                public void SerializeEnumWithDCXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeEnumWithDC (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""number"">0</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeEnumWithDCJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeEnumWithDC (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "0",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeEnumWithDC (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (ColorsWithDC));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new ColorsWithDC ());
                        }
                }

                [Test]
                public void SerializeEnumWithNoDCXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeEnumWithNoDC (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""number"">0</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeEnumWithNoDCJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeEnumWithNoDC (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "0",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeEnumWithNoDC (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (ColorsEnumMemberNoDC));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new ColorsEnumMemberNoDC ());
                        }
                }

                [Test]
                public void SerializeEnumWithDC2Xml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeEnumWithDC2 (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""number"">3</root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeEnumWithDC2Json ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeEnumWithDC2 (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                "3",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeEnumWithDC2 (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (ColorsWithDC));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, 3);
                        }
                }

/*
                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void SerializeEnumWithDCInvalid ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (ColorsWithDC));
                        StringWriter sw = new StringWriter ();
                        ColorsWithDC cdc = ColorsWithDC.Blue;
                        using (XmlWriter w = XmlWriter.Create (sw, settings)) {
                                ser.WriteObject (w, cdc);
                        }
                }
*/

                [Test]
                public void SerializeDCWithEnumXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializeDCWithEnum (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""object""><_colors type=""number"">0</_colors></root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeDCWithEnumJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializeDCWithEnum (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"{""_colors"":0}",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializeDCWithEnum (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCWithEnum));
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, new DCWithEnum ());
                        }
                }

                [Test]
                public void SerializerDCArrayXml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializerDCArray (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""array""><item type=""object""><_colors type=""number"">0</_colors></item><item type=""object""><_colors type=""number"">1</_colors></item></root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializerDCArrayJson ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializerDCArray (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"[{""_colors"":0},{""_colors"":1}]",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializerDCArray (XmlWriter writer)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (DCWithEnum []));
                        DCWithEnum [] arr = new DCWithEnum [2];
                        arr [0] = new DCWithEnum (); arr [0].colors = Colors.Red;
                        arr [1] = new DCWithEnum (); arr [1].colors = Colors.Green;
                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, arr);
                        }
                }

                [Test]
                public void SerializerDCArray2Xml ()
                {
                        StringWriter sw = new StringWriter ();
                        SerializerDCArray2 (XmlWriter.Create (sw, settings));
                        Assert.AreEqual (
                                @"<root type=""array""><item __type=""DCWithEnum:#MonoTests.System.Runtime.Serialization.Json"" type=""object""><_colors type=""number"">0</_colors></item><item __type=""DCSimple1:#MonoTests.System.Runtime.Serialization.Json"" type=""object""><Foo>hello</Foo></item></root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializerDCArray2Json ()
                {
                        MemoryStream ms = new MemoryStream ();
                        SerializerDCArray2 (JsonReaderWriterFactory.CreateJsonWriter (ms));
                        Assert.AreEqual (
                                @"[{""__type"":""DCWithEnum:#MonoTests.System.Runtime.Serialization.Json"",""_colors"":0},{""__type"":""DCSimple1:#MonoTests.System.Runtime.Serialization.Json"",""Foo"":""hello""}]",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                void SerializerDCArray2 (XmlWriter writer)
                {
                        List<Type> known = new List<Type> ();
                        known.Add (typeof (DCWithEnum));
                        known.Add (typeof (DCSimple1));
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (object []), known);
                        object [] arr = new object [2];
                        arr [0] = new DCWithEnum (); ((DCWithEnum)arr [0]).colors = Colors.Red;
                        arr [1] = new DCSimple1 (); ((DCSimple1) arr [1]).Foo = "hello";

                        using (XmlWriter w = writer) {
                                ser.WriteObject (w, arr);
                        }
                }

                [Test]
                public void SerializerDCArray3Xml ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (int []));
                        StringWriter sw = new StringWriter ();
                        int [] arr = new int [2];
                        arr [0] = 1; arr [1] = 2;

                        using (XmlWriter w = XmlWriter.Create (sw, settings)) {
                                ser.WriteObject (w, arr);
                        }

                        Assert.AreEqual (
                                @"<root type=""array""><item type=""number"">1</item><item type=""number"">2</item></root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializerDCArray3Json ()
                {
                        MemoryStream ms = new MemoryStream ();
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (int []));
                        int [] arr = new int [2];
                        arr [0] = 1; arr [1] = 2;

                        using (XmlWriter w = JsonReaderWriterFactory.CreateJsonWriter (ms)) {
                                ser.WriteObject (w, arr);
                        }

                        Assert.AreEqual (
                                @"[1,2]",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                [Test]
                // ... so, non-JSON XmlWriter is still accepted.
                public void SerializeNonDCArrayXml ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (SerializeNonDCArrayType));
                        StringWriter sw = new StringWriter ();
                        using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
                                ser.WriteObject (xw, new SerializeNonDCArrayType ());
                        }
                        Assert.AreEqual (@"<root type=""object""><IPAddresses type=""array"" /></root>",
                                sw.ToString ());
                }

                [Test]
                public void SerializeNonDCArrayJson ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (SerializeNonDCArrayType));
                        MemoryStream ms = new MemoryStream ();
                        using (XmlWriter xw = JsonReaderWriterFactory.CreateJsonWriter (ms)) {
                                ser.WriteObject (xw, new SerializeNonDCArrayType ());
                        }
                        Assert.AreEqual (@"{""IPAddresses"":[]}",
                                Encoding.UTF8.GetString (ms.ToArray ()));
                }

                [Test]
                public void SerializeNonDCArrayItems ()
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (typeof (SerializeNonDCArrayType));
                        StringWriter sw = new StringWriter ();
                        using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
                                SerializeNonDCArrayType obj = new SerializeNonDCArrayType ();
                                obj.IPAddresses = new NonDCItem [] {new NonDCItem () { Data = new byte [] {1, 2, 3, 4} } };
                                ser.WriteObject (xw, obj);
                        }

                        XmlDocument doc = new XmlDocument ();
                        doc.LoadXml (sw.ToString ());
                        XmlNamespaceManager nsmgr = new XmlNamespaceManager (doc.NameTable);
                        nsmgr.AddNamespace ("s", "http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization");
                        nsmgr.AddNamespace ("n", "http://schemas.datacontract.org/2004/07/System.Net");
                        nsmgr.AddNamespace ("a", "http://schemas.microsoft.com/2003/10/Serialization/Arrays");

                        Assert.AreEqual (1, doc.SelectNodes ("/root/IPAddresses/item", nsmgr).Count, "#1");
                        XmlElement el = doc.SelectSingleNode ("/root/IPAddresses/item/Data", nsmgr) as XmlElement;
                        Assert.IsNotNull (el, "#3");
                        Assert.AreEqual (4, el.SelectNodes ("item", nsmgr).Count, "#4");
                }

                [Test]
                public void MaxItemsInObjectGraph1 ()
                {
                        // object count == maximum
                        DataContractJsonSerializer s = new DataContractJsonSerializer (typeof (DCEmpty), null, 1, false, null, false);
                        s.WriteObject (XmlWriter.Create (TextWriter.Null), new DCEmpty ());
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void MaxItemsInObjectGraph2 ()
                {
                        // object count > maximum
                        DataContractJsonSerializer s = new DataContractJsonSerializer (typeof (DCSimple1), null, 1, false, null, false);
                        s.WriteObject (XmlWriter.Create (TextWriter.Null), new DCSimple1 ());
                }

                [Test]
                public void DeserializeString ()
                {
                        Assert.AreEqual ("ABC", Deserialize ("\"ABC\"", typeof (string)));
                }

                [Test]
                public void DeserializeInt ()
                {
                        Assert.AreEqual (5, Deserialize ("5", typeof (int)));
                }

                [Test]
                public void DeserializeArray ()
                {
                        int [] ret = (int []) Deserialize ("[5,6,7]", typeof (int []));
                        Assert.AreEqual (5, ret [0], "#1");
                        Assert.AreEqual (6, ret [1], "#2");
                        Assert.AreEqual (7, ret [2], "#3");
                }

                [Test]
                public void DeserializeArrayUntyped ()
                {
                        object [] ret = (object []) Deserialize ("[5,6,7]", typeof (object []));
                        Assert.AreEqual (5, ret [0], "#1");
                        Assert.AreEqual (6, ret [1], "#2");
                        Assert.AreEqual (7, ret [2], "#3");
                }

                [Test]
                public void DeserializeMixedArray ()
                {
                        object [] ret = (object []) Deserialize ("[5,\"6\",false]", typeof (object []));
                        Assert.AreEqual (5, ret [0], "#1");
                        Assert.AreEqual ("6", ret [1], "#2");
                        Assert.AreEqual (false, ret [2], "#3");
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void DeserializeEmptyAsString ()
                {
                        // it somehow expects "root" which should have been already consumed.
                        Deserialize ("", typeof (string));
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void DeserializeEmptyAsInt ()
                {
                        // it somehow expects "root" which should have been already consumed.
                        Deserialize ("", typeof (int));
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void DeserializeEmptyAsDBNull ()
                {
                        // it somehow expects "root" which should have been already consumed.
                        Deserialize ("", typeof (DBNull));
                }

                [Test]
                public void DeserializeEmptyObjectAsString ()
                {
                        // looks like it is converted to ""
                        Assert.AreEqual (String.Empty, Deserialize ("{}", typeof (string)));
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void DeserializeEmptyObjectAsInt ()
                {
                        Deserialize ("{}", typeof (int));
                }

                [Test]
                public void DeserializeEmptyObjectAsDBNull ()
                {
                        Assert.AreEqual (DBNull.Value, Deserialize ("{}", typeof (DBNull)));
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void DeserializeEnumByName ()
                {
                        // enum is parsed into long
                        Deserialize (@"""Red""", typeof (Colors));
                }

                [Test]
                public void DeserializeEnum2 ()
                {
                        object o = Deserialize ("0", typeof (Colors));

                        Assert.AreEqual (typeof (Colors), o.GetType (), "#de3");
                        Colors c = (Colors) o;
                        Assert.AreEqual (Colors.Red, c, "#de4");
                }
                
                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void DeserializeEnumInvalid ()
                {
                        Deserialize ("", typeof (Colors));
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                [Ignore ("NotDotNet")] // 0.0 is an invalid Colors value.
                public void DeserializeEnumInvalid3 ()
                {
                        //"0.0" instead of "0"
                        Deserialize (
                                "0.0",
                                typeof (Colors));
                }

                [Test]
                public void DeserializeEnumWithDC ()
                {
                        object o = Deserialize ("0", typeof (ColorsWithDC));
                        
                        Assert.AreEqual (typeof (ColorsWithDC), o.GetType (), "#de5");
                        ColorsWithDC cdc = (ColorsWithDC) o;
                        Assert.AreEqual (ColorsWithDC.Red, o, "#de6");
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                [Ignore ("NotDotNet")] // 4 is an invalid Colors value.
                [Category ("NotWorking")]
                public void DeserializeEnumWithDCInvalid ()
                {
                        Deserialize (
                                "4",
                                typeof (ColorsWithDC));
                }

                [Test]
                public void DeserializeDCWithEnum ()
                {
                        object o = Deserialize (
                                "{\"_colors\":0}",
                                typeof (DCWithEnum));

                        Assert.AreEqual (typeof (DCWithEnum), o.GetType (), "#de7");
                        DCWithEnum dc = (DCWithEnum) o;
                        Assert.AreEqual (Colors.Red, dc.colors, "#de8");
                }

                [Test]
                public void ReadObjectVerifyObjectNameFalse ()
                {
                        string xml = @"<any><Member1>bar</Member1></any>";
                        object o = new DataContractJsonSerializer (typeof (VerifyObjectNameTestData))
                                .ReadObject (XmlReader.Create (new StringReader (xml)), false);
                        Assert.IsTrue (o is VerifyObjectNameTestData, "#1");

                        string xml2 = @"<any><x:Member1 xmlns:x=""http://schemas.datacontract.org/2004/07/MonoTests.System.Runtime.Serialization"">bar</x:Member1></any>";
                        o = new DataContractJsonSerializer (typeof (VerifyObjectNameTestData))
                                .ReadObject (XmlReader.Create (new StringReader (xml2)), false);
                        Assert.IsTrue (o is VerifyObjectNameTestData, "#2");
                }

                [Test]
                [ExpectedException (typeof (SerializationException))]
                public void ReadObjectVerifyObjectNameTrue ()
                {
                        string xml = @"<any><Member1>bar</Member1></any>";
                        new DataContractJsonSerializer (typeof (VerifyObjectNameTestData))
                                .ReadObject (XmlReader.Create (new StringReader (xml)), true);
                }

                [Test] // member name is out of scope
                public void ReadObjectVerifyObjectNameTrue2 ()
                {
                        string xml = @"<root><Member2>bar</Member2></root>";
                        new DataContractJsonSerializer (typeof (VerifyObjectNameTestData))
                                .ReadObject (XmlReader.Create (new StringReader (xml)), true);
                }

                [Test]
                public void ReadTypedObjectJson ()
                {
                        object o = Deserialize (@"{""__type"":""DCWithEnum:#MonoTests.System.Runtime.Serialization.Json"",""_colors"":0}", typeof (DCWithEnum));
                        Assert.AreEqual (typeof (DCWithEnum), o.GetType ());
                }

                [Test]
                public void ReadObjectDCArrayJson ()
                {
                        object o = Deserialize (@"[{""__type"":""DCWithEnum:#MonoTests.System.Runtime.Serialization.Json"",""_colors"":0}]",
                                typeof (object []), typeof (DCWithEnum));
                        Assert.AreEqual (typeof (object []), o.GetType (), "#1");
                        object [] arr = (object []) o;
                        Assert.AreEqual (typeof (DCWithEnum), arr [0].GetType (), "#2");
                }

                [Test]
                public void ReadObjectDCArray2Json ()
                {
                        object o = Deserialize (@"[{""__type"":""DCWithEnum:#MonoTests.System.Runtime.Serialization.Json"",""_colors"":0},{""__type"":""DCSimple1:#MonoTests.System.Runtime.Serialization.Json"",""Foo"":""hello""}]",
                                typeof (object []), typeof (DCWithEnum), typeof (DCSimple1));
                        Assert.AreEqual (typeof (object []), o.GetType (), "#1");
                        object [] arr = (object []) o;
                        Assert.AreEqual (typeof (DCWithEnum), arr [0].GetType (), "#2");
                        Assert.AreEqual (typeof (DCSimple1), arr [1].GetType (), "#3");
                }

                private object Deserialize (string xml, Type type, params Type [] knownTypes)
                {
                        DataContractJsonSerializer ser = new DataContractJsonSerializer (type, knownTypes);
                        XmlReader xr = JsonReaderWriterFactory.CreateJsonReader (Encoding.UTF8.GetBytes (xml), new XmlDictionaryReaderQuotas ());
                        return ser.ReadObject (xr);
                }

                public T Deserialize<T>(string json)
                {
                        var bytes = Encoding.Unicode.GetBytes (json);
                        using (MemoryStream stream = new MemoryStream (bytes)) {
                                var serializer = new DataContractJsonSerializer (typeof(T));
                                return (T)serializer.ReadObject (stream);       
                        }
                }

                [Test]
                public void IsStartObject ()
                {
                        DataContractJsonSerializer s = new DataContractJsonSerializer (typeof (DCSimple1));
                        Assert.IsTrue (s.IsStartObject (XmlReader.Create (new StringReader ("<root></root>"))), "#1");
                        Assert.IsFalse (s.IsStartObject (XmlReader.Create (new StringReader ("<dummy></dummy>"))), "#2");
                        Assert.IsFalse (s.IsStartObject (XmlReader.Create (new StringReader ("<Foo></Foo>"))), "#3");
                        Assert.IsFalse (s.IsStartObject (XmlReader.Create (new StringReader ("<root xmlns='urn:foo'></root>"))), "#4");
                }

                [Test]
                public void SerializeNonDC2 ()
                {
                        var ser = new DataContractJsonSerializer (typeof (TestData));
                        StringWriter sw = new StringWriter ();
                        var obj = new TestData () { Foo = "foo", Bar = "bar", Baz = "baz" };

                        // XML
                        using (var xw = XmlWriter.Create (sw))
                                ser.WriteObject (xw, obj);
                        var s = sw.ToString ();
                        // since the order is not preserved, we compare only contents.
                        Assert.IsTrue (s.IndexOf ("<Foo>foo</Foo>") > 0, "#1-1");
                        Assert.IsTrue (s.IndexOf ("<Bar>bar</Bar>") > 0, "#1-2");
                        Assert.IsFalse (s.IndexOf ("<Baz>baz</Baz>") > 0, "#1-3");

                        // JSON
                        MemoryStream ms = new MemoryStream ();
                        using (var xw = JsonReaderWriterFactory.CreateJsonWriter (ms))
                                ser.WriteObject (ms, obj);
                        s = new StreamReader (new MemoryStream (ms.ToArray ())).ReadToEnd ().Replace ('"', '/');
                        // since the order is not preserved, we compare only contents.
                        Assert.IsTrue (s.IndexOf ("/Foo/:/foo/") > 0, "#2-1");
                        Assert.IsTrue (s.IndexOf ("/Bar/:/bar/") > 0, "#2-2");
                        Assert.IsFalse (s.IndexOf ("/Baz/:/baz/") > 0, "#2-3");
                }

                [Test]
                public void AlwaysEmitTypeInformation ()
                {
                        var ms = new MemoryStream ();
                        var ds = new DataContractJsonSerializer (typeof (string), "root", null, 10, false, null, true);
                        ds.WriteObject (ms, "foobar");
                        var s = Encoding.UTF8.GetString (ms.ToArray ());
                        Assert.AreEqual ("\"foobar\"", s, "#1");
                }

                [Test]
                public void AlwaysEmitTypeInformation2 ()
                {
                        var ms = new MemoryStream ();
                        var ds = new DataContractJsonSerializer (typeof (TestData), "root", null, 10, false, null, true);
                        ds.WriteObject (ms, new TestData () { Foo = "foo"});
                        var s = Encoding.UTF8.GetString (ms.ToArray ());
                        Assert.AreEqual (@"{""__type"":""TestData:#MonoTests.System.Runtime.Serialization.Json"",""Bar"":null,""Foo"":""foo""}", s, "#1");
                }

                [Test]
                public void AlwaysEmitTypeInformation3 ()
                {
                        var ms = new MemoryStream ();
                        var ds = new DataContractJsonSerializer (typeof (TestData), "root", null, 10, false, null, false);
                        ds.WriteObject (ms, new TestData () { Foo = "foo"});
                        var s = Encoding.UTF8.GetString (ms.ToArray ());
                        Assert.AreEqual (@"{""Bar"":null,""Foo"":""foo""}", s, "#1");
                }

                [Test]
                public void TestNonpublicDeserialization ()
                {
                        string s1= @"{""Bar"":""bar"", ""Foo"":""foo"", ""Baz"":""baz""}";
                        TestData o1 = ((TestData)(new DataContractJsonSerializer (typeof (TestData)).ReadObject (JsonReaderWriterFactory.CreateJsonReader (Encoding.UTF8.GetBytes (s1), new XmlDictionaryReaderQuotas ()))));

                        Assert.AreEqual (null, o1.Baz, "#1");

                        string s2 = @"{""TestData"":[{""key"":""key1"",""value"":""value1""}]}";
                        KeyValueTestData o2 = ((KeyValueTestData)(new DataContractJsonSerializer (typeof (KeyValueTestData)).ReadObject (JsonReaderWriterFactory.CreateJsonReader (Encoding.UTF8.GetBytes (s2), new XmlDictionaryReaderQuotas ()))));

                        Assert.AreEqual (1, o2.TestData.Count, "#2");
                        Assert.AreEqual ("key1", o2.TestData[0].Key, "#3");
                        Assert.AreEqual ("value1", o2.TestData[0].Value, "#4");
                }

                // [Test] use this case if you want to check lame silverlight parser behavior. Seealso #549756
                public void QuotelessDeserialization ()
                {
                        string s1 = @"{FooMember:""value""}";
                        var ds = new DataContractJsonSerializer (typeof (DCWithName));
                        ds.ReadObject (new MemoryStream (Encoding.UTF8.GetBytes (s1)));

                        string s2 = @"{FooMember:"" \""{dummy:string}\""""}";
                        ds.ReadObject (new MemoryStream (Encoding.UTF8.GetBytes (s2)));
                }

                [Test]
                [Category ("NotWorking")]
                public void TypeIsNotPartsOfKnownTypes ()
                {
                        var dcs = new DataContractSerializer (typeof (string));
                        Assert.AreEqual (0, dcs.KnownTypes.Count, "KnownTypes #1");
                        var dcjs = new DataContractJsonSerializer (typeof (string));
                        Assert.AreEqual (0, dcjs.KnownTypes.Count, "KnownTypes #2");
                }

                [Test]
                public void ReadWriteNullObject ()
                {
                        DataContractJsonSerializer dcjs = new DataContractJsonSerializer (typeof (string));
                        using (MemoryStream ms = new MemoryStream ()) {
                                dcjs.WriteObject (ms, null);
                                ms.Position = 0;
                                using (StreamReader sr = new StreamReader (ms)) {
                                        string data = sr.ReadToEnd ();
                                        Assert.AreEqual ("null", data, "WriteObject(stream,null)");

                                        ms.Position = 0;
                                        Assert.IsNull (dcjs.ReadObject (ms), "ReadObject(stream)");
                                }
                        };
                }

                object ReadWriteObject (Type type, object obj, string expected)
                {
                        using (MemoryStream ms = new MemoryStream ()) {
                                DataContractJsonSerializer dcjs = new DataContractJsonSerializer (type);
                                dcjs.WriteObject (ms, obj);
                                ms.Position = 0;
                                using (StreamReader sr = new StreamReader (ms)) {
                                        Assert.AreEqual (expected, sr.ReadToEnd (), "WriteObject");

                                        ms.Position = 0;
                                        return dcjs.ReadObject (ms);
                                }
                        }
                }

                [Test]
                [Ignore ("Wrong test case. See bug #573691")]
                public void ReadWriteObject_Single_SpecialCases ()
                {
                        Assert.IsTrue (Single.IsNaN ((float) ReadWriteObject (typeof (float), Single.NaN, "NaN")));
                        Assert.IsTrue (Single.IsNegativeInfinity ((float) ReadWriteObject (typeof (float), Single.NegativeInfinity, "-INF")));
                        Assert.IsTrue (Single.IsPositiveInfinity ((float) ReadWriteObject (typeof (float), Single.PositiveInfinity, "INF")));
                }

                [Test]
                [Ignore ("Wrong test case. See bug #573691")]
                public void ReadWriteObject_Double_SpecialCases ()
                {
                        Assert.IsTrue (Double.IsNaN ((double) ReadWriteObject (typeof (double), Double.NaN, "NaN")));
                        Assert.IsTrue (Double.IsNegativeInfinity ((double) ReadWriteObject (typeof (double), Double.NegativeInfinity, "-INF")));
                        Assert.IsTrue (Double.IsPositiveInfinity ((double) ReadWriteObject (typeof (double), Double.PositiveInfinity, "INF")));
                }

                [Test]
                public void ReadWriteDateTime ()
                {
                        var ms = new MemoryStream ();
                        DataContractJsonSerializer serializer = new DataContractJsonSerializer (typeof (Query));
                        Query query = new Query () {
                                StartDate = DateTime.SpecifyKind (new DateTime (2010, 3, 4, 5, 6, 7), DateTimeKind.Utc),
                                EndDate = DateTime.SpecifyKind (new DateTime (2010, 4, 5, 6, 7, 8), DateTimeKind.Utc)
                                };
                        serializer.WriteObject (ms, query);
                        Assert.AreEqual ("{\"StartDate\":\"\\/Date(1267679167000)\\/\",\"EndDate\":\"\\/Date(1270447628000)\\/\"}", Encoding.UTF8.GetString (ms.ToArray ()), "#1");
                        ms.Position = 0;
                        Console.WriteLine (new StreamReader (ms).ReadToEnd ());
                        ms.Position = 0;
                        var q = (Query) serializer.ReadObject(ms);
                        Assert.AreEqual (query.StartDate, q.StartDate, "#2");
                        Assert.AreEqual (query.EndDate, q.EndDate, "#3");
                }

                [DataContract(Name = "DateTest")]
                public class DateTest
                {
                        [DataMember(Name = "should_have_value")]
                        public DateTime? ShouldHaveValue { get; set; }
                }

                //
                // This tests both the extended format "number-0500" as well
                // as the nullable field in the structure
                [Test]
                public void BugXamarin163 ()
                {
                        string json = @"{""should_have_value"":""\/Date(1277355600000)\/""}";

                        byte[] bytes = global::System.Text.Encoding.UTF8.GetBytes(json);
                        Stream inputStream = new MemoryStream(bytes);
                        
                        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(DateTest));
                        DateTest t = serializer.ReadObject(inputStream) as DateTest;
                        Assert.AreEqual (634129524000000000, t.ShouldHaveValue.Value.Ticks, "#1");
                }

                [Test]
                public void NullableFieldsShouldSupportNullValue ()
                {
                        string json = @"{""should_have_value"":null}";
                        var inputStream = new MemoryStream (Encoding.UTF8.GetBytes (json));
                        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(DateTest));
                        Console.WriteLine ("# serializer assembly: {0}", serializer.GetType ().Assembly.Location);
                        DateTest t = serializer.ReadObject (inputStream) as DateTest;
                        Assert.AreEqual (false, t.ShouldHaveValue.HasValue, "#2");
                }
                
                [Test]
                public void DeserializeNullMember ()
                {
                        var ds = new DataContractJsonSerializer (typeof (ClassA));
                        var stream = new MemoryStream ();
                        var a = new ClassA ();
                        ds.WriteObject (stream, a);
                        stream.Position = 0;
                        a = (ClassA) ds.ReadObject (stream);
                        Assert.IsNull (a.B, "#1");
                }

                [Test]
                public void OnDeserializationMethods ()
                {
                        var ds = new DataContractJsonSerializer (typeof (GSPlayerListErg));
                        var obj = new GSPlayerListErg ();
                        var ms = new MemoryStream ();
                        ds.WriteObject (ms, obj);
                        ms.Position = 0;
                        ds.ReadObject (ms);
                        Assert.IsTrue (GSPlayerListErg.A, "A");
                        Assert.IsTrue (GSPlayerListErg.B, "B");
                        Assert.IsTrue (GSPlayerListErg.C, "C");
                }
                
                [Test]
                public void WriteChar ()
                {
                        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof (CharTest));
                        using (MemoryStream ms = new MemoryStream()) {
                                serializer.WriteObject(ms, new CharTest ());
                                ms.Position = 0L;
                                using (StreamReader reader = new StreamReader(ms)) {
                                        reader.ReadToEnd();
                                }
                        }
                }

                [Test]
                public void DictionarySerialization ()
                {
                        var dict = new MyDictionary<string,string> ();
                        dict.Add ("key", "value");
                        var serializer = new DataContractJsonSerializer (dict.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, dict);
                        stream.Position = 0;

                        Assert.AreEqual ("[{\"Key\":\"key\",\"Value\":\"value\"}]", new StreamReader (stream).ReadToEnd (), "#1");
                        stream.Position = 0;
                        dict = (MyDictionary<string,string>) serializer.ReadObject (stream);
                        Assert.AreEqual (1, dict.Count, "#2");
                        Assert.AreEqual ("value", dict ["key"], "#3");
                }

                [Test]
                public void ExplicitCustomDictionarySerialization ()
                {
                        var dict = new MyExplicitDictionary<string,string> ();
                        dict.Add ("key", "value");
                        var serializer = new DataContractJsonSerializer (dict.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, dict);
                        stream.Position = 0;

                        Assert.AreEqual ("[{\"Key\":\"key\",\"Value\":\"value\"}]", new StreamReader (stream).ReadToEnd (), "#1");
                        stream.Position = 0;
                        dict = (MyExplicitDictionary<string,string>) serializer.ReadObject (stream);
                        Assert.AreEqual (1, dict.Count, "#2");
                        Assert.AreEqual ("value", dict ["key"], "#3");
                }

                [Test]
                public void Bug13485 ()
                {
                        const string json = "{ \"Name\" : \"Test\", \"Value\" : \"ValueA\" }";

                        string result = string.Empty;
                        var serializer = new DataContractJsonSerializer (typeof (Bug13485Type));
                        Bug13485Type entity;
                        using (var stream = new MemoryStream (Encoding.UTF8.GetBytes (json)))
                                entity = (Bug13485Type) serializer.ReadObject (stream);

                        result = entity.GetValue;
                        Assert.AreEqual ("ValueA", result, "#1");
                }

                [DataContract(Name = "UriTest")]
                public class UriTest
                {
                        [DataMember(Name = "members")]
                        public Uri MembersRelativeLink { get; set; }
                }

                [Test]
                public void Bug15169 ()
                {
                        const string json = "{\"members\":\"foo/bar/members\"}";
                        var serializer = new DataContractJsonSerializer (typeof (UriTest));
                        UriTest entity;
                        using (var stream = new MemoryStream (Encoding.UTF8.GetBytes (json)))
                                entity = (UriTest) serializer.ReadObject (stream);

                        Assert.AreEqual ("foo/bar/members", entity.MembersRelativeLink.ToString ());
                }
                
                #region Test methods for collection serialization
                
                [Test]
                public void TestArrayListSerialization ()
                {
                        var collection = new ArrayListContainer ();
                        var expectedOutput = "{\"Items\":[\"banana\",\"apple\"]}";
                        var expectedItemsCount = 4;
                        
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);

                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");

                        stream.Position = 0;
                        collection = (ArrayListContainer) serializer.ReadObject (stream);
                        
                        Assert.AreEqual (expectedItemsCount, collection.Items.Count, "#2");
                }
                
                [Test]
                [ExpectedException (typeof (InvalidDataContractException))]
                public void TestBitArraySerialization ()
                {
                        var collection = new BitArrayContainer ();
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                }
                
                [Test]
                public void TestHashtableSerialization ()
                {
                        var collection = new HashtableContainer ();
                        var expectedOutput = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
                        
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);

                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");
                }
                
                [Test]
                [ExpectedException (typeof (ArgumentException))]
                public void TestHashtableDeserialization ()
                {
                        var collection = new HashtableContainer ();
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                        
                        stream.Position = 0;
                        serializer.ReadObject (stream);
                }
                
                [Test]
                [ExpectedException (typeof (InvalidDataContractException))]
                public void TestQueueSerialization ()
                {
                        var collection = new QueueContainer ();
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                }
                
                [Test]
                public void TestSortedListSerialization ()
                {
                        var collection = new SortedListContainer ();
                        var expectedOutput = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
                        
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);

                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");
                }
                
                [Test]
                [ExpectedException (typeof (ArgumentException))]
                public void TestSortedListDeserialization ()
                {
                        var collection = new SortedListContainer ();
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                        
                        stream.Position = 0;
                        serializer.ReadObject (stream);
                }
                
                [Test]
                [ExpectedException (typeof (InvalidDataContractException))]
                public void TestStackSerialization ()
                {
                        var collection = new StackContainer ();
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                }
                
                [Test]
                public void TestEnumerableWithAddSerialization ()
                {
                        var collection = new EnumerableWithAddContainer ();
                        var expectedOutput = "{\"Items\":[\"banana\",\"apple\"]}";
                        var expectedItemsCount = 4;
                        
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);

                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");

                        stream.Position = 0;
                        collection = (EnumerableWithAddContainer) serializer.ReadObject (stream);
                        
                        Assert.AreEqual (expectedItemsCount, collection.Items.Count, "#2");
                }
                
                [Test]
                [ExpectedException (typeof (InvalidDataContractException))]
                public void TestEnumerableWithSpecialAddSerialization ()
                {
                        var collection = new EnumerableWithSpecialAddContainer ();                      
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                }
        
                [Test]
                public void TestHashSetSerialization ()
                {
                        var collection = new GenericHashSetContainer ();
                        var expectedOutput = "{\"Items\":[\"banana\",\"apple\"]}";
                        var expectedItemsCount = 2;
                        
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);

                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");

                        stream.Position = 0;
                        collection = (GenericHashSetContainer) serializer.ReadObject (stream);
                        
                        Assert.AreEqual (expectedItemsCount, collection.Items.Count, "#2");
                }
                
                [Test]
                public void TestLinkedListSerialization ()
                {
                        var collection = new GenericLinkedListContainer ();
                        var expectedOutput = "{\"Items\":[\"banana\",\"apple\"]}";
                        var expectedItemsCount = 4;
                        
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);

                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");

                        stream.Position = 0;
                        collection = (GenericLinkedListContainer) serializer.ReadObject (stream);
                        
                        Assert.AreEqual (expectedItemsCount, collection.Items.Count, "#2");
                }
                
                [Test]
                [ExpectedException (typeof (InvalidDataContractException))]
                public void TestGenericQueueSerialization ()
                {
                        var collection = new GenericQueueContainer ();                  
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                }
                
                [Test]
                [ExpectedException (typeof (InvalidDataContractException))]
                public void TestGenericStackSerialization ()
                {
                        var collection = new GenericStackContainer ();                  
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                }
                
                [Test]
                public void TestGenericDictionarySerialization ()
                {
                        var collection = new GenericDictionaryContainer ();                     
                        var expectedOutput = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                        
                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");
                }
                
                [Test]
                [ExpectedException (typeof (ArgumentException))]
                public void TestGenericDictionaryDeserialization ()
                {
                        var collection = new GenericDictionaryContainer ();                     
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                        
                        stream.Position = 0;
                        serializer.ReadObject (stream);
                }
                
                [Test]
                public void TestGenericSortedListSerialization ()
                {
                        var collection = new GenericSortedListContainer ();                     
                        var expectedOutput = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                        
                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");
                }
                
                [Test]
                [ExpectedException (typeof (ArgumentException))]
                public void TestGenericSortedListDeserialization ()
                {
                        var collection = new GenericSortedListContainer ();                     
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                        
                        stream.Position = 0;
                        serializer.ReadObject (stream);
                }
                
                [Test]
                public void TestGenericSortedDictionarySerialization ()
                {
                        var collection = new GenericSortedDictionaryContainer ();                       
                        var expectedOutput = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                        
                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");
                }
                
                [Test]
                [ExpectedException (typeof (ArgumentException))]
                public void TestGenericSortedDictionaryDeserialization ()
                {
                        var collection = new GenericSortedDictionaryContainer ();                       
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                        
                        stream.Position = 0;
                        serializer.ReadObject (stream);
                }
                
                [Test]
                public void TestGenericEnumerableWithAddSerialization ()
                {
                        var collection = new GenericEnumerableWithAddContainer ();
                        var expectedOutput = "{\"Items\":[\"banana\",\"apple\"]}";
                        var expectedItemsCount = 4;
                        
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);

                        stream.Position = 0;
                        Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");

                        stream.Position = 0;
                        collection = (GenericEnumerableWithAddContainer) serializer.ReadObject (stream);
                        
                        Assert.AreEqual (expectedItemsCount, collection.Items.Count, "#2");
                }
                
                [Test]
                [ExpectedException (typeof (InvalidDataContractException))]
                public void TestGenericEnumerableWithSpecialAddSerialization ()
                {
                        var collection = new GenericEnumerableWithSpecialAddContainer ();                       
                        var serializer = new DataContractJsonSerializer (collection.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, collection);
                }
                
                [Test]
                [ExpectedException (typeof (InvalidDataContractException))]
                public void TestNonCollectionGetOnlyProperty ()
                {
                        var o = new NonCollectionGetOnlyContainer ();                   
                        var serializer = new DataContractJsonSerializer (o.GetType ());
                        var stream = new MemoryStream ();
                        serializer.WriteObject (stream, o);
                }
                
                // properly deserialize object with a polymorphic property (known derived type)
                [Test]
                public void Bug23058()
                {
                        string serializedObj = @"{""PolymorphicProperty"":{""__type"":""KnownDerivedType:#MonoTests.System.Runtime.Serialization.Json"",""BaseTypeProperty"":""Base"",""DerivedProperty"":""Derived 1""},""Name"":""Parent2""}";
                        ParentType deserializedObj = Deserialize<ParentType> (serializedObj);

                        Assert.AreEqual (deserializedObj.PolymorphicProperty.GetType ().FullName, "MonoTests.System.Runtime.Serialization.Json.KnownDerivedType");
                        Assert.AreEqual (deserializedObj.PolymorphicProperty.BaseTypeProperty, "Base");
                        Assert.AreEqual ((deserializedObj.PolymorphicProperty as KnownDerivedType).DerivedProperty, "Derived 1");
                        Assert.AreEqual (deserializedObj.Name, "Parent2");
                }

                // properly deserialize object with a polymorphic property (base type with __type hint)
                [Test]
                public void DeserializeBaseTypePropHint()
                {
                        string serializedObj = @"{""PolymorphicProperty"":{""__type"":""BaseType:#MonoTests.System.Runtime.Serialization.Json"",""BaseTypeProperty"":""Base""},""Name"":""Parent2""}";
                        ParentType deserializedObj = Deserialize<ParentType> (serializedObj);

                        Assert.AreEqual (deserializedObj.PolymorphicProperty.GetType ().FullName, "MonoTests.System.Runtime.Serialization.Json.BaseType");
                        Assert.AreEqual (deserializedObj.PolymorphicProperty.BaseTypeProperty, "Base");
                }

                // properly deserialize object with a polymorphic property (base type with __type hint)
                [Test]
                public void DeserializeBaseTypePropNoHint()
                {
                        string serializedObj = @"{""PolymorphicProperty"":{""BaseTypeProperty"":""Base""},""Name"":""Parent2""}";
                        ParentType deserializedObj = Deserialize<ParentType> (serializedObj);

                        Assert.AreEqual (deserializedObj.PolymorphicProperty.GetType ().FullName, "MonoTests.System.Runtime.Serialization.Json.BaseType");
                        Assert.AreEqual (deserializedObj.PolymorphicProperty.BaseTypeProperty, "Base");
                }

                // properly fail deserializing object with a polymorphic property (unknown derived type)
                [ExpectedException (typeof (SerializationException))]
                [Test]
                public void FailDeserializingUnknownTypeProp()
                {
                        string serializedObj = @"{""PolymorphicProperty"":{""__type"":""UnknownDerivedType:#MonoTests.System.Runtime.Serialization.Json"",""BaseTypeProperty"":""Base"",""DerivedProperty"":""Derived 1""},""Name"":""Parent2""}";
                        ParentType deserializedObj = Deserialize<ParentType> (serializedObj);
                }

                [Test]
                public void SubclassTest ()
                {
                        var knownTypes = new List<Type> { typeof(IntList) };
                        var serializer = new DataContractJsonSerializer(typeof(ListOfNumbers), knownTypes);

                        string json = "{\"Numbers\": [85]}";
                        using (var stream = new MemoryStream(UTF8Encoding.Default.GetBytes(json)))
                        {
                                var nums = (ListOfNumbers)serializer.ReadObject(stream);
                                Assert.AreEqual (1, nums.Numbers.Count);
                        }
                }
                [DataContract]
                public class ListOfNumbers
                {
                        [DataMember]
                        public IntList Numbers;
                }

                public class IntList : List<int>{}
                #endregion

                [Test]
                public void DefaultValueDeserialization ()
                {
                        // value type
                        var person = new Person { name = "John" };
                        using (var ms = new MemoryStream()) {
                                var serializer = new DataContractJsonSerializer (typeof (Person), new DataContractJsonSerializerSettings {
                                        SerializeReadOnlyTypes = true,
                                        UseSimpleDictionaryFormat = true
                                        });
                                serializer.WriteObject (ms, person);
                        }

                        // reference type
                        var person2 = new PersonWithContact {
                                name = "Jane",
                                contact = new Contact { url = "localhost", email = "jane@localhost" } };
                        using (var ms = new MemoryStream ()) {
                                var serializer = new DataContractJsonSerializer (typeof (PersonWithContact), new DataContractJsonSerializerSettings {
                                        SerializeReadOnlyTypes = true,
                                        UseSimpleDictionaryFormat = true
                                        });
                                serializer.WriteObject (ms, person2);
                        }
                }
        }
        
        public class CharTest
        {
                public char Foo;
        }

        public class TestData
        {
                public string Foo { get; set; }
                public string Bar { get; set; }
                internal string Baz { get; set; }
        }

        public enum Colors {
                Red, Green, Blue
        }

        [DataContract (Name = "_ColorsWithDC")]
        public enum ColorsWithDC {

                [EnumMember (Value = "_Red")]
                Red, 
                [EnumMember]
                Green, 
                Blue
        }


        public enum ColorsEnumMemberNoDC {
                [EnumMember (Value = "_Red")]
                Red, 
                [EnumMember]
                Green, 
                Blue
        }

        [DataContract]
        public class DCWithEnum {
                [DataMember (Name = "_colors")]
                public Colors colors;
        }

        [DataContract]
        public class DCEmpty
        {
                // serializer doesn't touch it.
                public string Foo = "TEST";
        }

        [DataContract]
        public class DCSimple1
        {
                [DataMember]
                public string Foo = "TEST";
        }

        [DataContract]
        public class DCHasNonDC
        {
                [DataMember]
                public NonDC Hoge= new NonDC ();
        }

        public class NonDC
        {
                public string Whee = "whee!";
        }

        [DataContract]
        public class DCHasSerializable
        {
                [DataMember]
                public SimpleSer1 Ser = new SimpleSer1 ();
        }

        [DataContract (Name = "Foo")]
        public class DCWithName
        {
                [DataMember (Name = "FooMember")]
                public string DMWithName = "value";
        }

        [DataContract (Name = "")]
        public class DCWithEmptyName
        {
                [DataMember]
                public string Foo;
        }

        [DataContract (Name = null)]
        public class DCWithNullName
        {
                [DataMember]
                public string Foo;
        }

        [DataContract (Namespace = "")]
        public class DCWithEmptyNamespace
        {
                [DataMember]
                public string Foo;
        }

        [Serializable]
        public class SimpleSer1
        {
                public string Doh = "doh!";
        }

        public class Wrapper
        {
                [DataContract]
                public class DCWrapped
                {
                }
        }

        [DataContract]
        public class CollectionContainer
        {
                Collection<string> items = new Collection<string> ();

                [DataMember]
                public Collection<string> Items {
                        get { return items; }
                }
        }

        [CollectionDataContract]
        public class DataCollection<T> : Collection<T>
        {
        }

        [DataContract]
        public class DataCollectionContainer
        {
                DataCollection<string> items = new DataCollection<string> ();

                [DataMember]
                public DataCollection<string> Items {
                        get { return items; }
                }
        }

        [DataContract]
        class SerializeNonDCArrayType
        {
                [DataMember]
                public NonDCItem [] IPAddresses = new NonDCItem [0];
        }

        public class NonDCItem
        {
                public byte [] Data { get; set; }
        }

        [DataContract]
        public class VerifyObjectNameTestData
        {
                [DataMember]
                string Member1 = "foo";
        }

        [Serializable]
        public class KeyValueTestData {
                public List<KeyValuePair<string,string>> TestData = new List<KeyValuePair<string,string>>();
        }

        [DataContract] // bug #586169
        public class Query
        {
                [DataMember (Order=1)]
                public DateTime StartDate { get; set; }
                [DataMember (Order=2)]
                public DateTime EndDate { get; set; }
        }

        public class ClassA {
                public ClassB B { get; set; }
        }

        public class ClassB
        {
        }

        public class GSPlayerListErg
        {
                public GSPlayerListErg ()
                {
                        Init ();
                }

                void Init ()
                {
                        C = true;
                        ServerTimeUTC = DateTime.SpecifyKind (DateTime.MinValue, DateTimeKind.Utc);
                }

                [OnDeserializing]
                public void OnDeserializing (StreamingContext c)
                {
                        A = true;
                        Init ();
                }

                [OnDeserialized]
                void OnDeserialized (StreamingContext c)
                {
                        B = true;
                }

                public static bool A, B, C;

                [DataMember (Name = "T")]
                public long CodedServerTimeUTC { get; set; }
                public DateTime ServerTimeUTC { get; set; }
        }

        #region polymorphism test helper classes

        [DataContract]
        [KnownType (typeof (KnownDerivedType))]
        public class ParentType
        {
                [DataMember]
                public string Name { get; set; }

                [DataMember]
                public BaseType PolymorphicProperty { get; set; }
        }

        [DataContract]
        public class BaseType
        {
                [DataMember]
                public string BaseTypeProperty { get; set; }
        }

        [DataContract]
        public class KnownDerivedType : BaseType
        {
                [DataMemberAttribute]
                public string DerivedProperty { get; set; }
        }

        [DataContract]
        public class UnknownDerivedType : BaseType
        {
                [DataMember]
                public string DerivedProperty { get; set; }
        }

        #endregion
}

[DataContract]
class GlobalSample1
{
}


public class MyDictionary<K, V> : System.Collections.Generic.IDictionary<K, V>
{
        Dictionary<K,V> dic = new Dictionary<K,V> ();

        public void Add (K key, V value)
        {
                dic.Add (key,  value);
        }

        public bool ContainsKey (K key)
        {
                return dic.ContainsKey (key);
        }

        public ICollection<K> Keys {
                get { return dic.Keys; }
        }

        public bool Remove (K key)
        {
                return dic.Remove (key);
        }

        public bool TryGetValue (K key, out V value)
        {
                return dic.TryGetValue (key, out value);
        }

        public ICollection<V> Values {
                get { return dic.Values; }
        }

        public V this [K key] {
                get { return dic [key]; }
                set { dic [key] = value; }
        }

        IEnumerator IEnumerable.GetEnumerator ()
        {
                return dic.GetEnumerator ();
        }

        ICollection<KeyValuePair<K,V>> Coll {
                get { return (ICollection<KeyValuePair<K,V>>) dic; }
        }

        public void Add (KeyValuePair<K, V> item)
        {
                Coll.Add (item);
        }

        public void Clear ()
        {
                dic.Clear ();
        }

        public bool Contains (KeyValuePair<K, V> item)
        {
                return Coll.Contains (item);
        }

        public void CopyTo (KeyValuePair<K, V> [] array, int arrayIndex)
        {
                Coll.CopyTo (array, arrayIndex);
        }

        public int Count {
                get { return dic.Count; }
        }

        public bool IsReadOnly {
                get { return Coll.IsReadOnly; }
        }

        public bool Remove (KeyValuePair<K, V> item)
        {
                return Coll.Remove (item);
        }

        public IEnumerator<KeyValuePair<K, V>> GetEnumerator ()
        {
                return Coll.GetEnumerator ();
        }
}

public class MyExplicitDictionary<K, V> : IDictionary<K, V> {

        Dictionary<K,V> dic = new Dictionary<K,V> ();

        public void Add (K key, V value)
        {
                dic.Add (key,  value);
        }

        public bool ContainsKey (K key)
        {
                return dic.ContainsKey (key);
        }

        ICollection<K> IDictionary<K, V>.Keys {
                get { return dic.Keys; }
        }

        public bool Remove (K key)
        {
                return dic.Remove (key);
        }

        public bool TryGetValue (K key, out V value)
        {
                return dic.TryGetValue (key, out value);
        }

        ICollection<V> IDictionary<K, V>.Values {
                get { return dic.Values; }
        }

        public V this [K key] {
                get { return dic [key]; }
                set { dic [key] = value; }
        }

        IEnumerator IEnumerable.GetEnumerator ()
        {
                return dic.GetEnumerator ();
        }

        ICollection<KeyValuePair<K,V>> Coll {
                get { return (ICollection<KeyValuePair<K,V>>) dic; }
        }

        public void Add (KeyValuePair<K, V> item)
        {
                Coll.Add (item);
        }

        public void Clear ()
        {
                dic.Clear ();
        }

        public bool Contains (KeyValuePair<K, V> item)
        {
                return Coll.Contains (item);
        }

        public void CopyTo (KeyValuePair<K, V> [] array, int arrayIndex)
        {
                Coll.CopyTo (array, arrayIndex);
        }

        public int Count {
                get { return dic.Count; }
        }

        public bool IsReadOnly {
                get { return Coll.IsReadOnly; }
        }

        public bool Remove (KeyValuePair<K, V> item)
        {
                return Coll.Remove (item);
        }

        public IEnumerator<KeyValuePair<K, V>> GetEnumerator ()
        {
                return Coll.GetEnumerator ();
        }
}

[DataContract]
public class Bug13485Type
{
        [DataMember]
        public string Name { get; set; }

        [DataMember (Name = "Value")]
        private string Value { get; set; }

        public string GetValue { get { return this.Value; } }
}

#region Test classes for Collection serialization

[DataContract]
        public abstract class CollectionContainer <V>
        {
                V items;

                [DataMember]
                public V Items
                {
                        get {
                                if (items == null) items = Init ();
                                return items;
                        }
                }
                
                public CollectionContainer ()
                {
                        Init ();
                }
        
                protected abstract V Init ();
        }
        
        [DataContract]
        public class ArrayListContainer : CollectionContainer<ArrayList> {
                protected override ArrayList Init ()
                {
                        return new ArrayList { "banana", "apple" };
                }
        }
        
        [DataContract]
        public class BitArrayContainer : CollectionContainer<BitArray> {
                protected override BitArray Init ()
                {
                        return new BitArray (new [] { false, true });
                }
        }
        
        [DataContract]
        public class HashtableContainer : CollectionContainer<Hashtable> {
                protected override Hashtable Init ()
                {
                        var ht = new Hashtable ();
                        ht.Add ("key1", "banana");
                        ht.Add ("key2", "apple");
                        return ht;
                }
        }
        
        [DataContract]
        public class QueueContainer : CollectionContainer<Queue> {
                protected override Queue Init ()
                {
                        var q = new Queue ();
                        q.Enqueue ("banana");
                        q.Enqueue ("apple");
                        return q;
                }
        }
        
        [DataContract]
        public class SortedListContainer : CollectionContainer<SortedList> {
                protected override SortedList Init ()
                {
                        var l = new SortedList ();
                        l.Add ("key1", "banana");
                        l.Add ("key2", "apple");
                        return l;
                }
        }
        
        [DataContract]
        public class StackContainer : CollectionContainer<Stack> {
                protected override Stack Init ()
                {
                        var s = new Stack ();
                        s.Push ("banana");
                        s.Push ("apple");
                        return s;
                }
        }

        public class EnumerableWithAdd : IEnumerable
        {
                private ArrayList items;

                public EnumerableWithAdd()
                {
                        items = new ArrayList();
                }

                public IEnumerator GetEnumerator()
                {
                        return items.GetEnumerator();
                }

                public void Add(object value)
                {
                        items.Add(value);
                }

                public int Count
                {
                        get {
                                return items.Count;
                        }
                }
        }

        public class EnumerableWithSpecialAdd : IEnumerable
        {
                private ArrayList items;

                public EnumerableWithSpecialAdd()
                {
                        items = new ArrayList();
                }

                public IEnumerator GetEnumerator()
                {
                        return items.GetEnumerator();
                }

                public void Add(object value, int index)
                {
                        items.Add(value);
                }

                public int Count
                {
                        get
                        {
                                return items.Count;
                        }
                }
        }

        [DataContract]
        public class EnumerableWithAddContainer : CollectionContainer<EnumerableWithAdd>
        {
                protected override EnumerableWithAdd Init()
                {
                        var s = new EnumerableWithAdd();
                        s.Add ("banana");
                        s.Add ("apple");
                        return s;
                }
        }

        [DataContract]
        public class EnumerableWithSpecialAddContainer : CollectionContainer<EnumerableWithSpecialAdd>
        {
                protected override EnumerableWithSpecialAdd Init()
                {
                        var s = new EnumerableWithSpecialAdd();
                        s.Add("banana", 0);
                        s.Add("apple", 0);
                        return s;
                }
        }

        [DataContract]
        public class GenericDictionaryContainer : CollectionContainer<Dictionary<string, string>> {
                protected override Dictionary<string, string> Init ()
                {
                        var d = new Dictionary<string, string> ();
                        d.Add ("key1", "banana");
                        d.Add ("key2", "apple");
                        return d;
                }
        }

        [DataContract]
        public class GenericHashSetContainer : CollectionContainer<HashSet<string>> {
                protected override HashSet<string> Init ()
                {
                        return new HashSet<string> { "banana", "apple" };
                }
        }

        [DataContract]
        public class GenericLinkedListContainer : CollectionContainer<LinkedList<string>> {
                protected override LinkedList<string> Init ()
                {
                        var l = new LinkedList<string> ();
                        l.AddFirst ("apple");
                        l.AddFirst ("banana");
                        return l;
                }
        }

        [DataContract]
        public class GenericListContainer : CollectionContainer<List<string>> {
                protected override List<string> Init ()
                {
                        return new List<string> { "banana", "apple" };
                }
        }

        [DataContract]
        public class GenericQueueContainer : CollectionContainer<Queue<string>> {
                protected override Queue<string> Init ()
                {
                        var q = new Queue<string> ();
                        q.Enqueue ("banana");
                        q.Enqueue ("apple" );
                        return q;
                }
        }

        [DataContract]
        public class GenericSortedDictionaryContainer : CollectionContainer<SortedDictionary<string, string>> {
                protected override SortedDictionary<string, string> Init ()
                {
                        var d = new SortedDictionary<string, string> ();
                        d.Add ("key1", "banana");
                        d.Add ("key2", "apple");
                        return d;
                }
        }

        [DataContract]
        public class GenericSortedListContainer : CollectionContainer<SortedList<string, string>> {
                protected override SortedList<string, string> Init ()
                {
                        var d = new SortedList<string, string> ();
                        d.Add ("key1", "banana");
                        d.Add ("key2", "apple");
                        return d;
                }
        }

        [DataContract]
        public class GenericStackContainer : CollectionContainer<Stack<string>> {
                protected override Stack<string> Init ()
                {
                        var s = new Stack<string> ();
                        s.Push ("banana");
                        s.Push ("apple" );
                        return s;
                }
        }

        public class GenericEnumerableWithAdd : IEnumerable<string>
        {
                private List<string> items;

                public GenericEnumerableWithAdd()
                {
                        items = new List<string>();
                }

                IEnumerator IEnumerable.GetEnumerator()
                {
                        return items.GetEnumerator ();
                }

                public IEnumerator<string> GetEnumerator()
                {
                        return items.GetEnumerator ();
                }

                public void Add(string value)
                {
                        items.Add(value);
                }

                public int Count
                {
                        get {
                                return items.Count;
                        }
                }
        }

        public class GenericEnumerableWithSpecialAdd : IEnumerable<string>
        {
                private List<string> items;

                public GenericEnumerableWithSpecialAdd()
                {
                        items = new List<string>();
                }

                IEnumerator IEnumerable.GetEnumerator()
                {
                        return items.GetEnumerator ();
                }

                public IEnumerator<string> GetEnumerator()
                {
                        return items.GetEnumerator ();
                }

                public void Add(string value, int index)
                {
                        items.Add(value);
                }

                public int Count
                {
                        get
                        {
                                return items.Count;
                        }
                }
        }

        [DataContract]
        public class GenericEnumerableWithAddContainer : CollectionContainer<GenericEnumerableWithAdd>
        {
                protected override GenericEnumerableWithAdd Init()
                {
                        var s = new GenericEnumerableWithAdd();
                        s.Add ("banana");
                        s.Add ("apple");
                        return s;
                }
        }

        [DataContract]
        public class GenericEnumerableWithSpecialAddContainer : CollectionContainer<GenericEnumerableWithSpecialAdd>
        {
                protected override GenericEnumerableWithSpecialAdd Init()
                {
                        var s = new GenericEnumerableWithSpecialAdd();
                        s.Add("banana", 0);
                        s.Add("apple", 0);
                        return s;
                }
        }       

        [DataContract]
        public class NonCollectionGetOnlyContainer
        {
                string _test = "my string";
        
                [DataMember]
                public string MyString {
                        get {
                                return _test;
                        }
                }
        }       

#endregion

#region DefaultValueDeserialization
    [DataContract]
    public class Person
    {
        [DataMember(EmitDefaultValue = false)]
        public string name { get; set; }
    }

    [DataContract]
    public class PersonWithContact
    {
        [DataMember(EmitDefaultValue = false)]
        public string name { get; set; }

        [DataMember(EmitDefaultValue = false)]
        public Contact contact { get; set; }
    }

    [DataContract]
    public class Contact
    {
        [DataMember(EmitDefaultValue = false)]
        public string url { get; set; }

        [DataMember(EmitDefaultValue = false)]
        public string email{ get; set; }
    }
#endregion