public void SerializeDeserialize_DictionaryContextContainsGuid_DeserializesItemAsGuid()
{
const string contextKey = "k1";
var someValue = new Guid("5dd2dba0-20c0-49f8-a054-1fa3b0a8d774");
Dictionary <string, Guid> inputContext = new Dictionary <string, Guid>();
inputContext.Add(contextKey, someValue);
JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented,
TypeNameHandling = TypeNameHandling.All,
MetadataPropertyHandling = MetadataPropertyHandling.ReadAhead
};
string serializedString = JsonConvertX.SerializeObject(inputContext, jsonSerializerSettings);
StringAssert.AreEqual(@"{
""$type"": """ + ReflectionUtils.GetTypeName(typeof(Dictionary <string, Guid>), 0, PreserveReferencesHandlingTests._bingderInstance) + @""",
""k1"": ""5dd2dba0-20c0-49f8-a054-1fa3b0a8d774""
}", serializedString);
var deserializedObject = (Dictionary <string, Guid>)JsonConvertX.DeserializeObject(serializedString, jsonSerializerSettings);
Assert.AreEqual(someValue, deserializedObject[contextKey]);
}
public void DeserializeReferenceInList()
{
string json = @"[
{
""$id"": ""1"",
""Name"": ""e1"",
""Manager"": null
},
{
""$id"": ""2"",
""Name"": ""e2"",
""Manager"": null
},
{
""$ref"": ""1""
},
{
""$ref"": ""2""
}
]";
List <EmployeeReference> employees = JsonConvertX.DeserializeObject <List <EmployeeReference> >(json);
Assert.AreEqual(4, employees.Count);
Assert.AreEqual("e1", employees[0].Name);
Assert.AreEqual("e2", employees[1].Name);
Assert.AreEqual("e1", employees[2].Name);
Assert.AreEqual("e2", employees[3].Name);
Assert.AreEqual(employees[0], employees[2]);
Assert.AreEqual(employees[1], employees[3]);
}
public void SerializeDefaultValueAttributeTest()
{
string json = JsonConvertX.SerializeObject(new DefaultValueAttributeTestClass(),
Formatting.None, new JsonSerializerSettings {
DefaultValueHandling = DefaultValueHandling.Ignore
});
Assert.AreEqual(@"{""TestField1"":0,""TestProperty1"":null}", json);
json = JsonConvertX.SerializeObject(new DefaultValueAttributeTestClass {
TestField1 = int.MinValue, TestProperty1 = "NotDefault"
},
Formatting.None, new JsonSerializerSettings {
DefaultValueHandling = DefaultValueHandling.Ignore
});
Assert.AreEqual(@"{""TestField1"":-2147483648,""TestProperty1"":""NotDefault""}", json);
json = JsonConvertX.SerializeObject(new DefaultValueAttributeTestClass {
TestField1 = 21, TestProperty1 = "NotDefault"
},
Formatting.None, new JsonSerializerSettings {
DefaultValueHandling = DefaultValueHandling.Ignore
});
Assert.AreEqual(@"{""TestProperty1"":""NotDefault""}", json);
json = JsonConvertX.SerializeObject(new DefaultValueAttributeTestClass {
TestField1 = 21, TestProperty1 = "TestProperty1Value"
},
Formatting.None, new JsonSerializerSettings {
DefaultValueHandling = DefaultValueHandling.Ignore
});
Assert.AreEqual(@"{}", json);
}
public void JsonConvertSerializerSettings()
{
Person person = new Person();
person.BirthDate = new DateTime(2000, 11, 20, 23, 55, 44, DateTimeKind.Utc);
person.LastModified = new DateTime(2000, 11, 20, 23, 55, 44, DateTimeKind.Utc);
person.Name = "Name!";
string json = JsonConvertX.SerializeObject(person, Formatting.Indented, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
StringAssert.AreEqual(@"{
""name"": ""Name!"",
""birthDate"": ""2000-11-20T23:55:44Z"",
""lastModified"": ""2000-11-20T23:55:44Z""
}", json);
Person deserializedPerson = JsonConvertX.DeserializeObject <Person>(json, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
Assert.AreEqual(person.BirthDate, deserializedPerson.BirthDate);
Assert.AreEqual(person.LastModified, deserializedPerson.LastModified);
Assert.AreEqual(person.Name, deserializedPerson.Name);
json = JsonConvertX.SerializeObject(person, Formatting.Indented);
StringAssert.AreEqual(@"{
""Name"": ""Name!"",
""BirthDate"": ""2000-11-20T23:55:44Z"",
""LastModified"": ""2000-11-20T23:55:44Z""
}", json);
}
public void Run()
{
var dict = new Dictionary <string, object>
{
{ "KeyA", 101 },
{ "KeyB", Guid.NewGuid() },
{ "KeyC", CombGuid.NewComb() },
};
var json = JsonConvertX.SerializeObject(dict);
var newDict = JsonConvertX.DeserializeObject <Dictionary <string, object> >(json);
Assert.AreEqual((int)dict["KeyA"], newDict.Deserialize <int>("KeyA"));
Assert.AreEqual((Guid)dict["KeyB"], newDict.Deserialize <Guid>("KeyB"));
Assert.AreEqual((CombGuid)dict["KeyC"], newDict.Deserialize <CombGuid>("KeyC"));
#if !NET40
json = SpanJson.JsonSerializer.Generic.Utf16.Serialize(dict);
newDict = SpanJson.JsonSerializer.Generic.Utf16.Deserialize <Dictionary <string, object> >(json);
Assert.AreEqual((int)dict["KeyA"], newDict.Deserialize <int>("KeyA"));
Assert.AreEqual((Guid)dict["KeyB"], newDict.Deserialize <Guid>("KeyB"));
Assert.AreEqual((CombGuid)dict["KeyC"], newDict.Deserialize <CombGuid>("KeyC"));
#endif
}
public void DataBagDoesNotInheritFromDictionaryClass()
{
Example e = new Example();
e.Data.Add("extensionData1", new int[] { 1, 2, 3 });
string json = JsonConvertX.SerializeObject(e, Formatting.Indented);
StringAssert.AreEqual(@"{
""extensionData1"": [
1,
2,
3
]
}", json);
Example e2 = JsonConvertX.DeserializeObject <Example>(json);
JArray o1 = (JArray)e2.Data["extensionData1"];
Assert.AreEqual(JTokenType.Array, o1.Type);
Assert.AreEqual(3, o1.Count);
Assert.AreEqual(1, (int)o1[0]);
Assert.AreEqual(2, (int)o1[1]);
Assert.AreEqual(3, (int)o1[2]);
}
public void DeserializePublicExtensionDataTypeNamdHandlingNonDefaultConstructor()
{
string json = @"{
""$id"": ""1"",
""Name"": ""Name!"",
""Test"": 1,
""Self"": {
""$type"": ""Newtonsoft.Json.Tests.TestObjects.Organization.WagePerson, JsonExtensions.Tests"",
""HourlyWage"": 2.0,
""Name"": null,
""BirthDate"": ""0001-01-01T00:00:00"",
""LastModified"": ""0001-01-01T00:00:00""
}
}";
PublicExtensionDataAttributeTestClassWithNonDefaultConstructor c2 = JsonConvertX.DeserializeObject <PublicExtensionDataAttributeTestClassWithNonDefaultConstructor>(json, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects
});
Assert.AreEqual("Name!", c2.Name);
WagePerson bizzaroC2 = (WagePerson)c2.ExtensionData["Self"];
Assert.AreEqual(2m, bizzaroC2.HourlyWage);
}
public void PrimitiveType_MetadataPropertyIgnore_WithNoType()
{
ItemWithUntypedPayload actual = JsonConvertX.DeserializeObject <ItemWithUntypedPayload>(@"{
""Payload"": {
""$type"": ""System.Single, mscorlib"",
""$value"": ""5""
}
}",
new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
});
Assert.AreEqual(5f, actual.Payload);
actual = JsonConvertX.DeserializeObject <ItemWithUntypedPayload>(@"{
""Payload"": {
""$type"": ""System.Single, mscorlib"",
""$value"": ""5""
}
}",
new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto,
MetadataPropertyHandling = MetadataPropertyHandling.Ignore
});
Assert.IsTrue(actual.Payload is JObject);
}
public void DeserializeObject()
{
string json = @"
{
""Value"": ""2017-12-05T21:59:00""
}";
DateTimeWrapper c1 = JsonConvertX.DeserializeObject <DateTimeWrapper>(json, new JsonSerializerSettings()
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
});
DateTimeWrapper c2 = JsonConvertX.DeserializeObject <DateTimeWrapper>(json, new JsonSerializerSettings()
{
DateTimeZoneHandling = DateTimeZoneHandling.Local
});
DateTimeWrapper c3 = JsonConvertX.DeserializeObject <DateTimeWrapper>(json, new JsonSerializerSettings()
{
DateTimeZoneHandling = DateTimeZoneHandling.Unspecified
});
DateTimeWrapper c4 = JsonConvertX.DeserializeObject <DateTimeWrapper>(json);
Assert.AreEqual(DateTimeKind.Utc, c1.Value.Kind);
Assert.AreEqual(DateTimeKind.Local, c2.Value.Kind);
Assert.AreEqual(DateTimeKind.Unspecified, c3.Value.Kind);
Assert.AreEqual(DateTimeKind.Unspecified, c4.Value.Kind);
}
public void PrimitiveType_MetadataPropertyIgnore()
{
Item actual = JsonConvertX.DeserializeObject <Item>(@"{
""SourceTypeID"": ""d8220a4b-75b1-4b7a-8112-b7bdae956a45"",
""BrokerID"": ""951663c4-924e-4c86-a57a-7ed737501dbd"",
""Latitude"": 33.657145,
""Longitude"": -117.766684,
""TimeStamp"": ""2000-03-01T23:59:59Z"",
""Payload"": {
""$type"": ""System.Byte[], mscorlib"",
""$value"": ""AAECAwQFBgcICQ==""
}
}",
new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.Ignore
});
Assert.AreEqual(new Guid("d8220a4b-75b1-4b7a-8112-b7bdae956a45"), actual.SourceTypeID);
Assert.AreEqual(new Guid("951663c4-924e-4c86-a57a-7ed737501dbd"), actual.BrokerID);
JObject o = (JObject)actual.Payload;
Assert.AreEqual("System.Byte[], mscorlib", (string)o["$type"]);
Assert.AreEqual("AAECAwQFBgcICQ==", (string)o["$value"]);
Assert.AreEqual(null, o.Parent);
}
public void ReadAhead_TypedJValue_NoParent()
{
ItemWithJTokens actual = (ItemWithJTokens)JsonConvertX.DeserializeObject(@"{
""Payload1"": 1,
""Payload2"": {'prop1':1,'prop2':[2]},
""Payload3"": [1],
""$type"": ""JsonExtensions.Tests.Serialization.MetadataPropertyHandlingTests+ItemWithJTokens, JsonExtensions.Tests""
}",
new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.ReadAhead,
TypeNameHandling = TypeNameHandling.All
});
Assert.AreEqual(JTokenType.Integer, actual.Payload1.Type);
Assert.AreEqual(1, (int)actual.Payload1);
Assert.AreEqual(null, actual.Payload1.Parent);
Assert.AreEqual(JTokenType.Object, actual.Payload2.Type);
Assert.AreEqual(1, (int)actual.Payload2["prop1"]);
Assert.AreEqual(2, (int)actual.Payload2["prop2"][0]);
Assert.AreEqual(null, actual.Payload2.Parent);
Assert.AreEqual(1, (int)actual.Payload3[0]);
Assert.AreEqual(null, actual.Payload3.Parent);
}
public void MetadataPropertyHandlingIgnore()
{
MetadataPropertyDisabledTestClass c1 = new MetadataPropertyDisabledTestClass
{
Id = "Id!",
Ref = "Ref!",
Type = "Type!",
Value = "Value!",
Values = "Values!"
};
string json = JsonConvertX.SerializeObject(c1, Formatting.Indented);
StringAssert.AreEqual(@"{
""$id"": ""Id!"",
""$ref"": ""Ref!"",
""$value"": ""Value!"",
""$values"": ""Values!"",
""$type"": ""Type!""
}", json);
MetadataPropertyDisabledTestClass c2 = JsonConvertX.DeserializeObject <MetadataPropertyDisabledTestClass>(json, new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.Ignore
});
Assert.AreEqual("Id!", c2.Id);
Assert.AreEqual("Ref!", c2.Ref);
Assert.AreEqual("Type!", c2.Type);
Assert.AreEqual("Value!", c2.Value);
Assert.AreEqual("Values!", c2.Values);
}
public void DeserializeEmployeeReference()
{
string json = @"[
{
""Name"": ""Mike Manager"",
""$id"": ""1"",
""Manager"": null
},
{
""Name"": ""Joe User"",
""$id"": ""2"",
""Manager"": {
""$ref"": ""1""
}
}
]";
List <EmployeeReference> employees = JsonConvertX.DeserializeObject <List <EmployeeReference> >(json, new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.ReadAhead
});
Assert.AreEqual(2, employees.Count);
Assert.AreEqual("Mike Manager", employees[0].Name);
Assert.AreEqual("Joe User", employees[1].Name);
Assert.AreEqual(employees[0], employees[1].Manager);
}
public void SerializeRefNull()
{
var reference = new Dictionary <string, object>();
reference.Add("blah", "blah!");
reference.Add("$ref", null);
reference.Add("$id", null);
var child = new Dictionary <string, object>();
child.Add("_id", 2);
child.Add("Name", "Isabell");
child.Add("Father", reference);
string json = JsonConvertX.SerializeObject(child, Formatting.Indented);
StringAssert.AreEqual(@"{
""_id"": 2,
""Name"": ""Isabell"",
""Father"": {
""blah"": ""blah!"",
""$ref"": null,
""$id"": null
}
}", json);
Dictionary <string, object> result = JsonConvertX.DeserializeObject <Dictionary <string, object> >(json, new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.ReadAhead
});
Assert.AreEqual(3, result.Count);
Assert.AreEqual(1, ((JObject)result["Father"]).Count);
Assert.AreEqual("blah!", (string)((JObject)result["Father"])["blah"]);
}
public void DeserializingErrorInChildObject()
{
ListErrorObjectCollection c = JsonConvertX.DeserializeObject <ListErrorObjectCollection>(@"[
{
""Member"": ""Value1"",
""Member2"": null
},
{
""Member"": ""Value2""
},
{
""ThrowError"": ""Value"",
""Object"": {
""Array"": [
1,
2
]
}
},
{
""ThrowError"": ""Handle this!"",
""Member"": ""Value3""
}
]");
Assert.AreEqual(3, c.Count);
Assert.AreEqual("Value1", c[0].Member);
Assert.AreEqual("Value2", c[1].Member);
Assert.AreEqual("Value3", c[2].Member);
Assert.AreEqual("Handle this!", c[2].ThrowError);
}
public void DeserializeFromJObject()
{
string json = @"
{
""Value"": ""2017-12-05T21:59:00""
}";
JObject jo = JObject.Parse(json);
DateTimeWrapper c1 = jo.ToObject <DateTimeWrapper>(JsonSerializer.Create(new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
}));
DateTimeWrapper c2 = jo.ToObject <DateTimeWrapper>(JsonSerializer.Create(new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Local
}));
DateTimeWrapper c3 = jo.ToObject <DateTimeWrapper>(JsonSerializer.Create(new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Unspecified
}));
DateTimeWrapper c4 = jo.ToObject <DateTimeWrapper>();
Assert.AreEqual(DateTimeKind.Utc, c1.Value.Kind);
Assert.AreEqual(DateTimeKind.Local, c2.Value.Kind);
Assert.AreEqual(DateTimeKind.Unspecified, c3.Value.Kind);
Assert.AreEqual(DateTimeKind.Unspecified, c4.Value.Kind);
}
public void SerializeSerializableType()
{
SerializableType serializableType = new SerializableType("protected")
{
publicField = "public",
protectedInternalField = "protected internal",
internalField = "internal",
PublicProperty = "private",
nonSerializedField = "Error"
};
#if !(NET20 || NET35 || PORTABLE || DNXCORE50 || PORTABLE40)
MemoryStream ms = new MemoryStream();
DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(SerializableType));
dataContractJsonSerializer.WriteObject(ms, serializableType);
string dtJson = Encoding.UTF8.GetString(ms.ToArray());
string dtExpected = @"{""internalField"":""internal"",""privateField"":""private"",""protectedField"":""protected"",""protectedInternalField"":""protected internal"",""publicField"":""public""}";
Assert.AreEqual(dtExpected, dtJson);
#endif
string expected = "{\"publicField\":\"public\",\"internalField\":\"internal\",\"protectedInternalField\":\"protected internal\",\"protectedField\":\"protected\",\"privateField\":\"private\"}";
string json = JsonConvertX.SerializeObject(serializableType, new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver
{
#if !(PORTABLE || DNXCORE50 || PORTABLE40) || NETSTANDARD1_3 || NETSTANDARD2_0
IgnoreSerializableAttribute = false
#endif
}
});
Assert.AreEqual(expected, json);
}
public void NullValueHandlingSerialization()
{
Store s1 = new Store();
JsonSerializer jsonSerializer = new JsonSerializer();
jsonSerializer.NullValueHandling = NullValueHandling.Ignore;
StringWriter sw = new StringWriter();
jsonSerializer.Serialize(sw, s1);
//JsonConvertX.ConvertDateTimeToJavaScriptTicks(s1.Establised.DateTime)
Assert.AreEqual(@"{""Color"":4,""Establised"":""2010-01-22T01:01:01Z"",""Width"":1.1,""Employees"":999,""RoomsPerFloor"":[1,2,3,4,5,6,7,8,9],""Open"":false,""Symbol"":""@"",""Mottos"":[""Hello World"",""öäüÖÄÜ\\'{new Date(12345);}[222]_µ@²³~"",null,"" ""],""Cost"":100980.1,""Escape"":""\r\n\t\f\b?{\\r\\n\""'"",""product"":[{""Name"":""Rocket"",""ExpiryDate"":""2000-02-02T23:01:30Z"",""Price"":0.0},{""Name"":""Alien"",""ExpiryDate"":""2000-01-01T00:00:00Z"",""Price"":0.0}]}", sw.GetStringBuilder().ToString());
Store s2 = (Store)jsonSerializer.Deserialize(new JsonTextReader(new StringReader("{}")), typeof(Store));
Assert.AreEqual("\r\n\t\f\b?{\\r\\n\"\'", s2.Escape);
Store s3 = (Store)jsonSerializer.Deserialize(new JsonTextReader(new StringReader(@"{""Escape"":null}")), typeof(Store));
Assert.AreEqual("\r\n\t\f\b?{\\r\\n\"\'", s3.Escape);
Store s4 = (Store)jsonSerializer.Deserialize(new JsonTextReader(new StringReader(@"{""Color"":2,""Establised"":""\/Date(1264071600000+1300)\/"",""Width"":1.1,""Employees"":999,""RoomsPerFloor"":[1,2,3,4,5,6,7,8,9],""Open"":false,""Symbol"":""@"",""Mottos"":[""Hello World"",""öäüÖÄÜ\\'{new Date(12345);}[222]_µ@²³~"",null,"" ""],""Cost"":100980.1,""Escape"":""\r\n\t\f\b?{\\r\\n\""'"",""product"":[{""Name"":""Rocket"",""ExpiryDate"":""\/Date(949485690000+1300)\/"",""Price"":0},{""Name"":""Alien"",""ExpiryDate"":""\/Date(946638000000)\/"",""Price"":0.0}]}")), typeof(Store));
Assert.AreEqual(s1.Establised, s3.Establised);
}
public void ExtensionDataTest()
{
string json = @"{
""Ints"": [1,2,3],
""Ignored"": [1,2,3],
""Readonly"": ""Readonly"",
""Name"": ""Actually set!"",
""CustomName"": ""Wrong name!"",
""GetPrivate"": true,
""GetOnly"": true,
""NewValueSimple"": true,
""NewValueComplex"": [1,2,3]
}";
ExtensionDataTestClass c = JsonConvertX.DeserializeObject <ExtensionDataTestClass>(json);
Assert.AreEqual("Actually set!", c.Name);
Assert.AreEqual(4, c.Ints.Count);
Assert.AreEqual("Readonly", (string)c.ExtensionData["Readonly"]);
Assert.AreEqual("Wrong name!", (string)c.ExtensionData["CustomName"]);
Assert.AreEqual(true, (bool)c.ExtensionData["GetPrivate"]);
Assert.AreEqual(true, (bool)c.ExtensionData["GetOnly"]);
Assert.AreEqual(true, (bool)c.ExtensionData["NewValueSimple"]);
Assert.IsTrue(JToken.DeepEquals(new JArray(1, 2, 3), c.ExtensionData["NewValueComplex"]));
Assert.IsTrue(JToken.DeepEquals(new JArray(1, 2, 3), c.ExtensionData["Ignored"]));
Assert.AreEqual(7, c.ExtensionData.Count);
}
public void ShouldSerializeTest()
{
ShouldSerializeTestClass c = new ShouldSerializeTestClass();
c.Name = "James";
c.Age = 27;
string json = JsonConvertX.SerializeObject(c, Formatting.Indented);
StringAssert.AreEqual(@"{
""Age"": 27
}", json);
c._shouldSerializeName = true;
json = JsonConvertX.SerializeObject(c, Formatting.Indented);
StringAssert.AreEqual(@"{
""Name"": ""James"",
""Age"": 27
}", json);
ShouldSerializeTestClass deserialized = JsonConvertX.DeserializeObject <ShouldSerializeTestClass>(json);
Assert.AreEqual("James", deserialized.Name);
Assert.AreEqual(27, deserialized.Age);
}
public void MemberSearchFlags()
{
PrivateMembersClass privateMembersClass = new PrivateMembersClass("PrivateString!", "InternalString!");
string json = JsonConvertX.SerializeObject(privateMembersClass, Formatting.Indented, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver {
DefaultMembersSearchFlags = BindingFlags.NonPublic | BindingFlags.Instance
}
});
StringAssert.AreEqual(@"{
""_privateString"": ""PrivateString!"",
""i"": 0,
""_internalString"": ""InternalString!""
}", json);
PrivateMembersClass deserializedPrivateMembersClass = JsonConvertX.DeserializeObject <PrivateMembersClass>(@"{
""_privateString"": ""Private!"",
""i"": -2,
""_internalString"": ""Internal!""
}", new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver {
DefaultMembersSearchFlags = BindingFlags.NonPublic | BindingFlags.Instance
}
});
Assert.AreEqual("Private!", ReflectionUtils.GetMemberValue(typeof(PrivateMembersClass).GetField("_privateString", BindingFlags.Instance | BindingFlags.NonPublic), deserializedPrivateMembersClass));
Assert.AreEqual("Internal!", ReflectionUtils.GetMemberValue(typeof(PrivateMembersClass).GetField("_internalString", BindingFlags.Instance | BindingFlags.NonPublic), deserializedPrivateMembersClass));
// readonly
Assert.AreEqual(0, ReflectionUtils.GetMemberValue(typeof(PrivateMembersClass).GetField("i", BindingFlags.Instance | BindingFlags.NonPublic), deserializedPrivateMembersClass));
}
public void ObjectWithConstructorEvents()
{
SerializationEventTestObjectWithConstructor obj = new SerializationEventTestObjectWithConstructor(11, "Hello World!", null);
Assert.AreEqual(11, obj.Member1);
Assert.AreEqual("Hello World!", obj.Member2);
Assert.AreEqual("This is a nonserialized value", obj.Member3);
Assert.AreEqual(null, obj.Member4);
string json = JsonConvertX.SerializeObject(obj, Formatting.Indented);
StringAssert.AreEqual(@"{
""Member1"": 11,
""Member2"": ""This value went into the data file during serialization."",
""Member4"": null
}", json);
Assert.AreEqual(11, obj.Member1);
Assert.AreEqual("This value was reset after serialization.", obj.Member2);
Assert.AreEqual("This is a nonserialized value", obj.Member3);
Assert.AreEqual(null, obj.Member4);
obj = JsonConvertX.DeserializeObject <SerializationEventTestObjectWithConstructor>(json);
Assert.AreEqual(11, obj.Member1);
Assert.AreEqual("This value went into the data file during serialization.", obj.Member2);
Assert.AreEqual("This value was set during deserialization", obj.Member3);
Assert.AreEqual("This value was set after deserialization.", obj.Member4);
}
public void ConstructorParametersRespectDefaultValueTest()
{
var testObject = JsonConvertX.DeserializeObject<ConstructorParametersRespectDefaultValue>("{}", new JsonSerializerSettings() { ContractResolver = ConstructorParameterDefaultStringValueContractResolver.Instance });
Assert.AreEqual("Default Value", testObject.Parameter1);
Assert.AreEqual("Default Value", testObject.Parameter2);
}
public void ObjectEventsDocumentationExample()
{
SerializationEventTestObject obj = new SerializationEventTestObject();
Assert.AreEqual(11, obj.Member1);
Assert.AreEqual("Hello World!", obj.Member2);
Assert.AreEqual("This is a nonserialized value", obj.Member3);
Assert.AreEqual(null, obj.Member4);
Assert.AreEqual(null, obj.Member5);
string json = JsonConvertX.SerializeObject(obj, Formatting.Indented);
StringAssert.AreEqual(@"{
""Member1"": 11,
""Member2"": ""This value went into the data file during serialization."",
""Member4"": null
}", json);
Assert.AreEqual(11, obj.Member1);
Assert.AreEqual("This value was reset after serialization.", obj.Member2);
Assert.AreEqual("This is a nonserialized value", obj.Member3);
Assert.AreEqual(null, obj.Member4);
Assert.AreEqual("Error message for member Member6 = Error getting value from 'Member6' on 'Newtonsoft.Json.Tests.TestObjects.SerializationEventTestObject'.", obj.Member5);
obj = JsonConvertX.DeserializeObject <SerializationEventTestObject>(json);
Assert.AreEqual(11, obj.Member1);
Assert.AreEqual("This value went into the data file during serialization.", obj.Member2);
Assert.AreEqual("This value was set during deserialization", obj.Member3);
Assert.AreEqual("This value was set after deserialization.", obj.Member4);
Assert.AreEqual(null, obj.Member5);
}
public void DeserializeCircularReference()
{
string json = @"{
""$id"": ""1"",
""Name"": ""c1"",
""Child"": {
""$id"": ""2"",
""Name"": ""c2"",
""Child"": {
""$id"": ""3"",
""Name"": ""c3"",
""Child"": {
""$ref"": ""1""
}
}
}
}";
CircularReferenceClass c1 =
JsonConvertX.DeserializeObject <CircularReferenceClass>(json, new JsonSerializerSettings
{
PreserveReferencesHandling = PreserveReferencesHandling.Objects
});
Assert.AreEqual("c1", c1.Name);
Assert.AreEqual("c2", c1.Child.Name);
Assert.AreEqual("c3", c1.Child.Child.Name);
Assert.AreEqual("c1", c1.Child.Child.Child.Name);
}
public void JTokenWriter_OverrideSpecifiedName()
{
JsonIgnoreAttributeOnClassTestClass ignoreAttributeOnClassTestClass = new JsonIgnoreAttributeOnClassTestClass();
ignoreAttributeOnClassTestClass.Field = int.MinValue;
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy
{
OverrideSpecifiedNames = true
}
};
JsonSerializer serializer = new JsonSerializer();
serializer.ContractResolver = contractResolver;
JTokenWriter writer = new JTokenWriter();
serializer.Serialize(writer, ignoreAttributeOnClassTestClass);
JObject o = (JObject)writer.Token;
JProperty p = o.Property("theField");
Assert.IsNotNull(p);
Assert.AreEqual(int.MinValue, (int)p.Value);
}
public void DeserializeReferenceInDictionary()
{
string json = @"{
""One"": {
""$id"": ""1"",
""Name"": ""e1"",
""Manager"": null
},
""Two"": {
""$id"": ""2"",
""Name"": ""e2"",
""Manager"": null
},
""Three"": {
""$ref"": ""1""
},
""Four"": {
""$ref"": ""2""
}
}";
Dictionary <string, EmployeeReference> employees = JsonConvertX.DeserializeObject <Dictionary <string, EmployeeReference> >(json);
Assert.AreEqual(4, employees.Count);
EmployeeReference e1 = employees["One"];
EmployeeReference e2 = employees["Two"];
Assert.AreEqual("e1", e1.Name);
Assert.AreEqual("e2", e2.Name);
Assert.AreEqual(e1, employees["Three"]);
Assert.AreEqual(e2, employees["Four"]);
}
public void ErrorDeserializingListHandled()
{
string json = @"[
{
""Name"": ""Jim"",
""BirthDate"": ""\/Date(978048000000)\/"",
""LastModified"": ""\/Date(978048000000)\/""
},
{
""Name"": ""Jim"",
""BirthDate"": ""\/Date(978048000000)\/"",
""LastModified"": ""\/Date(978048000000)\/""
}
]";
var possibleMsgs = new[]
{
"[1] - Error message for member 1 = An item with the same key has already been added.",
"[1] - Error message for member 1 = An element with the same key already exists in the dictionary.", // mono
"[1] - Error message for member 1 = An item with the same key has already been added. Key: Jim" // netcore
};
VersionKeyedCollection c = JsonConvertX.DeserializeObject <VersionKeyedCollection>(json);
Assert.AreEqual(1, c.Count);
Assert.AreEqual(1, c.Messages.Count);
Console.WriteLine(c.Messages[0]);
Assert.IsTrue(possibleMsgs.Any(m => m == c.Messages[0]), "Expected One of: " + Environment.NewLine + string.Join(Environment.NewLine, possibleMsgs) + Environment.NewLine + "Was: " + Environment.NewLine + c.Messages[0]);
}
public void CreateObjectWithParameters()
{
int count = 0;
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterType <TaskRepository>().As <ITaskRepository>();
builder.RegisterType <TaskController>();
builder.Register(c =>
{
count++;
return(new LogManager(new DateTime(2000, 12, 12)));
}).As <ILogger>();
IContainer container = builder.Build();
AutofacContractResolver contractResolver = new AutofacContractResolver(container);
TaskController controller = JsonConvertX.DeserializeObject <TaskController>(@"{
'Logger': {
'Level':'Debug'
}
}", new JsonSerializerSettings
{
ContractResolver = contractResolver
});
Assert.IsNotNull(controller);
Assert.IsNotNull(controller.Logger);
Assert.AreEqual(1, count);
Assert.AreEqual(new DateTime(2000, 12, 12), controller.Logger.DateTime);
Assert.AreEqual("Debug", controller.Logger.Level);
}
public static async Task <TException> ThrowsAsync <TException>(Func <Task> action, params string[] possibleMessages)
where TException : Exception
{
try
{
await action();
Assert.Fail("Exception of type {0} expected. No exception thrown.", typeof(TException).Name);
return(null);
}
catch (TException ex)
{
if (possibleMessages == null || possibleMessages.Length == 0)
{
return(ex);
}
foreach (string possibleMessage in possibleMessages)
{
if (StringAssert.Equals(possibleMessage, ex.Message))
{
return(ex);
}
}
throw new Exception("Unexpected exception message." + Environment.NewLine + "Expected one of: " + string.Join(Environment.NewLine, possibleMessages) + Environment.NewLine + "Got: " + ex.Message + Environment.NewLine + Environment.NewLine + ex);
}
catch (Exception ex)
{
throw new Exception(string.Format("Exception of type {0} expected; got exception of type {1}.", typeof(TException).Name, ex.GetType().Name), ex);
}
}
