public void MissingMemberDeserializeOkay()
{
Product product = new Product();
product.Name = "Apple";
product.ExpiryDate = new DateTime(2008, 12, 28);
product.Price = 3.99M;
product.Sizes = new string[] { "Small", "Medium", "Large" };
string output = JsonConvertX.SerializeObject(product);
//{
// "Name": "Apple",
// "ExpiryDate": new Date(1230422400000),
// "Price": 3.99,
// "Sizes": [
// "Small",
// "Medium",
// "Large"
// ]
//}
JsonSerializer jsonSerializer = new JsonSerializer();
jsonSerializer.MissingMemberHandling = MissingMemberHandling.Ignore;
object deserializedValue;
using (JsonReader jsonReader = new JsonTextReader(new StringReader(output)))
{
deserializedValue = jsonSerializer.Deserialize(jsonReader, typeof(ProductShort));
}
ProductShort deserializedProductShort = (ProductShort)deserializedValue;
Assert.AreEqual("Apple", deserializedProductShort.Name);
Assert.AreEqual(new DateTime(2008, 12, 28), deserializedProductShort.ExpiryDate);
Assert.AreEqual("Small", deserializedProductShort.Sizes[0]);
Assert.AreEqual("Medium", deserializedProductShort.Sizes[1]);
Assert.AreEqual("Large", deserializedProductShort.Sizes[2]);
}
public void SerializeDynamicObjectWithNullValueHandlingInclude()
{
dynamic o = new TestDynamicObject();
o.Text = "Text!";
o.Int = int.MaxValue;
o.ChildObject = null; // Tests an explicitly defined property of a dynamic object with a null value.
o.DynamicChildObject = null; // vs. a completely dynamic defined property.
string json = JsonConvertX.SerializeObject(o, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Include,
});
StringAssert.AreEqual(@"{
""Explicit"": false,
""Text"": ""Text!"",
""DynamicChildObject"": null,
""Int"": 2147483647,
""ChildObject"": null
}", json);
}
public void ShouldSerializeExample()
{
Employee joe = new Employee();
joe.Name = "Joe Employee";
Employee mike = new Employee();
mike.Name = "Mike Manager";
joe.Manager = mike;
mike.Manager = mike;
string json = JsonConvertX.SerializeObject(new[] { joe, mike }, Formatting.Indented);
// [
// {
// "Name": "Joe Employee",
// "Manager": {
// "Name": "Mike Manager"
// }
// },
// {
// "Name": "Mike Manager"
// }
// ]
StringAssert.AreEqual(@"[
{
""Name"": ""Joe Employee"",
""Manager"": {
""Name"": ""Mike Manager""
}
},
{
""Name"": ""Mike Manager""
}
]", json);
}
public void ExtensionDataTest_SerializeWithNamingStrategy_Disabled()
{
ExtensionDataTestClass c = new ExtensionDataTestClass()
{
ExtensionData = new Dictionary <string, JToken>
{
["TestValue1"] = 1,
["alreadyCamelCase"] = new JObject
{
["NotProcessed"] = true
}
}
};
string json = JsonConvertX.SerializeObject(c, new JsonSerializerSettings
{
ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver
{
NamingStrategy = new Newtonsoft.Json.Serialization.CamelCaseNamingStrategy()
},
Formatting = Formatting.Indented
});
StringAssert.AreEqual(@"{
""readonly"": ""Readonly"",
""name"": null,
""custom_name"": null,
""getPrivate"": false,
""getOnly"": true,
""ints"": [
0
],
""TestValue1"": 1,
""alreadyCamelCase"": {
""NotProcessed"": true
}
}", json);
}
public void ExtensionDataDeserializeWithNonDefaultConstructorTest()
{
ExtensionDataDeserializeWithNonDefaultConstructor c = new ExtensionDataDeserializeWithNonDefaultConstructor("Name!");
c._extensionData = new Dictionary <string, JToken>
{
{ "Key!", "Value!" }
};
string json = JsonConvertX.SerializeObject(c, Formatting.Indented);
StringAssert.AreEqual(@"{
""Name"": ""Name!"",
""Key!"": ""Value!""
}", json);
var c2 = JsonConvertX.DeserializeObject <ExtensionDataDeserializeWithNonDefaultConstructor>(json);
Assert.AreEqual("Name!", c2.Name);
Assert.IsNotNull(c2._extensionData);
Assert.AreEqual(1, c2._extensionData.Count);
Assert.AreEqual("Value!", (string)c2._extensionData["Key!"]);
}
public void ExtensionDataExample()
{
string json = @"{
'HourlyRate': 150,
'Hours': 40,
'TaxRate': 0.125
}";
var invoice = JsonConvertX.DeserializeObject <CustomerInvoice>(json);
// increase tax to 15%
invoice.TaxRate = 0.15m;
string result = JsonConvertX.SerializeObject(invoice);
// {
// 'TaxRate': 0.15,
// 'HourlyRate': 150,
// 'Hours': 40
// }
Assert.AreEqual(@"{""TaxRate"":0.15,""HourlyRate"":150,""Hours"":40}", result);
}
public void Json_StringEnumConverter_Test()
{
var obj = new StringEmumObject()
{
Worten = Antworten.Second, My = MyEnum.Value2
};
var json = JsonConvertX.SerializeObject(obj, JsonConvertX.IndentedSettings);
var newobj = JsonConvertX.DeserializeObject <StringEmumObject>(json, JsonConvertX.DefaultDeserializerSettings);
Assert.Equal(obj.Worten, newobj.Worten);
Assert.Equal(obj.My, newobj.My);
json = JsonConvertX.SerializeObject(obj, JsonConvertX.IndentedSettings);
newobj = JsonConvertX.DeserializeObject <StringEmumObject>(json, JsonConvertX.DefaultDeserializerSettings);
Assert.Equal(obj.Worten, newobj.Worten);
Assert.Equal(obj.My, newobj.My);
json = JsonConvertX.SerializeObject(obj, JsonConvertX.IndentedCamelCaseSettings);
newobj = JsonConvertX.DeserializeObject <StringEmumObject>(json, JsonConvertX.DefaultDeserializerSettings);
Assert.Equal(obj.Worten, newobj.Worten);
Assert.Equal(obj.My, newobj.My);
}
public void ListEvents()
{
SerializationEventTestList obj = new SerializationEventTestList
{
1.1m,
2.222222222m,
int.MaxValue,
Convert.ToDecimal(Math.PI)
};
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(@"[
-1.0,
1.1,
2.222222222,
2147483647.0,
3.14159265358979
]", 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 <SerializationEventTestList>(json);
Assert.AreEqual(11, obj.Member1);
Assert.AreEqual("Hello World!", obj.Member2);
Assert.AreEqual("This value was set during deserialization", obj.Member3);
Assert.AreEqual("This value was set after deserialization.", obj.Member4);
}
public void SerializeCircularReference()
{
CircularReferenceClass c1 = new CircularReferenceClass {
Name = "c1"
};
CircularReferenceClass c2 = new CircularReferenceClass {
Name = "c2"
};
CircularReferenceClass c3 = new CircularReferenceClass {
Name = "c3"
};
c1.Child = c2;
c2.Child = c3;
c3.Child = c1;
string json = JsonConvertX.SerializeObject(c1, Formatting.Indented, new JsonSerializerSettings
{
PreserveReferencesHandling = PreserveReferencesHandling.Objects
});
StringAssert.AreEqual(@"{
""$id"": ""1"",
""Name"": ""c1"",
""Child"": {
""$id"": ""2"",
""Name"": ""c2"",
""Child"": {
""$id"": ""3"",
""Name"": ""c3"",
""Child"": {
""$ref"": ""1""
}
}
}
}", json);
}
public void SerializeInvoice()
{
Invoice invoice = new Invoice
{
Company = "Acme Ltd.",
Amount = 50.0m,
Paid = false,
FollowUpDays = 30,
FollowUpEmailAddress = string.Empty,
PaidDate = null
};
string included = JsonConvertX.SerializeObject(invoice,
Formatting.Indented,
new JsonSerializerSettings {
});
StringAssert.AreEqual(@"{
""Company"": ""Acme Ltd."",
""Amount"": 50.0,
""Paid"": false,
""PaidDate"": null,
""FollowUpDays"": 30,
""FollowUpEmailAddress"": """"
}", included);
string ignored = JsonConvertX.SerializeObject(invoice,
Formatting.Indented,
new JsonSerializerSettings {
DefaultValueHandling = DefaultValueHandling.Ignore
});
StringAssert.AreEqual(@"{
""Company"": ""Acme Ltd."",
""Amount"": 50.0
}", ignored);
}
public void DictionaryEvents()
{
SerializationEventTestDictionary obj = new SerializationEventTestDictionary
{
{ 1.1m, "first" },
{ 2.222222222m, "second" },
{ int.MaxValue, "third" },
{ Convert.ToDecimal(Math.PI), "fourth" }
};
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(@"{
""1.1"": ""first"",
""2.222222222"": ""second"",
""2147483647"": ""third"",
""3.14159265358979"": ""fourth"",
""79228162514264337593543950335"": ""Inserted on serializing""
}", 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 <SerializationEventTestDictionary>(json);
Assert.AreEqual(11, obj.Member1);
Assert.AreEqual("Hello World!", obj.Member2);
Assert.AreEqual("This value was set during deserialization", obj.Member3);
Assert.AreEqual("This value was set after deserialization.", obj.Member4);
}
public void DictionaryCamelCasePropertyNames_Disabled()
{
Dictionary <string, string> values = new Dictionary <string, string>
{
{ "First", "Value1!" },
{ "Second", "Value2!" }
};
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
string json = JsonConvertX.SerializeObject(values, Formatting.Indented,
new JsonSerializerSettings
{
ContractResolver = contractResolver
});
StringAssert.AreEqual(@"{
""First"": ""Value1!"",
""Second"": ""Value2!""
}", json);
}
public void DeserializeGuid()
{
Item expected = new Item()
{
SourceTypeID = new Guid("d8220a4b-75b1-4b7a-8112-b7bdae956a45"),
BrokerID = new Guid("951663c4-924e-4c86-a57a-7ed737501dbd"),
Latitude = 33.657145,
Longitude = -117.766684,
TimeStamp = new DateTime(2000, 3, 1, 23, 59, 59, DateTimeKind.Utc),
Payload = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
};
string jsonString = JsonConvertX.SerializeObject(expected, Formatting.Indented);
StringAssert.AreEqual(@"{
""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"": """ + ReflectionUtils.GetTypeName(typeof(byte[]), 0, PreserveReferencesHandlingTests._bingderInstance) + @""",
""$value"": ""AAECAwQFBgcICQ==""
}
}", jsonString);
Item actual = JsonConvertX.DeserializeObject <Item>(jsonString, new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.ReadAhead
});
Assert.AreEqual(new Guid("d8220a4b-75b1-4b7a-8112-b7bdae956a45"), actual.SourceTypeID);
Assert.AreEqual(new Guid("951663c4-924e-4c86-a57a-7ed737501dbd"), actual.BrokerID);
byte[] bytes = (byte[])actual.Payload;
CollectionAssert.AreEquivalent(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, bytes);
}
public void NullValueHandlingBlogPost()
{
Movie movie = new Movie();
movie.Name = "Bad Boys III";
movie.Description = "It's no Bad Boys";
string included = JsonConvertX.SerializeObject(movie,
Formatting.Indented,
new JsonSerializerSettings {
});
// {
// "Name": "Bad Boys III",
// "Description": "It's no Bad Boys",
// "Classification": null,
// "Studio": null,
// "ReleaseDate": null,
// "ReleaseCountries": null
// }
string ignored = JsonConvertX.SerializeObject(movie,
Formatting.Indented,
new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
// {
// "Name": "Bad Boys III",
// "Description": "It's no Bad Boys"
// }
StringAssert.AreEqual(MovieNullValueHandlingIncludeExpectedResult, included);
StringAssert.AreEqual(MovieNullValueHandlingIgnoreExpectedResult, ignored);
}
public string ToJson()
{
return(JsonConvertX.SerializeObject(this, Formatting.Indented));
}
public void SerializeReadOnlyProperty()
{
Child c = new Child
{
PropertyName = "value?"
};
IList <string> l = new List <string>
{
"value!"
};
Parent p = new Parent
{
Child1 = c,
Child2 = c,
List1 = l,
List2 = l
};
string json = JsonConvertX.SerializeObject(p, new JsonSerializerSettings
{
Formatting = Formatting.Indented,
PreserveReferencesHandling = PreserveReferencesHandling.All
});
StringAssert.AreEqual(@"{
""$id"": ""1"",
""ReadOnlyChild"": {
""PropertyName"": ""value?""
},
""Child1"": {
""$id"": ""2"",
""PropertyName"": ""value?""
},
""Child2"": {
""$ref"": ""2""
},
""ReadOnlyList"": [
""value!""
],
""List1"": {
""$id"": ""3"",
""$values"": [
""value!""
]
},
""List2"": {
""$ref"": ""3""
}
}", json);
Parent newP = JsonConvertX.DeserializeObject <Parent>(json, new JsonSerializerSettings
{
Formatting = Formatting.Indented,
PreserveReferencesHandling = PreserveReferencesHandling.All
});
Assert.AreEqual("value?", newP.Child1.PropertyName);
Assert.AreEqual(newP.Child1, newP.Child2);
Assert.AreEqual(newP.Child1, newP.ReadOnlyChild);
Assert.AreEqual("value!", newP.List1[0]);
Assert.AreEqual(newP.List1, newP.List2);
Assert.AreEqual(newP.List1, newP.ReadOnlyList);
}
public void SerializeDefaultArray()
{
ExceptionAssert.Throws <InvalidOperationException>(
() => JsonConvertX.SerializeObject(default(ImmutableArray <int>), Formatting.Indented),
"This operation cannot be performed on a default instance of ImmutableArray<T>. Consider initializing the array, or checking the ImmutableArray<T>.IsDefault property.");
}
public void SerializeEntity()
{
Folder rootFolder = CreateEntitiesTestData();
string json = JsonConvertX.SerializeObject(rootFolder, Formatting.Indented, new IsoDateTimeConverter());
string expected = @"{
""$id"": ""1"",
""FolderId"": ""a4e8ba80-eb24-4591-bb1c-62d3ad83701e"",
""Name"": ""Root folder"",
""Description"": ""Description!"",
""CreatedDate"": ""2000-12-10T10:50:00Z"",
""Files"": [],
""ChildFolders"": [
{
""$id"": ""2"",
""FolderId"": ""484936e2-7cbb-4592-93ff-b2103e5705e4"",
""Name"": ""Child folder"",
""Description"": ""Description!"",
""CreatedDate"": ""2001-11-20T10:50:00Z"",
""Files"": [
{
""$id"": ""3"",
""FileId"": ""cc76d734-49f1-4616-bb38-41514228ac6c"",
""Name"": ""File 1"",
""Description"": ""Description!"",
""CreatedDate"": ""2002-10-30T10:50:00Z"",
""Folder"": {
""$ref"": ""2""
},
""EntityKey"": {
""$id"": ""4"",
""EntitySetName"": ""File"",
""EntityContainerName"": ""DataServicesTestDatabaseEntities"",
""EntityKeyValues"": [
{
""Key"": ""FileId"",
""Type"": ""System.Guid"",
""Value"": ""cc76d734-49f1-4616-bb38-41514228ac6c""
}
]
}
}
],
""ChildFolders"": [],
""ParentFolder"": {
""$ref"": ""1""
},
""EntityKey"": {
""$id"": ""5"",
""EntitySetName"": ""Folder"",
""EntityContainerName"": ""DataServicesTestDatabaseEntities"",
""EntityKeyValues"": [
{
""Key"": ""FolderId"",
""Type"": ""System.Guid"",
""Value"": ""484936e2-7cbb-4592-93ff-b2103e5705e4""
}
]
}
}
],
""ParentFolder"": null,
""EntityKey"": {
""$id"": ""6"",
""EntitySetName"": ""Folder"",
""EntityContainerName"": ""DataServicesTestDatabaseEntities"",
""EntityKeyValues"": [
{
""Key"": ""FolderId"",
""Type"": ""System.Guid"",
""Value"": ""a4e8ba80-eb24-4591-bb1c-62d3ad83701e""
}
]
}
}";
StringAssert.AreEqual(expected, json);
}
public void SerializeEntityCamelCase()
{
Folder rootFolder = CreateEntitiesTestData();
JsonSerializerSettings settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Converters = { new IsoDateTimeConverter() }
};
string json = JsonConvertX.SerializeObject(rootFolder, settings);
Console.WriteLine(json);
string expected = @"{
""$id"": ""1"",
""folderId"": ""a4e8ba80-eb24-4591-bb1c-62d3ad83701e"",
""name"": ""Root folder"",
""description"": ""Description!"",
""createdDate"": ""2000-12-10T10:50:00Z"",
""files"": [],
""childFolders"": [
{
""$id"": ""2"",
""folderId"": ""484936e2-7cbb-4592-93ff-b2103e5705e4"",
""name"": ""Child folder"",
""description"": ""Description!"",
""createdDate"": ""2001-11-20T10:50:00Z"",
""files"": [
{
""$id"": ""3"",
""fileId"": ""cc76d734-49f1-4616-bb38-41514228ac6c"",
""name"": ""File 1"",
""description"": ""Description!"",
""createdDate"": ""2002-10-30T10:50:00Z"",
""folder"": {
""$ref"": ""2""
},
""entityKey"": {
""$id"": ""4"",
""entitySetName"": ""File"",
""entityContainerName"": ""DataServicesTestDatabaseEntities"",
""entityKeyValues"": [
{
""key"": ""FileId"",
""type"": ""System.Guid"",
""value"": ""cc76d734-49f1-4616-bb38-41514228ac6c""
}
]
}
}
],
""childFolders"": [],
""parentFolder"": {
""$ref"": ""1""
},
""entityKey"": {
""$id"": ""5"",
""entitySetName"": ""Folder"",
""entityContainerName"": ""DataServicesTestDatabaseEntities"",
""entityKeyValues"": [
{
""key"": ""FolderId"",
""type"": ""System.Guid"",
""value"": ""484936e2-7cbb-4592-93ff-b2103e5705e4""
}
]
}
}
],
""parentFolder"": null,
""entityKey"": {
""$id"": ""6"",
""entitySetName"": ""Folder"",
""entityContainerName"": ""DataServicesTestDatabaseEntities"",
""entityKeyValues"": [
{
""key"": ""FolderId"",
""type"": ""System.Guid"",
""value"": ""a4e8ba80-eb24-4591-bb1c-62d3ad83701e""
}
]
}
}";
StringAssert.AreEqual(expected, json);
}
public void SerializeExtensionData_NoGetter()
{
ExceptionAssert.Throws <JsonException>(
() => { JsonConvertX.SerializeObject(new DocNoGetter()); },
"Invalid extension data attribute on 'JsonExtensions.Tests.Serialization.ExtensionDataTests+DocNoGetter'. Member 'Content' must have a getter.");
}
public void SerializingErrorIn3DArray()
{
ListErrorObject[,,] c = new ListErrorObject[, , ]
{
{
{
new ListErrorObject
{
Member = "Value1",
ThrowError = "Handle this!",
Member2 = "Member1"
},
new ListErrorObject
{
Member = "Value2",
Member2 = "Member2"
},
new ListErrorObject
{
Member = "Value3",
ThrowError = "Handle that!",
Member2 = "Member3"
}
},
{
new ListErrorObject
{
Member = "Value1",
ThrowError = "Handle this!",
Member2 = "Member1"
},
new ListErrorObject
{
Member = "Value2",
Member2 = "Member2"
},
new ListErrorObject
{
Member = "Value3",
ThrowError = "Handle that!",
Member2 = "Member3"
}
}
}
};
string json = JsonConvertX.SerializeObject(c, new JsonSerializerSettings
{
Formatting = Formatting.Indented,
Error = (s, e) =>
{
if (e.CurrentObject.GetType().IsArray)
{
e.ErrorContext.Handled = true;
}
}
});
StringAssert.AreEqual(@"[
[
[
{
""Member"": ""Value1"",
""ThrowError"": ""Handle this!"",
""Member2"": ""Member1""
},
{
""Member"": ""Value2""
},
{
""Member"": ""Value3"",
""ThrowError"": ""Handle that!"",
""Member2"": ""Member3""
}
],
[
{
""Member"": ""Value1"",
""ThrowError"": ""Handle this!"",
""Member2"": ""Member1""
},
{
""Member"": ""Value2""
},
{
""Member"": ""Value3"",
""ThrowError"": ""Handle that!"",
""Member2"": ""Member3""
}
]
]
]", json);
}
public void VirtualShouldSerializeSimple()
{
string json = JsonConvertX.SerializeObject(new B());
Assert.AreEqual("{}", json);
}
public void SerializeMultiValueEntityKeyCameCase()
{
EntityKey e = new EntityKey("DataServicesTestDatabaseEntities.Folder",
new List <EntityKeyMember>
{
new EntityKeyMember("GuidId", new Guid("A4E8BA80-EB24-4591-BB1C-62D3AD83701E")),
new EntityKeyMember("IntId", int.MaxValue),
new EntityKeyMember("LongId", long.MaxValue),
new EntityKeyMember("StringId", "String!"),
new EntityKeyMember("DateTimeId", new DateTime(2000, 12, 10, 10, 50, 0, DateTimeKind.Utc))
});
string json = JsonConvertX.SerializeObject(e, Formatting.Indented);
StringAssert.AreEqual(@"{
""$id"": ""1"",
""EntitySetName"": ""Folder"",
""EntityContainerName"": ""DataServicesTestDatabaseEntities"",
""EntityKeyValues"": [
{
""Key"": ""GuidId"",
""Type"": ""System.Guid"",
""Value"": ""a4e8ba80-eb24-4591-bb1c-62d3ad83701e""
},
{
""Key"": ""IntId"",
""Type"": ""System.Int32"",
""Value"": ""2147483647""
},
{
""Key"": ""LongId"",
""Type"": ""System.Int64"",
""Value"": ""9223372036854775807""
},
{
""Key"": ""StringId"",
""Type"": ""System.String"",
""Value"": ""String!""
},
{
""Key"": ""DateTimeId"",
""Type"": ""System.DateTime"",
""Value"": ""12/10/2000 10:50:00""
}
]
}", json);
EntityKey newKey = JsonConvertX.DeserializeObject <EntityKey>(json);
Assert.IsFalse(ReferenceEquals(e, newKey));
Assert.AreEqual(5, newKey.EntityKeyValues.Length);
Assert.AreEqual("GuidId", newKey.EntityKeyValues[0].Key);
Assert.AreEqual(new Guid("A4E8BA80-EB24-4591-BB1C-62D3AD83701E"), newKey.EntityKeyValues[0].Value);
Assert.AreEqual("IntId", newKey.EntityKeyValues[1].Key);
Assert.AreEqual(int.MaxValue, newKey.EntityKeyValues[1].Value);
Assert.AreEqual("LongId", newKey.EntityKeyValues[2].Key);
Assert.AreEqual(long.MaxValue, newKey.EntityKeyValues[2].Value);
Assert.AreEqual("StringId", newKey.EntityKeyValues[3].Key);
Assert.AreEqual("String!", newKey.EntityKeyValues[3].Value);
Assert.AreEqual("DateTimeId", newKey.EntityKeyValues[4].Key);
Assert.AreEqual(new DateTime(2000, 12, 10, 10, 50, 0, DateTimeKind.Utc), newKey.EntityKeyValues[4].Value);
}
public void JsonObjectTypeDeserializer_Test()
{
var dict = new Dictionary <string, object>(StringComparer.Ordinal)
{
["name"] = "apple",
["Age"] = 18,
["Id"] = Guid.NewGuid(),
["createDateTime"] = DateTime.Now,
["combGuid"] = CombGuid.NewComb(),
["dtOffset"] = DateTimeOffset.Now,
["double"] = 10.56d,
["float"] = 20.06f,
["decimal"] = 8.000056M,
["bytes"] = new byte[] { 1 },
["emptybytes"] = new byte[0],
["Worten1"] = 0,
["Worten"] = "second",
};
var json = JsonConvertX.SerializeObject(dict, JsonConvertX.DefaultSettings);
var newDict = JsonConvertX.DeserializeObject <Dictionary <string, object> >(json, JsonConvertX.DefaultSettings);
Assert.Equal(dict["name"], JsonObjectTypeDeserializer.Deserialize <string>(newDict, "name"));
Assert.Equal(dict["Age"], JsonObjectTypeDeserializer.Deserialize <int>(newDict, "Age"));
Assert.Equal(dict["Id"], JsonObjectTypeDeserializer.Deserialize <Guid>(newDict, "Id"));
// camelcase key test
Assert.Equal(dict["createDateTime"], JsonObjectTypeDeserializer.Deserialize <DateTime>(newDict, "CreateDateTime"));
Assert.Equal(dict["createDateTime"], JsonObjectTypeDeserializer.Deserialize <DateTimeOffset>(newDict, "CreateDateTime").DateTime);
Assert.Equal(dict["combGuid"], JsonObjectTypeDeserializer.Deserialize <CombGuid>(newDict, "combGuid"));
Assert.Equal(dict["dtOffset"], JsonObjectTypeDeserializer.Deserialize <DateTimeOffset>(newDict, "dtOffset"));
Assert.Equal(dict["double"], JsonObjectTypeDeserializer.Deserialize <double>(newDict, "double"));
Assert.Equal(dict["float"], JsonObjectTypeDeserializer.Deserialize <float>(newDict, "float"));
Assert.Equal(dict["decimal"], JsonObjectTypeDeserializer.Deserialize <decimal>(newDict, "decimal"));
Assert.Equal(dict["bytes"], JsonObjectTypeDeserializer.Deserialize <byte[]>(newDict, "bytes"));
Assert.Equal(dict["emptybytes"], JsonObjectTypeDeserializer.Deserialize <byte[]>(newDict, "emptybytes"));
Assert.Equal(Antworten.First, JsonObjectTypeDeserializer.Deserialize <Antworten>(newDict, "Worten1"));
Assert.Equal(Antworten.Second, JsonObjectTypeDeserializer.Deserialize <Antworten>(newDict, "Worten"));
Assert.Equal(dict["name"], newDict.Deserialize <string>("name"));
Assert.Equal(dict["Age"], newDict.Deserialize <int>("Age"));
Assert.Equal(dict["Id"], newDict.Deserialize <Guid>("Id"));
// camelcase key test
Assert.Equal(dict["createDateTime"], newDict.Deserialize <DateTime>("CreateDateTime"));
Assert.Equal(dict["combGuid"], newDict.Deserialize <CombGuid>("combGuid"));
Assert.Equal(dict["dtOffset"], newDict.Deserialize <DateTimeOffset>("dtOffset"));
Assert.Equal(dict["double"], newDict.Deserialize <double>("double"));
Assert.Equal(dict["float"], newDict.Deserialize <float>("float"));
Assert.Equal(dict["decimal"], newDict.Deserialize <decimal>("decimal"));
Assert.Equal(dict["bytes"], newDict.Deserialize <byte[]>("bytes"));
Assert.Equal(dict["emptybytes"], newDict.Deserialize <byte[]>("emptybytes"));
Assert.Equal(dict["name"], dict.Deserialize <string>("name"));
Assert.Equal(dict["Age"], dict.Deserialize <int>("Age"));
Assert.Equal(dict["Id"], dict.Deserialize <Guid>("Id"));
// camelcase key test
Assert.Equal(dict["createDateTime"], dict.Deserialize <DateTime>("CreateDateTime"));
Assert.Equal(dict["combGuid"], dict.Deserialize <CombGuid>("combGuid"));
Assert.Equal(dict["dtOffset"], dict.Deserialize <DateTimeOffset>("dtOffset"));
Assert.Equal(dict["double"], dict.Deserialize <double>("double"));
Assert.Equal(dict["float"], dict.Deserialize <float>("float"));
Assert.Equal(dict["decimal"], dict.Deserialize <decimal>("decimal"));
Assert.Equal(dict["bytes"], dict.Deserialize <byte[]>("bytes"));
Assert.Equal(dict["emptybytes"], dict.Deserialize <byte[]>("emptybytes"));
var combGuid = CombGuid.NewComb();
var jsonStr = combGuid.ToString();
Assert.Equal(combGuid, JsonObjectTypeDeserializer.Deserialize <CombGuid>(jsonStr));
Assert.Equal(combGuid, JsonObjectTypeDeserializer.Deserialize <CombGuid>(combGuid));
Assert.Equal((Guid)combGuid, JsonObjectTypeDeserializer.Deserialize <Guid>(combGuid));
Assert.Equal(combGuid.ToString(), JsonObjectTypeDeserializer.Deserialize <string>(combGuid));
Assert.Equal(combGuid.ToByteArray(), JsonObjectTypeDeserializer.Deserialize <byte[]>(combGuid));
Assert.Equal(combGuid.DateTime, JsonObjectTypeDeserializer.Deserialize <DateTime>(combGuid));
Assert.Equal(DateTime.UtcNow.Date, JsonObjectTypeDeserializer.Deserialize <DateTime>(combGuid).Date);
Assert.Equal(new DateTimeOffset(combGuid.DateTime), JsonObjectTypeDeserializer.Deserialize <DateTimeOffset>(combGuid));
}
