Files
mono/mcs/class/System.ServiceModel.Web/Test/System.Runtime.Serialization.Json/DataContractJsonSerializerTest.cs
T
Sebastien Pouliot 13ff02dc31 [System.ServiceModel.Web] Fix issue with types explicitly implementing IDictionary or IDictionary<,>
Issue: The previous code, with new tests [1], failed when the linker was
enabled.

That was caused because the code looks for the Keys and Item properties
getter using reflection. The linker handled that imperfectly (it left
some holes), in part because:

* System.Collections.Generic.IDictionary`2 does not implement
  System.Collections.IDictionary; and

* It preserved the explicit methods - not the implicit one that were
  used the the reflection-based code;

That later fact is also a bug (without the linker involvment) and solved
by this commit. A unit test was added to show the issue (NRE).

The patch also avoid the use of reflection for IDictionary since we can
simply typecast to get the same result (without the additional cost).
2014-05-26 17:27:26 -04:00

2577 lines
69 KiB
C#

//
// DataContractJsonSerializerTest.cs
//
// Author:
// Atsushi Enomoto <[email protected]>
// Ankit Jain <[email protected]>
// Antoine Cailliau <[email protected]>
//
// 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))]
[Category ("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))]
[Category ("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);
}
[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 = new DateTime (2010, 3, 4, 5, 6, 7),
EndDate = new DateTime (2010, 4, 5, 6, 7, 8)
};
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-0500)\/""}";
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 (634129344000000000, 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);
}
#endregion
}
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;
}
[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; }
}
}
[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