Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: 1836deff6a
Fetching contributors…

Cannot retrieve contributors at this time

519 lines (441 sloc) 18.096 kb
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Xunit;
using Xunit.Extensions;
namespace System.Net.Http.Formatting
{
public class JsonNetSerializationTest
{
public static IEnumerable<object[]> SerializedJson
{
get
{
return new TheoryDataSet<object, string>()
{
// Primitives
{ 'f', "\"f\"" },
{ "abc", "\"abc\"" },
{ "\"\\", @"""\""\\""" },
{ 256, "256" },
{ (ulong)long.MaxValue, long.MaxValue.ToString() },
{ 45.78m, "45.78" },
{ .00000457823432, "4.57823432E-06" },
{ (byte)24, "24" },
{ false, "false" },
{ AttributeTargets.Assembly | AttributeTargets.Constructor, "33" },
{ ConsoleColor.DarkCyan, "3" },
{ new DateTimeOffset(1999, 5, 27, 4, 34, 45, TimeSpan.Zero), "\"1999-05-27T04:34:45+00:00\"" },
{ new TimeSpan(5, 30, 0), "\"05:30:00\"" },
{ new Uri("http://www.bing.com"), @"""http://www.bing.com/""" },
{ new Guid("4ed1cd44-11d7-4b27-b623-0b8b553c8906"), "\"4ed1cd44-11d7-4b27-b623-0b8b553c8906\"" },
// Structs
{ new Point() { x = 45, Y = -5}, "{\"x\":45,\"Y\":-5}" },
// Arrays
{ new object[] {}, "[]" },
{ new int[] { 1, 2, 3}, "[1,2,3]" },
{ new string[] { "a", "b"}, "[\"a\",\"b\"]" },
{ new Point[] { new Point() { x = 10, Y = 10}, new Point() { x = 20, Y = 20}}, "[{\"x\":10,\"Y\":10},{\"x\":20,\"Y\":20}]" },
// Collections
{ new List<int> { 1, 2, 3}, "[1,2,3]" },
{ new List<string> { "a", "b"}, "[\"a\",\"b\"]" },
{ new List<Point> { new Point() { x = 10, Y = 10}, new Point() { x = 20, Y = 20}}, "[{\"x\":10,\"Y\":10},{\"x\":20,\"Y\":20}]" },
{ new MyList<int> { 1, 2, 3}, "[1,2,3]" },
{ new MyList<string> { "a", "b"}, "[\"a\",\"b\"]" },
{ new MyList<Point> { new Point() { x = 10, Y = 10}, new Point() { x = 20, Y = 20}}, "[{\"x\":10,\"Y\":10},{\"x\":20,\"Y\":20}]" },
// Dictionaries
{ new Dictionary<string, string> { { "k1", "v1" }, { "k2", "v2" } }, "{\"k1\":\"v1\",\"k2\":\"v2\"}" },
{ new Dictionary<int, string> { { 1, "v1" }, { 2, "v2" } }, "{\"1\":\"v1\",\"2\":\"v2\"}" },
// Anonymous types
{ new { Anon1 = 56, Anon2 = "foo"}, "{\"Anon1\":56,\"Anon2\":\"foo\"}" },
// Classes
{ new DataContractType() { s = "foo", i = 49, NotAMember = "Error" }, "{\"s\":\"foo\",\"i\":49}" },
{ new POCOType() { s = "foo", t = "Error"}, "{\"s\":\"foo\"}" },
{ new SerializableType("protected") { publicField = "public", protectedInternalField = "protected internal", internalField = "internal", PublicProperty = "private", nonSerializedField = "Error" }, "{\"publicField\":\"public\",\"internalField\":\"internal\",\"protectedInternalField\":\"protected internal\",\"protectedField\":\"protected\",\"privateField\":\"private\"}" },
// Generics
{ new KeyValuePair<string, bool>("foo", false), "{\"Key\":\"foo\",\"Value\":false}" },
// ISerializable types
{ new ArgumentNullException("param"), "{\"ClassName\":\"System.ArgumentNullException\",\"Message\":\"Value cannot be null.\",\"Data\":null,\"InnerException\":null,\"HelpURL\":null,\"StackTraceString\":null,\"RemoteStackTraceString\":null,\"RemoteStackIndex\":0,\"ExceptionMethod\":null,\"HResult\":-2147467261,\"Source\":null,\"WatsonBuckets\":null,\"ParamName\":\"param\"}" },
// JSON Values
{ new JValue(false), "false" },
{ new JValue(54), "54" },
{ new JValue("s"), "\"s\"" },
{ new JArray() { new JValue(1), new JValue(2) }, "[1,2]" },
{ new JObject() { { "k1", new JValue("v1") }, { "k2", new JValue("v2") } }, "{\"k1\":\"v1\",\"k2\":\"v2\"}" },
{ new KeyValuePair<JToken, JToken>(new JValue("k"), new JArray() { new JValue("v1"), new JValue("v2") }), "{\"Key\":\"k\",\"Value\":[\"v1\",\"v2\"]}" },
};
}
}
public static IEnumerable<object[]> TypedSerializedJson
{
get
{
return new TheoryDataSet<object, string, Type>()
{
// Null
{ null, "null", typeof(POCOType) },
{ null, "null", typeof(JToken) },
// Nullables
{ new int?(), "null", typeof(int?) },
{ new Point?(), "null", typeof(Point?) },
{ new ConsoleColor?(), "null", typeof(ConsoleColor?) },
{ new int?(45), "45", typeof(int?) },
{ new Point?(new Point() { x = 45, Y = -5 }), "{\"x\":45,\"Y\":-5}", typeof(Point?) },
{ new ConsoleColor?(ConsoleColor.DarkMagenta), "5", typeof(ConsoleColor?)},
};
}
}
[Theory]
[PropertyData("SerializedJson")]
public void ObjectsSerializeToExpectedJson(object o, string expectedJson)
{
ObjectsSerializeToExpectedJsonWithProvidedType(o, expectedJson, o.GetType());
}
[Theory]
[PropertyData("SerializedJson")]
public void JsonDeserializesToExpectedObject(object expectedObject, string json)
{
JsonDeserializesToExpectedObjectWithProvidedType(expectedObject, json, expectedObject.GetType());
}
[Theory]
[PropertyData("TypedSerializedJson")]
public void ObjectsSerializeToExpectedJsonWithProvidedType(object o, string expectedJson, Type type)
{
Assert.Equal(expectedJson, Serialize(o, type));
}
[Theory]
[PropertyData("TypedSerializedJson")]
public void JsonDeserializesToExpectedObjectWithProvidedType(object expectedObject, string json, Type type)
{
if (expectedObject == null)
{
Assert.Null(Deserialize(json, type));
}
else
{
Assert.Equal(expectedObject, Deserialize(json, type), new ObjectComparer());
}
}
[Fact]
public void CallbacksGetCalled()
{
TypeWithCallbacks o = new TypeWithCallbacks();
string json = Serialize(o, typeof(TypeWithCallbacks));
Assert.Equal("12", o.callbackOrder);
TypeWithCallbacks deserializedObject = Deserialize(json, typeof(TypeWithCallbacks)) as TypeWithCallbacks;
Assert.Equal("34", deserializedObject.callbackOrder);
}
[Fact]
public void DerivedTypesArePreserved()
{
JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
formatter.SerializerSettings.TypeNameHandling = TypeNameHandling.Objects;
string json = Serialize(new Derived(), typeof(Base), formatter);
object deserializedObject = Deserialize(json, typeof(Base), formatter);
Assert.IsType(typeof(Derived), deserializedObject);
}
[Fact]
public void ArbitraryTypesArentDeserializedByDefault()
{
string json = "{\"$type\":\"" + typeof(DangerousType).AssemblyQualifiedName + "\"}";
object deserializedObject = Deserialize(json, typeof(object));
Assert.IsNotType(typeof(DangerousType), deserializedObject);
}
[Fact]
public void ReferencesArePreserved()
{
Ref ref1 = new Ref();
Ref ref2 = new Ref();
ref1.Reference = ref2;
ref2.Reference = ref1;
string json = Serialize(ref1, typeof(Ref));
Ref deserializedObject = Deserialize(json, typeof(Ref)) as Ref;
Assert.ReferenceEquals(deserializedObject, deserializedObject.Reference.Reference);
}
[Fact]
public void DeserializingDeepArraysThrows()
{
StringBuilder sb = new StringBuilder();
int depth = 500;
for (int i = 0; i < depth; i++)
{
sb.Append("[");
}
sb.Append("null");
for (int i = 0; i < depth; i++)
{
sb.Append("]");
}
string json = sb.ToString();
Assert.Throws(typeof(JsonReaderQuotaException), () => Deserialize(json, typeof(object)));
}
[Theory]
// existing good surrogate pair
[InlineData("ABC \\ud800\\udc00 DEF", "ABC \ud800\udc00 DEF")]
// invalid surrogates (two high back-to-back)
[InlineData("ABC \\ud800\\ud800 DEF", "ABC \ufffd\ufffd DEF")]
// invalid high surrogate at end of string
[InlineData("ABC \\ud800", "ABC \ufffd")]
// high surrogate not followed by low surrogate
[InlineData("ABC \\ud800 DEF", "ABC \ufffd DEF")]
// low surrogate not preceded by high surrogate
[InlineData("ABC \\udc00\\ud800 DEF", "ABC \ufffd\ufffd DEF")]
// make sure unencoded invalid surrogate characters don't make it through
[InlineData("\udc00\ud800\ud800", "??????")]
public void InvalidUnicodeStringsAreFixedUp(string input, string expectedString)
{
string json = "\"" + input + "\"";
string deserializedString = Deserialize(json, typeof(string)) as string;
Assert.Equal(expectedString, deserializedString);
}
private static string Serialize(object o, Type type, MediaTypeFormatter formatter = null)
{
formatter = formatter ?? new JsonMediaTypeFormatter();
MemoryStream ms = new MemoryStream();
formatter.WriteToStreamAsync(type, o, ms, null, null).Wait();
ms.Flush();
ms.Position = 0;
return new StreamReader(ms).ReadToEnd();
}
internal static object Deserialize(string json, Type type, MediaTypeFormatter formatter = null, IFormatterLogger formatterLogger = null)
{
formatter = formatter ?? new JsonMediaTypeFormatter();
MemoryStream ms = new MemoryStream();
byte[] bytes = Encoding.Default.GetBytes(json);
ms.Write(bytes, 0, bytes.Length);
ms.Flush();
ms.Position = 0;
Task<object> readTask = formatter.ReadFromStreamAsync(type, ms, contentHeaders: null, formatterLogger: formatterLogger);
readTask.WaitUntilCompleted();
if (readTask.IsFaulted)
{
throw readTask.Exception.GetBaseException();
}
return readTask.Result;
}
}
public class ObjectComparer : IEqualityComparer<object>
{
bool IEqualityComparer<object>.Equals(object x, object y)
{
Type xType = x.GetType();
if (xType == y.GetType())
{
if (typeof(JToken).IsAssignableFrom(xType) || xType == typeof(ArgumentNullException) || xType == typeof(KeyValuePair<JToken, JToken>))
{
return x.ToString() == y.ToString();
}
if (xType == typeof(DataContractType))
{
return Equals<DataContractType>(x, y);
}
if (xType == typeof(POCOType))
{
return Equals<POCOType>(x, y);
}
if (xType == typeof(SerializableType))
{
return Equals<SerializableType>(x, y);
}
if (xType == typeof(Point))
{
return Equals<Point>(x, y);
}
if (typeof(IEnumerable).IsAssignableFrom(xType))
{
IEnumerator xEnumerator = ((IEnumerable)x).GetEnumerator();
IEnumerator yEnumerator = ((IEnumerable)y).GetEnumerator();
while (xEnumerator.MoveNext())
{
// if x is longer than y
if (!yEnumerator.MoveNext())
{
return false;
}
else
{
if (!xEnumerator.Current.Equals(yEnumerator.Current))
{
return false;
}
}
}
// if y is longer than x
if (yEnumerator.MoveNext())
{
return false;
}
return true;
}
}
return x.Equals(y);
}
int IEqualityComparer<object>.GetHashCode(object obj)
{
throw new NotImplementedException();
}
bool Equals<T>(object x, object y) where T : IEquatable<T>
{
IEquatable<T> yEquatable = (IEquatable<T>)y;
return yEquatable.Equals((T)x);
}
}
// Marked as [Serializable] to check that [DataContract] takes precedence over [Serializable]
[DataContract]
[Serializable]
public class DataContractType : IEquatable<DataContractType>
{
[DataMember]
public string s;
[DataMember]
internal int i;
public string NotAMember;
public bool Equals(DataContractType other)
{
return this.s == other.s && this.i == other.i;
}
}
public class POCOType : IEquatable<POCOType>
{
public string s;
internal string t;
public bool Equals(POCOType other)
{
return this.s == other.s;
}
}
public class MyList<T> : ICollection<T>
{
List<T> innerList = new List<T>();
public IEnumerator<T> GetEnumerator()
{
return innerList.GetEnumerator();
}
public void Add(T item)
{
innerList.Add(item);
}
public void Clear()
{
innerList.Clear();
}
public bool Contains(T item)
{
return innerList.Contains(item);
}
public void CopyTo(T[] array, int arrayIndex)
{
innerList.CopyTo(array, arrayIndex);
}
public int Count
{
get { return innerList.Count; }
}
public bool IsReadOnly
{
get { return ((ICollection<T>)innerList).IsReadOnly; }
}
public bool Remove(T item)
{
return innerList.Remove(item);
}
IEnumerator IEnumerable.GetEnumerator()
{
return innerList.GetEnumerator();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return innerList.GetEnumerator();
}
}
[Serializable]
class SerializableType : IEquatable<SerializableType>
{
public SerializableType(string protectedFieldValue)
{
this.protectedField = protectedFieldValue;
}
public string publicField;
internal string internalField;
protected internal string protectedInternalField;
protected string protectedField;
private string privateField;
public string PublicProperty
{
get
{
return privateField;
}
set
{
this.privateField = value;
}
}
[NonSerialized]
public string nonSerializedField;
public bool Equals(SerializableType other)
{
return this.publicField == other.publicField &&
this.internalField == other.internalField &&
this.protectedInternalField == other.protectedInternalField &&
this.protectedField == other.protectedField &&
this.privateField == other.privateField;
}
}
public struct Point : IEquatable<Point>
{
public int x;
public int Y { get; set; }
public bool Equals(Point other)
{
return this.x == other.x && this.Y == other.Y;
}
}
[DataContract(IsReference = true)]
public class Ref
{
[DataMember]
public Ref Reference;
}
public class Base
{
}
public class Derived : Base
{
}
[DataContract]
public class TypeWithCallbacks
{
public string callbackOrder = "";
[OnSerializing]
public void OnSerializing(StreamingContext c)
{
callbackOrder += "1";
}
[OnSerialized]
public void OnSerialized(StreamingContext c)
{
callbackOrder += "2";
}
[OnDeserializing]
public void OnDeserializing(StreamingContext c)
{
callbackOrder += "3";
}
[OnDeserialized]
public void OnDeserialized(StreamingContext c)
{
callbackOrder += "4";
}
}
public class DangerousType
{
}
}
Jump to Line
Something went wrong with that request. Please try again.