public void TestAlias()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
js.Options.TagMode = TagMode.Aliases;
var v = new SampleTree { Value = 9 };
var result = js.ToString(v);
Assert.AreEqual("{\"a\":9,\"b\":null}", result);
js.Options.TagMode = TagMode.Names;
var result1 = js.ToString(v);
Assert.AreEqual("{\"Value\":9,\"Children\":null}", result1);
js.Options.TagMode = TagMode.Ids;
var result2 = js.ToString(v);
Assert.AreEqual("{\"AAAB\":9,\"AAAC\":null}", result2);
var prev = IdGenerator.GetNextId();
for (int i = 0; i < 2 * 52 - 5; ++i) {
var next = IdGenerator.GetNextId();
Assert.IsTrue(String.CompareOrdinal(prev, next) < 0);
prev = next;
}
Assert.AreEqual("AABz", IdGenerator.GetNextId());
var jd = new JsonDeserializer();
jd.Options.TagMode = TagMode.Aliases;
var w = new SampleTree();
jd.FromString(w, result);
Assert.AreEqual(9, w.Value);
Assert.AreEqual(null, w.Children);
}
public void TestJsonLongListInt()
{
var list1 = new SampleMatrix { M = new List<List<int>>() };
for (int i = 0; i < 300; ++i) {
list1.M.Add(new List<int>());
for (int j = 0; j < 400; ++j)
list1.M[i].Add(i * j * 97);
}
var js = new JsonSerializer();
var result1 = js.ToString(list1);
Assert.IsTrue(result1 != "");
var list2 = new SampleMatrix();
var jd = new JsonDeserializer();
jd.FromString(list2, result1);
Assert.AreEqual(list1.M.Count, list2.M.Count);
for (int i = 0; i < list1.M.Count; ++i) {
for (int j = 0; j < list1.M[i].Count; ++j)
Assert.AreEqual(list1.M[i][j], list2.M[i][j]);
}
var jdg = new SampleMatrix_JsonDeserializer();
var list3 = (SampleMatrix)jdg.FromString(result1);
Assert.AreEqual(list1.M.Count, list3.M.Count);
}
public static void WriteIReadOnlyCollectionTOfArray()
{
IReadOnlyCollection <int[]> input = new List <int[]>
{
new int[] { 1, 2 },
new int[] { 3, 4 }
};
string json = JsonSerializer.ToString(input);
Assert.Equal("[[1,2],[3,4]]", json);
}
public static void WriteIImmutableStackTOfArray()
{
IImmutableStack <int[]> input = ImmutableStack.CreateRange(new List <int[]>
{
new int[] { 1, 2 },
new int[] { 3, 4 }
});
string json = JsonSerializer.ToString(input);
Assert.Equal("[[3,4],[1,2]]", json);
}
public async Task <UserInfo> Login(LoginParameters loginParameters)
{
var stringContent = new StringContent(JsonSerializer.ToString(loginParameters), Encoding.UTF8, "application/json");
var result = await _httpClient.PostAsync("api/Authorize/Login", stringContent);
if (result.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
throw new Exception(await result.Content.ReadAsStringAsync());
}
result.EnsureSuccessStatusCode();
return(JsonSerializer.Parse <UserInfo>(await result.Content.ReadAsStringAsync()));
}
public static void NullObjectOutput()
{
{
string output = JsonSerializer.ToString <string>(null);
Assert.Equal("null", output);
}
{
string output = JsonSerializer.ToString <string>(null, null);
Assert.Equal("null", output);
}
}
public static void NoGetter()
{
var objNoSetter = new ClassWithNoSetter();
string json = JsonSerializer.ToString(objNoSetter);
Assert.Equal(@"{""MyString"":""DefaultValue""}", json);
ClassWithNoGetter objNoGetter = JsonSerializer.Parse <ClassWithNoGetter>(json);
Assert.Equal("DefaultValue", objNoGetter.GetMyString());
}
public static void CamelCaseSerialize()
{
var options = new JsonSerializerOptions();
options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
SimpleTestClass obj = JsonSerializer.Parse <SimpleTestClass>(@"{}", options);
string json = JsonSerializer.ToString(obj, options);
Assert.Contains(@"""myInt16"":0", json);
Assert.Contains(@"""myInt32"":0", json);
}
public static void JsonNameConflictOnCaseInsensitiveFail()
{
string json = @"{""myInt"":1,""MyInt"":2}";
{
var options = new JsonSerializerOptions();
options.PropertyNameCaseInsensitive = true;
Assert.Throws <InvalidOperationException>(() => JsonSerializer.Parse <IntPropertyNamesDifferentByCaseOnly_TestClass>(json, options));
Assert.Throws <InvalidOperationException>(() => JsonSerializer.ToString(new IntPropertyNamesDifferentByCaseOnly_TestClass(), options));
}
}
public static void JsonNameAttributeDuplicateDesignTimeFail()
{
{
var options = new JsonSerializerOptions();
Assert.Throws <InvalidOperationException>(() => JsonSerializer.Parse <DuplicatePropertyNameDesignTime_TestClass>("{}", options));
}
{
var options = new JsonSerializerOptions();
Assert.Throws <InvalidOperationException>(() => JsonSerializer.ToString(new DuplicatePropertyNameDesignTime_TestClass(), options));
}
}
public static void WriteListOfArray()
{
var input = new List <int[]>
{
new int[] { 1, 2 },
new int[] { 3, 4 }
};
string json = JsonSerializer.ToString(input);
Assert.Equal("[[1,2],[3,4]]", json);
}
public static void DictionaryOfList()
{
const string JsonString = @"{""Key1"":[1,2],""Key2"":[3,4]}";
{
IDictionary <string, List <int> > obj = JsonSerializer.Parse <IDictionary <string, List <int> > >(JsonString);
Assert.Equal(2, obj.Count);
Assert.Equal(2, obj["Key1"].Count);
Assert.Equal(1, obj["Key1"][0]);
Assert.Equal(2, obj["Key1"][1]);
Assert.Equal(2, obj["Key2"].Count);
Assert.Equal(3, obj["Key2"][0]);
Assert.Equal(4, obj["Key2"][1]);
string json = JsonSerializer.ToString(obj);
Assert.Equal(JsonString, json);
}
{
ImmutableDictionary <string, List <int> > obj = JsonSerializer.Parse <ImmutableDictionary <string, List <int> > >(JsonString);
Assert.Equal(2, obj.Count);
Assert.Equal(2, obj["Key1"].Count);
Assert.Equal(1, obj["Key1"][0]);
Assert.Equal(2, obj["Key1"][1]);
Assert.Equal(2, obj["Key2"].Count);
Assert.Equal(3, obj["Key2"][0]);
Assert.Equal(4, obj["Key2"][1]);
string json = JsonSerializer.ToString(obj);
const string ReorderedJsonString = @"{""Key2"":[3,4],""Key1"":[1,2]}";
Assert.True(JsonString == json || ReorderedJsonString == json);
}
{
IImmutableDictionary <string, List <int> > obj = JsonSerializer.Parse <IImmutableDictionary <string, List <int> > >(JsonString);
Assert.Equal(2, obj.Count);
Assert.Equal(2, obj["Key1"].Count);
Assert.Equal(1, obj["Key1"][0]);
Assert.Equal(2, obj["Key1"][1]);
Assert.Equal(2, obj["Key2"].Count);
Assert.Equal(3, obj["Key2"][0]);
Assert.Equal(4, obj["Key2"][1]);
string json = JsonSerializer.ToString(obj);
const string ReorderedJsonString = @"{""Key2"":[3,4],""Key1"":[1,2]}";
Assert.True(JsonString == json || ReorderedJsonString == json);
}
}
public static void WriteIImmutableSetTOfArray()
{
IImmutableSet <int[]> input = ImmutableHashSet.CreateRange(new List <int[]>
{
new int[] { 1, 2 },
new int[] { 3, 4 }
});
string json = JsonSerializer.ToString(input);
Assert.True(json.Contains("[1,2]"));
Assert.True(json.Contains("[3,4]"));
}
public void JsonSerializer_ReadSimple()
{
string output;
Simple o;
output = JsonSerializer.ToString(new Simple(10, 123.456, "Hello World!", true));
o = (Simple)JsonSerializer.Read(output, typeof(Simple));
Assert.AreEqual(10, o.Int);
Assert.AreEqual(123.456, o.Double);
Assert.AreEqual("Hello World!", o.String);
Assert.IsTrue(o.Bool);
}
public static void WriteHashSetTOfArray()
{
HashSet <int[]> input = new HashSet <int[]>(new List <int[]>
{
new int[] { 1, 2 },
new int[] { 3, 4 }
});
string json = JsonSerializer.ToString(input);
Assert.True(json.Contains("[1,2]"));
Assert.True(json.Contains("[3,4]"));
}
public void TestJsonLongListLong()
{
var list1 = new List <long>();
for (int i = 0; i < 100000; ++i)
{
list1.Add(i * 1973457);
}
var js = new JsonSerializer();
var result1 = js.ToString(list1);
Assert.IsTrue(result1 != "");
}
public void ShouldSerializeAndParseSample()
{
var jsonSerializerOptions = new JsonSerializerOptions();
var person = new Person {
FirstName = "Steve", LastName = "Cramer", BirthDay = new DateTime(1967, 09, 27)
};
string json = JsonSerializer.ToString(person, jsonSerializerOptions);
Person parsed = JsonSerializer.Parse <Person>(json, jsonSerializerOptions);
parsed.BirthDay.ShouldBe(person.BirthDay);
parsed.FirstName.ShouldBe(person.FirstName);
parsed.LastName.ShouldBe(person.LastName);
}
public static void CustomAttributeOnProperty()
{
const string json = @"{""Point1"":""1,2""}";
ClassWithJsonConverterAttribute obj = JsonSerializer.Parse <ClassWithJsonConverterAttribute>(json);
Assert.Equal(1, obj.Point1.X);
Assert.Equal(2, obj.Point1.Y);
string jsonSerialized = JsonSerializer.ToString(obj);
Assert.Equal(json, jsonSerialized);
}
public static void CustomAttributeOnType()
{
const string json = @"""1,2""";
AttributedPoint point = JsonSerializer.Parse <AttributedPoint>(json);
Assert.Equal(1, point.X);
Assert.Equal(2, point.Y);
string jsonSerialized = JsonSerializer.ToString(point);
Assert.Equal(json, jsonSerialized);
}
public static void CustomAttributeExtraInformation()
{
const string json = @"{""Point1"":""1,2""}";
ClassWithPointConverterAttribute obj = JsonSerializer.Parse <ClassWithPointConverterAttribute>(json);
Assert.Equal(11, obj.Point1.X);
Assert.Equal(12, obj.Point1.Y);
string jsonSerialized = JsonSerializer.ToString(obj);
Assert.Equal(json, jsonSerialized);
}
// TODO: 2) Serialize the "account" object to a "pretty-printed" JSON string and return it.
private static string SerializePrettyPrint(Account account)
{
// 2a) Find the serializer options and the flag that would let you write indented
var options = new JsonSerializerOptions()
{
WriteIndented = true
};
// 2b) Make sure to pass the options to the ToString method
string jsonString = JsonSerializer.ToString <Account>(account, options);
return(jsonString);
}
public static void NoSetter()
{
var obj = new ClassWithNoSetter();
string json = JsonSerializer.ToString(obj);
Assert.Contains(@"""MyString"":""DefaultValue""", json);
Assert.Contains(@"""MyInts"":[1,2]", json);
obj = JsonSerializer.Parse <ClassWithNoSetter>(@"{""MyString"":""IgnoreMe"",""MyInts"":[0]}");
Assert.Equal("DefaultValue", obj.MyString);
Assert.Equal(2, obj.MyInts.Length);
}
public static void OverrideWriteOnAttribute()
{
JsonSerializerOptions options = new JsonSerializerOptions();
JsonPropertyValueAttribute attr = new JsonPropertyValueAttribute();
attr.IgnoreNullValueOnWrite = true;
options.AddAttribute(typeof(TestClassWithNull), attr);
var input = new TestClassWithNull();
string json = JsonSerializer.ToString(input, options);
Assert.Equal(@"{}", json);
}
public void SerializeList()
{
ImmutableList <string> data = ImmutableList.CreateRange(new List <string>
{
"One",
"II",
"3"
});
string json = JsonSerializer.ToString(data);
Assert.Equal(@"[""One"",""II"",""3""]", json);
}
public static void CustomAttributeOnTypeAndProperty()
{
const string json = @"{""Point1"":""1,2""}";
ClassWithJsonConverterAttributeOverride point = JsonSerializer.Parse <ClassWithJsonConverterAttributeOverride>(json);
// The property attribute overides the type attribute.
Assert.Equal(101, point.Point1.X);
Assert.Equal(102, point.Point1.Y);
string jsonSerialized = JsonSerializer.ToString(point);
Assert.Equal(json, jsonSerialized);
}
public static void NullReferences()
{
var obj = new ObjectWithObjectProperties();
obj.Address = null;
obj.Array = null;
obj.List = null;
obj.NullableInt = null;
obj.NullableIntArray = null;
string json = JsonSerializer.ToString(obj);
Assert.Equal(ObjectWithObjectProperties.ExpectedJsonAllNulls, json);
}
public static void DictionaryOfObject()
{
Dictionary <string, object> obj = JsonSerializer.Parse <Dictionary <string, object> >(@"{""Key1"":1}");
Assert.Equal(1, obj.Count);
JsonElement element = (JsonElement)obj["Key1"];
Assert.Equal(JsonValueType.Number, element.Type);
Assert.Equal(1, element.GetInt32());
string json = JsonSerializer.ToString(obj);
Assert.Equal(@"{""Key1"":1}", json);
}
public void ConvertEnumUsingAttributes()
{
Week week = new Week {
WorkStart = DayOfWeek.Monday, WorkEnd = DayOfWeek.Friday, WeekEnd = DayOfWeek.Saturday
};
string json = JsonSerializer.ToString(week);
Assert.Equal(@"{""WorkStart"":""Monday"",""WorkEnd"":5,""WeekEnd"":""saturday""}", json);
week = JsonSerializer.Parse <Week>(json);
Assert.Equal(DayOfWeek.Monday, week.WorkStart);
Assert.Equal(DayOfWeek.Friday, week.WorkEnd);
Assert.Equal(DayOfWeek.Saturday, week.WeekEnd);
}
public void TestJsonToBinarySimple()
{
var bs = new BinarySerializer();
var bd = new BinaryDeserializer();
var js = new JsonSerializer();
js.JsonOptions.FieldSeparator = "";
js.JsonOptions.Indent = "";
js.JsonOptions.SaveRootClass = true;
var jd = new JsonDeserializer();
var data1 = "{\"class\":\"YuzuTest.Sample1, YuzuTest\",\"X\":98,\"Y\":\"\"}";
var result1 = js.ToString(bd.FromBytes(bs.ToBytes(jd.FromString(data1))));
Assert.AreEqual(data1, result1);
}
public static void WriteArrayOfStackT()
{
Stack <int>[] input = new Stack <int> [2];
input[0] = new Stack <int>(new List <int> {
1, 2
});
input[1] = new Stack <int>(new List <int> {
3, 4
});
string json = JsonSerializer.ToString(input);
Assert.Equal("[[2,1],[4,3]]", json);
}
public static void WriteArrayOfSortedSetT()
{
SortedSet <int>[] input = new SortedSet <int> [2];
input[0] = new SortedSet <int>(new List <int> {
1, 2
});
input[1] = new SortedSet <int>(new List <int> {
3, 4
});
string json = JsonSerializer.ToString(input);
Assert.Equal("[[1,2],[3,4]]", json);
}
public void SerializeDateTime()
{
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
string result;
result = JsonSerializer.ToString(d);
Assert.Equal(@"""2000-12-15T22:11:03.055Z""", result);
Assert.Equal(d, JsonSerializer.Parse <DateTime>(result));
d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Local);
result = JsonSerializer.ToString(d);
Assert.Equal(@"""2000-12-15T22:11:03.055" + GetUtcOffsetText(d) + @"""", result);
}
public static void ReadSimpleTestClassWithSimpleTestStruct()
{
SimpleTestClass testObject = new SimpleTestClass();
testObject.Initialize();
testObject.MySimpleTestStruct = new SimpleTestStruct {
MyInt64 = 64, MyString = "Hello", MyInt32Array = new int[] { 32 }
};
string json = JsonSerializer.ToString(testObject);
SimpleTestClass parsedObject = JsonSerializer.Parse <SimpleTestClass>(json);
parsedObject.Verify();
}
public void TestAbstract()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
js.JsonOptions.SaveRootClass = true;
var jd = new JsonDeserializer();
SampleAbstract v1 = new SampleConcrete { XX = 81 };
var result1 = js.ToString(v1);
Assert.AreEqual("{\"class\":\"YuzuTest.SampleConcrete, YuzuTest\",\"XX\":81}", result1);
var w1 = jd.FromString<SampleAbstract>(result1);
Assert.AreEqual((v1 as SampleConcrete).XX, (w1 as SampleConcrete).XX);
var w1g = (SampleConcrete)SampleAbstract_JsonDeserializer.Instance.FromString(result1);
Assert.AreEqual((v1 as SampleConcrete).XX, w1g.XX);
var v2 = new List<SampleAbstract>();
v2.Add(new SampleConcrete { XX = 51 });
var w2 = jd.FromString<List<SampleAbstract>>(js.ToString(v2));
Assert.AreEqual(v2.Count, w2.Count);
Assert.AreEqual((v2[0] as SampleConcrete).XX, (w2[0] as SampleConcrete).XX);
}
public void TestBinaryToJsonUnknown()
{
var bs = new BinarySerializer();
var bd = new BinaryDeserializer();
var js = new JsonSerializer();
js.JsonOptions.SaveRootClass = true;
var jd = new JsonDeserializer();
var n = "NewType".ToCharArray().Select(ch => (byte)ch).ToList();
var data1 =
new byte[] { 0x20, 0x01, 0x00, (byte)n.Count }.Concat(n).
Concat(new byte[] { 0x01, 0x00, 0x01, (byte)'X', (byte)RoughType.String, 0x01, 0x00,
0x03, (byte)'a', (byte)'b', (byte)'c', 0, 0
}).ToArray();
var result1 = bs.ToBytes(jd.FromString(js.ToString(bd.FromBytes(data1))));
CollectionAssert.AreEqual(data1, result1);
}
public void TestAfterDeserialization()
{
var js = new JsonSerializer();
var v0 = new SampleAfter { X = "m" };
var result0 = js.ToString(v0);
Assert.AreEqual("{\n\t\"X\":\"m\"\n}", result0);
var jd = new JsonDeserializer();
var w0 = new SampleAfter();
jd.FromString(w0, result0);
Assert.AreEqual("m1", w0.X);
var w1 = new SampleAfter2();
jd.FromString(w1, result0);
Assert.AreEqual("m231", w1.X);
var w2 = (SampleAfter2)SampleAfter2_JsonDeserializer.Instance.FromString(result0);
Assert.AreEqual("m231", w2.X);
}
public void TestJsonLongArrayStr()
{
var list1 = new SampleArray { A = new string[100000] };
for (int i = 0; i < list1.A.Length; ++i)
list1.A[i] = i.ToString();
var js = new JsonSerializer();
js.JsonOptions.ArrayLengthPrefix = true;
var result1 = js.ToString(list1);
Assert.IsTrue(result1 != "");
var list2 = new SampleArray();
var jd = new JsonDeserializer();
jd.JsonOptions.ArrayLengthPrefix = true;
jd.FromString(list2, result1);
Assert.AreEqual(list1.A.Length, list2.A.Length);
var jdg = new SampleArray_JsonDeserializer();
var list3 = (SampleArray)jdg.FromString(result1);
Assert.AreEqual(list1.A.Length, list3.A.Length);
}
public void TestJsonLongListDouble()
{
var list1 = new List<double>();
var rnd = new Random();
for (int i = 0; i < 50000; ++i)
list1.Add(i * 19234.73457);
for (int i = 0; i < 50000; ++i)
list1.Add(rnd.NextDouble());
for (int i = 0; i < 10000; ++i)
list1.Add(rnd.NextDouble() * 1e27);
for (int i = 0; i < 10000; ++i)
list1.Add(rnd.NextDouble() * 1e-27);
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
var result1 = js.ToString(list1);
Assert.IsTrue(result1 != "");
var list2 = (new JsonDeserializer()).FromString<List<double>>(result1);
for (int i = 0; i < list1.Count; ++i)
Assert.AreEqual(list1[i], list2[i]);
}
public void TestDelegate()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
var v1 = new SampleSelfDelegate { x = 77 };
v1.OnSomething = v1.Handler1;
var result = js.ToString(v1);
Assert.AreEqual("{\"OnSomething\":\"Handler1\",\"x\":77}", result);
var w1 = new SampleSelfDelegate();
var jd = new JsonDeserializer();
jd.FromString(w1, result);
Assert.AreEqual(v1.x, w1.x);
w1.OnSomething(10);
Assert.AreEqual(87, w1.x);
jd.FromString(w1, result.Replace("Handler1", "Handler2"));
w1.OnSomething(10);
Assert.AreEqual(770, w1.x);
}
public void TestEscape()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
var s = "\"/{\u0001}\n\t\"\"";
var v = new Sample1 { Y = s };
var result = js.ToString(v);
Assert.AreEqual("{\"X\":0,\"Y\":\"\\\"/{\\u0001}\\n\\t\\\"\\\"\"}", result);
var w = new Sample1();
var jd = new JsonDeserializer();
jd.FromString(w, result);
Assert.AreEqual(s, w.Y);
v.Y = result;
var result1 = js.ToString(v);
jd.FromString(w, result1);
Assert.AreEqual(result, w.Y);
v.Y = "привет";
var result2 = js.ToString(v);
Assert.AreEqual("{\"X\":0,\"Y\":\"привет\"}", result2);
jd.FromString(w, result2);
Assert.AreEqual(v.Y, w.Y);
jd.FromString(w, "{\"X\":0,\"Y\":\"\u043F\u0440\u0438\u0432\u0435\u0442\"}");
Assert.AreEqual(v.Y, w.Y);
}
public void TestClassNames()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.SaveRootClass = true;
js.Options.TagMode = TagMode.Names;
Assert.AreEqual(
"{\n\"class\":\"YuzuTest.SampleBase, YuzuTest\",\n\"FBase\":0\n}", js.ToString(new SampleBase()));
Assert.AreEqual(
"{\n\"class\":\"YuzuTest.SampleDerivedA, YuzuTest\",\n\"FBase\":0,\n\"FA\":0\n}",
js.ToString(new SampleDerivedA()));
var jd = new JsonDeserializer();
jd.Options.TagMode = TagMode.Names;
var v = jd.FromString(
"{\n\"class\":\"YuzuTest.SampleDerivedB, YuzuTest\",\n\"FBase\":3,\n\"FB\":7\n}");
Assert.IsInstanceOfType(v, typeof(SampleDerivedB));
var b = (SampleDerivedB)v;
Assert.AreEqual(3, b.FBase);
Assert.AreEqual(7, b.FB);
}
public void TestCompact()
{
var v = new SampleRect {
A = new SamplePoint { X = 33, Y = 44 },
B = new SamplePoint { X = 55, Y = 66 },
};
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = " ";
var result = js.ToString(v);
Assert.AreEqual("{ \"A\":[ 33, 44 ], \"B\":[ 55, 66 ] }", result);
var jd = new JsonDeserializer();
var w = new SampleRect();
jd.FromString(w, result);
CheckSampleRect(v, w);
w = (SampleRect)SampleRect_JsonDeserializer.Instance.FromString(result);
CheckSampleRect(v, w);
}
public void TestDecimal()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
var v = new SampleDecimal { N = -12.34m };
var jd = new JsonDeserializer();
var result1 = js.ToString(v);
Assert.AreEqual("{\n\"N\":-12.34\n}", result1);
var w1 = new SampleDecimal();
jd.FromString(w1, result1);
Assert.AreEqual(v.N, w1.N);
jd.JsonOptions.DecimalAsString = js.JsonOptions.DecimalAsString = true;
var result2 = js.ToString(v);
Assert.AreEqual("{\n\"N\":\"-12.34\"\n}", result2);
var w2 = new SampleDecimal();
jd.FromString(w2, result2);
Assert.AreEqual(v.N, w2.N);
var w3 = (SampleDecimal)SampleDecimal_JsonDeserializer.Instance.FromString(result1);
Assert.AreEqual(v.N, w3.N);
}
public void TestMatrix()
{
var src = "{\"M\":[[1,2,3],[4,5],[6],[]]}";
var v = new SampleMatrix();
(new JsonDeserializer()).FromString(v, src);
Assert.AreEqual(4, v.M.Count);
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, v.M[0]);
CollectionAssert.AreEqual(new int[] { 4, 5 }, v.M[1]);
CollectionAssert.AreEqual(new int[] { 6 }, v.M[2]);
Assert.AreEqual(0, v.M[3].Count);
v = (SampleMatrix)SampleMatrix_JsonDeserializer.Instance.FromString(src);
Assert.AreEqual(4, v.M.Count);
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, v.M[0]);
CollectionAssert.AreEqual(new int[] { 4, 5 }, v.M[1]);
CollectionAssert.AreEqual(new int[] { 6 }, v.M[2]);
Assert.AreEqual(0, v.M[3].Count);
var js = new JsonSerializer();
js.JsonOptions.FieldSeparator = "";
js.JsonOptions.Indent = "";
Assert.AreEqual(src, js.ToString(v));
}
public void TestLong()
{
var js = new JsonSerializer();
var v1 = new SampleLong { S = -1L << 33, U = 1UL << 33 };
js.JsonOptions.Indent = "";
var result = js.ToString(v1);
Assert.AreEqual("{\n\"S\":-8589934592,\n\"U\":8589934592\n}", result);
var v2 = new SampleLong();
var jd = new JsonDeserializer();
jd.FromString(v2, result);
Assert.AreEqual(v1.S, v2.S);
Assert.AreEqual(v1.U, v2.U);
js.JsonOptions.Int64AsString = true;
var result1 = js.ToString(v1);
Assert.AreEqual("{\n\"S\":\"-8589934592\",\n\"U\":\"8589934592\"\n}", result1);
var jd1 = new JsonDeserializer();
jd1.JsonOptions.Int64AsString = true;
jd1.FromString(v2, result1);
Assert.AreEqual(v1.S, v2.S);
Assert.AreEqual(v1.U, v2.U);
js.JsonOptions.Int64AsString = false;
v1.S = long.MinValue;
v1.U = ulong.MaxValue;
jd.FromString(v2, js.ToString(v1));
Assert.AreEqual(v1.S, v2.S);
Assert.AreEqual(v1.U, v2.U);
}
public void TestList()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.Options.TagMode = TagMode.Names;
var jd = new JsonDeserializer();
jd.Options.TagMode = TagMode.Names;
var v0 = new SampleList { E = new List<string> { "a", "b", "c" } };
var result0 = js.ToString(v0);
Assert.AreEqual("{\n\"E\":[\n\"a\",\n\"b\",\n\"c\"\n]\n}", result0);
var w0 = new SampleList();
jd.FromString(w0, result0);
CollectionAssert.AreEqual(v0.E, w0.E);
var v1 = new SampleTree { Value = 11, Children = new List<SampleTree>() };
Assert.AreEqual("{\n\"Value\":11,\n\"Children\":[]\n}", js.ToString(v1));
var w1 = new SampleTree();
jd.FromString(w1, js.ToString(v1));
Assert.AreEqual(0, w1.Children.Count);
var v2 = new SampleTree {
Value = 11,
Children = new List<SampleTree> {
new SampleTree {
Value = 12,
Children = new List<SampleTree>(),
},
new SampleTree {
Value = 13,
}
}
};
var result2 = js.ToString(v2);
Assert.AreEqual(
"{\n\"Value\":11,\n\"Children\":[\n" +
"{\n\"Value\":12,\n\"Children\":[]\n},\n" +
"{\n\"Value\":13,\n\"Children\":null\n}\n" +
"]\n}",
result2);
SampleTree w2 = new SampleTree();
jd.FromString(w2, result2);
Assert.AreEqual(v2.Value, w2.Value);
Assert.AreEqual(v2.Children.Count, w2.Children.Count);
Assert.AreEqual(v2.Children[0].Value, w2.Children[0].Value);
Assert.AreEqual(v2.Children[1].Children, w2.Children[1].Children);
Assert.AreEqual("{\n}", js.ToString(new SampleEmptyList()));
Assert.AreEqual("{\n\"E\":null\n}", js.ToString(new SampleEmptyList { E = null }));
}
public void TestInterface()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
var v1 = new SampleInterfaceField { I = new SampleInterfaced { X = 34 } };
var result1 = js.ToString(v1);
Assert.AreEqual("{\"I\":{\"class\":\"YuzuTest.SampleInterfaced, YuzuTest\",\"X\":34}}", result1);
var w1 = new SampleInterfaceField();
var jd = new JsonDeserializer();
jd.FromString(w1, result1);
Assert.IsInstanceOfType(w1.I, typeof(SampleInterfaced));
Assert.AreEqual(34, w1.I.X);
var w1g = (SampleInterfaceField)SampleInterfaceField_JsonDeserializer.Instance.FromString(result1);
Assert.IsInstanceOfType(w1g.I, typeof(SampleInterfaced));
Assert.AreEqual(34, w1g.I.X);
var w1n = (SampleInterfaceField)SampleInterfaceField_JsonDeserializer.Instance.FromString("{\"I\":null}");
Assert.AreEqual(null, w1n.I);
var v2 = new List<ISample> { null, new SampleInterfaced { X = 37 } };
var result2 = js.ToString(v2);
Assert.AreEqual("[null,{\"class\":\"YuzuTest.SampleInterfaced, YuzuTest\",\"X\":37}]", result2);
var w2 = new List<ISample>();
jd.FromString(w2, result2);
Assert.AreEqual(2, w2.Count);
Assert.IsNull(w2[0]);
Assert.AreEqual(37, w2[1].X);
ISampleField v3 = new SampleInterfacedField { X = 41 };
js.JsonOptions.SaveRootClass = true;
var result3 = js.ToString(v3);
Assert.AreEqual("{\"class\":\"YuzuTest.SampleInterfacedField, YuzuTest\",\"X\":41}", result3);
var w3 = (ISampleField)jd.FromString(result3);
Assert.AreEqual(41, w3.X);
}
public void TestIndentation()
{
var js = new JsonSerializer();
js.JsonOptions.SaveRootClass = true;
var v1 = new SampleTree {
Value = 1, Children = new List<SampleTree> {
new SampleTree {
Value = 11,
Children = null
},
new SampleTree {
Value = 12,
Children = new List<SampleTree> {
new SampleTree {
Value = 121,
Children = null
},
},
},
}
};
Assert.AreEqual(
"{\n" +
"\t\"class\":\"YuzuTest.SampleTree, YuzuTest\",\n" +
"\t\"a\":1,\n" +
"\t\"b\":[\n" +
"\t\t{\n" +
"\t\t\t\"a\":11,\n" +
"\t\t\t\"b\":null\n" +
"\t\t},\n" +
"\t\t{\n" +
"\t\t\t\"a\":12,\n" +
"\t\t\t\"b\":[\n" +
"\t\t\t\t{\n" +
"\t\t\t\t\t\"a\":121,\n" +
"\t\t\t\t\t\"b\":null\n" +
"\t\t\t\t}\n" +
"\t\t\t]\n" +
"\t\t}\n" +
"\t]\n" +
"}",
js.ToString(v1));
var v2 = new Dictionary<string, SamplePoint> {
{ "a", new SamplePoint { X = 4, Y = 3 } }
};
Assert.AreEqual(
"{\n" +
"\t\"a\":[\n" +
"\t\t4,\n" +
"\t\t3\n" +
"\t]\n" +
"}",
js.ToString(v2));
}
public void TestGeneric()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
var v1 = new SampleInterfaceField { I = new SampleInterfacedGeneric<string> { X = 35, G = "qq" } };
var n = "YuzuTest.SampleInterfacedGeneric`1[[System.String]], YuzuTest";
var result1 = js.ToString(v1);
Assert.AreEqual(
String.Format("{{\"I\":{{\"class\":\"{0}\",\"G\":\"qq\",\"X\":35}}}}", n), result1);
var w1 = (SampleInterfaceField)(new JsonDeserializer()).FromString(new SampleInterfaceField(), result1);
Assert.AreEqual(w1.I.X, 35);
Assert.AreEqual((w1.I as SampleInterfacedGeneric<string>).G, "qq");
var w1g = (SampleInterfaceField)SampleInterfaceField_JsonDeserializer.Instance.FromString(result1);
Assert.AreEqual(w1g.I.X, 35);
Assert.AreEqual((w1g.I as SampleInterfacedGeneric<string>).G, "qq");
}
public void TestDefault()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = " ";
var v1 = new Sample1 { X = 6, Y = "ttt" };
var result1 = js.ToString(v1);
Assert.AreEqual("{ \"X\":6 }", result1);
var w1 = (Sample1)Sample1_JsonDeserializer.Instance.FromString(result1);
Assert.AreEqual(6, w1.X);
Assert.AreEqual("zzz", w1.Y);
var v2 = new Sample2 { X = 5, Y = "5" };
var result2 = js.ToString(v2);
Assert.AreEqual("{ \"X\":5 }", result2);
var v3 = new SampleDefault();
Assert.AreEqual("{ }", js.ToString(new SampleDefault()));
v3.B = "z";
var result3 = js.ToString(v3);
Assert.AreEqual("{ \"B\":\"z\" }", result3);
var w3 = new SampleDefault();
(new JsonDeserializer()).FromString(w3, result3);
Assert.AreEqual(3, w3.A);
Assert.AreEqual("z", w3.B);
Assert.AreEqual(new SamplePoint { X = 7, Y = 2 }, w3.P);
}
public void TestDeclarationErrors()
{
var js = new JsonSerializer();
js.Options.TagMode = TagMode.Aliases;
XAssert.Throws<YuzuException>(() => js.ToString(new Bad1()), "F");
XAssert.Throws<YuzuException>(() => js.ToString(new Bad2()), "F");
XAssert.Throws<YuzuException>(() => js.ToString(new Bad3()), "G");
XAssert.Throws<YuzuException>(() => js.ToString(new BadPrivate()), "'F'");
XAssert.Throws<YuzuException>(() => js.ToString(new BadPrivateGetter()), "'F'");
XAssert.Throws<YuzuException>(() => js.ToString(new SampleMultiCollection()), "SampleMultiCollection");
}
public void TestMemberOfInterface()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
var v1 = new List<ISampleMember>();
var result1 = js.ToString(v1);
Assert.AreEqual("[]", result1);
var jd = new JsonDeserializer();
var w1 = new List<ISampleMember>();
jd.FromString(w1, result1);
Assert.AreEqual(0, w1.Count);
v1.Add(new SampleMemberI());
var result1p = js.ToString(v1);
Assert.AreEqual("[{\"class\":\"YuzuTest.SampleMemberI, YuzuTest\"}]", result1p);
jd.FromString(w1, result1p);
Assert.AreEqual(71, w1[0].X);
var v2 = new List<ISampleMember> { new SampleMemberI(), new SampleMemberI { X = 99 } };
var result2 = js.ToString(v2);
var w2 = new List<ISampleMember>();
jd.FromString(w2, result2);
YuzuGen.System.Collections.Generic.List_ISampleMember_JsonDeserializer.Instance.FromString(w2, result2);
Assert.AreEqual(v2[0].X, w2[0].X);
Assert.AreEqual(v2[1].X, w2[1].X);
Assert.AreEqual("[]", js.ToString(new List<SampleMemberAbstract>()));
var v3 = new List<SampleMemberAbstract> { new SampleMemberConcrete() };
var result3 = js.ToString(v3);
Assert.AreEqual("[{\"class\":\"YuzuTest.SampleMemberConcrete, YuzuTest\"}]", result3);
var w3 = new List<SampleMemberAbstract>();
jd.FromString(w3, result3);
Assert.AreEqual(72, w3[0].X);
}
public void TestDate()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = " ";
var jd = new JsonDeserializer();
var n = DateTime.Now;
Assert.AreEqual("\"" + n.ToString("O") + "\"", js.ToString(n));
var t = DateTime.Now - DateTime.MinValue;
Assert.AreEqual("\"" + t.ToString("c") + "\"", js.ToString(t));
var v1 = new SampleDate { D = new DateTime(2011, 3, 25), T = TimeSpan.FromMinutes(5) };
var result1 = js.ToString(v1);
Assert.AreEqual("{ \"D\":\"2011-03-25T00:00:00.0000000\", \"T\":\"00:05:00\" }", result1);
js.JsonOptions.DateFormat = @"yyyy";
js.JsonOptions.TimeSpanFormat = @"hh\#mm\#ss";
Assert.AreEqual("{ \"D\":\"2011\", \"T\":\"00#05#00\" }", js.ToString(v1));
var w1 = new SampleDate();
(new JsonDeserializer()).FromString(w1, result1);
Assert.AreEqual(v1.D, w1.D);
Assert.AreEqual(v1.T, w1.T);
w1 = (SampleDate)SampleDate_JsonDeserializer.Instance.FromString(result1);
Assert.AreEqual(v1.D, w1.D);
Assert.AreEqual(v1.T, w1.T);
js.JsonOptions.DateFormat = "O";
var v2 = new DateTime(2011, 3, 25, 1, 2, 3, DateTimeKind.Utc);
var result2 = js.ToString(v2);
Assert.AreEqual("\"2011-03-25T01:02:03.0000000Z\"", result2);
var w2 = jd.FromString<DateTime>(result2);
Assert.AreEqual(v2, w2);
Assert.AreEqual(v2.Kind, w2.Kind);
var v3 = new DateTime(2011, 3, 25, 1, 2, 3, DateTimeKind.Local);
var result3 = js.ToString(v3);
var w3 = jd.FromString<DateTime>(result3);
Assert.AreEqual(v3, w3);
Assert.AreEqual(v3.Kind, w3.Kind);
}
public void TestMemberOrder()
{
var js = new JsonSerializer();
js.Options.TagMode = TagMode.Names;
js.JsonOptions.Indent = "";
var result = js.ToString(new SampleMethodOrder());
Assert.AreEqual("{\n\"F1\":0,\n\"P1\":0,\n\"F2\":0,\n\"P2\":0\n}", result);
}
public void TestCollection()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
var jd = new JsonDeserializer();
var v0 = new SampleWithCollection();
v0.A.Add(new SampleInterfaced { X = 9 });
v0.B.Add(7);
v0.B.Add(6);
var result0 = js.ToString(v0);
Assert.AreEqual(
"{\n" +
"\"A\":[\n{\n\"class\":\"YuzuTest.SampleInterfaced, YuzuTest\",\n\"X\":9\n}\n],\n" +
"\"B\":[\n7,\n6\n]\n" +
"}",
result0);
var w0 = new SampleWithCollection();
jd.FromString(w0, result0);
Assert.AreEqual(1, w0.A.Count);
Assert.IsInstanceOfType(w0.A.First(), typeof(SampleInterfaced));
Assert.AreEqual(9, w0.A.First().X);
CollectionAssert.AreEqual(new int[] { 7, 6 }, w0.B.ToList());
var w1 = (SampleWithCollection)SampleWithCollection_JsonDeserializer.Instance.FromString(result0);
Assert.AreEqual(1, w1.A.Count);
Assert.IsInstanceOfType(w1.A.First(), typeof(SampleInterfaced));
Assert.AreEqual(9, w1.A.First().X);
CollectionAssert.AreEqual(new int[] { 7, 6 }, w1.B.ToList());
var v2 = new SampleCollection<int> { 2, 5, 4 };
var result1 = js.ToString(v2);
Assert.AreEqual("[\n2,\n5,\n4\n]", result1);
var w2 = (SampleCollection<int>)SampleCollection_Int32_JsonDeserializer.Instance.FromString(result1);
CollectionAssert.AreEqual(v2.ToList(), w2.ToList());
var w2g = (SampleExplicitCollection<int>)
SampleExplicitCollection_Int32_JsonDeserializer.Instance.FromString(result1);
CollectionAssert.AreEqual(v2.ToList(), w2g.ToList());
var v3 = new SampleConcreteCollection { 8, 3, 1 };
var result3 = js.ToString(v3);
Assert.AreEqual("[\n8,\n3,\n1\n]", result3);
var w3 = new SampleConcreteCollection();
jd.FromString(w3, result3);
CollectionAssert.AreEqual(v3.ToList(), w3.ToList());
var w3g = (SampleConcreteCollection)
SampleConcreteCollection_JsonDeserializer.Instance.FromString(result3);
CollectionAssert.AreEqual(v3.ToList(), w3g.ToList());
}
public void TestErrors()
{
var js = new JsonSerializer();
XAssert.Throws<YuzuException>(() => js.ToString(new Empty()), "Empty");
XAssert.Throws<YuzuException>(() => js.ToString(new SampleCollectionWithField<int>()), "collection");
XAssert.Throws<YuzuException>(() => js.ToString(new SampleInterfacedFieldDup()), "X");
XAssert.Throws<YuzuException>(() => js.ToString(new BadMerge1()), "merge");
XAssert.Throws<YuzuException>(() => js.ToString(new BadMerge2()), "merge");
var jd = new JsonDeserializer();
var w = new Sample1();
XAssert.Throws<YuzuException>(() => jd.FromString(w, "{}"), "X");
XAssert.Throws<YuzuException>(() => jd.FromString("{null:1}"), "'n'");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"X\" }"), ":");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "nn"), "'u'");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"X\":1, \"Y\": \"\\z\" }"), "z");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"X\":1, \"Y\": \"\\uQ\" }"), "Q");
XAssert.Throws<YuzuException>(() => jd.FromString(new SampleBool(), "{ \"B\": 1 }"), "1");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ ,}"), ",");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"Y\": \"q\" }"), "'X'");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "[]"), "'Sample1'");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"class\": \"Q\" }"), "'Q'");
XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"class\": \"YuzuTest.Sample2, YuzuTest\" }"), ".Sample2");
XAssert.Throws<YuzuException>(() => jd.FromString(
new Sample2Allow(), "{ \"class\": \"YuzuTest.Sample1, YuzuTest\" }"), ".Sample1");
XAssert.Throws<YuzuException>(() => jd.FromString(new SamplePoint(), "[ \"QQ\" ]"), "");
XAssert.Throws<YuzuException>(() => jd.FromString(new object(), "{}"), "object");
XAssert.Throws<EndOfStreamException>(() => jd.FromString(""), "");
XAssert.Throws<EndOfStreamException>(() => jd.FromString(w, "{ \"X\": 1"));
XAssert.Throws<YuzuException>(() => jd.FromString(
"{\"class\":\"YuzuTest.SampleInterfaceField, YuzuTest\",\"I\":{}}"), "class");
XAssert.Throws<YuzuException>(() => jd.FromString(
"{\"class\":\"YuzuTest.SampleInterfaceField, YuzuTest\",\"I\":{\"class\":\"YuzuTest.Sample1, YuzuTest\"}}"),
"ISample");
jd.Options.ReportErrorPosition = true;
XAssert.Throws<YuzuException>(() => jd.FromString(w, " z"), "7");
jd.Options.ReportErrorPosition = false;
try {
jd.FromString(w, " z");
}
catch (YuzuException e) {
Assert.IsFalse(e.Message.Contains("7"));
}
}
public void TestEnum()
{
var js = new JsonSerializer();
var v = new Sample4 { E = SampleEnum.E3 };
js.JsonOptions.Indent = "";
var result1 = js.ToString(v);
Assert.AreEqual("{\n\"E\":2\n}", result1);
js.JsonOptions.EnumAsString = true;
var result2 = js.ToString(v);
Assert.AreEqual("{\n\"E\":\"E3\"\n}", result2);
var jd = new JsonDeserializer();
var w = new Sample4();
jd.FromString(w, result1);
Assert.AreEqual(SampleEnum.E3, w.E);
w.E = SampleEnum.E1;
jd.JsonOptions.EnumAsString = true;
jd.FromString(w, result2);
Assert.AreEqual(SampleEnum.E3, w.E);
w = (Sample4)Sample4_JsonDeserializer.Instance.FromString(result2);
Assert.AreEqual(SampleEnum.E3, w.E);
}
public void TestDictionaryKeys()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.JsonOptions.FieldSeparator = "";
var v0 = new SampleDictKeys {
I = new Dictionary<int, int> { { 5, 7 } },
E = new Dictionary<SampleEnum, int> { { SampleEnum.E2, 8 } },
K = new Dictionary<SampleKey, int> { { new SampleKey { V = 3 }, 9 } },
};
var result0 = js.ToString(v0);
Assert.AreEqual(
"{" +
"\"E\":{\"E2\":8}," +
"\"I\":{\"5\":7}," +
"\"K\":{\"3!\":9}" +
"}", result0);
JsonDeserializer.RegisterKeyParser(
typeof(SampleKey),
s => new SampleKey { V = int.Parse(s.Substring(0, s.Length - 1)) });
var jd = new JsonDeserializer();
var w = new SampleDictKeys();
jd.FromString(w, result0);
Assert.AreEqual(1, w.I.Count);
Assert.AreEqual(7, w.I[5]);
Assert.AreEqual(1, w.E.Count);
Assert.AreEqual(8, w.E[SampleEnum.E2]);
Assert.AreEqual(1, w.K.Count);
Assert.AreEqual(9, w.K[new SampleKey { V = 3 }]);
w = (SampleDictKeys)SampleDictKeys_JsonDeserializer.Instance.FromString(result0);
Assert.AreEqual(1, w.I.Count);
Assert.AreEqual(7, w.I[5]);
Assert.AreEqual(1, w.E.Count);
Assert.AreEqual(8, w.E[SampleEnum.E2]);
Assert.AreEqual(1, w.K.Count);
Assert.AreEqual(9, w.K[new SampleKey { V = 3 }]);
}
public void TestDictionary()
{
var js = new JsonSerializer();
js.JsonOptions.Indent = "";
js.Options.TagMode = TagMode.Names;
var jd = new JsonDeserializer();
jd.Options.TagMode = TagMode.Names;
var v0 = new SampleDict {
Value = 3, Children = new Dictionary<string, SampleDict> {
{ "a", new SampleDict { Value = 5, Children = new Dictionary<string, SampleDict>() } },
{ "b", new SampleDict { Value = 7 } },
}
};
var result0 = js.ToString(v0);
Assert.AreEqual(
"{\n\"Value\":3,\n\"Children\":{\n" +
"\"a\":{\n\"Value\":5,\n\"Children\":{}\n},\n" +
"\"b\":{\n\"Value\":7,\n\"Children\":null\n}\n" +
"}\n}", result0);
var w0 = new SampleDict();
jd.FromString(w0, result0);
Assert.AreEqual(v0.Value, w0.Value);
Assert.AreEqual(v0.Children.Count, w0.Children.Count);
Assert.AreEqual(v0.Children["a"].Value, w0.Children["a"].Value);
var w1 = (SampleDict)SampleDict_JsonDeserializer.Instance.FromString(result0);
Assert.AreEqual(v0.Value, w1.Value);
Assert.AreEqual(v0.Children.Count, w1.Children.Count);
Assert.AreEqual(v0.Children["a"].Value, w1.Children["a"].Value);
}
public void TestFloat()
{
var js = new JsonSerializer();
js.Options.TagMode = TagMode.Names;
var v = new SampleFloat { F = 1e-20f, D = -3.1415e100d };
js.JsonOptions.Indent = "";
var result1 = js.ToString(v);
Assert.AreEqual("{\n\"F\":1E-20,\n\"D\":-3.1415E100\n}", result1);
var w = new SampleFloat();
var jd = new JsonDeserializer();
jd.Options.TagMode = TagMode.Names;
jd.FromString(w, result1);
Assert.AreEqual(v.F, w.F);
Assert.AreEqual(v.D, w.D);
Assert.AreEqual("NaN", js.ToString(Double.NaN));
Assert.AreEqual("Infinity", js.ToString(Double.PositiveInfinity));
Assert.AreEqual("-Infinity", js.ToString(Double.NegativeInfinity));
}
