-Line endings
This commit is contained in:
@@ -1,168 +1,168 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
#if !SILVERLIGHT && !PocketPC && !NET20 && !NETFX_CORE
|
||||
using System.Data.Linq;
|
||||
#endif
|
||||
#if !(SILVERLIGHT || NETFX_CORE)
|
||||
using System.Data.SqlTypes;
|
||||
#endif
|
||||
using System.Text;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class BinaryConverterTests : TestFixtureBase
|
||||
{
|
||||
private static readonly byte[] TestData = Encoding.UTF8.GetBytes("This is some test data!!!");
|
||||
|
||||
public class ByteArrayClass
|
||||
{
|
||||
public byte[] ByteArray { get; set; }
|
||||
public byte[] NullByteArray { get; set; }
|
||||
}
|
||||
|
||||
#if !SILVERLIGHT && !PocketPC && !NET20 && !NETFX_CORE
|
||||
[Test]
|
||||
public void DeserializeBinaryClass()
|
||||
{
|
||||
string json = @"{
|
||||
""Binary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullBinary"": null
|
||||
}";
|
||||
|
||||
BinaryClass binaryClass = JsonConvert.DeserializeObject<BinaryClass>(json, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(new Binary(TestData), binaryClass.Binary);
|
||||
Assert.AreEqual(null, binaryClass.NullBinary);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeBinaryClassFromJsonArray()
|
||||
{
|
||||
string json = @"{
|
||||
""Binary"": [0, 1, 2, 3],
|
||||
""NullBinary"": null
|
||||
}";
|
||||
|
||||
BinaryClass binaryClass = JsonConvert.DeserializeObject<BinaryClass>(json, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(new byte[] { 0, 1, 2, 3 }, binaryClass.Binary.ToArray());
|
||||
Assert.AreEqual(null, binaryClass.NullBinary);
|
||||
}
|
||||
|
||||
public class BinaryClass
|
||||
{
|
||||
public Binary Binary { get; set; }
|
||||
public Binary NullBinary { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeBinaryClass()
|
||||
{
|
||||
BinaryClass binaryClass = new BinaryClass();
|
||||
binaryClass.Binary = new Binary(TestData);
|
||||
binaryClass.NullBinary = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(binaryClass, Formatting.Indented, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Binary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullBinary"": null
|
||||
}", json);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void SerializeByteArrayClass()
|
||||
{
|
||||
ByteArrayClass byteArrayClass = new ByteArrayClass();
|
||||
byteArrayClass.ByteArray = TestData;
|
||||
byteArrayClass.NullByteArray = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(byteArrayClass, Formatting.Indented, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""ByteArray"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullByteArray"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
#if !(SILVERLIGHT || NETFX_CORE)
|
||||
public class SqlBinaryClass
|
||||
{
|
||||
public SqlBinary SqlBinary { get; set; }
|
||||
public SqlBinary? NullableSqlBinary1 { get; set; }
|
||||
public SqlBinary? NullableSqlBinary2 { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeSqlBinaryClass()
|
||||
{
|
||||
SqlBinaryClass sqlBinaryClass = new SqlBinaryClass();
|
||||
sqlBinaryClass.SqlBinary = new SqlBinary(TestData);
|
||||
sqlBinaryClass.NullableSqlBinary1 = new SqlBinary(TestData);
|
||||
sqlBinaryClass.NullableSqlBinary2 = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(sqlBinaryClass, Formatting.Indented, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""SqlBinary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullableSqlBinary1"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullableSqlBinary2"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeSqlBinaryClass()
|
||||
{
|
||||
string json = @"{
|
||||
""SqlBinary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullableSqlBinary1"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullableSqlBinary2"": null
|
||||
}";
|
||||
|
||||
SqlBinaryClass sqlBinaryClass = JsonConvert.DeserializeObject<SqlBinaryClass>(json, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(new SqlBinary(TestData), sqlBinaryClass.SqlBinary);
|
||||
Assert.AreEqual(new SqlBinary(TestData), sqlBinaryClass.NullableSqlBinary1);
|
||||
Assert.AreEqual(null, sqlBinaryClass.NullableSqlBinary2);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void DeserializeByteArrayClass()
|
||||
{
|
||||
string json = @"{
|
||||
""ByteArray"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullByteArray"": null
|
||||
}";
|
||||
|
||||
ByteArrayClass byteArrayClass = JsonConvert.DeserializeObject<ByteArrayClass>(json, new BinaryConverter());
|
||||
|
||||
CollectionAssert.AreEquivalent(TestData, byteArrayClass.ByteArray);
|
||||
Assert.AreEqual(null, byteArrayClass.NullByteArray);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeByteArrayFromJsonArray()
|
||||
{
|
||||
string json = @"{
|
||||
""ByteArray"": [0, 1, 2, 3],
|
||||
""NullByteArray"": null
|
||||
}";
|
||||
|
||||
ByteArrayClass c = JsonConvert.DeserializeObject<ByteArrayClass>(json);
|
||||
Assert.IsNotNull(c.ByteArray);
|
||||
Assert.AreEqual(4, c.ByteArray.Length);
|
||||
CollectionAssert.AreEquivalent(new byte[] { 0, 1, 2, 3 }, c.ByteArray);
|
||||
}
|
||||
}
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
#if !SILVERLIGHT && !PocketPC && !NET20 && !NETFX_CORE
|
||||
using System.Data.Linq;
|
||||
#endif
|
||||
#if !(SILVERLIGHT || NETFX_CORE)
|
||||
using System.Data.SqlTypes;
|
||||
#endif
|
||||
using System.Text;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class BinaryConverterTests : TestFixtureBase
|
||||
{
|
||||
private static readonly byte[] TestData = Encoding.UTF8.GetBytes("This is some test data!!!");
|
||||
|
||||
public class ByteArrayClass
|
||||
{
|
||||
public byte[] ByteArray { get; set; }
|
||||
public byte[] NullByteArray { get; set; }
|
||||
}
|
||||
|
||||
#if !SILVERLIGHT && !PocketPC && !NET20 && !NETFX_CORE
|
||||
[Test]
|
||||
public void DeserializeBinaryClass()
|
||||
{
|
||||
string json = @"{
|
||||
""Binary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullBinary"": null
|
||||
}";
|
||||
|
||||
BinaryClass binaryClass = JsonConvert.DeserializeObject<BinaryClass>(json, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(new Binary(TestData), binaryClass.Binary);
|
||||
Assert.AreEqual(null, binaryClass.NullBinary);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeBinaryClassFromJsonArray()
|
||||
{
|
||||
string json = @"{
|
||||
""Binary"": [0, 1, 2, 3],
|
||||
""NullBinary"": null
|
||||
}";
|
||||
|
||||
BinaryClass binaryClass = JsonConvert.DeserializeObject<BinaryClass>(json, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(new byte[] { 0, 1, 2, 3 }, binaryClass.Binary.ToArray());
|
||||
Assert.AreEqual(null, binaryClass.NullBinary);
|
||||
}
|
||||
|
||||
public class BinaryClass
|
||||
{
|
||||
public Binary Binary { get; set; }
|
||||
public Binary NullBinary { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeBinaryClass()
|
||||
{
|
||||
BinaryClass binaryClass = new BinaryClass();
|
||||
binaryClass.Binary = new Binary(TestData);
|
||||
binaryClass.NullBinary = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(binaryClass, Formatting.Indented, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Binary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullBinary"": null
|
||||
}", json);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void SerializeByteArrayClass()
|
||||
{
|
||||
ByteArrayClass byteArrayClass = new ByteArrayClass();
|
||||
byteArrayClass.ByteArray = TestData;
|
||||
byteArrayClass.NullByteArray = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(byteArrayClass, Formatting.Indented, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""ByteArray"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullByteArray"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
#if !(SILVERLIGHT || NETFX_CORE)
|
||||
public class SqlBinaryClass
|
||||
{
|
||||
public SqlBinary SqlBinary { get; set; }
|
||||
public SqlBinary? NullableSqlBinary1 { get; set; }
|
||||
public SqlBinary? NullableSqlBinary2 { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeSqlBinaryClass()
|
||||
{
|
||||
SqlBinaryClass sqlBinaryClass = new SqlBinaryClass();
|
||||
sqlBinaryClass.SqlBinary = new SqlBinary(TestData);
|
||||
sqlBinaryClass.NullableSqlBinary1 = new SqlBinary(TestData);
|
||||
sqlBinaryClass.NullableSqlBinary2 = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(sqlBinaryClass, Formatting.Indented, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""SqlBinary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullableSqlBinary1"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullableSqlBinary2"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeSqlBinaryClass()
|
||||
{
|
||||
string json = @"{
|
||||
""SqlBinary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullableSqlBinary1"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullableSqlBinary2"": null
|
||||
}";
|
||||
|
||||
SqlBinaryClass sqlBinaryClass = JsonConvert.DeserializeObject<SqlBinaryClass>(json, new BinaryConverter());
|
||||
|
||||
Assert.AreEqual(new SqlBinary(TestData), sqlBinaryClass.SqlBinary);
|
||||
Assert.AreEqual(new SqlBinary(TestData), sqlBinaryClass.NullableSqlBinary1);
|
||||
Assert.AreEqual(null, sqlBinaryClass.NullableSqlBinary2);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void DeserializeByteArrayClass()
|
||||
{
|
||||
string json = @"{
|
||||
""ByteArray"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
|
||||
""NullByteArray"": null
|
||||
}";
|
||||
|
||||
ByteArrayClass byteArrayClass = JsonConvert.DeserializeObject<ByteArrayClass>(json, new BinaryConverter());
|
||||
|
||||
CollectionAssert.AreEquivalent(TestData, byteArrayClass.ByteArray);
|
||||
Assert.AreEqual(null, byteArrayClass.NullByteArray);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeByteArrayFromJsonArray()
|
||||
{
|
||||
string json = @"{
|
||||
""ByteArray"": [0, 1, 2, 3],
|
||||
""NullByteArray"": null
|
||||
}";
|
||||
|
||||
ByteArrayClass c = JsonConvert.DeserializeObject<ByteArrayClass>(json);
|
||||
Assert.IsNotNull(c.ByteArray);
|
||||
Assert.AreEqual(4, c.ByteArray.Length);
|
||||
CollectionAssert.AreEquivalent(new byte[] { 0, 1, 2, 3 }, c.ByteArray);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,235 +1,235 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class CustomCreationConverterTests : TestFixtureBase
|
||||
{
|
||||
public interface IPerson
|
||||
{
|
||||
string FirstName { get; set; }
|
||||
string LastName { get; set; }
|
||||
DateTime BirthDate { get; set; }
|
||||
}
|
||||
|
||||
public class Employee : IPerson
|
||||
{
|
||||
public string FirstName { get; set; }
|
||||
public string LastName { get; set; }
|
||||
public DateTime BirthDate { get; set; }
|
||||
|
||||
public string Department { get; set; }
|
||||
public string JobTitle { get; set; }
|
||||
}
|
||||
|
||||
public class PersonConverter : CustomCreationConverter<IPerson>
|
||||
{
|
||||
public override IPerson Create(Type objectType)
|
||||
{
|
||||
return new Employee();
|
||||
}
|
||||
}
|
||||
|
||||
public void DeserializeObject()
|
||||
{
|
||||
string json = JsonConvert.SerializeObject(new List<Employee>
|
||||
{
|
||||
new Employee
|
||||
{
|
||||
BirthDate = new DateTime(1977, 12, 30, 1, 1, 1, DateTimeKind.Utc),
|
||||
FirstName = "Maurice",
|
||||
LastName = "Moss",
|
||||
Department = "IT",
|
||||
JobTitle = "Support"
|
||||
},
|
||||
new Employee
|
||||
{
|
||||
BirthDate = new DateTime(1978, 3, 15, 1, 1, 1, DateTimeKind.Utc),
|
||||
FirstName = "Jen",
|
||||
LastName = "Barber",
|
||||
Department = "IT",
|
||||
JobTitle = "Manager"
|
||||
}
|
||||
}, Formatting.Indented);
|
||||
|
||||
//[
|
||||
// {
|
||||
// "FirstName": "Maurice",
|
||||
// "LastName": "Moss",
|
||||
// "BirthDate": "\/Date(252291661000)\/",
|
||||
// "Department": "IT",
|
||||
// "JobTitle": "Support"
|
||||
// },
|
||||
// {
|
||||
// "FirstName": "Jen",
|
||||
// "LastName": "Barber",
|
||||
// "BirthDate": "\/Date(258771661000)\/",
|
||||
// "Department": "IT",
|
||||
// "JobTitle": "Manager"
|
||||
// }
|
||||
//]
|
||||
|
||||
List<IPerson> people = JsonConvert.DeserializeObject<List<IPerson>>(json, new PersonConverter());
|
||||
|
||||
IPerson person = people[0];
|
||||
|
||||
Console.WriteLine(person.GetType());
|
||||
// Newtonsoft.Json.Tests.Employee
|
||||
|
||||
Console.WriteLine(person.FirstName);
|
||||
// Maurice
|
||||
|
||||
Employee employee = (Employee)person;
|
||||
|
||||
Console.WriteLine(employee.JobTitle);
|
||||
// Support
|
||||
}
|
||||
|
||||
public class MyClass
|
||||
{
|
||||
public string Value { get; set; }
|
||||
|
||||
[JsonConverter(typeof(MyThingConverter))]
|
||||
public IThing Thing { get; set; }
|
||||
}
|
||||
|
||||
public interface IThing
|
||||
{
|
||||
int Number { get; }
|
||||
}
|
||||
|
||||
public class MyThing : IThing
|
||||
{
|
||||
public int Number { get; set; }
|
||||
}
|
||||
|
||||
public class MyThingConverter : CustomCreationConverter<IThing>
|
||||
{
|
||||
public override IThing Create(Type objectType)
|
||||
{
|
||||
return new MyThing();
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AssertDoesDeserialize()
|
||||
{
|
||||
const string json = @"{
|
||||
""Value"": ""A value"",
|
||||
""Thing"": {
|
||||
""Number"": 123
|
||||
}
|
||||
}
|
||||
";
|
||||
MyClass myClass = JsonConvert.DeserializeObject<MyClass>(json);
|
||||
Assert.IsNotNull(myClass);
|
||||
Assert.AreEqual("A value", myClass.Value);
|
||||
Assert.IsNotNull(myClass.Thing);
|
||||
Assert.AreEqual(123, myClass.Thing.Number);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AssertShouldSerializeTest()
|
||||
{
|
||||
MyClass myClass = new MyClass
|
||||
{
|
||||
Value = "Foo",
|
||||
Thing = new MyThing { Number = 456, }
|
||||
};
|
||||
string json = JsonConvert.SerializeObject(myClass); // <-- Exception here
|
||||
|
||||
const string expected = @"{""Value"":""Foo"",""Thing"":{""Number"":456}}";
|
||||
Assert.AreEqual(expected, json);
|
||||
}
|
||||
|
||||
internal interface IRange<T>
|
||||
{
|
||||
T First { get; }
|
||||
T Last { get; }
|
||||
}
|
||||
|
||||
internal class Range<T> : IRange<T>
|
||||
{
|
||||
public T First { get; set; }
|
||||
public T Last { get; set; }
|
||||
}
|
||||
|
||||
internal class NullInterfaceTestClass
|
||||
{
|
||||
public virtual Guid Id { get; set; }
|
||||
public virtual int? Year { get; set; }
|
||||
public virtual string Company { get; set; }
|
||||
public virtual IRange<decimal> DecimalRange { get; set; }
|
||||
public virtual IRange<int> IntRange { get; set; }
|
||||
public virtual IRange<decimal> NullDecimalRange { get; set; }
|
||||
}
|
||||
|
||||
internal class DecimalRangeConverter : CustomCreationConverter<IRange<decimal>>
|
||||
{
|
||||
public override IRange<decimal> Create(Type objectType)
|
||||
{
|
||||
return new Range<decimal>();
|
||||
}
|
||||
}
|
||||
|
||||
internal class IntRangeConverter : CustomCreationConverter<IRange<int>>
|
||||
{
|
||||
public override IRange<int> Create(Type objectType)
|
||||
{
|
||||
return new Range<int>();
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeAndConvertNullValue()
|
||||
{
|
||||
NullInterfaceTestClass initial = new NullInterfaceTestClass
|
||||
{
|
||||
Company = "Company!",
|
||||
DecimalRange = new Range<decimal> { First = 0, Last = 1 },
|
||||
Id = new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
|
||||
IntRange = new Range<int> { First = int.MinValue, Last = int.MaxValue },
|
||||
Year = 2010,
|
||||
NullDecimalRange = null
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(initial, Formatting.Indented);
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Id"": ""00000001-0002-0003-0405-060708090a0b"",
|
||||
""Year"": 2010,
|
||||
""Company"": ""Company!"",
|
||||
""DecimalRange"": {
|
||||
""First"": 0.0,
|
||||
""Last"": 1.0
|
||||
},
|
||||
""IntRange"": {
|
||||
""First"": -2147483648,
|
||||
""Last"": 2147483647
|
||||
},
|
||||
""NullDecimalRange"": null
|
||||
}", json);
|
||||
|
||||
NullInterfaceTestClass deserialized = JsonConvert.DeserializeObject<NullInterfaceTestClass>(
|
||||
json, new IntRangeConverter(), new DecimalRangeConverter());
|
||||
|
||||
Assert.AreEqual("Company!", deserialized.Company);
|
||||
Assert.AreEqual(new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), deserialized.Id);
|
||||
Assert.AreEqual(0, deserialized.DecimalRange.First);
|
||||
Assert.AreEqual(1, deserialized.DecimalRange.Last);
|
||||
Assert.AreEqual(int.MinValue, deserialized.IntRange.First);
|
||||
Assert.AreEqual(int.MaxValue, deserialized.IntRange.Last);
|
||||
Assert.AreEqual(null, deserialized.NullDecimalRange);
|
||||
Assert.AreEqual(2010, deserialized.Year);
|
||||
}
|
||||
}
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class CustomCreationConverterTests : TestFixtureBase
|
||||
{
|
||||
public interface IPerson
|
||||
{
|
||||
string FirstName { get; set; }
|
||||
string LastName { get; set; }
|
||||
DateTime BirthDate { get; set; }
|
||||
}
|
||||
|
||||
public class Employee : IPerson
|
||||
{
|
||||
public string FirstName { get; set; }
|
||||
public string LastName { get; set; }
|
||||
public DateTime BirthDate { get; set; }
|
||||
|
||||
public string Department { get; set; }
|
||||
public string JobTitle { get; set; }
|
||||
}
|
||||
|
||||
public class PersonConverter : CustomCreationConverter<IPerson>
|
||||
{
|
||||
public override IPerson Create(Type objectType)
|
||||
{
|
||||
return new Employee();
|
||||
}
|
||||
}
|
||||
|
||||
public void DeserializeObject()
|
||||
{
|
||||
string json = JsonConvert.SerializeObject(new List<Employee>
|
||||
{
|
||||
new Employee
|
||||
{
|
||||
BirthDate = new DateTime(1977, 12, 30, 1, 1, 1, DateTimeKind.Utc),
|
||||
FirstName = "Maurice",
|
||||
LastName = "Moss",
|
||||
Department = "IT",
|
||||
JobTitle = "Support"
|
||||
},
|
||||
new Employee
|
||||
{
|
||||
BirthDate = new DateTime(1978, 3, 15, 1, 1, 1, DateTimeKind.Utc),
|
||||
FirstName = "Jen",
|
||||
LastName = "Barber",
|
||||
Department = "IT",
|
||||
JobTitle = "Manager"
|
||||
}
|
||||
}, Formatting.Indented);
|
||||
|
||||
//[
|
||||
// {
|
||||
// "FirstName": "Maurice",
|
||||
// "LastName": "Moss",
|
||||
// "BirthDate": "\/Date(252291661000)\/",
|
||||
// "Department": "IT",
|
||||
// "JobTitle": "Support"
|
||||
// },
|
||||
// {
|
||||
// "FirstName": "Jen",
|
||||
// "LastName": "Barber",
|
||||
// "BirthDate": "\/Date(258771661000)\/",
|
||||
// "Department": "IT",
|
||||
// "JobTitle": "Manager"
|
||||
// }
|
||||
//]
|
||||
|
||||
List<IPerson> people = JsonConvert.DeserializeObject<List<IPerson>>(json, new PersonConverter());
|
||||
|
||||
IPerson person = people[0];
|
||||
|
||||
Console.WriteLine(person.GetType());
|
||||
// Newtonsoft.Json.Tests.Employee
|
||||
|
||||
Console.WriteLine(person.FirstName);
|
||||
// Maurice
|
||||
|
||||
Employee employee = (Employee)person;
|
||||
|
||||
Console.WriteLine(employee.JobTitle);
|
||||
// Support
|
||||
}
|
||||
|
||||
public class MyClass
|
||||
{
|
||||
public string Value { get; set; }
|
||||
|
||||
[JsonConverter(typeof(MyThingConverter))]
|
||||
public IThing Thing { get; set; }
|
||||
}
|
||||
|
||||
public interface IThing
|
||||
{
|
||||
int Number { get; }
|
||||
}
|
||||
|
||||
public class MyThing : IThing
|
||||
{
|
||||
public int Number { get; set; }
|
||||
}
|
||||
|
||||
public class MyThingConverter : CustomCreationConverter<IThing>
|
||||
{
|
||||
public override IThing Create(Type objectType)
|
||||
{
|
||||
return new MyThing();
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AssertDoesDeserialize()
|
||||
{
|
||||
const string json = @"{
|
||||
""Value"": ""A value"",
|
||||
""Thing"": {
|
||||
""Number"": 123
|
||||
}
|
||||
}
|
||||
";
|
||||
MyClass myClass = JsonConvert.DeserializeObject<MyClass>(json);
|
||||
Assert.IsNotNull(myClass);
|
||||
Assert.AreEqual("A value", myClass.Value);
|
||||
Assert.IsNotNull(myClass.Thing);
|
||||
Assert.AreEqual(123, myClass.Thing.Number);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void AssertShouldSerializeTest()
|
||||
{
|
||||
MyClass myClass = new MyClass
|
||||
{
|
||||
Value = "Foo",
|
||||
Thing = new MyThing { Number = 456, }
|
||||
};
|
||||
string json = JsonConvert.SerializeObject(myClass); // <-- Exception here
|
||||
|
||||
const string expected = @"{""Value"":""Foo"",""Thing"":{""Number"":456}}";
|
||||
Assert.AreEqual(expected, json);
|
||||
}
|
||||
|
||||
internal interface IRange<T>
|
||||
{
|
||||
T First { get; }
|
||||
T Last { get; }
|
||||
}
|
||||
|
||||
internal class Range<T> : IRange<T>
|
||||
{
|
||||
public T First { get; set; }
|
||||
public T Last { get; set; }
|
||||
}
|
||||
|
||||
internal class NullInterfaceTestClass
|
||||
{
|
||||
public virtual Guid Id { get; set; }
|
||||
public virtual int? Year { get; set; }
|
||||
public virtual string Company { get; set; }
|
||||
public virtual IRange<decimal> DecimalRange { get; set; }
|
||||
public virtual IRange<int> IntRange { get; set; }
|
||||
public virtual IRange<decimal> NullDecimalRange { get; set; }
|
||||
}
|
||||
|
||||
internal class DecimalRangeConverter : CustomCreationConverter<IRange<decimal>>
|
||||
{
|
||||
public override IRange<decimal> Create(Type objectType)
|
||||
{
|
||||
return new Range<decimal>();
|
||||
}
|
||||
}
|
||||
|
||||
internal class IntRangeConverter : CustomCreationConverter<IRange<int>>
|
||||
{
|
||||
public override IRange<int> Create(Type objectType)
|
||||
{
|
||||
return new Range<int>();
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeAndConvertNullValue()
|
||||
{
|
||||
NullInterfaceTestClass initial = new NullInterfaceTestClass
|
||||
{
|
||||
Company = "Company!",
|
||||
DecimalRange = new Range<decimal> { First = 0, Last = 1 },
|
||||
Id = new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
|
||||
IntRange = new Range<int> { First = int.MinValue, Last = int.MaxValue },
|
||||
Year = 2010,
|
||||
NullDecimalRange = null
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(initial, Formatting.Indented);
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Id"": ""00000001-0002-0003-0405-060708090a0b"",
|
||||
""Year"": 2010,
|
||||
""Company"": ""Company!"",
|
||||
""DecimalRange"": {
|
||||
""First"": 0.0,
|
||||
""Last"": 1.0
|
||||
},
|
||||
""IntRange"": {
|
||||
""First"": -2147483648,
|
||||
""Last"": 2147483647
|
||||
},
|
||||
""NullDecimalRange"": null
|
||||
}", json);
|
||||
|
||||
NullInterfaceTestClass deserialized = JsonConvert.DeserializeObject<NullInterfaceTestClass>(
|
||||
json, new IntRangeConverter(), new DecimalRangeConverter());
|
||||
|
||||
Assert.AreEqual("Company!", deserialized.Company);
|
||||
Assert.AreEqual(new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), deserialized.Id);
|
||||
Assert.AreEqual(0, deserialized.DecimalRange.First);
|
||||
Assert.AreEqual(1, deserialized.DecimalRange.Last);
|
||||
Assert.AreEqual(int.MinValue, deserialized.IntRange.First);
|
||||
Assert.AreEqual(int.MaxValue, deserialized.IntRange.Last);
|
||||
Assert.AreEqual(null, deserialized.NullDecimalRange);
|
||||
Assert.AreEqual(2010, deserialized.Year);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,383 +1,383 @@
|
||||
#if !(SILVERLIGHT || NETFX_CORE)
|
||||
using System;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Serialization;
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
using System.Data;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
public class DataSetConverterTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public void SerializeAndDeserialize()
|
||||
{
|
||||
DataSet dataSet = new DataSet("dataSet");
|
||||
dataSet.Namespace = "NetFrameWork";
|
||||
DataTable table = new DataTable();
|
||||
DataColumn idColumn = new DataColumn("id", typeof(int));
|
||||
idColumn.AutoIncrement = true;
|
||||
|
||||
DataColumn itemColumn = new DataColumn("item");
|
||||
table.Columns.Add(idColumn);
|
||||
table.Columns.Add(itemColumn);
|
||||
dataSet.Tables.Add(table);
|
||||
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
DataRow newRow = table.NewRow();
|
||||
newRow["item"] = "item " + i;
|
||||
table.Rows.Add(newRow);
|
||||
}
|
||||
|
||||
dataSet.AcceptChanges();
|
||||
|
||||
string json = JsonConvert.SerializeObject(dataSet, Formatting.Indented);
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Table1"": [
|
||||
{
|
||||
""id"": 0,
|
||||
""item"": ""item 0""
|
||||
},
|
||||
{
|
||||
""id"": 1,
|
||||
""item"": ""item 1""
|
||||
}
|
||||
]
|
||||
}", json);
|
||||
|
||||
DataSet deserializedDataSet = JsonConvert.DeserializeObject<DataSet>(json);
|
||||
Assert.IsNotNull(deserializedDataSet);
|
||||
|
||||
Assert.AreEqual(1, deserializedDataSet.Tables.Count);
|
||||
|
||||
DataTable dt = deserializedDataSet.Tables[0];
|
||||
|
||||
Assert.AreEqual("Table1", dt.TableName);
|
||||
Assert.AreEqual(2, dt.Columns.Count);
|
||||
Assert.AreEqual("id", dt.Columns[0].ColumnName);
|
||||
Assert.AreEqual(typeof(long), dt.Columns[0].DataType);
|
||||
Assert.AreEqual("item", dt.Columns[1].ColumnName);
|
||||
Assert.AreEqual(typeof(string), dt.Columns[1].DataType);
|
||||
|
||||
Assert.AreEqual(2, dt.Rows.Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeMultiTableDataSet()
|
||||
{
|
||||
DataSet ds = new DataSet();
|
||||
ds.Tables.Add(CreateDataTable("FirstTable", 2));
|
||||
ds.Tables.Add(CreateDataTable("SecondTable", 1));
|
||||
|
||||
string json = JsonConvert.SerializeObject(ds, Formatting.Indented, new IsoDateTimeConverter());
|
||||
// {
|
||||
// "FirstTable": [
|
||||
// {
|
||||
// "StringCol": "Item Name",
|
||||
// "Int32Col": 1,
|
||||
// "BooleanCol": true,
|
||||
// "TimeSpanCol": "10.22:10:15.1000000",
|
||||
// "DateTimeCol": "2000-12-29T00:00:00Z",
|
||||
// "DecimalCol": 64.0021
|
||||
// },
|
||||
// {
|
||||
// "StringCol": "Item Name",
|
||||
// "Int32Col": 2,
|
||||
// "BooleanCol": true,
|
||||
// "TimeSpanCol": "10.22:10:15.1000000",
|
||||
// "DateTimeCol": "2000-12-29T00:00:00Z",
|
||||
// "DecimalCol": 64.0021
|
||||
// }
|
||||
// ],
|
||||
// "SecondTable": [
|
||||
// {
|
||||
// "StringCol": "Item Name",
|
||||
// "Int32Col": 1,
|
||||
// "BooleanCol": true,
|
||||
// "TimeSpanCol": "10.22:10:15.1000000",
|
||||
// "DateTimeCol": "2000-12-29T00:00:00Z",
|
||||
// "DecimalCol": 64.0021
|
||||
// }
|
||||
// ]
|
||||
// }
|
||||
|
||||
DataSet deserializedDs = JsonConvert.DeserializeObject<DataSet>(json, new IsoDateTimeConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""FirstTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
},
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""SecondTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
]
|
||||
}", json);
|
||||
|
||||
Assert.IsNotNull(deserializedDs);
|
||||
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeMultiTableDataSet()
|
||||
{
|
||||
string json = @"{
|
||||
""FirstTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2147483647,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""SecondTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2147483647,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
]
|
||||
}";
|
||||
|
||||
DataSet ds = JsonConvert.DeserializeObject<DataSet>(json);
|
||||
Assert.IsNotNull(ds);
|
||||
|
||||
Assert.AreEqual(2, ds.Tables.Count);
|
||||
Assert.AreEqual("FirstTable", ds.Tables[0].TableName);
|
||||
Assert.AreEqual("SecondTable", ds.Tables[1].TableName);
|
||||
|
||||
DataTable dt = ds.Tables[0];
|
||||
Assert.AreEqual("StringCol", dt.Columns[0].ColumnName);
|
||||
Assert.AreEqual(typeof(string), dt.Columns[0].DataType);
|
||||
Assert.AreEqual("Int32Col", dt.Columns[1].ColumnName);
|
||||
Assert.AreEqual(typeof(long), dt.Columns[1].DataType);
|
||||
Assert.AreEqual("BooleanCol", dt.Columns[2].ColumnName);
|
||||
Assert.AreEqual(typeof(bool), dt.Columns[2].DataType);
|
||||
Assert.AreEqual("TimeSpanCol", dt.Columns[3].ColumnName);
|
||||
Assert.AreEqual(typeof(string), dt.Columns[3].DataType);
|
||||
Assert.AreEqual("DateTimeCol", dt.Columns[4].ColumnName);
|
||||
Assert.AreEqual(typeof(DateTime), dt.Columns[4].DataType);
|
||||
Assert.AreEqual("DecimalCol", dt.Columns[5].ColumnName);
|
||||
Assert.AreEqual(typeof(double), dt.Columns[5].DataType);
|
||||
|
||||
Assert.AreEqual(1, ds.Tables[0].Rows.Count);
|
||||
Assert.AreEqual(1, ds.Tables[1].Rows.Count);
|
||||
}
|
||||
|
||||
private DataTable CreateDataTable(string dataTableName, int rows)
|
||||
{
|
||||
// create a new DataTable.
|
||||
DataTable myTable = new DataTable(dataTableName);
|
||||
|
||||
// create DataColumn objects of data types.
|
||||
DataColumn colString = new DataColumn("StringCol");
|
||||
colString.DataType = typeof(string);
|
||||
myTable.Columns.Add(colString);
|
||||
|
||||
DataColumn colInt32 = new DataColumn("Int32Col");
|
||||
colInt32.DataType = typeof(int);
|
||||
myTable.Columns.Add(colInt32);
|
||||
|
||||
DataColumn colBoolean = new DataColumn("BooleanCol");
|
||||
colBoolean.DataType = typeof(bool);
|
||||
myTable.Columns.Add(colBoolean);
|
||||
|
||||
DataColumn colTimeSpan = new DataColumn("TimeSpanCol");
|
||||
colTimeSpan.DataType = typeof(TimeSpan);
|
||||
myTable.Columns.Add(colTimeSpan);
|
||||
|
||||
DataColumn colDateTime = new DataColumn("DateTimeCol");
|
||||
colDateTime.DataType = typeof(DateTime);
|
||||
colDateTime.DateTimeMode = DataSetDateTime.Utc;
|
||||
myTable.Columns.Add(colDateTime);
|
||||
|
||||
DataColumn colDecimal = new DataColumn("DecimalCol");
|
||||
colDecimal.DataType = typeof(decimal);
|
||||
myTable.Columns.Add(colDecimal);
|
||||
|
||||
for (int i = 1; i <= rows; i++)
|
||||
{
|
||||
DataRow myNewRow = myTable.NewRow();
|
||||
|
||||
myNewRow["StringCol"] = "Item Name";
|
||||
myNewRow["Int32Col"] = i;
|
||||
myNewRow["BooleanCol"] = true;
|
||||
myNewRow["TimeSpanCol"] = new TimeSpan(10, 22, 10, 15, 100);
|
||||
myNewRow["DateTimeCol"] = new DateTime(2000, 12, 29, 0, 0, 0, DateTimeKind.Utc);
|
||||
myNewRow["DecimalCol"] = 64.0021;
|
||||
myTable.Rows.Add(myNewRow);
|
||||
}
|
||||
|
||||
return myTable;
|
||||
}
|
||||
|
||||
public class DataSetAndTableTestClass
|
||||
{
|
||||
public string Before { get; set; }
|
||||
public DataSet Set { get; set; }
|
||||
public string Middle { get; set; }
|
||||
public DataTable Table { get; set; }
|
||||
public string After { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeWithCamelCaseResolver()
|
||||
{
|
||||
DataSet ds = new DataSet();
|
||||
ds.Tables.Add(CreateDataTable("FirstTable", 2));
|
||||
ds.Tables.Add(CreateDataTable("SecondTable", 1));
|
||||
|
||||
string json = JsonConvert.SerializeObject(ds, Formatting.Indented, new JsonSerializerSettings
|
||||
{
|
||||
ContractResolver = new CamelCasePropertyNamesContractResolver()
|
||||
});
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""firstTable"": [
|
||||
{
|
||||
""stringCol"": ""Item Name"",
|
||||
""int32Col"": 1,
|
||||
""booleanCol"": true,
|
||||
""timeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""dateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""decimalCol"": 64.0021
|
||||
},
|
||||
{
|
||||
""stringCol"": ""Item Name"",
|
||||
""int32Col"": 2,
|
||||
""booleanCol"": true,
|
||||
""timeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""dateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""decimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""secondTable"": [
|
||||
{
|
||||
""stringCol"": ""Item Name"",
|
||||
""int32Col"": 1,
|
||||
""booleanCol"": true,
|
||||
""timeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""dateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""decimalCol"": 64.0021
|
||||
}
|
||||
]
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDataSetProperty()
|
||||
{
|
||||
DataSet ds = new DataSet();
|
||||
ds.Tables.Add(CreateDataTable("FirstTable", 2));
|
||||
ds.Tables.Add(CreateDataTable("SecondTable", 1));
|
||||
|
||||
DataSetAndTableTestClass c = new DataSetAndTableTestClass
|
||||
{
|
||||
Before = "Before",
|
||||
Set = ds,
|
||||
Middle = "Middle",
|
||||
Table = CreateDataTable("LoneTable", 2),
|
||||
After = "After"
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new IsoDateTimeConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Before"": ""Before"",
|
||||
""Set"": {
|
||||
""FirstTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
},
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""SecondTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
]
|
||||
},
|
||||
""Middle"": ""Middle"",
|
||||
""Table"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
},
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""After"": ""After""
|
||||
}", json);
|
||||
|
||||
DataSetAndTableTestClass c2 = JsonConvert.DeserializeObject<DataSetAndTableTestClass>(json, new IsoDateTimeConverter());
|
||||
|
||||
Assert.AreEqual(c.Before, c2.Before);
|
||||
Assert.AreEqual(c.Set.Tables.Count, c2.Set.Tables.Count);
|
||||
Assert.AreEqual(c.Middle, c2.Middle);
|
||||
Assert.AreEqual(c.Table.Rows.Count, c2.Table.Rows.Count);
|
||||
Assert.AreEqual(c.After, c2.After);
|
||||
}
|
||||
}
|
||||
}
|
||||
#if !(SILVERLIGHT || NETFX_CORE)
|
||||
using System;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Serialization;
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
using System.Data;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
public class DataSetConverterTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public void SerializeAndDeserialize()
|
||||
{
|
||||
DataSet dataSet = new DataSet("dataSet");
|
||||
dataSet.Namespace = "NetFrameWork";
|
||||
DataTable table = new DataTable();
|
||||
DataColumn idColumn = new DataColumn("id", typeof(int));
|
||||
idColumn.AutoIncrement = true;
|
||||
|
||||
DataColumn itemColumn = new DataColumn("item");
|
||||
table.Columns.Add(idColumn);
|
||||
table.Columns.Add(itemColumn);
|
||||
dataSet.Tables.Add(table);
|
||||
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
DataRow newRow = table.NewRow();
|
||||
newRow["item"] = "item " + i;
|
||||
table.Rows.Add(newRow);
|
||||
}
|
||||
|
||||
dataSet.AcceptChanges();
|
||||
|
||||
string json = JsonConvert.SerializeObject(dataSet, Formatting.Indented);
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Table1"": [
|
||||
{
|
||||
""id"": 0,
|
||||
""item"": ""item 0""
|
||||
},
|
||||
{
|
||||
""id"": 1,
|
||||
""item"": ""item 1""
|
||||
}
|
||||
]
|
||||
}", json);
|
||||
|
||||
DataSet deserializedDataSet = JsonConvert.DeserializeObject<DataSet>(json);
|
||||
Assert.IsNotNull(deserializedDataSet);
|
||||
|
||||
Assert.AreEqual(1, deserializedDataSet.Tables.Count);
|
||||
|
||||
DataTable dt = deserializedDataSet.Tables[0];
|
||||
|
||||
Assert.AreEqual("Table1", dt.TableName);
|
||||
Assert.AreEqual(2, dt.Columns.Count);
|
||||
Assert.AreEqual("id", dt.Columns[0].ColumnName);
|
||||
Assert.AreEqual(typeof(long), dt.Columns[0].DataType);
|
||||
Assert.AreEqual("item", dt.Columns[1].ColumnName);
|
||||
Assert.AreEqual(typeof(string), dt.Columns[1].DataType);
|
||||
|
||||
Assert.AreEqual(2, dt.Rows.Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeMultiTableDataSet()
|
||||
{
|
||||
DataSet ds = new DataSet();
|
||||
ds.Tables.Add(CreateDataTable("FirstTable", 2));
|
||||
ds.Tables.Add(CreateDataTable("SecondTable", 1));
|
||||
|
||||
string json = JsonConvert.SerializeObject(ds, Formatting.Indented, new IsoDateTimeConverter());
|
||||
// {
|
||||
// "FirstTable": [
|
||||
// {
|
||||
// "StringCol": "Item Name",
|
||||
// "Int32Col": 1,
|
||||
// "BooleanCol": true,
|
||||
// "TimeSpanCol": "10.22:10:15.1000000",
|
||||
// "DateTimeCol": "2000-12-29T00:00:00Z",
|
||||
// "DecimalCol": 64.0021
|
||||
// },
|
||||
// {
|
||||
// "StringCol": "Item Name",
|
||||
// "Int32Col": 2,
|
||||
// "BooleanCol": true,
|
||||
// "TimeSpanCol": "10.22:10:15.1000000",
|
||||
// "DateTimeCol": "2000-12-29T00:00:00Z",
|
||||
// "DecimalCol": 64.0021
|
||||
// }
|
||||
// ],
|
||||
// "SecondTable": [
|
||||
// {
|
||||
// "StringCol": "Item Name",
|
||||
// "Int32Col": 1,
|
||||
// "BooleanCol": true,
|
||||
// "TimeSpanCol": "10.22:10:15.1000000",
|
||||
// "DateTimeCol": "2000-12-29T00:00:00Z",
|
||||
// "DecimalCol": 64.0021
|
||||
// }
|
||||
// ]
|
||||
// }
|
||||
|
||||
DataSet deserializedDs = JsonConvert.DeserializeObject<DataSet>(json, new IsoDateTimeConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""FirstTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
},
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""SecondTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
]
|
||||
}", json);
|
||||
|
||||
Assert.IsNotNull(deserializedDs);
|
||||
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeMultiTableDataSet()
|
||||
{
|
||||
string json = @"{
|
||||
""FirstTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2147483647,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""SecondTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2147483647,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
]
|
||||
}";
|
||||
|
||||
DataSet ds = JsonConvert.DeserializeObject<DataSet>(json);
|
||||
Assert.IsNotNull(ds);
|
||||
|
||||
Assert.AreEqual(2, ds.Tables.Count);
|
||||
Assert.AreEqual("FirstTable", ds.Tables[0].TableName);
|
||||
Assert.AreEqual("SecondTable", ds.Tables[1].TableName);
|
||||
|
||||
DataTable dt = ds.Tables[0];
|
||||
Assert.AreEqual("StringCol", dt.Columns[0].ColumnName);
|
||||
Assert.AreEqual(typeof(string), dt.Columns[0].DataType);
|
||||
Assert.AreEqual("Int32Col", dt.Columns[1].ColumnName);
|
||||
Assert.AreEqual(typeof(long), dt.Columns[1].DataType);
|
||||
Assert.AreEqual("BooleanCol", dt.Columns[2].ColumnName);
|
||||
Assert.AreEqual(typeof(bool), dt.Columns[2].DataType);
|
||||
Assert.AreEqual("TimeSpanCol", dt.Columns[3].ColumnName);
|
||||
Assert.AreEqual(typeof(string), dt.Columns[3].DataType);
|
||||
Assert.AreEqual("DateTimeCol", dt.Columns[4].ColumnName);
|
||||
Assert.AreEqual(typeof(DateTime), dt.Columns[4].DataType);
|
||||
Assert.AreEqual("DecimalCol", dt.Columns[5].ColumnName);
|
||||
Assert.AreEqual(typeof(double), dt.Columns[5].DataType);
|
||||
|
||||
Assert.AreEqual(1, ds.Tables[0].Rows.Count);
|
||||
Assert.AreEqual(1, ds.Tables[1].Rows.Count);
|
||||
}
|
||||
|
||||
private DataTable CreateDataTable(string dataTableName, int rows)
|
||||
{
|
||||
// create a new DataTable.
|
||||
DataTable myTable = new DataTable(dataTableName);
|
||||
|
||||
// create DataColumn objects of data types.
|
||||
DataColumn colString = new DataColumn("StringCol");
|
||||
colString.DataType = typeof(string);
|
||||
myTable.Columns.Add(colString);
|
||||
|
||||
DataColumn colInt32 = new DataColumn("Int32Col");
|
||||
colInt32.DataType = typeof(int);
|
||||
myTable.Columns.Add(colInt32);
|
||||
|
||||
DataColumn colBoolean = new DataColumn("BooleanCol");
|
||||
colBoolean.DataType = typeof(bool);
|
||||
myTable.Columns.Add(colBoolean);
|
||||
|
||||
DataColumn colTimeSpan = new DataColumn("TimeSpanCol");
|
||||
colTimeSpan.DataType = typeof(TimeSpan);
|
||||
myTable.Columns.Add(colTimeSpan);
|
||||
|
||||
DataColumn colDateTime = new DataColumn("DateTimeCol");
|
||||
colDateTime.DataType = typeof(DateTime);
|
||||
colDateTime.DateTimeMode = DataSetDateTime.Utc;
|
||||
myTable.Columns.Add(colDateTime);
|
||||
|
||||
DataColumn colDecimal = new DataColumn("DecimalCol");
|
||||
colDecimal.DataType = typeof(decimal);
|
||||
myTable.Columns.Add(colDecimal);
|
||||
|
||||
for (int i = 1; i <= rows; i++)
|
||||
{
|
||||
DataRow myNewRow = myTable.NewRow();
|
||||
|
||||
myNewRow["StringCol"] = "Item Name";
|
||||
myNewRow["Int32Col"] = i;
|
||||
myNewRow["BooleanCol"] = true;
|
||||
myNewRow["TimeSpanCol"] = new TimeSpan(10, 22, 10, 15, 100);
|
||||
myNewRow["DateTimeCol"] = new DateTime(2000, 12, 29, 0, 0, 0, DateTimeKind.Utc);
|
||||
myNewRow["DecimalCol"] = 64.0021;
|
||||
myTable.Rows.Add(myNewRow);
|
||||
}
|
||||
|
||||
return myTable;
|
||||
}
|
||||
|
||||
public class DataSetAndTableTestClass
|
||||
{
|
||||
public string Before { get; set; }
|
||||
public DataSet Set { get; set; }
|
||||
public string Middle { get; set; }
|
||||
public DataTable Table { get; set; }
|
||||
public string After { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeWithCamelCaseResolver()
|
||||
{
|
||||
DataSet ds = new DataSet();
|
||||
ds.Tables.Add(CreateDataTable("FirstTable", 2));
|
||||
ds.Tables.Add(CreateDataTable("SecondTable", 1));
|
||||
|
||||
string json = JsonConvert.SerializeObject(ds, Formatting.Indented, new JsonSerializerSettings
|
||||
{
|
||||
ContractResolver = new CamelCasePropertyNamesContractResolver()
|
||||
});
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""firstTable"": [
|
||||
{
|
||||
""stringCol"": ""Item Name"",
|
||||
""int32Col"": 1,
|
||||
""booleanCol"": true,
|
||||
""timeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""dateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""decimalCol"": 64.0021
|
||||
},
|
||||
{
|
||||
""stringCol"": ""Item Name"",
|
||||
""int32Col"": 2,
|
||||
""booleanCol"": true,
|
||||
""timeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""dateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""decimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""secondTable"": [
|
||||
{
|
||||
""stringCol"": ""Item Name"",
|
||||
""int32Col"": 1,
|
||||
""booleanCol"": true,
|
||||
""timeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""dateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""decimalCol"": 64.0021
|
||||
}
|
||||
]
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDataSetProperty()
|
||||
{
|
||||
DataSet ds = new DataSet();
|
||||
ds.Tables.Add(CreateDataTable("FirstTable", 2));
|
||||
ds.Tables.Add(CreateDataTable("SecondTable", 1));
|
||||
|
||||
DataSetAndTableTestClass c = new DataSetAndTableTestClass
|
||||
{
|
||||
Before = "Before",
|
||||
Set = ds,
|
||||
Middle = "Middle",
|
||||
Table = CreateDataTable("LoneTable", 2),
|
||||
After = "After"
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new IsoDateTimeConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Before"": ""Before"",
|
||||
""Set"": {
|
||||
""FirstTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
},
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""SecondTable"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
]
|
||||
},
|
||||
""Middle"": ""Middle"",
|
||||
""Table"": [
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 1,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
},
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
],
|
||||
""After"": ""After""
|
||||
}", json);
|
||||
|
||||
DataSetAndTableTestClass c2 = JsonConvert.DeserializeObject<DataSetAndTableTestClass>(json, new IsoDateTimeConverter());
|
||||
|
||||
Assert.AreEqual(c.Before, c2.Before);
|
||||
Assert.AreEqual(c.Set.Tables.Count, c2.Set.Tables.Count);
|
||||
Assert.AreEqual(c.Middle, c2.Middle);
|
||||
Assert.AreEqual(c.Table.Rows.Count, c2.Table.Rows.Count);
|
||||
Assert.AreEqual(c.After, c2.After);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -1,213 +1,213 @@
|
||||
#if !(SILVERLIGHT || NETFX_CORE)
|
||||
using System;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
#if !NETFX_CORE
|
||||
using System.Data;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
public class DataTableConverterTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public void Deserialize()
|
||||
{
|
||||
string json = @"[
|
||||
{
|
||||
""id"": 0,
|
||||
""item"": ""item 0""
|
||||
},
|
||||
{
|
||||
""id"": 1,
|
||||
""item"": ""item 1""
|
||||
}
|
||||
]";
|
||||
|
||||
DataTable deserializedDataTable = JsonConvert.DeserializeObject<DataTable>(json);
|
||||
Assert.IsNotNull(deserializedDataTable);
|
||||
|
||||
Assert.AreEqual(string.Empty, deserializedDataTable.TableName);
|
||||
Assert.AreEqual(2, deserializedDataTable.Columns.Count);
|
||||
Assert.AreEqual("id", deserializedDataTable.Columns[0].ColumnName);
|
||||
Assert.AreEqual(typeof(long), deserializedDataTable.Columns[0].DataType);
|
||||
Assert.AreEqual("item", deserializedDataTable.Columns[1].ColumnName);
|
||||
Assert.AreEqual(typeof(string), deserializedDataTable.Columns[1].DataType);
|
||||
|
||||
Assert.AreEqual(2, deserializedDataTable.Rows.Count);
|
||||
|
||||
DataRow dr1 = deserializedDataTable.Rows[0];
|
||||
Assert.AreEqual(0, dr1["id"]);
|
||||
Assert.AreEqual("item 0", dr1["item"]);
|
||||
|
||||
DataRow dr2 = deserializedDataTable.Rows[1];
|
||||
Assert.AreEqual(1, dr2["id"]);
|
||||
Assert.AreEqual("item 1", dr2["item"]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Serialize()
|
||||
{
|
||||
// create a new DataTable.
|
||||
DataTable myTable = new DataTable("blah");
|
||||
|
||||
// create DataColumn objects of data types.
|
||||
DataColumn colString = new DataColumn("StringCol");
|
||||
colString.DataType = typeof(string);
|
||||
myTable.Columns.Add(colString);
|
||||
|
||||
DataColumn colInt32 = new DataColumn("Int32Col");
|
||||
colInt32.DataType = typeof(int);
|
||||
myTable.Columns.Add(colInt32);
|
||||
|
||||
DataColumn colBoolean = new DataColumn("BooleanCol");
|
||||
colBoolean.DataType = typeof(bool);
|
||||
myTable.Columns.Add(colBoolean);
|
||||
|
||||
DataColumn colTimeSpan = new DataColumn("TimeSpanCol");
|
||||
colTimeSpan.DataType = typeof(TimeSpan);
|
||||
myTable.Columns.Add(colTimeSpan);
|
||||
|
||||
DataColumn colDateTime = new DataColumn("DateTimeCol");
|
||||
colDateTime.DataType = typeof(DateTime);
|
||||
colDateTime.DateTimeMode = DataSetDateTime.Utc;
|
||||
myTable.Columns.Add(colDateTime);
|
||||
|
||||
DataColumn colDecimal = new DataColumn("DecimalCol");
|
||||
colDecimal.DataType = typeof(decimal);
|
||||
myTable.Columns.Add(colDecimal);
|
||||
|
||||
// populate one row with values.
|
||||
DataRow myNewRow = myTable.NewRow();
|
||||
|
||||
myNewRow["StringCol"] = "Item Name";
|
||||
myNewRow["Int32Col"] = 2147483647;
|
||||
myNewRow["BooleanCol"] = true;
|
||||
myNewRow["TimeSpanCol"] = new TimeSpan(10, 22, 10, 15, 100);
|
||||
myNewRow["DateTimeCol"] = new DateTime(2000, 12, 29, 0, 0, 0, DateTimeKind.Utc);
|
||||
myNewRow["DecimalCol"] = 64.0021;
|
||||
myTable.Rows.Add(myNewRow);
|
||||
|
||||
string json = JsonConvert.SerializeObject(myTable, Formatting.Indented);
|
||||
Assert.AreEqual(@"[
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2147483647,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
]", json);
|
||||
}
|
||||
|
||||
public class TestDataTableConverter : JsonConverter
|
||||
{
|
||||
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
|
||||
{
|
||||
DataTable d = (DataTable)value;
|
||||
writer.WriteValue(d.TableName);
|
||||
}
|
||||
|
||||
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
|
||||
{
|
||||
//reader.Read();
|
||||
DataTable d = new DataTable((string)reader.Value);
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
public override bool CanConvert(Type objectType)
|
||||
{
|
||||
return (objectType == typeof(DataTable));
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void PassedInJsonConverterOverridesInternalConverter()
|
||||
{
|
||||
DataTable t1 = new DataTable("Custom");
|
||||
|
||||
string json = JsonConvert.SerializeObject(t1, Formatting.Indented, new TestDataTableConverter());
|
||||
Assert.AreEqual(@"""Custom""", json);
|
||||
|
||||
DataTable t2 = JsonConvert.DeserializeObject<DataTable>(json, new TestDataTableConverter());
|
||||
Assert.AreEqual(t1.TableName, t2.TableName);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDataTableWithNull()
|
||||
{
|
||||
var table = new DataTable();
|
||||
table.Columns.Add("item");
|
||||
table.Columns.Add("price", typeof(double));
|
||||
table.Rows.Add("shirt", 49.99);
|
||||
table.Rows.Add("pants", 54.99);
|
||||
table.Rows.Add("shoes"); // no price
|
||||
|
||||
var json = JsonConvert.SerializeObject(table);
|
||||
Assert.AreEqual(@"["
|
||||
+ @"{""item"":""shirt"",""price"":49.99},"
|
||||
+ @"{""item"":""pants"",""price"":54.99},"
|
||||
+ @"{""item"":""shoes"",""price"":null}]", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDataTableWithNullAndIgnoreNullHandling()
|
||||
{
|
||||
var table = new DataTable();
|
||||
table.Columns.Add("item");
|
||||
table.Columns.Add("price", typeof(double));
|
||||
table.Rows.Add("shirt", 49.99);
|
||||
table.Rows.Add("pants", 54.99);
|
||||
table.Rows.Add("shoes"); // no price
|
||||
|
||||
var json = JsonConvert.SerializeObject(table, Formatting.None, new JsonSerializerSettings
|
||||
{
|
||||
NullValueHandling = NullValueHandling.Ignore
|
||||
});
|
||||
Assert.AreEqual(@"["
|
||||
+ @"{""item"":""shirt"",""price"":49.99},"
|
||||
+ @"{""item"":""pants"",""price"":54.99},"
|
||||
+ @"{""item"":""shoes""}]", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DerializeDataTableWithImplicitNull()
|
||||
{
|
||||
const string json = @"["
|
||||
+ @"{""item"":""shirt"",""price"":49.99},"
|
||||
+ @"{""item"":""pants"",""price"":54.99},"
|
||||
+ @"{""item"":""shoes""}]";
|
||||
var table = JsonConvert.DeserializeObject<DataTable>(json);
|
||||
Assert.AreEqual("shirt", table.Rows[0]["item"]);
|
||||
Assert.AreEqual("pants", table.Rows[1]["item"]);
|
||||
Assert.AreEqual("shoes", table.Rows[2]["item"]);
|
||||
Assert.AreEqual(49.99, (double)table.Rows[0]["price"], 0.01);
|
||||
Assert.AreEqual(54.99, (double)table.Rows[1]["price"], 0.01);
|
||||
Assert.IsInstanceOfType(typeof(System.DBNull), table.Rows[2]["price"]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DerializeDataTableWithExplicitNull()
|
||||
{
|
||||
const string json = @"["
|
||||
+ @"{""item"":""shirt"",""price"":49.99},"
|
||||
+ @"{""item"":""pants"",""price"":54.99},"
|
||||
+ @"{""item"":""shoes"",""price"":null}]";
|
||||
var table = JsonConvert.DeserializeObject<DataTable>(json);
|
||||
Assert.AreEqual("shirt", table.Rows[0]["item"]);
|
||||
Assert.AreEqual("pants", table.Rows[1]["item"]);
|
||||
Assert.AreEqual("shoes", table.Rows[2]["item"]);
|
||||
Assert.AreEqual(49.99, (double)table.Rows[0]["price"], 0.01);
|
||||
Assert.AreEqual(54.99, (double)table.Rows[1]["price"], 0.01);
|
||||
Assert.IsInstanceOfType(typeof(System.DBNull), table.Rows[2]["price"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
#if !(SILVERLIGHT || NETFX_CORE)
|
||||
using System;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
#if !NETFX_CORE
|
||||
using System.Data;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
public class DataTableConverterTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public void Deserialize()
|
||||
{
|
||||
string json = @"[
|
||||
{
|
||||
""id"": 0,
|
||||
""item"": ""item 0""
|
||||
},
|
||||
{
|
||||
""id"": 1,
|
||||
""item"": ""item 1""
|
||||
}
|
||||
]";
|
||||
|
||||
DataTable deserializedDataTable = JsonConvert.DeserializeObject<DataTable>(json);
|
||||
Assert.IsNotNull(deserializedDataTable);
|
||||
|
||||
Assert.AreEqual(string.Empty, deserializedDataTable.TableName);
|
||||
Assert.AreEqual(2, deserializedDataTable.Columns.Count);
|
||||
Assert.AreEqual("id", deserializedDataTable.Columns[0].ColumnName);
|
||||
Assert.AreEqual(typeof(long), deserializedDataTable.Columns[0].DataType);
|
||||
Assert.AreEqual("item", deserializedDataTable.Columns[1].ColumnName);
|
||||
Assert.AreEqual(typeof(string), deserializedDataTable.Columns[1].DataType);
|
||||
|
||||
Assert.AreEqual(2, deserializedDataTable.Rows.Count);
|
||||
|
||||
DataRow dr1 = deserializedDataTable.Rows[0];
|
||||
Assert.AreEqual(0, dr1["id"]);
|
||||
Assert.AreEqual("item 0", dr1["item"]);
|
||||
|
||||
DataRow dr2 = deserializedDataTable.Rows[1];
|
||||
Assert.AreEqual(1, dr2["id"]);
|
||||
Assert.AreEqual("item 1", dr2["item"]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Serialize()
|
||||
{
|
||||
// create a new DataTable.
|
||||
DataTable myTable = new DataTable("blah");
|
||||
|
||||
// create DataColumn objects of data types.
|
||||
DataColumn colString = new DataColumn("StringCol");
|
||||
colString.DataType = typeof(string);
|
||||
myTable.Columns.Add(colString);
|
||||
|
||||
DataColumn colInt32 = new DataColumn("Int32Col");
|
||||
colInt32.DataType = typeof(int);
|
||||
myTable.Columns.Add(colInt32);
|
||||
|
||||
DataColumn colBoolean = new DataColumn("BooleanCol");
|
||||
colBoolean.DataType = typeof(bool);
|
||||
myTable.Columns.Add(colBoolean);
|
||||
|
||||
DataColumn colTimeSpan = new DataColumn("TimeSpanCol");
|
||||
colTimeSpan.DataType = typeof(TimeSpan);
|
||||
myTable.Columns.Add(colTimeSpan);
|
||||
|
||||
DataColumn colDateTime = new DataColumn("DateTimeCol");
|
||||
colDateTime.DataType = typeof(DateTime);
|
||||
colDateTime.DateTimeMode = DataSetDateTime.Utc;
|
||||
myTable.Columns.Add(colDateTime);
|
||||
|
||||
DataColumn colDecimal = new DataColumn("DecimalCol");
|
||||
colDecimal.DataType = typeof(decimal);
|
||||
myTable.Columns.Add(colDecimal);
|
||||
|
||||
// populate one row with values.
|
||||
DataRow myNewRow = myTable.NewRow();
|
||||
|
||||
myNewRow["StringCol"] = "Item Name";
|
||||
myNewRow["Int32Col"] = 2147483647;
|
||||
myNewRow["BooleanCol"] = true;
|
||||
myNewRow["TimeSpanCol"] = new TimeSpan(10, 22, 10, 15, 100);
|
||||
myNewRow["DateTimeCol"] = new DateTime(2000, 12, 29, 0, 0, 0, DateTimeKind.Utc);
|
||||
myNewRow["DecimalCol"] = 64.0021;
|
||||
myTable.Rows.Add(myNewRow);
|
||||
|
||||
string json = JsonConvert.SerializeObject(myTable, Formatting.Indented);
|
||||
Assert.AreEqual(@"[
|
||||
{
|
||||
""StringCol"": ""Item Name"",
|
||||
""Int32Col"": 2147483647,
|
||||
""BooleanCol"": true,
|
||||
""TimeSpanCol"": ""10.22:10:15.1000000"",
|
||||
""DateTimeCol"": ""2000-12-29T00:00:00Z"",
|
||||
""DecimalCol"": 64.0021
|
||||
}
|
||||
]", json);
|
||||
}
|
||||
|
||||
public class TestDataTableConverter : JsonConverter
|
||||
{
|
||||
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
|
||||
{
|
||||
DataTable d = (DataTable)value;
|
||||
writer.WriteValue(d.TableName);
|
||||
}
|
||||
|
||||
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
|
||||
{
|
||||
//reader.Read();
|
||||
DataTable d = new DataTable((string)reader.Value);
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
public override bool CanConvert(Type objectType)
|
||||
{
|
||||
return (objectType == typeof(DataTable));
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void PassedInJsonConverterOverridesInternalConverter()
|
||||
{
|
||||
DataTable t1 = new DataTable("Custom");
|
||||
|
||||
string json = JsonConvert.SerializeObject(t1, Formatting.Indented, new TestDataTableConverter());
|
||||
Assert.AreEqual(@"""Custom""", json);
|
||||
|
||||
DataTable t2 = JsonConvert.DeserializeObject<DataTable>(json, new TestDataTableConverter());
|
||||
Assert.AreEqual(t1.TableName, t2.TableName);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDataTableWithNull()
|
||||
{
|
||||
var table = new DataTable();
|
||||
table.Columns.Add("item");
|
||||
table.Columns.Add("price", typeof(double));
|
||||
table.Rows.Add("shirt", 49.99);
|
||||
table.Rows.Add("pants", 54.99);
|
||||
table.Rows.Add("shoes"); // no price
|
||||
|
||||
var json = JsonConvert.SerializeObject(table);
|
||||
Assert.AreEqual(@"["
|
||||
+ @"{""item"":""shirt"",""price"":49.99},"
|
||||
+ @"{""item"":""pants"",""price"":54.99},"
|
||||
+ @"{""item"":""shoes"",""price"":null}]", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDataTableWithNullAndIgnoreNullHandling()
|
||||
{
|
||||
var table = new DataTable();
|
||||
table.Columns.Add("item");
|
||||
table.Columns.Add("price", typeof(double));
|
||||
table.Rows.Add("shirt", 49.99);
|
||||
table.Rows.Add("pants", 54.99);
|
||||
table.Rows.Add("shoes"); // no price
|
||||
|
||||
var json = JsonConvert.SerializeObject(table, Formatting.None, new JsonSerializerSettings
|
||||
{
|
||||
NullValueHandling = NullValueHandling.Ignore
|
||||
});
|
||||
Assert.AreEqual(@"["
|
||||
+ @"{""item"":""shirt"",""price"":49.99},"
|
||||
+ @"{""item"":""pants"",""price"":54.99},"
|
||||
+ @"{""item"":""shoes""}]", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DerializeDataTableWithImplicitNull()
|
||||
{
|
||||
const string json = @"["
|
||||
+ @"{""item"":""shirt"",""price"":49.99},"
|
||||
+ @"{""item"":""pants"",""price"":54.99},"
|
||||
+ @"{""item"":""shoes""}]";
|
||||
var table = JsonConvert.DeserializeObject<DataTable>(json);
|
||||
Assert.AreEqual("shirt", table.Rows[0]["item"]);
|
||||
Assert.AreEqual("pants", table.Rows[1]["item"]);
|
||||
Assert.AreEqual("shoes", table.Rows[2]["item"]);
|
||||
Assert.AreEqual(49.99, (double)table.Rows[0]["price"], 0.01);
|
||||
Assert.AreEqual(54.99, (double)table.Rows[1]["price"], 0.01);
|
||||
Assert.IsInstanceOfType(typeof(System.DBNull), table.Rows[2]["price"]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DerializeDataTableWithExplicitNull()
|
||||
{
|
||||
const string json = @"["
|
||||
+ @"{""item"":""shirt"",""price"":49.99},"
|
||||
+ @"{""item"":""pants"",""price"":54.99},"
|
||||
+ @"{""item"":""shoes"",""price"":null}]";
|
||||
var table = JsonConvert.DeserializeObject<DataTable>(json);
|
||||
Assert.AreEqual("shirt", table.Rows[0]["item"]);
|
||||
Assert.AreEqual("pants", table.Rows[1]["item"]);
|
||||
Assert.AreEqual("shoes", table.Rows[2]["item"]);
|
||||
Assert.AreEqual(49.99, (double)table.Rows[0]["price"], 0.01);
|
||||
Assert.AreEqual(54.99, (double)table.Rows[1]["price"], 0.01);
|
||||
Assert.IsInstanceOfType(typeof(System.DBNull), table.Rows[2]["price"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -1,165 +1,165 @@
|
||||
#if !(NET35 || NET20 || WINDOWS_PHONE)
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
#if !SILVERLIGHT && !PocketPC && !NET20 && !NETFX_CORE
|
||||
using System.Data.Linq;
|
||||
#endif
|
||||
#if !SILVERLIGHT && !NETFX_CORE
|
||||
using System.Data.SqlTypes;
|
||||
#endif
|
||||
using System.Dynamic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class ExpandoObjectConverterTests : TestFixtureBase
|
||||
{
|
||||
public class ExpandoContainer
|
||||
{
|
||||
public string Before { get; set; }
|
||||
public ExpandoObject Expando { get; set; }
|
||||
public string After { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeExpandoObject()
|
||||
{
|
||||
ExpandoContainer d = new ExpandoContainer
|
||||
{
|
||||
Before = "Before!",
|
||||
Expando = new ExpandoObject(),
|
||||
After = "After!"
|
||||
};
|
||||
|
||||
dynamic o = d.Expando;
|
||||
|
||||
o.String = "String!";
|
||||
o.Integer = 234;
|
||||
o.Float = 1.23d;
|
||||
o.List = new List<string> {"First", "Second", "Third"};
|
||||
o.Object = new Dictionary<string, object>
|
||||
{
|
||||
{"First", 1}
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(d, Formatting.Indented);
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Before"": ""Before!"",
|
||||
""Expando"": {
|
||||
""String"": ""String!"",
|
||||
""Integer"": 234,
|
||||
""Float"": 1.23,
|
||||
""List"": [
|
||||
""First"",
|
||||
""Second"",
|
||||
""Third""
|
||||
],
|
||||
""Object"": {
|
||||
""First"": 1
|
||||
}
|
||||
},
|
||||
""After"": ""After!""
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeNullExpandoObject()
|
||||
{
|
||||
ExpandoContainer d = new ExpandoContainer();
|
||||
|
||||
string json = JsonConvert.SerializeObject(d, Formatting.Indented);
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Before"": null,
|
||||
""Expando"": null,
|
||||
""After"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeExpandoObject()
|
||||
{
|
||||
string json = @"{
|
||||
""Before"": ""Before!"",
|
||||
""Expando"": {
|
||||
""String"": ""String!"",
|
||||
""Integer"": 234,
|
||||
""Float"": 1.23,
|
||||
""List"": [
|
||||
""First"",
|
||||
""Second"",
|
||||
""Third""
|
||||
],
|
||||
""Object"": {
|
||||
""First"": 1
|
||||
}
|
||||
},
|
||||
""After"": ""After!""
|
||||
}";
|
||||
|
||||
ExpandoContainer o = JsonConvert.DeserializeObject<ExpandoContainer>(json);
|
||||
|
||||
Assert.AreEqual(o.Before, "Before!");
|
||||
Assert.AreEqual(o.After, "After!");
|
||||
Assert.IsNotNull(o.Expando);
|
||||
|
||||
dynamic d = o.Expando;
|
||||
CustomAssert.IsInstanceOfType(typeof(ExpandoObject), d);
|
||||
|
||||
Assert.AreEqual("String!", d.String);
|
||||
CustomAssert.IsInstanceOfType(typeof(string), d.String);
|
||||
|
||||
Assert.AreEqual(234, d.Integer);
|
||||
CustomAssert.IsInstanceOfType(typeof(long), d.Integer);
|
||||
|
||||
Assert.AreEqual(1.23, d.Float);
|
||||
CustomAssert.IsInstanceOfType(typeof(double), d.Float);
|
||||
|
||||
Assert.IsNotNull(d.List);
|
||||
Assert.AreEqual(3, d.List.Count);
|
||||
CustomAssert.IsInstanceOfType(typeof(List<object>), d.List);
|
||||
|
||||
Assert.AreEqual("First", d.List[0]);
|
||||
CustomAssert.IsInstanceOfType(typeof(string), d.List[0]);
|
||||
|
||||
Assert.AreEqual("Second", d.List[1]);
|
||||
Assert.AreEqual("Third", d.List[2]);
|
||||
|
||||
Assert.IsNotNull(d.Object);
|
||||
CustomAssert.IsInstanceOfType(typeof(ExpandoObject), d.Object);
|
||||
|
||||
Assert.AreEqual(1, d.Object.First);
|
||||
CustomAssert.IsInstanceOfType(typeof(long), d.Object.First);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNullExpandoObject()
|
||||
{
|
||||
string json = @"{
|
||||
""Before"": null,
|
||||
""Expando"": null,
|
||||
""After"": null
|
||||
}";
|
||||
|
||||
ExpandoContainer c = JsonConvert.DeserializeObject<ExpandoContainer>(json);
|
||||
|
||||
Assert.AreEqual(null, c.Expando);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#if !(NET35 || NET20 || WINDOWS_PHONE)
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
#if !SILVERLIGHT && !PocketPC && !NET20 && !NETFX_CORE
|
||||
using System.Data.Linq;
|
||||
#endif
|
||||
#if !SILVERLIGHT && !NETFX_CORE
|
||||
using System.Data.SqlTypes;
|
||||
#endif
|
||||
using System.Dynamic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class ExpandoObjectConverterTests : TestFixtureBase
|
||||
{
|
||||
public class ExpandoContainer
|
||||
{
|
||||
public string Before { get; set; }
|
||||
public ExpandoObject Expando { get; set; }
|
||||
public string After { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeExpandoObject()
|
||||
{
|
||||
ExpandoContainer d = new ExpandoContainer
|
||||
{
|
||||
Before = "Before!",
|
||||
Expando = new ExpandoObject(),
|
||||
After = "After!"
|
||||
};
|
||||
|
||||
dynamic o = d.Expando;
|
||||
|
||||
o.String = "String!";
|
||||
o.Integer = 234;
|
||||
o.Float = 1.23d;
|
||||
o.List = new List<string> {"First", "Second", "Third"};
|
||||
o.Object = new Dictionary<string, object>
|
||||
{
|
||||
{"First", 1}
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(d, Formatting.Indented);
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Before"": ""Before!"",
|
||||
""Expando"": {
|
||||
""String"": ""String!"",
|
||||
""Integer"": 234,
|
||||
""Float"": 1.23,
|
||||
""List"": [
|
||||
""First"",
|
||||
""Second"",
|
||||
""Third""
|
||||
],
|
||||
""Object"": {
|
||||
""First"": 1
|
||||
}
|
||||
},
|
||||
""After"": ""After!""
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeNullExpandoObject()
|
||||
{
|
||||
ExpandoContainer d = new ExpandoContainer();
|
||||
|
||||
string json = JsonConvert.SerializeObject(d, Formatting.Indented);
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Before"": null,
|
||||
""Expando"": null,
|
||||
""After"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeExpandoObject()
|
||||
{
|
||||
string json = @"{
|
||||
""Before"": ""Before!"",
|
||||
""Expando"": {
|
||||
""String"": ""String!"",
|
||||
""Integer"": 234,
|
||||
""Float"": 1.23,
|
||||
""List"": [
|
||||
""First"",
|
||||
""Second"",
|
||||
""Third""
|
||||
],
|
||||
""Object"": {
|
||||
""First"": 1
|
||||
}
|
||||
},
|
||||
""After"": ""After!""
|
||||
}";
|
||||
|
||||
ExpandoContainer o = JsonConvert.DeserializeObject<ExpandoContainer>(json);
|
||||
|
||||
Assert.AreEqual(o.Before, "Before!");
|
||||
Assert.AreEqual(o.After, "After!");
|
||||
Assert.IsNotNull(o.Expando);
|
||||
|
||||
dynamic d = o.Expando;
|
||||
CustomAssert.IsInstanceOfType(typeof(ExpandoObject), d);
|
||||
|
||||
Assert.AreEqual("String!", d.String);
|
||||
CustomAssert.IsInstanceOfType(typeof(string), d.String);
|
||||
|
||||
Assert.AreEqual(234, d.Integer);
|
||||
CustomAssert.IsInstanceOfType(typeof(long), d.Integer);
|
||||
|
||||
Assert.AreEqual(1.23, d.Float);
|
||||
CustomAssert.IsInstanceOfType(typeof(double), d.Float);
|
||||
|
||||
Assert.IsNotNull(d.List);
|
||||
Assert.AreEqual(3, d.List.Count);
|
||||
CustomAssert.IsInstanceOfType(typeof(List<object>), d.List);
|
||||
|
||||
Assert.AreEqual("First", d.List[0]);
|
||||
CustomAssert.IsInstanceOfType(typeof(string), d.List[0]);
|
||||
|
||||
Assert.AreEqual("Second", d.List[1]);
|
||||
Assert.AreEqual("Third", d.List[2]);
|
||||
|
||||
Assert.IsNotNull(d.Object);
|
||||
CustomAssert.IsInstanceOfType(typeof(ExpandoObject), d.Object);
|
||||
|
||||
Assert.AreEqual(1, d.Object.First);
|
||||
CustomAssert.IsInstanceOfType(typeof(long), d.Object.First);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNullExpandoObject()
|
||||
{
|
||||
string json = @"{
|
||||
""Before"": null,
|
||||
""Expando"": null,
|
||||
""After"": null
|
||||
}";
|
||||
|
||||
ExpandoContainer c = JsonConvert.DeserializeObject<ExpandoContainer>(json);
|
||||
|
||||
Assert.AreEqual(null, c.Expando);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,272 +1,272 @@
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
using System;
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Converters;
|
||||
using Newtonsoft.Json.Utilities;
|
||||
using System.Globalization;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class IsoDateTimeConverterTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public void PropertiesShouldBeSet()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter();
|
||||
Assert.AreEqual(CultureInfo.CurrentCulture, converter.Culture);
|
||||
Assert.AreEqual(string.Empty, converter.DateTimeFormat);
|
||||
Assert.AreEqual(DateTimeStyles.RoundtripKind, converter.DateTimeStyles);
|
||||
|
||||
converter = new IsoDateTimeConverter()
|
||||
{
|
||||
DateTimeFormat = "F",
|
||||
Culture = CultureInfo.InvariantCulture,
|
||||
DateTimeStyles = DateTimeStyles.None
|
||||
};
|
||||
|
||||
Assert.AreEqual(CultureInfo.InvariantCulture, converter.Culture);
|
||||
Assert.AreEqual("F", converter.DateTimeFormat);
|
||||
Assert.AreEqual(DateTimeStyles.None, converter.DateTimeStyles);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDateTime()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter();
|
||||
|
||||
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""2000-12-15T22:11:03.055Z""", result);
|
||||
|
||||
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
|
||||
|
||||
d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Local);
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""2000-12-15T22:11:03.055" + d.GetUtcOffsetText() + @"""", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeFormattedDateTimeInvariantCulture()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.InvariantCulture };
|
||||
|
||||
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
|
||||
|
||||
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
|
||||
|
||||
d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeCustomFormattedDateTime()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter
|
||||
{
|
||||
DateTimeFormat = "dd/MM/yyyy",
|
||||
Culture = CultureInfo.InvariantCulture
|
||||
};
|
||||
|
||||
string json = @"""09/12/2006""";
|
||||
|
||||
DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
|
||||
|
||||
Assert.AreEqual(9, d.Day);
|
||||
Assert.AreEqual(12, d.Month);
|
||||
Assert.AreEqual(2006, d.Year);
|
||||
}
|
||||
|
||||
#if !SILVERLIGHT && !NETFX_CORE
|
||||
[Test]
|
||||
public void SerializeFormattedDateTimeNewZealandCulture()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.GetCultureInfo("en-NZ") };
|
||||
|
||||
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
|
||||
|
||||
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
|
||||
|
||||
d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDateTimeCulture()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter() { Culture = CultureInfo.GetCultureInfo("en-NZ") };
|
||||
|
||||
string json = @"""09/12/2006""";
|
||||
|
||||
DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
|
||||
|
||||
Assert.AreEqual(9, d.Day);
|
||||
Assert.AreEqual(12, d.Month);
|
||||
Assert.AreEqual(2006, d.Year);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !PocketPC && !NET20
|
||||
[Test]
|
||||
public void SerializeDateTimeOffset()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter();
|
||||
|
||||
DateTimeOffset d = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""2000-12-15T22:11:03.055+00:00""", result);
|
||||
|
||||
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTimeOffset>(result, converter));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeUTC()
|
||||
{
|
||||
DateTimeTestClass c = new DateTimeTestClass();
|
||||
c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);
|
||||
|
||||
//test the other edge case too
|
||||
c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.DateTimeOffsetField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-01-01T01:01:01Z"",""DateTimeOffsetField"":""2008-01-01T01:01:01+00:00"",""PostField"":""Post""}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void NullableSerializeUTC()
|
||||
{
|
||||
NullableDateTimeTestClass c = new NullableDateTimeTestClass();
|
||||
c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);
|
||||
|
||||
//test the other edge case too
|
||||
c.DateTimeField = null;
|
||||
c.DateTimeOffsetField = null;
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void NullableDeserializeEmptyString()
|
||||
{
|
||||
string json = @"{""DateTimeField"":""""}";
|
||||
|
||||
NullableDateTimeTestClass c = JsonConvert.DeserializeObject<NullableDateTimeTestClass>(json,
|
||||
new JsonSerializerSettings { Converters = new [] {new IsoDateTimeConverter()}});
|
||||
Assert.AreEqual(null, c.DateTimeField);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNullToNonNullable()
|
||||
{
|
||||
ExceptionAssert.Throws<Exception>("Cannot convert null value to System.DateTime.",
|
||||
() =>
|
||||
{
|
||||
DateTimeTestClass c2 =
|
||||
JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
});
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeShouldChangeNonUTCDates()
|
||||
{
|
||||
DateTime localDateTime = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Local);
|
||||
|
||||
DateTimeTestClass c = new DateTimeTestClass();
|
||||
c.DateTimeField = localDateTime;
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal }); //note that this fails without the Utc converter...
|
||||
c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc);
|
||||
string json2 = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
|
||||
TimeSpan offset = localDateTime.GetUtcOffset();
|
||||
|
||||
// if the current timezone is utc then local already equals utc
|
||||
if (offset == TimeSpan.Zero)
|
||||
Assert.AreEqual(json, json2);
|
||||
else
|
||||
Assert.AreNotEqual(json, json2);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void BlogCodeSample()
|
||||
{
|
||||
Person p = new Person
|
||||
{
|
||||
Name = "Keith",
|
||||
BirthDate = new DateTime(1980, 3, 8),
|
||||
LastModified = new DateTime(2009, 4, 12, 20, 44, 55),
|
||||
};
|
||||
|
||||
string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());
|
||||
// {
|
||||
// "Name": "Keith",
|
||||
// "BirthDate": "1980-03-08T00:00:00",
|
||||
// "LastModified": "2009-04-12T20:44:55"
|
||||
// }
|
||||
|
||||
Console.WriteLine(jsonText);
|
||||
|
||||
}
|
||||
}
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
using System;
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Converters;
|
||||
using Newtonsoft.Json.Utilities;
|
||||
using System.Globalization;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class IsoDateTimeConverterTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public void PropertiesShouldBeSet()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter();
|
||||
Assert.AreEqual(CultureInfo.CurrentCulture, converter.Culture);
|
||||
Assert.AreEqual(string.Empty, converter.DateTimeFormat);
|
||||
Assert.AreEqual(DateTimeStyles.RoundtripKind, converter.DateTimeStyles);
|
||||
|
||||
converter = new IsoDateTimeConverter()
|
||||
{
|
||||
DateTimeFormat = "F",
|
||||
Culture = CultureInfo.InvariantCulture,
|
||||
DateTimeStyles = DateTimeStyles.None
|
||||
};
|
||||
|
||||
Assert.AreEqual(CultureInfo.InvariantCulture, converter.Culture);
|
||||
Assert.AreEqual("F", converter.DateTimeFormat);
|
||||
Assert.AreEqual(DateTimeStyles.None, converter.DateTimeStyles);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDateTime()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter();
|
||||
|
||||
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""2000-12-15T22:11:03.055Z""", result);
|
||||
|
||||
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
|
||||
|
||||
d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Local);
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""2000-12-15T22:11:03.055" + d.GetUtcOffsetText() + @"""", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeFormattedDateTimeInvariantCulture()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.InvariantCulture };
|
||||
|
||||
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
|
||||
|
||||
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
|
||||
|
||||
d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeCustomFormattedDateTime()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter
|
||||
{
|
||||
DateTimeFormat = "dd/MM/yyyy",
|
||||
Culture = CultureInfo.InvariantCulture
|
||||
};
|
||||
|
||||
string json = @"""09/12/2006""";
|
||||
|
||||
DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
|
||||
|
||||
Assert.AreEqual(9, d.Day);
|
||||
Assert.AreEqual(12, d.Month);
|
||||
Assert.AreEqual(2006, d.Year);
|
||||
}
|
||||
|
||||
#if !SILVERLIGHT && !NETFX_CORE
|
||||
[Test]
|
||||
public void SerializeFormattedDateTimeNewZealandCulture()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.GetCultureInfo("en-NZ") };
|
||||
|
||||
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
|
||||
|
||||
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
|
||||
|
||||
d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeDateTimeCulture()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter() { Culture = CultureInfo.GetCultureInfo("en-NZ") };
|
||||
|
||||
string json = @"""09/12/2006""";
|
||||
|
||||
DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
|
||||
|
||||
Assert.AreEqual(9, d.Day);
|
||||
Assert.AreEqual(12, d.Month);
|
||||
Assert.AreEqual(2006, d.Year);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !PocketPC && !NET20
|
||||
[Test]
|
||||
public void SerializeDateTimeOffset()
|
||||
{
|
||||
IsoDateTimeConverter converter = new IsoDateTimeConverter();
|
||||
|
||||
DateTimeOffset d = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual(@"""2000-12-15T22:11:03.055+00:00""", result);
|
||||
|
||||
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTimeOffset>(result, converter));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeUTC()
|
||||
{
|
||||
DateTimeTestClass c = new DateTimeTestClass();
|
||||
c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);
|
||||
|
||||
//test the other edge case too
|
||||
c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.DateTimeOffsetField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-01-01T01:01:01Z"",""DateTimeOffsetField"":""2008-01-01T01:01:01+00:00"",""PostField"":""Post""}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void NullableSerializeUTC()
|
||||
{
|
||||
NullableDateTimeTestClass c = new NullableDateTimeTestClass();
|
||||
c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);
|
||||
|
||||
//test the other edge case too
|
||||
c.DateTimeField = null;
|
||||
c.DateTimeOffsetField = null;
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void NullableDeserializeEmptyString()
|
||||
{
|
||||
string json = @"{""DateTimeField"":""""}";
|
||||
|
||||
NullableDateTimeTestClass c = JsonConvert.DeserializeObject<NullableDateTimeTestClass>(json,
|
||||
new JsonSerializerSettings { Converters = new [] {new IsoDateTimeConverter()}});
|
||||
Assert.AreEqual(null, c.DateTimeField);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNullToNonNullable()
|
||||
{
|
||||
ExceptionAssert.Throws<Exception>("Cannot convert null value to System.DateTime.",
|
||||
() =>
|
||||
{
|
||||
DateTimeTestClass c2 =
|
||||
JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
});
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeShouldChangeNonUTCDates()
|
||||
{
|
||||
DateTime localDateTime = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Local);
|
||||
|
||||
DateTimeTestClass c = new DateTimeTestClass();
|
||||
c.DateTimeField = localDateTime;
|
||||
c.PreField = "Pre";
|
||||
c.PostField = "Post";
|
||||
string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal }); //note that this fails without the Utc converter...
|
||||
c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc);
|
||||
string json2 = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
|
||||
|
||||
TimeSpan offset = localDateTime.GetUtcOffset();
|
||||
|
||||
// if the current timezone is utc then local already equals utc
|
||||
if (offset == TimeSpan.Zero)
|
||||
Assert.AreEqual(json, json2);
|
||||
else
|
||||
Assert.AreNotEqual(json, json2);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void BlogCodeSample()
|
||||
{
|
||||
Person p = new Person
|
||||
{
|
||||
Name = "Keith",
|
||||
BirthDate = new DateTime(1980, 3, 8),
|
||||
LastModified = new DateTime(2009, 4, 12, 20, 44, 55),
|
||||
};
|
||||
|
||||
string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());
|
||||
// {
|
||||
// "Name": "Keith",
|
||||
// "BirthDate": "1980-03-08T00:00:00",
|
||||
// "LastModified": "2009-04-12T20:44:55"
|
||||
// }
|
||||
|
||||
Console.WriteLine(jsonText);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,133 +1,133 @@
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
using System;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Converters;
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class JavaScriptDateTimeConverterTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public void SerializeDateTime()
|
||||
{
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
|
||||
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual("new Date(976918263055)", result);
|
||||
}
|
||||
|
||||
#if !PocketPC && !NET20
|
||||
[Test]
|
||||
public void SerializeDateTimeOffset()
|
||||
{
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
|
||||
DateTimeOffset now = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(now, converter);
|
||||
Assert.AreEqual("new Date(976918263055)", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void sdfs()
|
||||
{
|
||||
int i = Convert.ToInt32("+1");
|
||||
Console.WriteLine(i);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeNullableDateTimeClass()
|
||||
{
|
||||
NullableDateTimeTestClass t = new NullableDateTimeTestClass()
|
||||
{
|
||||
DateTimeField = null,
|
||||
DateTimeOffsetField = null
|
||||
};
|
||||
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(t, converter);
|
||||
Assert.AreEqual(@"{""PreField"":null,""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":null}", result);
|
||||
|
||||
t = new NullableDateTimeTestClass()
|
||||
{
|
||||
DateTimeField = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc),
|
||||
DateTimeOffsetField = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero)
|
||||
};
|
||||
|
||||
result = JsonConvert.SerializeObject(t, converter);
|
||||
Assert.AreEqual(@"{""PreField"":null,""DateTimeField"":new Date(976918263055),""DateTimeOffsetField"":new Date(976918263055),""PostField"":null}", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNullToNonNullable()
|
||||
{
|
||||
ExceptionAssert.Throws<Exception>("Cannot convert null value to System.DateTime.",
|
||||
() =>
|
||||
{
|
||||
DateTimeTestClass c2 =
|
||||
JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new JavaScriptDateTimeConverter());
|
||||
});
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeDateTimeOffset()
|
||||
{
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
DateTimeOffset start = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
|
||||
|
||||
string json = JsonConvert.SerializeObject(start, converter);
|
||||
|
||||
DateTimeOffset result = JsonConvert.DeserializeObject<DateTimeOffset>(json, converter);
|
||||
Assert.AreEqual(new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero), result);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void DeserializeDateTime()
|
||||
{
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
|
||||
DateTime result = JsonConvert.DeserializeObject<DateTime>("new Date(976918263055)", converter);
|
||||
Assert.AreEqual(new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc), result);
|
||||
}
|
||||
}
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
using System;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Converters;
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class JavaScriptDateTimeConverterTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public void SerializeDateTime()
|
||||
{
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
|
||||
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(d, converter);
|
||||
Assert.AreEqual("new Date(976918263055)", result);
|
||||
}
|
||||
|
||||
#if !PocketPC && !NET20
|
||||
[Test]
|
||||
public void SerializeDateTimeOffset()
|
||||
{
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
|
||||
DateTimeOffset now = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(now, converter);
|
||||
Assert.AreEqual("new Date(976918263055)", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void sdfs()
|
||||
{
|
||||
int i = Convert.ToInt32("+1");
|
||||
Console.WriteLine(i);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeNullableDateTimeClass()
|
||||
{
|
||||
NullableDateTimeTestClass t = new NullableDateTimeTestClass()
|
||||
{
|
||||
DateTimeField = null,
|
||||
DateTimeOffsetField = null
|
||||
};
|
||||
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
|
||||
string result;
|
||||
|
||||
result = JsonConvert.SerializeObject(t, converter);
|
||||
Assert.AreEqual(@"{""PreField"":null,""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":null}", result);
|
||||
|
||||
t = new NullableDateTimeTestClass()
|
||||
{
|
||||
DateTimeField = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc),
|
||||
DateTimeOffsetField = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero)
|
||||
};
|
||||
|
||||
result = JsonConvert.SerializeObject(t, converter);
|
||||
Assert.AreEqual(@"{""PreField"":null,""DateTimeField"":new Date(976918263055),""DateTimeOffsetField"":new Date(976918263055),""PostField"":null}", result);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNullToNonNullable()
|
||||
{
|
||||
ExceptionAssert.Throws<Exception>("Cannot convert null value to System.DateTime.",
|
||||
() =>
|
||||
{
|
||||
DateTimeTestClass c2 =
|
||||
JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new JavaScriptDateTimeConverter());
|
||||
});
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeDateTimeOffset()
|
||||
{
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
DateTimeOffset start = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
|
||||
|
||||
string json = JsonConvert.SerializeObject(start, converter);
|
||||
|
||||
DateTimeOffset result = JsonConvert.DeserializeObject<DateTimeOffset>(json, converter);
|
||||
Assert.AreEqual(new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero), result);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void DeserializeDateTime()
|
||||
{
|
||||
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
|
||||
|
||||
DateTime result = JsonConvert.DeserializeObject<DateTime>("new Date(976918263055)", converter);
|
||||
Assert.AreEqual(new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc), result);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,60 +1,60 @@
|
||||
using System.IO;
|
||||
using Newtonsoft.Json.Bson;
|
||||
using Newtonsoft.Json.Utilities;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class ObjectIdConverterTests : TestFixtureBase
|
||||
{
|
||||
public class ObjectIdTestClass
|
||||
{
|
||||
[JsonProperty("_id")]
|
||||
public BsonObjectId Id { get; set; }
|
||||
[JsonProperty("test")]
|
||||
public string Test { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Serialize()
|
||||
{
|
||||
ObjectIdTestClass c = new ObjectIdTestClass
|
||||
{
|
||||
Id = new BsonObjectId(MiscellaneousUtils.HexToBytes("4ABBED9D1D8B0F0218000001")),
|
||||
Test = "1234£56"
|
||||
};
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
|
||||
// serialize product to BSON
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
serializer.Serialize(writer, c);
|
||||
|
||||
byte[] expected = MiscellaneousUtils.HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
|
||||
|
||||
CollectionAssert.AreEquivalent(expected, ms.ToArray());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Deserialize()
|
||||
{
|
||||
byte[] bson = MiscellaneousUtils.HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
|
||||
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
|
||||
BsonReader reader = new BsonReader(new MemoryStream(bson));
|
||||
ObjectIdTestClass c = serializer.Deserialize<ObjectIdTestClass>(reader);
|
||||
|
||||
CollectionAssert.AreEquivalent(c.Id.Value, MiscellaneousUtils.HexToBytes("4ABBED9D1D8B0F0218000001"));
|
||||
Assert.AreEqual(c.Test, "1234£56");
|
||||
}
|
||||
}
|
||||
}
|
||||
using System.IO;
|
||||
using Newtonsoft.Json.Bson;
|
||||
using Newtonsoft.Json.Utilities;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class ObjectIdConverterTests : TestFixtureBase
|
||||
{
|
||||
public class ObjectIdTestClass
|
||||
{
|
||||
[JsonProperty("_id")]
|
||||
public BsonObjectId Id { get; set; }
|
||||
[JsonProperty("test")]
|
||||
public string Test { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Serialize()
|
||||
{
|
||||
ObjectIdTestClass c = new ObjectIdTestClass
|
||||
{
|
||||
Id = new BsonObjectId(MiscellaneousUtils.HexToBytes("4ABBED9D1D8B0F0218000001")),
|
||||
Test = "1234£56"
|
||||
};
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
|
||||
// serialize product to BSON
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
serializer.Serialize(writer, c);
|
||||
|
||||
byte[] expected = MiscellaneousUtils.HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
|
||||
|
||||
CollectionAssert.AreEquivalent(expected, ms.ToArray());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Deserialize()
|
||||
{
|
||||
byte[] bson = MiscellaneousUtils.HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
|
||||
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
|
||||
BsonReader reader = new BsonReader(new MemoryStream(bson));
|
||||
ObjectIdTestClass c = serializer.Deserialize<ObjectIdTestClass>(reader);
|
||||
|
||||
CollectionAssert.AreEquivalent(c.Id.Value, MiscellaneousUtils.HexToBytes("4ABBED9D1D8B0F0218000001"));
|
||||
Assert.AreEqual(c.Test, "1234£56");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,161 +1,161 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
#if !SILVERLIGHT && !PocketPC && !NET20 && !NETFX_CORE
|
||||
using System.Data.Linq;
|
||||
#endif
|
||||
#if !SILVERLIGHT && !NETFX_CORE
|
||||
using System.Data.SqlTypes;
|
||||
#endif
|
||||
using System.IO;
|
||||
using System.Text.RegularExpressions;
|
||||
using Newtonsoft.Json.Bson;
|
||||
using Newtonsoft.Json.Converters;
|
||||
using Newtonsoft.Json.Utilities;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class RegexConverterTests : TestFixtureBase
|
||||
{
|
||||
public class RegexTestClass
|
||||
{
|
||||
public Regex Regex { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeToText()
|
||||
{
|
||||
Regex regex = new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
|
||||
|
||||
string json = JsonConvert.SerializeObject(regex, Formatting.Indented, new RegexConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Pattern"": ""abc"",
|
||||
""Options"": 513
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeToBson()
|
||||
{
|
||||
Regex regex = new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
serializer.Serialize(writer, new RegexTestClass { Regex = regex });
|
||||
|
||||
string expected = "13-00-00-00-0B-52-65-67-65-78-00-61-62-63-00-69-75-00-00";
|
||||
string bson = MiscellaneousUtils.BytesToHex(ms.ToArray());
|
||||
|
||||
Assert.AreEqual(expected, bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeFromText()
|
||||
{
|
||||
string json = @"{
|
||||
""Pattern"": ""abc"",
|
||||
""Options"": 513
|
||||
}";
|
||||
|
||||
Regex newRegex = JsonConvert.DeserializeObject<Regex>(json, new RegexConverter());
|
||||
Assert.AreEqual("abc", newRegex.ToString());
|
||||
Assert.AreEqual(RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, newRegex.Options);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeFromBson()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream(MiscellaneousUtils.HexToBytes("13-00-00-00-0B-52-65-67-65-78-00-61-62-63-00-69-75-00-00"));
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
|
||||
|
||||
Assert.AreEqual("abc", c.Regex.ToString());
|
||||
Assert.AreEqual(RegexOptions.IgnoreCase, c.Regex.Options);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ConvertEmptyRegexBson()
|
||||
{
|
||||
Regex regex = new Regex(string.Empty);
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
serializer.Serialize(writer, new RegexTestClass { Regex = regex });
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
|
||||
|
||||
Assert.AreEqual("", c.Regex.ToString());
|
||||
Assert.AreEqual(RegexOptions.None, c.Regex.Options);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ConvertRegexWithAllOptionsBson()
|
||||
{
|
||||
Regex regex = new Regex(
|
||||
"/",
|
||||
RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.ExplicitCapture);
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
serializer.Serialize(writer, new RegexTestClass { Regex = regex });
|
||||
|
||||
string expected = "14-00-00-00-0B-52-65-67-65-78-00-2F-00-69-6D-73-75-78-00-00";
|
||||
string bson = MiscellaneousUtils.BytesToHex(ms.ToArray());
|
||||
|
||||
Assert.AreEqual(expected, bson);
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
|
||||
|
||||
Assert.AreEqual("/", c.Regex.ToString());
|
||||
Assert.AreEqual(RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.ExplicitCapture, c.Regex.Options);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ConvertEmptyRegexJson()
|
||||
{
|
||||
Regex regex = new Regex("");
|
||||
|
||||
string json = JsonConvert.SerializeObject(new RegexTestClass { Regex = regex }, Formatting.Indented, new RegexConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Regex"": {
|
||||
""Pattern"": """",
|
||||
""Options"": 0
|
||||
}
|
||||
}", json);
|
||||
|
||||
RegexTestClass newRegex = JsonConvert.DeserializeObject<RegexTestClass>(json, new RegexConverter());
|
||||
Assert.AreEqual("", newRegex.Regex.ToString());
|
||||
Assert.AreEqual(RegexOptions.None, newRegex.Regex.Options);
|
||||
}
|
||||
}
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
#if !SILVERLIGHT && !PocketPC && !NET20 && !NETFX_CORE
|
||||
using System.Data.Linq;
|
||||
#endif
|
||||
#if !SILVERLIGHT && !NETFX_CORE
|
||||
using System.Data.SqlTypes;
|
||||
#endif
|
||||
using System.IO;
|
||||
using System.Text.RegularExpressions;
|
||||
using Newtonsoft.Json.Bson;
|
||||
using Newtonsoft.Json.Converters;
|
||||
using Newtonsoft.Json.Utilities;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class RegexConverterTests : TestFixtureBase
|
||||
{
|
||||
public class RegexTestClass
|
||||
{
|
||||
public Regex Regex { get; set; }
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeToText()
|
||||
{
|
||||
Regex regex = new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
|
||||
|
||||
string json = JsonConvert.SerializeObject(regex, Formatting.Indented, new RegexConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Pattern"": ""abc"",
|
||||
""Options"": 513
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeToBson()
|
||||
{
|
||||
Regex regex = new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
serializer.Serialize(writer, new RegexTestClass { Regex = regex });
|
||||
|
||||
string expected = "13-00-00-00-0B-52-65-67-65-78-00-61-62-63-00-69-75-00-00";
|
||||
string bson = MiscellaneousUtils.BytesToHex(ms.ToArray());
|
||||
|
||||
Assert.AreEqual(expected, bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeFromText()
|
||||
{
|
||||
string json = @"{
|
||||
""Pattern"": ""abc"",
|
||||
""Options"": 513
|
||||
}";
|
||||
|
||||
Regex newRegex = JsonConvert.DeserializeObject<Regex>(json, new RegexConverter());
|
||||
Assert.AreEqual("abc", newRegex.ToString());
|
||||
Assert.AreEqual(RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, newRegex.Options);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeFromBson()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream(MiscellaneousUtils.HexToBytes("13-00-00-00-0B-52-65-67-65-78-00-61-62-63-00-69-75-00-00"));
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
|
||||
|
||||
Assert.AreEqual("abc", c.Regex.ToString());
|
||||
Assert.AreEqual(RegexOptions.IgnoreCase, c.Regex.Options);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ConvertEmptyRegexBson()
|
||||
{
|
||||
Regex regex = new Regex(string.Empty);
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
serializer.Serialize(writer, new RegexTestClass { Regex = regex });
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
|
||||
|
||||
Assert.AreEqual("", c.Regex.ToString());
|
||||
Assert.AreEqual(RegexOptions.None, c.Regex.Options);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ConvertRegexWithAllOptionsBson()
|
||||
{
|
||||
Regex regex = new Regex(
|
||||
"/",
|
||||
RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.ExplicitCapture);
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
serializer.Serialize(writer, new RegexTestClass { Regex = regex });
|
||||
|
||||
string expected = "14-00-00-00-0B-52-65-67-65-78-00-2F-00-69-6D-73-75-78-00-00";
|
||||
string bson = MiscellaneousUtils.BytesToHex(ms.ToArray());
|
||||
|
||||
Assert.AreEqual(expected, bson);
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
serializer.Converters.Add(new RegexConverter());
|
||||
|
||||
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
|
||||
|
||||
Assert.AreEqual("/", c.Regex.ToString());
|
||||
Assert.AreEqual(RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.ExplicitCapture, c.Regex.Options);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ConvertEmptyRegexJson()
|
||||
{
|
||||
Regex regex = new Regex("");
|
||||
|
||||
string json = JsonConvert.SerializeObject(new RegexTestClass { Regex = regex }, Formatting.Indented, new RegexConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Regex"": {
|
||||
""Pattern"": """",
|
||||
""Options"": 0
|
||||
}
|
||||
}", json);
|
||||
|
||||
RegexTestClass newRegex = JsonConvert.DeserializeObject<RegexTestClass>(json, new RegexConverter());
|
||||
Assert.AreEqual("", newRegex.Regex.ToString());
|
||||
Assert.AreEqual(RegexOptions.None, newRegex.Regex.Options);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,300 +1,300 @@
|
||||
using System;
|
||||
using System.Runtime.Serialization;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class StringEnumConverterTests : TestFixtureBase
|
||||
{
|
||||
public class EnumClass
|
||||
{
|
||||
public StoreColor StoreColor { get; set; }
|
||||
public StoreColor? NullableStoreColor1 { get; set; }
|
||||
public StoreColor? NullableStoreColor2 { get; set; }
|
||||
}
|
||||
|
||||
public class EnumContainer<T>
|
||||
{
|
||||
public T Enum { get; set; }
|
||||
}
|
||||
|
||||
[Flags]
|
||||
public enum FlagsTestEnum
|
||||
{
|
||||
Default = 0,
|
||||
First = 1,
|
||||
Second = 2
|
||||
}
|
||||
|
||||
public enum NegativeEnum
|
||||
{
|
||||
Negative = -1,
|
||||
Zero = 0,
|
||||
Positive = 1
|
||||
}
|
||||
|
||||
#if !NET20
|
||||
public enum NamedEnum
|
||||
{
|
||||
[EnumMember(Value = "@first")]
|
||||
First,
|
||||
[EnumMember(Value = "@second")]
|
||||
Second,
|
||||
Third
|
||||
}
|
||||
|
||||
public enum NamedEnumDuplicate
|
||||
{
|
||||
[EnumMember(Value = "Third")]
|
||||
First,
|
||||
[EnumMember(Value = "@second")]
|
||||
Second,
|
||||
Third
|
||||
}
|
||||
#endif
|
||||
|
||||
public class NegativeEnumClass
|
||||
{
|
||||
public NegativeEnum Value1 { get; set; }
|
||||
public NegativeEnum Value2 { get; set; }
|
||||
}
|
||||
|
||||
#if !NET20
|
||||
[Test]
|
||||
public void NamedEnumDuplicateTest()
|
||||
{
|
||||
ExceptionAssert.Throws<Exception>("Enum name 'Third' already exists on enum 'NamedEnumDuplicate'.",
|
||||
() =>
|
||||
{
|
||||
EnumContainer<NamedEnumDuplicate> c = new EnumContainer<NamedEnumDuplicate>
|
||||
{
|
||||
Enum = NamedEnumDuplicate.First
|
||||
};
|
||||
|
||||
JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter());
|
||||
});
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeNameEnumTest()
|
||||
{
|
||||
EnumContainer<NamedEnum> c = new EnumContainer<NamedEnum>
|
||||
{
|
||||
Enum = NamedEnum.First
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter());
|
||||
Assert.AreEqual(@"{
|
||||
""Enum"": ""@first""
|
||||
}", json);
|
||||
|
||||
c = new EnumContainer<NamedEnum>
|
||||
{
|
||||
Enum = NamedEnum.Third
|
||||
};
|
||||
|
||||
json = JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter());
|
||||
Assert.AreEqual(@"{
|
||||
""Enum"": ""Third""
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNameEnumTest()
|
||||
{
|
||||
string json = @"{
|
||||
""Enum"": ""@first""
|
||||
}";
|
||||
|
||||
EnumContainer<NamedEnum> c = JsonConvert.DeserializeObject<EnumContainer<NamedEnum>>(json, new StringEnumConverter());
|
||||
Assert.AreEqual(NamedEnum.First, c.Enum);
|
||||
|
||||
json = @"{
|
||||
""Enum"": ""Third""
|
||||
}";
|
||||
|
||||
c = JsonConvert.DeserializeObject<EnumContainer<NamedEnum>>(json, new StringEnumConverter());
|
||||
Assert.AreEqual(NamedEnum.Third, c.Enum);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void SerializeEnumClass()
|
||||
{
|
||||
EnumClass enumClass = new EnumClass();
|
||||
enumClass.StoreColor = StoreColor.Red;
|
||||
enumClass.NullableStoreColor1 = StoreColor.White;
|
||||
enumClass.NullableStoreColor2 = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""StoreColor"": ""Red"",
|
||||
""NullableStoreColor1"": ""White"",
|
||||
""NullableStoreColor2"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeEnumClassWithCamelCase()
|
||||
{
|
||||
EnumClass enumClass = new EnumClass();
|
||||
enumClass.StoreColor = StoreColor.Red;
|
||||
enumClass.NullableStoreColor1 = StoreColor.DarkGoldenrod;
|
||||
enumClass.NullableStoreColor2 = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter { CamelCaseText = true });
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""StoreColor"": ""red"",
|
||||
""NullableStoreColor1"": ""darkGoldenrod"",
|
||||
""NullableStoreColor2"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeEnumClassUndefined()
|
||||
{
|
||||
EnumClass enumClass = new EnumClass();
|
||||
enumClass.StoreColor = (StoreColor)1000;
|
||||
enumClass.NullableStoreColor1 = (StoreColor)1000;
|
||||
enumClass.NullableStoreColor2 = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""StoreColor"": 1000,
|
||||
""NullableStoreColor1"": 1000,
|
||||
""NullableStoreColor2"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeFlagEnum()
|
||||
{
|
||||
EnumClass enumClass = new EnumClass();
|
||||
enumClass.StoreColor = StoreColor.Red | StoreColor.White;
|
||||
enumClass.NullableStoreColor1 = StoreColor.White & StoreColor.Yellow;
|
||||
enumClass.NullableStoreColor2 = StoreColor.Red | StoreColor.White | StoreColor.Black;
|
||||
|
||||
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""StoreColor"": ""Red, White"",
|
||||
""NullableStoreColor1"": 0,
|
||||
""NullableStoreColor2"": ""Black, Red, White""
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeNegativeEnum()
|
||||
{
|
||||
NegativeEnumClass negativeEnumClass = new NegativeEnumClass();
|
||||
negativeEnumClass.Value1 = NegativeEnum.Negative;
|
||||
negativeEnumClass.Value2 = (NegativeEnum) int.MinValue;
|
||||
|
||||
string json = JsonConvert.SerializeObject(negativeEnumClass, Formatting.Indented, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Value1"": ""Negative"",
|
||||
""Value2"": -2147483648
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNegativeEnum()
|
||||
{
|
||||
string json = @"{
|
||||
""Value1"": ""Negative"",
|
||||
""Value2"": -2147483648
|
||||
}";
|
||||
|
||||
NegativeEnumClass negativeEnumClass = JsonConvert.DeserializeObject<NegativeEnumClass>(json, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(NegativeEnum.Negative, negativeEnumClass.Value1);
|
||||
Assert.AreEqual((NegativeEnum)int.MinValue, negativeEnumClass.Value2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeFlagEnum()
|
||||
{
|
||||
string json = @"{
|
||||
""StoreColor"": ""Red, White"",
|
||||
""NullableStoreColor1"": 0,
|
||||
""NullableStoreColor2"": ""black, Red, White""
|
||||
}";
|
||||
|
||||
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(StoreColor.Red | StoreColor.White, enumClass.StoreColor);
|
||||
Assert.AreEqual((StoreColor)0, enumClass.NullableStoreColor1);
|
||||
Assert.AreEqual(StoreColor.Red | StoreColor.White | StoreColor.Black, enumClass.NullableStoreColor2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeEnumClass()
|
||||
{
|
||||
string json = @"{
|
||||
""StoreColor"": ""Red"",
|
||||
""NullableStoreColor1"": ""White"",
|
||||
""NullableStoreColor2"": null
|
||||
}";
|
||||
|
||||
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(StoreColor.Red, enumClass.StoreColor);
|
||||
Assert.AreEqual(StoreColor.White, enumClass.NullableStoreColor1);
|
||||
Assert.AreEqual(null, enumClass.NullableStoreColor2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeEnumClassUndefined()
|
||||
{
|
||||
string json = @"{
|
||||
""StoreColor"": 1000,
|
||||
""NullableStoreColor1"": 1000,
|
||||
""NullableStoreColor2"": null
|
||||
}";
|
||||
|
||||
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual((StoreColor)1000, enumClass.StoreColor);
|
||||
Assert.AreEqual((StoreColor)1000, enumClass.NullableStoreColor1);
|
||||
Assert.AreEqual(null, enumClass.NullableStoreColor2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CamelCaseTextFlagEnumSerialization()
|
||||
{
|
||||
EnumContainer<FlagsTestEnum> c = new EnumContainer<FlagsTestEnum>
|
||||
{
|
||||
Enum = FlagsTestEnum.First | FlagsTestEnum.Second
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter { CamelCaseText = true });
|
||||
Assert.AreEqual(@"{
|
||||
""Enum"": ""first, second""
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CamelCaseTextFlagEnumDeserialization()
|
||||
{
|
||||
string json = @"{
|
||||
""Enum"": ""first, second""
|
||||
}";
|
||||
|
||||
EnumContainer<FlagsTestEnum> c = JsonConvert.DeserializeObject<EnumContainer<FlagsTestEnum>>(json, new StringEnumConverter { CamelCaseText = true });
|
||||
Assert.AreEqual(FlagsTestEnum.First | FlagsTestEnum.Second, c.Enum);
|
||||
}
|
||||
}
|
||||
using System;
|
||||
using System.Runtime.Serialization;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
using Newtonsoft.Json.Tests.TestObjects;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
[TestFixture]
|
||||
public class StringEnumConverterTests : TestFixtureBase
|
||||
{
|
||||
public class EnumClass
|
||||
{
|
||||
public StoreColor StoreColor { get; set; }
|
||||
public StoreColor? NullableStoreColor1 { get; set; }
|
||||
public StoreColor? NullableStoreColor2 { get; set; }
|
||||
}
|
||||
|
||||
public class EnumContainer<T>
|
||||
{
|
||||
public T Enum { get; set; }
|
||||
}
|
||||
|
||||
[Flags]
|
||||
public enum FlagsTestEnum
|
||||
{
|
||||
Default = 0,
|
||||
First = 1,
|
||||
Second = 2
|
||||
}
|
||||
|
||||
public enum NegativeEnum
|
||||
{
|
||||
Negative = -1,
|
||||
Zero = 0,
|
||||
Positive = 1
|
||||
}
|
||||
|
||||
#if !NET20
|
||||
public enum NamedEnum
|
||||
{
|
||||
[EnumMember(Value = "@first")]
|
||||
First,
|
||||
[EnumMember(Value = "@second")]
|
||||
Second,
|
||||
Third
|
||||
}
|
||||
|
||||
public enum NamedEnumDuplicate
|
||||
{
|
||||
[EnumMember(Value = "Third")]
|
||||
First,
|
||||
[EnumMember(Value = "@second")]
|
||||
Second,
|
||||
Third
|
||||
}
|
||||
#endif
|
||||
|
||||
public class NegativeEnumClass
|
||||
{
|
||||
public NegativeEnum Value1 { get; set; }
|
||||
public NegativeEnum Value2 { get; set; }
|
||||
}
|
||||
|
||||
#if !NET20
|
||||
[Test]
|
||||
public void NamedEnumDuplicateTest()
|
||||
{
|
||||
ExceptionAssert.Throws<Exception>("Enum name 'Third' already exists on enum 'NamedEnumDuplicate'.",
|
||||
() =>
|
||||
{
|
||||
EnumContainer<NamedEnumDuplicate> c = new EnumContainer<NamedEnumDuplicate>
|
||||
{
|
||||
Enum = NamedEnumDuplicate.First
|
||||
};
|
||||
|
||||
JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter());
|
||||
});
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeNameEnumTest()
|
||||
{
|
||||
EnumContainer<NamedEnum> c = new EnumContainer<NamedEnum>
|
||||
{
|
||||
Enum = NamedEnum.First
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter());
|
||||
Assert.AreEqual(@"{
|
||||
""Enum"": ""@first""
|
||||
}", json);
|
||||
|
||||
c = new EnumContainer<NamedEnum>
|
||||
{
|
||||
Enum = NamedEnum.Third
|
||||
};
|
||||
|
||||
json = JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter());
|
||||
Assert.AreEqual(@"{
|
||||
""Enum"": ""Third""
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNameEnumTest()
|
||||
{
|
||||
string json = @"{
|
||||
""Enum"": ""@first""
|
||||
}";
|
||||
|
||||
EnumContainer<NamedEnum> c = JsonConvert.DeserializeObject<EnumContainer<NamedEnum>>(json, new StringEnumConverter());
|
||||
Assert.AreEqual(NamedEnum.First, c.Enum);
|
||||
|
||||
json = @"{
|
||||
""Enum"": ""Third""
|
||||
}";
|
||||
|
||||
c = JsonConvert.DeserializeObject<EnumContainer<NamedEnum>>(json, new StringEnumConverter());
|
||||
Assert.AreEqual(NamedEnum.Third, c.Enum);
|
||||
}
|
||||
#endif
|
||||
|
||||
[Test]
|
||||
public void SerializeEnumClass()
|
||||
{
|
||||
EnumClass enumClass = new EnumClass();
|
||||
enumClass.StoreColor = StoreColor.Red;
|
||||
enumClass.NullableStoreColor1 = StoreColor.White;
|
||||
enumClass.NullableStoreColor2 = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""StoreColor"": ""Red"",
|
||||
""NullableStoreColor1"": ""White"",
|
||||
""NullableStoreColor2"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeEnumClassWithCamelCase()
|
||||
{
|
||||
EnumClass enumClass = new EnumClass();
|
||||
enumClass.StoreColor = StoreColor.Red;
|
||||
enumClass.NullableStoreColor1 = StoreColor.DarkGoldenrod;
|
||||
enumClass.NullableStoreColor2 = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter { CamelCaseText = true });
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""StoreColor"": ""red"",
|
||||
""NullableStoreColor1"": ""darkGoldenrod"",
|
||||
""NullableStoreColor2"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeEnumClassUndefined()
|
||||
{
|
||||
EnumClass enumClass = new EnumClass();
|
||||
enumClass.StoreColor = (StoreColor)1000;
|
||||
enumClass.NullableStoreColor1 = (StoreColor)1000;
|
||||
enumClass.NullableStoreColor2 = null;
|
||||
|
||||
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""StoreColor"": 1000,
|
||||
""NullableStoreColor1"": 1000,
|
||||
""NullableStoreColor2"": null
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeFlagEnum()
|
||||
{
|
||||
EnumClass enumClass = new EnumClass();
|
||||
enumClass.StoreColor = StoreColor.Red | StoreColor.White;
|
||||
enumClass.NullableStoreColor1 = StoreColor.White & StoreColor.Yellow;
|
||||
enumClass.NullableStoreColor2 = StoreColor.Red | StoreColor.White | StoreColor.Black;
|
||||
|
||||
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""StoreColor"": ""Red, White"",
|
||||
""NullableStoreColor1"": 0,
|
||||
""NullableStoreColor2"": ""Black, Red, White""
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeNegativeEnum()
|
||||
{
|
||||
NegativeEnumClass negativeEnumClass = new NegativeEnumClass();
|
||||
negativeEnumClass.Value1 = NegativeEnum.Negative;
|
||||
negativeEnumClass.Value2 = (NegativeEnum) int.MinValue;
|
||||
|
||||
string json = JsonConvert.SerializeObject(negativeEnumClass, Formatting.Indented, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(@"{
|
||||
""Value1"": ""Negative"",
|
||||
""Value2"": -2147483648
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeNegativeEnum()
|
||||
{
|
||||
string json = @"{
|
||||
""Value1"": ""Negative"",
|
||||
""Value2"": -2147483648
|
||||
}";
|
||||
|
||||
NegativeEnumClass negativeEnumClass = JsonConvert.DeserializeObject<NegativeEnumClass>(json, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(NegativeEnum.Negative, negativeEnumClass.Value1);
|
||||
Assert.AreEqual((NegativeEnum)int.MinValue, negativeEnumClass.Value2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeFlagEnum()
|
||||
{
|
||||
string json = @"{
|
||||
""StoreColor"": ""Red, White"",
|
||||
""NullableStoreColor1"": 0,
|
||||
""NullableStoreColor2"": ""black, Red, White""
|
||||
}";
|
||||
|
||||
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(StoreColor.Red | StoreColor.White, enumClass.StoreColor);
|
||||
Assert.AreEqual((StoreColor)0, enumClass.NullableStoreColor1);
|
||||
Assert.AreEqual(StoreColor.Red | StoreColor.White | StoreColor.Black, enumClass.NullableStoreColor2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeEnumClass()
|
||||
{
|
||||
string json = @"{
|
||||
""StoreColor"": ""Red"",
|
||||
""NullableStoreColor1"": ""White"",
|
||||
""NullableStoreColor2"": null
|
||||
}";
|
||||
|
||||
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual(StoreColor.Red, enumClass.StoreColor);
|
||||
Assert.AreEqual(StoreColor.White, enumClass.NullableStoreColor1);
|
||||
Assert.AreEqual(null, enumClass.NullableStoreColor2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeEnumClassUndefined()
|
||||
{
|
||||
string json = @"{
|
||||
""StoreColor"": 1000,
|
||||
""NullableStoreColor1"": 1000,
|
||||
""NullableStoreColor2"": null
|
||||
}";
|
||||
|
||||
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
|
||||
|
||||
Assert.AreEqual((StoreColor)1000, enumClass.StoreColor);
|
||||
Assert.AreEqual((StoreColor)1000, enumClass.NullableStoreColor1);
|
||||
Assert.AreEqual(null, enumClass.NullableStoreColor2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CamelCaseTextFlagEnumSerialization()
|
||||
{
|
||||
EnumContainer<FlagsTestEnum> c = new EnumContainer<FlagsTestEnum>
|
||||
{
|
||||
Enum = FlagsTestEnum.First | FlagsTestEnum.Second
|
||||
};
|
||||
|
||||
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter { CamelCaseText = true });
|
||||
Assert.AreEqual(@"{
|
||||
""Enum"": ""first, second""
|
||||
}", json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CamelCaseTextFlagEnumDeserialization()
|
||||
{
|
||||
string json = @"{
|
||||
""Enum"": ""first, second""
|
||||
}";
|
||||
|
||||
EnumContainer<FlagsTestEnum> c = JsonConvert.DeserializeObject<EnumContainer<FlagsTestEnum>>(json, new StringEnumConverter { CamelCaseText = true });
|
||||
Assert.AreEqual(FlagsTestEnum.First | FlagsTestEnum.Second, c.Enum);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,117 +1,117 @@
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
using System;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
public class VersionClass
|
||||
{
|
||||
public VersionClass(string version1, string version2)
|
||||
{
|
||||
this.StringProperty1 = "StringProperty1";
|
||||
this.Version1 = new Version(version1);
|
||||
this.Version2 = new Version(version2);
|
||||
this.StringProperty2 = "StringProperty2";
|
||||
}
|
||||
|
||||
public VersionClass()
|
||||
{
|
||||
}
|
||||
|
||||
public string StringProperty1 { get; set; }
|
||||
public Version Version1 { get; set; }
|
||||
public Version Version2 { get; set; }
|
||||
public string StringProperty2 { get; set; }
|
||||
}
|
||||
|
||||
[TestFixture]
|
||||
public class VersionConverterTests : TestFixtureBase
|
||||
{
|
||||
private void SerializeVersionClass(string version1, string version2)
|
||||
{
|
||||
VersionClass versionClass = new VersionClass(version1, version2);
|
||||
|
||||
string json = JsonConvert.SerializeObject(versionClass, Formatting.Indented, new VersionConverter());
|
||||
|
||||
string expectedJson = string.Format(@"{{
|
||||
""StringProperty1"": ""StringProperty1"",
|
||||
""Version1"": ""{0}"",
|
||||
""Version2"": ""{1}"",
|
||||
""StringProperty2"": ""StringProperty2""
|
||||
}}", version1, version2);
|
||||
|
||||
Assert.AreEqual(expectedJson, json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeVersionClass()
|
||||
{
|
||||
SerializeVersionClass("1.0.0.0", "2.0.0.0");
|
||||
SerializeVersionClass("1.2.0.0", "2.3.0.0");
|
||||
SerializeVersionClass("1.2.3.0", "2.3.4.0");
|
||||
SerializeVersionClass("1.2.3.4", "2.3.4.5");
|
||||
|
||||
SerializeVersionClass("1.2", "2.3");
|
||||
SerializeVersionClass("1.2.3", "2.3.4");
|
||||
SerializeVersionClass("1.2.3.4", "2.3.4.5");
|
||||
}
|
||||
|
||||
private void DeserializeVersionClass(string version1, string version2)
|
||||
{
|
||||
string json = string.Format(@"{{""StringProperty1"": ""StringProperty1"", ""Version1"": ""{0}"", ""Version2"": ""{1}"", ""StringProperty2"": ""StringProperty2""}}", version1, version2);
|
||||
Version expectedVersion1 = new Version(version1);
|
||||
Version expectedVersion2 = new Version(version2);
|
||||
|
||||
VersionClass versionClass = JsonConvert.DeserializeObject<VersionClass>(json, new VersionConverter());
|
||||
|
||||
Assert.AreEqual("StringProperty1", versionClass.StringProperty1);
|
||||
Assert.AreEqual(expectedVersion1, versionClass.Version1);
|
||||
Assert.AreEqual(expectedVersion2, versionClass.Version2);
|
||||
Assert.AreEqual("StringProperty2", versionClass.StringProperty2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeVersionClass()
|
||||
{
|
||||
DeserializeVersionClass("1.0.0.0", "2.0.0.0");
|
||||
DeserializeVersionClass("1.2.0.0", "2.3.0.0");
|
||||
DeserializeVersionClass("1.2.3.0", "2.3.4.0");
|
||||
DeserializeVersionClass("1.2.3.4", "2.3.4.5");
|
||||
|
||||
DeserializeVersionClass("1.2", "2.3");
|
||||
DeserializeVersionClass("1.2.3", "2.3.4");
|
||||
DeserializeVersionClass("1.2.3.4", "2.3.4.5");
|
||||
}
|
||||
}
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
using System;
|
||||
using Newtonsoft.Json.Converters;
|
||||
#if !NETFX_CORE
|
||||
using NUnit.Framework;
|
||||
#else
|
||||
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||
using TestFixture = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
|
||||
using Test = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
|
||||
#endif
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Converters
|
||||
{
|
||||
public class VersionClass
|
||||
{
|
||||
public VersionClass(string version1, string version2)
|
||||
{
|
||||
this.StringProperty1 = "StringProperty1";
|
||||
this.Version1 = new Version(version1);
|
||||
this.Version2 = new Version(version2);
|
||||
this.StringProperty2 = "StringProperty2";
|
||||
}
|
||||
|
||||
public VersionClass()
|
||||
{
|
||||
}
|
||||
|
||||
public string StringProperty1 { get; set; }
|
||||
public Version Version1 { get; set; }
|
||||
public Version Version2 { get; set; }
|
||||
public string StringProperty2 { get; set; }
|
||||
}
|
||||
|
||||
[TestFixture]
|
||||
public class VersionConverterTests : TestFixtureBase
|
||||
{
|
||||
private void SerializeVersionClass(string version1, string version2)
|
||||
{
|
||||
VersionClass versionClass = new VersionClass(version1, version2);
|
||||
|
||||
string json = JsonConvert.SerializeObject(versionClass, Formatting.Indented, new VersionConverter());
|
||||
|
||||
string expectedJson = string.Format(@"{{
|
||||
""StringProperty1"": ""StringProperty1"",
|
||||
""Version1"": ""{0}"",
|
||||
""Version2"": ""{1}"",
|
||||
""StringProperty2"": ""StringProperty2""
|
||||
}}", version1, version2);
|
||||
|
||||
Assert.AreEqual(expectedJson, json);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SerializeVersionClass()
|
||||
{
|
||||
SerializeVersionClass("1.0.0.0", "2.0.0.0");
|
||||
SerializeVersionClass("1.2.0.0", "2.3.0.0");
|
||||
SerializeVersionClass("1.2.3.0", "2.3.4.0");
|
||||
SerializeVersionClass("1.2.3.4", "2.3.4.5");
|
||||
|
||||
SerializeVersionClass("1.2", "2.3");
|
||||
SerializeVersionClass("1.2.3", "2.3.4");
|
||||
SerializeVersionClass("1.2.3.4", "2.3.4.5");
|
||||
}
|
||||
|
||||
private void DeserializeVersionClass(string version1, string version2)
|
||||
{
|
||||
string json = string.Format(@"{{""StringProperty1"": ""StringProperty1"", ""Version1"": ""{0}"", ""Version2"": ""{1}"", ""StringProperty2"": ""StringProperty2""}}", version1, version2);
|
||||
Version expectedVersion1 = new Version(version1);
|
||||
Version expectedVersion2 = new Version(version2);
|
||||
|
||||
VersionClass versionClass = JsonConvert.DeserializeObject<VersionClass>(json, new VersionConverter());
|
||||
|
||||
Assert.AreEqual("StringProperty1", versionClass.StringProperty1);
|
||||
Assert.AreEqual(expectedVersion1, versionClass.Version1);
|
||||
Assert.AreEqual(expectedVersion2, versionClass.Version2);
|
||||
Assert.AreEqual("StringProperty2", versionClass.StringProperty2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DeserializeVersionClass()
|
||||
{
|
||||
DeserializeVersionClass("1.0.0.0", "2.0.0.0");
|
||||
DeserializeVersionClass("1.2.0.0", "2.3.0.0");
|
||||
DeserializeVersionClass("1.2.3.0", "2.3.4.0");
|
||||
DeserializeVersionClass("1.2.3.4", "2.3.4.5");
|
||||
|
||||
DeserializeVersionClass("1.2", "2.3");
|
||||
DeserializeVersionClass("1.2.3", "2.3.4");
|
||||
DeserializeVersionClass("1.2.3.4", "2.3.4.5");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user