-Code reformat

This commit is contained in:
James Newton-King
2013-10-20 15:08:39 +13:00
parent d03963016e
commit bcd6982419
466 changed files with 71645 additions and 71598 deletions
@@ -35,6 +35,7 @@ using System.Text;
using Newtonsoft.Json.Converters;
#if !NETFX_CORE
using NUnit.Framework;
#else
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
@@ -43,151 +44,151 @@ using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAtt
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
[TestFixture]
public class BinaryConverterTests : TestFixtureBase
{
public byte[] ByteArray { get; set; }
public byte[] NullByteArray { get; set; }
}
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 || NET20 || NETFX_CORE || PORTABLE || PORTABLE40)
[Test]
public void DeserializeBinaryClass()
{
string json = @"{
[Test]
public void DeserializeBinaryClass()
{
string json = @"{
""Binary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
""NullBinary"": null
}";
BinaryClass binaryClass = JsonConvert.DeserializeObject<BinaryClass>(json, new BinaryConverter());
BinaryClass binaryClass = JsonConvert.DeserializeObject<BinaryClass>(json, new BinaryConverter());
Assert.AreEqual(new Binary(TestData), binaryClass.Binary);
Assert.AreEqual(null, binaryClass.NullBinary);
}
Assert.AreEqual(new Binary(TestData), binaryClass.Binary);
Assert.AreEqual(null, binaryClass.NullBinary);
}
[Test]
public void DeserializeBinaryClassFromJsonArray()
{
string json = @"{
[Test]
public void DeserializeBinaryClassFromJsonArray()
{
string json = @"{
""Binary"": [0, 1, 2, 3],
""NullBinary"": null
}";
BinaryClass binaryClass = JsonConvert.DeserializeObject<BinaryClass>(json, new BinaryConverter());
BinaryClass binaryClass = JsonConvert.DeserializeObject<BinaryClass>(json, new BinaryConverter());
Assert.AreEqual(new byte[] { 0, 1, 2, 3 }, binaryClass.Binary.ToArray());
Assert.AreEqual(null, binaryClass.NullBinary);
}
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; }
}
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;
[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());
string json = JsonConvert.SerializeObject(binaryClass, Formatting.Indented, new BinaryConverter());
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""Binary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
""NullBinary"": null
}", json);
}
}
#endif
[Test]
public void SerializeByteArrayClass()
{
ByteArrayClass byteArrayClass = new ByteArrayClass();
byteArrayClass.ByteArray = TestData;
byteArrayClass.NullByteArray = null;
[Test]
public void SerializeByteArrayClass()
{
ByteArrayClass byteArrayClass = new ByteArrayClass();
byteArrayClass.ByteArray = TestData;
byteArrayClass.NullByteArray = null;
string json = JsonConvert.SerializeObject(byteArrayClass, Formatting.Indented);
string json = JsonConvert.SerializeObject(byteArrayClass, Formatting.Indented);
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""ByteArray"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
""NullByteArray"": null
}", json);
}
}
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE || PORTABLE40)
public class SqlBinaryClass
{
public SqlBinary SqlBinary { get; set; }
public SqlBinary? NullableSqlBinary1 { get; set; }
public SqlBinary? NullableSqlBinary2 { get; set; }
}
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;
[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());
string json = JsonConvert.SerializeObject(sqlBinaryClass, Formatting.Indented, new BinaryConverter());
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""SqlBinary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
""NullableSqlBinary1"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
""NullableSqlBinary2"": null
}", json);
}
}
[Test]
public void DeserializeSqlBinaryClass()
{
string json = @"{
[Test]
public void DeserializeSqlBinaryClass()
{
string json = @"{
""SqlBinary"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
""NullableSqlBinary1"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
""NullableSqlBinary2"": null
}";
SqlBinaryClass sqlBinaryClass = JsonConvert.DeserializeObject<SqlBinaryClass>(json, new BinaryConverter());
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);
}
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 = @"{
[Test]
public void DeserializeByteArrayClass()
{
string json = @"{
""ByteArray"": ""VGhpcyBpcyBzb21lIHRlc3QgZGF0YSEhIQ=="",
""NullByteArray"": null
}";
ByteArrayClass byteArrayClass = JsonConvert.DeserializeObject<ByteArrayClass>(json);
ByteArrayClass byteArrayClass = JsonConvert.DeserializeObject<ByteArrayClass>(json);
CollectionAssert.AreEquivalent(TestData, byteArrayClass.ByteArray);
Assert.AreEqual(null, byteArrayClass.NullByteArray);
}
CollectionAssert.AreEquivalent(TestData, byteArrayClass.ByteArray);
Assert.AreEqual(null, byteArrayClass.NullByteArray);
}
[Test]
public void DeserializeByteArrayFromJsonArray()
{
string json = @"{
[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);
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);
}
}
}
}
@@ -28,6 +28,7 @@ using System.Collections.Generic;
using Newtonsoft.Json.Converters;
#if !NETFX_CORE
using NUnit.Framework;
#else
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
@@ -36,200 +37,200 @@ using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAtt
namespace Newtonsoft.Json.Tests.Converters
{
[TestFixture]
public class CustomCreationConverterTests : TestFixtureBase
{
public interface IPerson
[TestFixture]
public class CustomCreationConverterTests : TestFixtureBase
{
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>
public interface IPerson
{
new Employee
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)
{
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"
return new Employee();
}
}, Formatting.Indented);
}
//[
// {
// "FirstName": "Maurice",
// "LastName": "Moss",
// "BirthDate": "\/Date(252291661000)\/",
// "Department": "IT",
// "JobTitle": "Support"
// },
// {
// "FirstName": "Jen",
// "LastName": "Barber",
// "BirthDate": "\/Date(258771661000)\/",
// "Department": "IT",
// "JobTitle": "Manager"
// }
//]
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);
List<IPerson> people = JsonConvert.DeserializeObject<List<IPerson>>(json, new PersonConverter());
//[
// {
// "FirstName": "Maurice",
// "LastName": "Moss",
// "BirthDate": "\/Date(252291661000)\/",
// "Department": "IT",
// "JobTitle": "Support"
// },
// {
// "FirstName": "Jen",
// "LastName": "Barber",
// "BirthDate": "\/Date(258771661000)\/",
// "Department": "IT",
// "JobTitle": "Manager"
// }
//]
IPerson person = people[0];
List<IPerson> people = JsonConvert.DeserializeObject<List<IPerson>>(json, new PersonConverter());
Console.WriteLine(person.GetType());
// Newtonsoft.Json.Tests.Employee
IPerson person = people[0];
Console.WriteLine(person.FirstName);
// Maurice
Console.WriteLine(person.GetType());
// Newtonsoft.Json.Tests.Employee
Employee employee = (Employee)person;
Console.WriteLine(person.FirstName);
// Maurice
Console.WriteLine(employee.JobTitle);
// Support
}
Employee employee = (Employee)person;
public class MyClass
{
public string Value { get; set; }
Console.WriteLine(employee.JobTitle);
// Support
}
[JsonConverter(typeof(MyThingConverter))]
public IThing Thing { get; set; }
}
public class MyClass
{
public string Value { get; set; }
public interface IThing
{
int Number { get; }
}
[JsonConverter(typeof(MyThingConverter))]
public IThing Thing { get; set; }
}
public class MyThing : IThing
{
public int Number { get; set; }
}
public interface IThing
{
int Number { get; }
}
public class MyThingConverter : CustomCreationConverter<IThing>
{
public override IThing Create(Type objectType)
{
return new MyThing();
}
}
public class MyThing : IThing
{
public int Number { get; set; }
}
[Test]
public void AssertDoesDeserialize()
{
const string json = @"{
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);
}
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
[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);
}
const string expected = @"{""Value"":""Foo"",""Thing"":{""Number"":456}}";
Assert.AreEqual(expected, json);
}
internal interface IRange<T>
{
T First { get; }
T Last { get; }
}
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 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 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 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>();
}
}
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
};
[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);
string json = JsonConvert.SerializeObject(initial, Formatting.Indented);
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""Id"": ""00000001-0002-0003-0405-060708090a0b"",
""Year"": 2010,
""Company"": ""Company!"",
@@ -244,17 +245,17 @@ namespace Newtonsoft.Json.Tests.Converters
""NullDecimalRange"": null
}", json);
NullInterfaceTestClass deserialized = JsonConvert.DeserializeObject<NullInterfaceTestClass>(
json, new IntRangeConverter(), new DecimalRangeConverter());
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);
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);
}
}
}
}
@@ -39,34 +39,34 @@ using System.Data;
namespace Newtonsoft.Json.Tests.Converters
{
public class DataSetConverterTests : TestFixtureBase
{
[Test]
public void SerializeAndDeserialize()
public class DataSetConverterTests : TestFixtureBase
{
DataSet dataSet = new DataSet("dataSet");
dataSet.Namespace = "NetFrameWork";
DataTable table = new DataTable();
DataColumn idColumn = new DataColumn("id", typeof(int));
idColumn.AutoIncrement = true;
[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);
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);
}
for (int i = 0; i < 2; i++)
{
DataRow newRow = table.NewRow();
newRow["item"] = "item " + i;
table.Rows.Add(newRow);
}
dataSet.AcceptChanges();
dataSet.AcceptChanges();
string json = JsonConvert.SerializeObject(dataSet, Formatting.Indented);
Assert.AreEqual(@"{
string json = JsonConvert.SerializeObject(dataSet, Formatting.Indented);
Assert.AreEqual(@"{
""Table1"": [
{
""id"": 0,
@@ -79,65 +79,65 @@ namespace Newtonsoft.Json.Tests.Converters
]
}", json);
DataSet deserializedDataSet = JsonConvert.DeserializeObject<DataSet>(json);
Assert.IsNotNull(deserializedDataSet);
DataSet deserializedDataSet = JsonConvert.DeserializeObject<DataSet>(json);
Assert.IsNotNull(deserializedDataSet);
Assert.AreEqual(1, deserializedDataSet.Tables.Count);
Assert.AreEqual(1, deserializedDataSet.Tables.Count);
DataTable dt = deserializedDataSet.Tables[0];
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("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);
}
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));
[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
// }
// ]
// }
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());
DataSet deserializedDs = JsonConvert.DeserializeObject<DataSet>(json, new IsoDateTimeConverter());
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""FirstTable"": [
{
""StringCol"": ""Item Name"",
@@ -168,14 +168,13 @@ namespace Newtonsoft.Json.Tests.Converters
]
}", json);
Assert.IsNotNull(deserializedDs);
Assert.IsNotNull(deserializedDs);
}
}
[Test]
public void DeserializeMultiTableDataSet()
{
string json = @"{
[Test]
public void DeserializeMultiTableDataSet()
{
string json = @"{
""FirstTable"": [
{
""StringCol"": ""Item Name"",
@@ -198,100 +197,100 @@ namespace Newtonsoft.Json.Tests.Converters
]
}";
DataSet ds = JsonConvert.DeserializeObject<DataSet>(json);
Assert.IsNotNull(ds);
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);
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);
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);
}
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
private DataTable CreateDataTable(string dataTableName, int rows)
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
// create a new DataTable.
DataTable myTable = new DataTable(dataTableName);
Assert.AreEqual(@"{
// 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"",
@@ -321,27 +320,27 @@ namespace Newtonsoft.Json.Tests.Converters
}
]
}", 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
[Test]
public void SerializeDataSetProperty()
{
Before = "Before",
Set = ds,
Middle = "Middle",
Table = CreateDataTable("LoneTable", 2),
After = "After"
};
DataSet ds = new DataSet();
ds.Tables.Add(CreateDataTable("FirstTable", 2));
ds.Tables.Add(CreateDataTable("SecondTable", 1));
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new IsoDateTimeConverter());
DataSetAndTableTestClass c = new DataSetAndTableTestClass
{
Before = "Before",
Set = ds,
Middle = "Middle",
Table = CreateDataTable("LoneTable", 2),
After = "After"
};
Assert.AreEqual(@"{
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new IsoDateTimeConverter());
Assert.AreEqual(@"{
""Before"": ""Before"",
""Set"": {
""FirstTable"": [
@@ -395,24 +394,24 @@ namespace Newtonsoft.Json.Tests.Converters
""After"": ""After""
}", json);
DataSetAndTableTestClass c2 = JsonConvert.DeserializeObject<DataSetAndTableTestClass>(json, new IsoDateTimeConverter());
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);
}
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);
}
[Test]
public void SerializedTypedDataSet()
{
CustomerDataSet ds = new CustomerDataSet();
ds.Customers.AddCustomersRow("234");
[Test]
public void SerializedTypedDataSet()
{
CustomerDataSet ds = new CustomerDataSet();
ds.Customers.AddCustomersRow("234");
string json = JsonConvert.SerializeObject(ds, Formatting.Indented);
string json = JsonConvert.SerializeObject(ds, Formatting.Indented);
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""Customers"": [
{
""CustomerID"": ""234""
@@ -420,39 +419,40 @@ namespace Newtonsoft.Json.Tests.Converters
]
}", json);
CustomerDataSet ds1 = new CustomerDataSet();
DataTable table = ds1.Tables["Customers"];
DataRow row = ds1.Tables["Customers"].NewRow();
row["CustomerID"] = "234";
CustomerDataSet ds1 = new CustomerDataSet();
DataTable table = ds1.Tables["Customers"];
DataRow row = ds1.Tables["Customers"].NewRow();
row["CustomerID"] = "234";
table.Rows.Add(row);
table.Rows.Add(row);
string json1 = JsonConvert.SerializeObject(ds1, Formatting.Indented);
string json1 = JsonConvert.SerializeObject(ds1, Formatting.Indented);
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""Customers"": [
{
""CustomerID"": ""234""
}
]
}", json1);
}
}
[Test]
public void DeserializedTypedDataSet()
{
string json = @"{
[Test]
public void DeserializedTypedDataSet()
{
string json = @"{
""Customers"": [
{
""CustomerID"": ""234""
}
]
}";
var ds = JsonConvert.DeserializeObject<CustomerDataSet>(json);
Assert.AreEqual("234", ds.Customers[0].CustomerID);
var ds = JsonConvert.DeserializeObject<CustomerDataSet>(json);
Assert.AreEqual("234", ds.Customers[0].CustomerID);
}
}
}
}
#endif
@@ -40,12 +40,12 @@ using Newtonsoft.Json.Tests.TestObjects;
namespace Newtonsoft.Json.Tests.Converters
{
public class DataTableConverterTests : TestFixtureBase
{
[Test]
public void Deserialize()
public class DataTableConverterTests : TestFixtureBase
{
string json = @"[
[Test]
public void Deserialize()
{
string json = @"[
{
""id"": 0,
""item"": ""item 0""
@@ -56,72 +56,72 @@ namespace Newtonsoft.Json.Tests.Converters
}
]";
DataTable deserializedDataTable = JsonConvert.DeserializeObject<DataTable>(json);
Assert.IsNotNull(deserializedDataTable);
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(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);
Assert.AreEqual(2, deserializedDataTable.Rows.Count);
DataRow dr1 = deserializedDataTable.Rows[0];
Assert.AreEqual(0, dr1["id"]);
Assert.AreEqual("item 0", dr1["item"]);
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"]);
}
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");
[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);
// 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 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 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 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 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);
DataColumn colDecimal = new DataColumn("DecimalCol");
colDecimal.DataType = typeof(decimal);
myTable.Columns.Add(colDecimal);
// populate one row with values.
DataRow myNewRow = myTable.NewRow();
// 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);
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(@"[
string json = JsonConvert.SerializeObject(myTable, Formatting.Indented);
Assert.AreEqual(@"[
{
""StringCol"": ""Item Name"",
""Int32Col"": 2147483647,
@@ -131,131 +131,131 @@ namespace Newtonsoft.Json.Tests.Converters
""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
public class TestDataTableConverter : JsonConverter
{
NullValueHandling = NullValueHandling.Ignore
});
Assert.AreEqual(@"["
+ @"{""item"":""shirt"",""price"":49.99},"
+ @"{""item"":""pants"",""price"":54.99},"
+ @"{""item"":""shoes""}]", json);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DataTable d = (DataTable)value;
writer.WriteValue(d.TableName);
}
[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);
CustomAssert.IsInstanceOfType(typeof(System.DBNull), table.Rows[2]["price"]);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
//reader.Read();
DataTable d = new DataTable((string)reader.Value);
[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);
CustomAssert.IsInstanceOfType(typeof(System.DBNull), table.Rows[2]["price"]);
}
return d;
}
[Test]
public void SerializeKeyValuePairWithDataTableKey()
{
DataTable table = new DataTable();
DataColumn idColumn = new DataColumn("id", typeof(int));
idColumn.AutoIncrement = true;
public override bool CanConvert(Type objectType)
{
return (objectType == typeof(DataTable));
}
}
DataColumn itemColumn = new DataColumn("item");
table.Columns.Add(idColumn);
table.Columns.Add(itemColumn);
[Test]
public void PassedInJsonConverterOverridesInternalConverter()
{
DataTable t1 = new DataTable("Custom");
DataRow r = table.NewRow();
r["item"] = "item!";
r.EndEdit();
table.Rows.Add(r);
string json = JsonConvert.SerializeObject(t1, Formatting.Indented, new TestDataTableConverter());
Assert.AreEqual(@"""Custom""", json);
KeyValuePair<DataTable, int> pair = new KeyValuePair<DataTable, int>(table, 1);
string serializedpair = JsonConvert.SerializeObject(pair, Formatting.Indented);
DataTable t2 = JsonConvert.DeserializeObject<DataTable>(json, new TestDataTableConverter());
Assert.AreEqual(t1.TableName, t2.TableName);
}
Assert.AreEqual(@"{
[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);
CustomAssert.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);
CustomAssert.IsInstanceOfType(typeof(System.DBNull), table.Rows[2]["price"]);
}
[Test]
public void SerializeKeyValuePairWithDataTableKey()
{
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);
DataRow r = table.NewRow();
r["item"] = "item!";
r.EndEdit();
table.Rows.Add(r);
KeyValuePair<DataTable, int> pair = new KeyValuePair<DataTable, int>(table, 1);
string serializedpair = JsonConvert.SerializeObject(pair, Formatting.Indented);
Assert.AreEqual(@"{
""Key"": [
{
""id"": 0,
@@ -265,42 +265,43 @@ namespace Newtonsoft.Json.Tests.Converters
""Value"": 1
}", serializedpair);
var pair2 = (KeyValuePair<DataTable, int>)JsonConvert.DeserializeObject(serializedpair, typeof(KeyValuePair<DataTable, int>));
var pair2 = (KeyValuePair<DataTable, int>)JsonConvert.DeserializeObject(serializedpair, typeof(KeyValuePair<DataTable, int>));
Assert.AreEqual(1, pair2.Value);
Assert.AreEqual(1, pair2.Key.Rows.Count);
Assert.AreEqual("item!", pair2.Key.Rows[0]["item"]);
}
Assert.AreEqual(1, pair2.Value);
Assert.AreEqual(1, pair2.Key.Rows.Count);
Assert.AreEqual("item!", pair2.Key.Rows[0]["item"]);
}
[Test]
public void SerializedTypedDataTable()
{
CustomerDataSet.CustomersDataTable dt = new CustomerDataSet.CustomersDataTable();
dt.AddCustomersRow("432");
[Test]
public void SerializedTypedDataTable()
{
CustomerDataSet.CustomersDataTable dt = new CustomerDataSet.CustomersDataTable();
dt.AddCustomersRow("432");
string json = JsonConvert.SerializeObject(dt, Formatting.Indented);
string json = JsonConvert.SerializeObject(dt, Formatting.Indented);
Assert.AreEqual(@"[
Assert.AreEqual(@"[
{
""CustomerID"": ""432""
}
]", json);
}
}
[Test]
public void DeserializedTypedDataTable()
{
string json = @"[
[Test]
public void DeserializedTypedDataTable()
{
string json = @"[
{
""CustomerID"": ""432""
}
]";
var dt = JsonConvert.DeserializeObject<CustomerDataSet.CustomersDataTable>(json);
var dt = JsonConvert.DeserializeObject<CustomerDataSet.CustomersDataTable>(json);
Assert.AreEqual("432", dt[0].CustomerID);
Assert.AreEqual("432", dt[0].CustomerID);
}
}
}
}
#endif
@@ -48,40 +48,40 @@ using Newtonsoft.Json.Tests.TestObjects;
namespace Newtonsoft.Json.Tests.Converters
{
[TestFixture]
public class ExpandoObjectConverterTests : TestFixtureBase
{
public class ExpandoContainer
[TestFixture]
public class ExpandoObjectConverterTests : TestFixtureBase
{
public string Before { get; set; }
public ExpandoObject Expando { get; set; }
public string After { get; set; }
}
[Test]
public void SerializeExpandoObject()
{
ExpandoContainer d = new ExpandoContainer
public class ExpandoContainer
{
Before = "Before!",
Expando = new ExpandoObject(),
After = "After!"
};
public string Before { get; set; }
public ExpandoObject Expando { get; set; }
public string After { get; set; }
}
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>
[Test]
public void SerializeExpandoObject()
{
{"First", 1}
};
ExpandoContainer d = new ExpandoContainer
{
Before = "Before!",
Expando = new ExpandoObject(),
After = "After!"
};
string json = JsonConvert.SerializeObject(d, Formatting.Indented);
dynamic o = d.Expando;
Assert.AreEqual(@"{
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!"",
@@ -98,26 +98,26 @@ namespace Newtonsoft.Json.Tests.Converters
},
""After"": ""After!""
}", json);
}
}
[Test]
public void SerializeNullExpandoObject()
{
ExpandoContainer d = new ExpandoContainer();
[Test]
public void SerializeNullExpandoObject()
{
ExpandoContainer d = new ExpandoContainer();
string json = JsonConvert.SerializeObject(d, Formatting.Indented);
string json = JsonConvert.SerializeObject(d, Formatting.Indented);
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""Before"": null,
""Expando"": null,
""After"": null
}", json);
}
}
[Test]
public void DeserializeExpandoObject()
{
string json = @"{
[Test]
public void DeserializeExpandoObject()
{
string json = @"{
""Before"": ""Before!"",
""Expando"": {
""String"": ""String!"",
@@ -135,56 +135,55 @@ namespace Newtonsoft.Json.Tests.Converters
""After"": ""After!""
}";
ExpandoContainer o = JsonConvert.DeserializeObject<ExpandoContainer>(json);
ExpandoContainer o = JsonConvert.DeserializeObject<ExpandoContainer>(json);
Assert.AreEqual(o.Before, "Before!");
Assert.AreEqual(o.After, "After!");
Assert.IsNotNull(o.Expando);
Assert.AreEqual(o.Before, "Before!");
Assert.AreEqual(o.After, "After!");
Assert.IsNotNull(o.Expando);
dynamic d = o.Expando;
CustomAssert.IsInstanceOfType(typeof(ExpandoObject), d);
dynamic d = o.Expando;
CustomAssert.IsInstanceOfType(typeof(ExpandoObject), d);
Assert.AreEqual("String!", d.String);
CustomAssert.IsInstanceOfType(typeof(string), d.String);
Assert.AreEqual("String!", d.String);
CustomAssert.IsInstanceOfType(typeof(string), d.String);
Assert.AreEqual(234, d.Integer);
CustomAssert.IsInstanceOfType(typeof(long), d.Integer);
Assert.AreEqual(234, d.Integer);
CustomAssert.IsInstanceOfType(typeof(long), d.Integer);
Assert.AreEqual(1.23, d.Float);
CustomAssert.IsInstanceOfType(typeof(double), d.Float);
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.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("First", d.List[0]);
CustomAssert.IsInstanceOfType(typeof(string), d.List[0]);
Assert.AreEqual("Second", d.List[1]);
Assert.AreEqual("Third", d.List[2]);
Assert.AreEqual("Second", d.List[1]);
Assert.AreEqual("Third", d.List[2]);
Assert.IsNotNull(d.Object);
CustomAssert.IsInstanceOfType(typeof(ExpandoObject), d.Object);
Assert.IsNotNull(d.Object);
CustomAssert.IsInstanceOfType(typeof(ExpandoObject), d.Object);
Assert.AreEqual(1, d.Object.First);
CustomAssert.IsInstanceOfType(typeof(long), d.Object.First);
}
Assert.AreEqual(1, d.Object.First);
CustomAssert.IsInstanceOfType(typeof(long), d.Object.First);
}
[Test]
public void DeserializeNullExpandoObject()
{
string json = @"{
[Test]
public void DeserializeNullExpandoObject()
{
string json = @"{
""Before"": null,
""Expando"": null,
""After"": null
}";
ExpandoContainer c = JsonConvert.DeserializeObject<ExpandoContainer>(json);
ExpandoContainer c = JsonConvert.DeserializeObject<ExpandoContainer>(json);
Assert.AreEqual(null, c.Expando);
Assert.AreEqual(null, c.Expando);
}
}
}
}
#endif
@@ -38,242 +38,241 @@ using System.Globalization;
namespace Newtonsoft.Json.Tests.Converters
{
[TestFixture]
public class IsoDateTimeConverterTests : TestFixtureBase
{
[Test]
public void PropertiesShouldBeSet()
[TestFixture]
public class IsoDateTimeConverterTests : TestFixtureBase
{
IsoDateTimeConverter converter = new IsoDateTimeConverter();
Assert.AreEqual(CultureInfo.CurrentCulture, converter.Culture);
Assert.AreEqual(string.Empty, converter.DateTimeFormat);
Assert.AreEqual(DateTimeStyles.RoundtripKind, converter.DateTimeStyles);
[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
};
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);
}
Assert.AreEqual(CultureInfo.InvariantCulture, converter.Culture);
Assert.AreEqual("F", converter.DateTimeFormat);
Assert.AreEqual(DateTimeStyles.None, converter.DateTimeStyles);
}
public static string GetUtcOffsetText(DateTime d)
{
TimeSpan utcOffset = d.GetUtcOffset();
public static string GetUtcOffsetText(DateTime d)
{
TimeSpan utcOffset = d.GetUtcOffset();
return utcOffset.Hours.ToString("+00;-00", CultureInfo.InvariantCulture) + ":" + utcOffset.Minutes.ToString("00;00", CultureInfo.InvariantCulture);
}
return utcOffset.Hours.ToString("+00;-00", CultureInfo.InvariantCulture) + ":" + utcOffset.Minutes.ToString("00;00", CultureInfo.InvariantCulture);
}
[Test]
public void SerializeDateTime()
{
IsoDateTimeConverter converter = new IsoDateTimeConverter();
[Test]
public void SerializeDateTime()
{
IsoDateTimeConverter converter = new IsoDateTimeConverter();
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
string result;
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);
result = JsonConvert.SerializeObject(d, converter);
Assert.AreEqual(@"""2000-12-15T22:11:03.055Z""", result);
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
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" + GetUtcOffsetText(d) + @"""", result);
}
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" + GetUtcOffsetText(d) + @"""", result);
}
[Test]
public void SerializeFormattedDateTimeInvariantCulture()
{
IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.InvariantCulture };
[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;
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);
result = JsonConvert.SerializeObject(d, converter);
Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
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);
}
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
};
[Test]
public void SerializeCustomFormattedDateTime()
{
IsoDateTimeConverter converter = new IsoDateTimeConverter
{
DateTimeFormat = "dd/MM/yyyy",
Culture = CultureInfo.InvariantCulture
};
string json = @"""09/12/2006""";
string json = @"""09/12/2006""";
DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
Assert.AreEqual(9, d.Day);
Assert.AreEqual(12, d.Month);
Assert.AreEqual(2006, d.Year);
}
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") };
[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;
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);
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));
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);
}
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") };
[Test]
public void SerializeDateTimeCulture()
{
IsoDateTimeConverter converter = new IsoDateTimeConverter() { Culture = CultureInfo.GetCultureInfo("en-NZ") };
string json = @"""09/12/2006""";
string json = @"""09/12/2006""";
DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
Assert.AreEqual(9, d.Day);
Assert.AreEqual(12, d.Month);
Assert.AreEqual(2006, d.Year);
}
Assert.AreEqual(9, d.Day);
Assert.AreEqual(12, d.Month);
Assert.AreEqual(2006, d.Year);
}
#endif
#if !NET20
[Test]
public void SerializeDateTimeOffset()
{
IsoDateTimeConverter converter = new IsoDateTimeConverter();
[Test]
public void SerializeDateTimeOffset()
{
IsoDateTimeConverter converter = new IsoDateTimeConverter();
DateTimeOffset d = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
string result;
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);
result = JsonConvert.SerializeObject(d, converter);
Assert.AreEqual(@"""2000-12-15T22:11:03.055+00:00""", result);
Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTimeOffset>(result, converter));
}
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]
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 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]
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 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"":""""}";
[Test]
public void NullableDeserializeEmptyString()
{
string json = @"{""DateTimeField"":""""}";
NullableDateTimeTestClass c = JsonConvert.DeserializeObject<NullableDateTimeTestClass>(json,
new JsonSerializerSettings { Converters = new [] {new IsoDateTimeConverter()}});
Assert.AreEqual(null, c.DateTimeField);
}
NullableDateTimeTestClass c = JsonConvert.DeserializeObject<NullableDateTimeTestClass>(json,
new JsonSerializerSettings { Converters = new[] { new IsoDateTimeConverter() } });
Assert.AreEqual(null, c.DateTimeField);
}
[Test]
public void DeserializeNullToNonNullable()
{
ExceptionAssert.Throws<JsonSerializationException>("Cannot convert null value to System.DateTime. Path 'DateTimeField', line 1, position 38.",
() =>
{
DateTimeTestClass c2 =
JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
});
}
[Test]
public void DeserializeNullToNonNullable()
{
ExceptionAssert.Throws<JsonSerializationException>("Cannot convert null value to System.DateTime. Path 'DateTimeField', line 1, position 38.",
() =>
{
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);
[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 });
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();
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);
}
// 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),
};
[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);
string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());
// {
// "Name": "Keith",
// "BirthDate": "1980-03-08T00:00:00",
// "LastModified": "2009-04-12T20:44:55"
// }
Console.WriteLine(jsonText);
}
}
}
}
@@ -38,109 +38,109 @@ using Newtonsoft.Json.Tests.TestObjects;
namespace Newtonsoft.Json.Tests.Converters
{
[TestFixture]
public class JavaScriptDateTimeConverterTests : TestFixtureBase
{
[Test]
public void SerializeDateTime()
[TestFixture]
public class JavaScriptDateTimeConverterTests : TestFixtureBase
{
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
[Test]
public void SerializeDateTime()
{
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
string result;
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);
}
result = JsonConvert.SerializeObject(d, converter);
Assert.AreEqual("new Date(976918263055)", result);
}
#if !NET20
[Test]
public void SerializeDateTimeOffset()
{
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
[Test]
public void SerializeDateTimeOffset()
{
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
DateTimeOffset now = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
string result;
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);
}
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 sdfs()
{
int i = Convert.ToInt32("+1");
Console.WriteLine(i);
}
[Test]
public void SerializeNullableDateTimeClass()
{
NullableDateTimeTestClass t = new NullableDateTimeTestClass()
{
DateTimeField = null,
DateTimeOffsetField = null
};
[Test]
public void SerializeNullableDateTimeClass()
{
NullableDateTimeTestClass t = new NullableDateTimeTestClass()
{
DateTimeField = null,
DateTimeOffsetField = null
};
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
JavaScriptDateTimeConverter converter = new JavaScriptDateTimeConverter();
string result;
string result;
result = JsonConvert.SerializeObject(t, converter);
Assert.AreEqual(@"{""PreField"":null,""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":null}", 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)
};
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);
}
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. Path 'DateTimeField', line 1, position 38.",
() =>
{
DateTimeTestClass c2 =
JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new JavaScriptDateTimeConverter());
});
}
[Test]
public void DeserializeNullToNonNullable()
{
ExceptionAssert.Throws<Exception>("Cannot convert null value to System.DateTime. Path 'DateTimeField', line 1, position 38.",
() =>
{
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);
[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);
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);
}
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();
[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);
}
DateTime result = JsonConvert.DeserializeObject<DateTime>("new Date(976918263055)", converter);
Assert.AreEqual(new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc), result);
}
[Test]
public void ConverterList()
{
ConverterList<object> l1 = new ConverterList<object>();
l1.Add(new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc));
l1.Add(new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc));
[Test]
public void ConverterList()
{
ConverterList<object> l1 = new ConverterList<object>();
l1.Add(new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc));
l1.Add(new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc));
string json = JsonConvert.SerializeObject(l1, Formatting.Indented);
Assert.AreEqual(@"[
string json = JsonConvert.SerializeObject(l1, Formatting.Indented);
Assert.AreEqual(@"[
new Date(
976651800000
),
@@ -149,22 +149,22 @@ namespace Newtonsoft.Json.Tests.Converters
)
]", json);
ConverterList<object> l2 = JsonConvert.DeserializeObject<ConverterList<object>>(json);
Assert.IsNotNull(l2);
ConverterList<object> l2 = JsonConvert.DeserializeObject<ConverterList<object>>(json);
Assert.IsNotNull(l2);
Assert.AreEqual(new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc), l2[0]);
Assert.AreEqual(new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc), l2[1]);
}
Assert.AreEqual(new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc), l2[0]);
Assert.AreEqual(new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc), l2[1]);
}
[Test]
public void ConverterDictionary()
{
ConverterDictionary<object> l1 = new ConverterDictionary<object>();
l1.Add("First", new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc));
l1.Add("Second", new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc));
[Test]
public void ConverterDictionary()
{
ConverterDictionary<object> l1 = new ConverterDictionary<object>();
l1.Add("First", new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc));
l1.Add("Second", new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc));
string json = JsonConvert.SerializeObject(l1, Formatting.Indented);
Assert.AreEqual(@"{
string json = JsonConvert.SerializeObject(l1, Formatting.Indented);
Assert.AreEqual(@"{
""First"": new Date(
976651800000
),
@@ -173,23 +173,23 @@ namespace Newtonsoft.Json.Tests.Converters
)
}", json);
ConverterDictionary<object> l2 = JsonConvert.DeserializeObject<ConverterDictionary<object>>(json);
Assert.IsNotNull(l2);
ConverterDictionary<object> l2 = JsonConvert.DeserializeObject<ConverterDictionary<object>>(json);
Assert.IsNotNull(l2);
Assert.AreEqual(new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc), l2["First"]);
Assert.AreEqual(new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc), l2["Second"]);
}
Assert.AreEqual(new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc), l2["First"]);
Assert.AreEqual(new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc), l2["Second"]);
}
[Test]
public void ConverterObject()
{
ConverterObject l1 = new ConverterObject();
l1.Object1 = new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc);
l1.Object2 = null;
l1.ObjectNotHandled = new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc);
[Test]
public void ConverterObject()
{
ConverterObject l1 = new ConverterObject();
l1.Object1 = new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc);
l1.Object2 = null;
l1.ObjectNotHandled = new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc);
string json = JsonConvert.SerializeObject(l1, Formatting.Indented);
Assert.AreEqual(@"{
string json = JsonConvert.SerializeObject(l1, Formatting.Indented);
Assert.AreEqual(@"{
""Object1"": new Date(
976651800000
),
@@ -197,52 +197,53 @@ namespace Newtonsoft.Json.Tests.Converters
""ObjectNotHandled"": 631122486000000000
}", json);
ConverterObject l2 = JsonConvert.DeserializeObject<ConverterObject>(json);
Assert.IsNotNull(l2);
ConverterObject l2 = JsonConvert.DeserializeObject<ConverterObject>(json);
Assert.IsNotNull(l2);
//Assert.AreEqual(new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc), l2["First"]);
//Assert.AreEqual(new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc), l2["Second"]);
//Assert.AreEqual(new DateTime(2000, 12, 12, 20, 10, 0, DateTimeKind.Utc), l2["First"]);
//Assert.AreEqual(new DateTime(1983, 10, 9, 23, 10, 0, DateTimeKind.Utc), l2["Second"]);
}
}
}
[JsonArray(ItemConverterType = typeof(JavaScriptDateTimeConverter))]
public class ConverterList<T> : List<T>
{
}
[JsonDictionary(ItemConverterType = typeof(JavaScriptDateTimeConverter))]
public class ConverterDictionary<T> : Dictionary<string, T>
{
}
[JsonObject(ItemConverterType = typeof(JavaScriptDateTimeConverter))]
public class ConverterObject
{
public object Object1 { get; set; }
public object Object2 { get; set; }
[JsonConverter(typeof(DateIntConverter))]
public object ObjectNotHandled { get; set; }
}
public class DateIntConverter : JsonConverter
{
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
[JsonArray(ItemConverterType = typeof(JavaScriptDateTimeConverter))]
public class ConverterList<T> : List<T>
{
DateTime? d = (DateTime?) value;
if (d == null)
writer.WriteNull();
else
writer.WriteValue(d.Value.Ticks);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
[JsonDictionary(ItemConverterType = typeof(JavaScriptDateTimeConverter))]
public class ConverterDictionary<T> : Dictionary<string, T>
{
return new DateTime(Convert.ToInt64(reader.Value), DateTimeKind.Utc);
}
public override bool CanConvert(Type objectType)
[JsonObject(ItemConverterType = typeof(JavaScriptDateTimeConverter))]
public class ConverterObject
{
return objectType == typeof (DateTime) || objectType == typeof (DateTime?);
public object Object1 { get; set; }
public object Object2 { get; set; }
[JsonConverter(typeof(DateIntConverter))]
public object ObjectNotHandled { get; set; }
}
public class DateIntConverter : JsonConverter
{
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DateTime? d = (DateTime?)value;
if (d == null)
writer.WriteNull();
else
writer.WriteValue(d.Value.Ticks);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
return new DateTime(Convert.ToInt64(reader.Value), DateTimeKind.Utc);
}
public override bool CanConvert(Type objectType)
{
return objectType == typeof(DateTime) || objectType == typeof(DateTime?);
}
}
}
}
@@ -23,6 +23,7 @@
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if NETFX_CORE
using System;
using Newtonsoft.Json.Converters;
@@ -28,6 +28,7 @@ using Newtonsoft.Json.Bson;
using Newtonsoft.Json.Utilities;
#if !NETFX_CORE
using NUnit.Framework;
#else
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
@@ -36,50 +37,51 @@ using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAtt
namespace Newtonsoft.Json.Tests.Converters
{
[TestFixture]
public class ObjectIdConverterTests : TestFixtureBase
{
public class ObjectIdTestClass
[TestFixture]
public class ObjectIdConverterTests : TestFixtureBase
{
[JsonProperty("_id")]
public BsonObjectId Id { get; set; }
[JsonProperty("test")]
public string Test { get; set; }
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(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 = HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
CollectionAssert.AreEquivalent(expected, ms.ToArray());
}
[Test]
public void Deserialize()
{
byte[] bson = HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
JsonSerializer serializer = new JsonSerializer();
BsonReader reader = new BsonReader(new MemoryStream(bson));
ObjectIdTestClass c = serializer.Deserialize<ObjectIdTestClass>(reader);
CollectionAssert.AreEquivalent(c.Id.Value, HexToBytes("4ABBED9D1D8B0F0218000001"));
Assert.AreEqual(c.Test, "1234£56");
}
}
[Test]
public void Serialize()
{
ObjectIdTestClass c = new ObjectIdTestClass
{
Id = new BsonObjectId(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 = HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
CollectionAssert.AreEquivalent(expected, ms.ToArray());
}
[Test]
public void Deserialize()
{
byte[] bson = HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
JsonSerializer serializer = new JsonSerializer();
BsonReader reader = new BsonReader(new MemoryStream(bson));
ObjectIdTestClass c = serializer.Deserialize<ObjectIdTestClass>(reader);
CollectionAssert.AreEquivalent(c.Id.Value, HexToBytes("4ABBED9D1D8B0F0218000001"));
Assert.AreEqual(c.Test, "1234£56");
}
}
}
}
@@ -48,65 +48,65 @@ using Newtonsoft.Json.Tests.TestObjects;
namespace Newtonsoft.Json.Tests.Converters
{
[TestFixture]
public class RegexConverterTests : TestFixtureBase
{
public class RegexTestClass
[TestFixture]
public class RegexConverterTests : TestFixtureBase
{
public Regex Regex { get; set; }
}
public class RegexTestClass
{
public Regex Regex { get; set; }
}
[Test]
public void SerializeToText()
{
Regex regex = new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
[Test]
public void SerializeToText()
{
Regex regex = new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
string json = JsonConvert.SerializeObject(regex, Formatting.Indented, new RegexConverter());
string json = JsonConvert.SerializeObject(regex, Formatting.Indented, new RegexConverter());
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""Pattern"": ""abc"",
""Options"": 513
}", json);
}
}
[Test]
public void SerializeCamelCaseAndStringEnums()
{
Regex regex = new Regex("abc", RegexOptions.IgnoreCase);
string json = JsonConvert.SerializeObject(regex, Formatting.Indented, new JsonSerializerSettings
[Test]
public void SerializeCamelCaseAndStringEnums()
{
Converters = {new RegexConverter(),new StringEnumConverter() { CamelCaseText = true }},
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
Regex regex = new Regex("abc", RegexOptions.IgnoreCase);
Assert.AreEqual(@"{
string json = JsonConvert.SerializeObject(regex, Formatting.Indented, new JsonSerializerSettings
{
Converters = { new RegexConverter(), new StringEnumConverter() { CamelCaseText = true } },
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
Assert.AreEqual(@"{
""pattern"": ""abc"",
""options"": ""ignoreCase""
}", json);
}
}
[Test]
public void DeserializeCamelCaseAndStringEnums()
{
string json = @"{
[Test]
public void DeserializeCamelCaseAndStringEnums()
{
string json = @"{
""pattern"": ""abc"",
""options"": ""ignoreCase""
}";
Regex regex = JsonConvert.DeserializeObject<Regex>(json, new JsonSerializerSettings
{
Converters = { new RegexConverter() }
});
Assert.AreEqual("abc", regex.ToString());
Assert.AreEqual(RegexOptions.IgnoreCase, regex.Options);
}
Regex regex = JsonConvert.DeserializeObject<Regex>(json, new JsonSerializerSettings
{
Converters = { new RegexConverter() }
});
[Test]
public void DeserializeISerializeRegexJson()
{
string json = @"{
Assert.AreEqual("abc", regex.ToString());
Assert.AreEqual(RegexOptions.IgnoreCase, regex.Options);
}
[Test]
public void DeserializeISerializeRegexJson()
{
string json = @"{
""Regex"": {
""pattern"": ""(hi)"",
""options"": 5,
@@ -114,125 +114,125 @@ namespace Newtonsoft.Json.Tests.Converters
}
}";
RegexTestClass r = JsonConvert.DeserializeObject<RegexTestClass>(json);
RegexTestClass r = JsonConvert.DeserializeObject<RegexTestClass>(json);
Assert.AreEqual("(hi)", r.Regex.ToString());
Assert.AreEqual(RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture, r.Regex.Options);
}
Assert.AreEqual("(hi)", r.Regex.ToString());
Assert.AreEqual(RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture, r.Regex.Options);
}
[Test]
public void SerializeToBson()
{
Regex regex = new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
[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());
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 });
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 = BytesToHex(ms.ToArray());
string expected = "13-00-00-00-0B-52-65-67-65-78-00-61-62-63-00-69-75-00-00";
string bson = BytesToHex(ms.ToArray());
Assert.AreEqual(expected, bson);
}
Assert.AreEqual(expected, bson);
}
[Test]
public void DeserializeFromText()
{
string json = @"{
[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);
}
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(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());
[Test]
public void DeserializeFromBson()
{
MemoryStream ms = new MemoryStream(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);
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
Assert.AreEqual("abc", c.Regex.ToString());
Assert.AreEqual(RegexOptions.IgnoreCase, c.Regex.Options);
}
Assert.AreEqual("abc", c.Regex.ToString());
Assert.AreEqual(RegexOptions.IgnoreCase, c.Regex.Options);
}
[Test]
public void ConvertEmptyRegexBson()
{
Regex regex = new Regex(string.Empty);
[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());
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 });
serializer.Serialize(writer, new RegexTestClass { Regex = regex });
ms.Seek(0, SeekOrigin.Begin);
BsonReader reader = new BsonReader(ms);
serializer.Converters.Add(new RegexConverter());
ms.Seek(0, SeekOrigin.Begin);
BsonReader reader = new BsonReader(ms);
serializer.Converters.Add(new RegexConverter());
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
Assert.AreEqual("", c.Regex.ToString());
Assert.AreEqual(RegexOptions.None, c.Regex.Options);
}
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);
[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());
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 });
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 = BytesToHex(ms.ToArray());
string expected = "14-00-00-00-0B-52-65-67-65-78-00-2F-00-69-6D-73-75-78-00-00";
string bson = BytesToHex(ms.ToArray());
Assert.AreEqual(expected, bson);
Assert.AreEqual(expected, bson);
ms.Seek(0, SeekOrigin.Begin);
BsonReader reader = new BsonReader(ms);
serializer.Converters.Add(new RegexConverter());
ms.Seek(0, SeekOrigin.Begin);
BsonReader reader = new BsonReader(ms);
serializer.Converters.Add(new RegexConverter());
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
RegexTestClass c = serializer.Deserialize<RegexTestClass>(reader);
Assert.AreEqual("/", c.Regex.ToString());
Assert.AreEqual(RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.ExplicitCapture, c.Regex.Options);
}
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("");
[Test]
public void ConvertEmptyRegexJson()
{
Regex regex = new Regex("");
string json = JsonConvert.SerializeObject(new RegexTestClass { Regex = regex }, Formatting.Indented, new RegexConverter());
string json = JsonConvert.SerializeObject(new RegexTestClass { Regex = regex }, Formatting.Indented, new RegexConverter());
Assert.AreEqual(@"{
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);
RegexTestClass newRegex = JsonConvert.DeserializeObject<RegexTestClass>(json, new RegexConverter());
Assert.AreEqual("", newRegex.Regex.ToString());
Assert.AreEqual(RegexOptions.None, newRegex.Regex.Options);
}
}
}
}
@@ -42,350 +42,350 @@ using Newtonsoft.Json.Tests.TestObjects;
namespace Newtonsoft.Json.Tests.Converters
{
[TestFixture]
public class StringEnumConverterTests : TestFixtureBase
{
public class EnumClass
[TestFixture]
public class StringEnumConverterTests : TestFixtureBase
{
public StoreColor StoreColor { get; set; }
public StoreColor? NullableStoreColor1 { get; set; }
public StoreColor? NullableStoreColor2 { get; set; }
}
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; }
}
public class EnumContainer<T>
{
public T Enum { get; set; }
}
[Flags]
public enum FlagsTestEnum
{
Default = 0,
First = 1,
Second = 2
}
[Flags]
public enum FlagsTestEnum
{
Default = 0,
First = 1,
Second = 2
}
public enum NegativeEnum
{
Negative = -1,
Zero = 0,
Positive = 1
}
public enum NegativeEnum
{
Negative = -1,
Zero = 0,
Positive = 1
}
#if !NET20
public enum NamedEnum
{
[EnumMember(Value = "@first")]
First,
public enum NamedEnum
{
[EnumMember(Value = "@first")]
First,
[EnumMember(Value = "@second")]
Second,
Third
}
[EnumMember(Value = "@second")]
Second,
Third
}
public enum NamedEnumDuplicate
{
[EnumMember(Value = "Third")]
First,
public enum NamedEnumDuplicate
{
[EnumMember(Value = "Third")]
First,
[EnumMember(Value = "@second")]
Second,
Third
}
[EnumMember(Value = "@second")]
Second,
Third
}
#endif
public class NegativeEnumClass
{
public NegativeEnum Value1 { get; set; }
public NegativeEnum Value2 { get; set; }
}
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
};
[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());
});
}
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>
[Test]
public void SerializeNameEnumTest()
{
EnumContainer<NamedEnum> c = new EnumContainer<NamedEnum>
{
Enum = NamedEnum.Third
Enum = NamedEnum.First
};
json = JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter());
Assert.AreEqual(@"{
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 = @"{
[Test]
public void DeserializeNameEnumTest()
{
string json = @"{
""Enum"": ""@first""
}";
EnumContainer<NamedEnum> c = JsonConvert.DeserializeObject<EnumContainer<NamedEnum>>(json, new StringEnumConverter());
Assert.AreEqual(NamedEnum.First, c.Enum);
EnumContainer<NamedEnum> c = JsonConvert.DeserializeObject<EnumContainer<NamedEnum>>(json, new StringEnumConverter());
Assert.AreEqual(NamedEnum.First, c.Enum);
json = @"{
json = @"{
""Enum"": ""Third""
}";
c = JsonConvert.DeserializeObject<EnumContainer<NamedEnum>>(json, new StringEnumConverter());
Assert.AreEqual(NamedEnum.Third, c.Enum);
}
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;
[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());
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
Assert.AreEqual(@"{
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;
[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});
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter { CamelCaseText = true });
Assert.AreEqual(@"{
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;
[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());
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
Assert.AreEqual(@"{
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;
[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());
string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
Assert.AreEqual(@"{
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;
[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());
string json = JsonConvert.SerializeObject(negativeEnumClass, Formatting.Indented, new StringEnumConverter());
Assert.AreEqual(@"{
Assert.AreEqual(@"{
""Value1"": ""Negative"",
""Value2"": -2147483648
}", json);
}
}
[Test]
public void DeserializeNegativeEnum()
{
string json = @"{
[Test]
public void DeserializeNegativeEnum()
{
string json = @"{
""Value1"": ""Negative"",
""Value2"": -2147483648
}";
NegativeEnumClass negativeEnumClass = JsonConvert.DeserializeObject<NegativeEnumClass>(json, new StringEnumConverter());
NegativeEnumClass negativeEnumClass = JsonConvert.DeserializeObject<NegativeEnumClass>(json, new StringEnumConverter());
Assert.AreEqual(NegativeEnum.Negative, negativeEnumClass.Value1);
Assert.AreEqual((NegativeEnum) int.MinValue, negativeEnumClass.Value2);
}
Assert.AreEqual(NegativeEnum.Negative, negativeEnumClass.Value1);
Assert.AreEqual((NegativeEnum)int.MinValue, negativeEnumClass.Value2);
}
[Test]
public void DeserializeFlagEnum()
{
string json = @"{
[Test]
public void DeserializeFlagEnum()
{
string json = @"{
""StoreColor"": ""Red, White"",
""NullableStoreColor1"": 0,
""NullableStoreColor2"": ""black, Red, White""
}";
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
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);
}
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 = @"{
[Test]
public void DeserializeEnumClass()
{
string json = @"{
""StoreColor"": ""Red"",
""NullableStoreColor1"": ""White"",
""NullableStoreColor2"": null
}";
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
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);
}
Assert.AreEqual(StoreColor.Red, enumClass.StoreColor);
Assert.AreEqual(StoreColor.White, enumClass.NullableStoreColor1);
Assert.AreEqual(null, enumClass.NullableStoreColor2);
}
[Test]
public void DeserializeEnumClassUndefined()
{
string json = @"{
[Test]
public void DeserializeEnumClassUndefined()
{
string json = @"{
""StoreColor"": 1000,
""NullableStoreColor1"": 1000,
""NullableStoreColor2"": null
}";
EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
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);
}
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
};
[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(@"{
string json = JsonConvert.SerializeObject(c, Formatting.Indented, new StringEnumConverter { CamelCaseText = true });
Assert.AreEqual(@"{
""Enum"": ""first, second""
}", json);
}
}
[Test]
public void CamelCaseTextFlagEnumDeserialization()
{
string 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);
}
EnumContainer<FlagsTestEnum> c = JsonConvert.DeserializeObject<EnumContainer<FlagsTestEnum>>(json, new StringEnumConverter { CamelCaseText = true });
Assert.AreEqual(FlagsTestEnum.First | FlagsTestEnum.Second, c.Enum);
}
[Test]
public void DeserializeEmptyStringIntoNullable()
{
string json = @"{
[Test]
public void DeserializeEmptyStringIntoNullable()
{
string json = @"{
""StoreColor"": ""Red"",
""NullableStoreColor1"": ""White"",
""NullableStoreColor2"": """"
}";
EnumClass c = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
Assert.IsNull(c.NullableStoreColor2);
}
EnumClass c = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
Assert.IsNull(c.NullableStoreColor2);
}
[Test]
public void DeserializeInvalidString()
{
string json = "{ \"Value\" : \"Three\" }";
[Test]
public void DeserializeInvalidString()
{
string json = "{ \"Value\" : \"Three\" }";
ExceptionAssert.Throws<JsonSerializationException>(
@"Error converting value ""Three"" to type 'Newtonsoft.Json.Tests.Converters.StringEnumConverterTests+MyEnum'. Path 'Value', line 1, position 19.",
() =>
{
var serializer = new JsonSerializer();
serializer.Converters.Add(new StringEnumConverter());
serializer.Deserialize<Bucket>(new JsonTextReader(new StringReader(json)));
});
}
ExceptionAssert.Throws<JsonSerializationException>(
@"Error converting value ""Three"" to type 'Newtonsoft.Json.Tests.Converters.StringEnumConverterTests+MyEnum'. Path 'Value', line 1, position 19.",
() =>
{
var serializer = new JsonSerializer();
serializer.Converters.Add(new StringEnumConverter());
serializer.Deserialize<Bucket>(new JsonTextReader(new StringReader(json)));
});
}
public class Bucket
{
public MyEnum Value;
}
public class Bucket
{
public MyEnum Value;
}
public enum MyEnum
{
Alpha,
Beta,
}
public enum MyEnum
{
Alpha,
Beta,
}
#if !NET20
[Test]
public void EnumMemberPlusFlags()
{
List<Foo> lfoo =
new List<Foo>
{
Foo.Bat | Foo.SerializeAsBaz,
Foo.FooBar,
Foo.Bat,
Foo.SerializeAsBaz,
Foo.FooBar | Foo.SerializeAsBaz,
(Foo) int.MaxValue
};
[Test]
public void EnumMemberPlusFlags()
{
List<Foo> lfoo =
new List<Foo>
{
Foo.Bat | Foo.SerializeAsBaz,
Foo.FooBar,
Foo.Bat,
Foo.SerializeAsBaz,
Foo.FooBar | Foo.SerializeAsBaz,
(Foo)int.MaxValue
};
string json1 = JsonConvert.SerializeObject(lfoo, Formatting.Indented, new StringEnumConverter {CamelCaseText = true});
string json1 = JsonConvert.SerializeObject(lfoo, Formatting.Indented, new StringEnumConverter { CamelCaseText = true });
Assert.AreEqual(@"[
Assert.AreEqual(@"[
""Bat, baz"",
""foo_bar"",
""Bat"",
@@ -394,57 +394,57 @@ namespace Newtonsoft.Json.Tests.Converters
2147483647
]", json1);
IList<Foo> foos = JsonConvert.DeserializeObject<List<Foo>>(json1);
IList<Foo> foos = JsonConvert.DeserializeObject<List<Foo>>(json1);
Assert.AreEqual(6, foos.Count);
Assert.AreEqual(Foo.Bat | Foo.SerializeAsBaz, foos[0]);
Assert.AreEqual(Foo.FooBar, foos[1]);
Assert.AreEqual(Foo.Bat, foos[2]);
Assert.AreEqual(Foo.SerializeAsBaz, foos[3]);
Assert.AreEqual(Foo.FooBar | Foo.SerializeAsBaz, foos[4]);
Assert.AreEqual((Foo) int.MaxValue, foos[5]);
Assert.AreEqual(6, foos.Count);
Assert.AreEqual(Foo.Bat | Foo.SerializeAsBaz, foos[0]);
Assert.AreEqual(Foo.FooBar, foos[1]);
Assert.AreEqual(Foo.Bat, foos[2]);
Assert.AreEqual(Foo.SerializeAsBaz, foos[3]);
Assert.AreEqual(Foo.FooBar | Foo.SerializeAsBaz, foos[4]);
Assert.AreEqual((Foo)int.MaxValue, foos[5]);
List<Bar> lbar = new List<Bar>() {Bar.FooBar, Bar.Bat, Bar.SerializeAsBaz};
List<Bar> lbar = new List<Bar>() { Bar.FooBar, Bar.Bat, Bar.SerializeAsBaz };
string json2 = JsonConvert.SerializeObject(lbar, Formatting.Indented, new StringEnumConverter {CamelCaseText = true});
string json2 = JsonConvert.SerializeObject(lbar, Formatting.Indented, new StringEnumConverter { CamelCaseText = true });
Assert.AreEqual(@"[
Assert.AreEqual(@"[
""foo_bar"",
""Bat"",
""baz""
]", json2);
IList<Bar> bars = JsonConvert.DeserializeObject<List<Bar>>(json2);
IList<Bar> bars = JsonConvert.DeserializeObject<List<Bar>>(json2);
Assert.AreEqual(3, bars.Count);
Assert.AreEqual(Bar.FooBar, bars[0]);
Assert.AreEqual(Bar.Bat, bars[1]);
Assert.AreEqual(Bar.SerializeAsBaz, bars[2]);
}
Assert.AreEqual(3, bars.Count);
Assert.AreEqual(Bar.FooBar, bars[0]);
Assert.AreEqual(Bar.Bat, bars[1]);
Assert.AreEqual(Bar.SerializeAsBaz, bars[2]);
}
// Define other methods and classes here
[Flags]
[JsonConverter(typeof (StringEnumConverter))]
private enum Foo
{
[EnumMember(Value = "foo_bar")]
FooBar = 0x01,
Bat = 0x02,
// Define other methods and classes here
[Flags]
[JsonConverter(typeof(StringEnumConverter))]
private enum Foo
{
[EnumMember(Value = "foo_bar")]
FooBar = 0x01,
Bat = 0x02,
[EnumMember(Value = "baz")]
SerializeAsBaz = 0x4,
};
[EnumMember(Value = "baz")]
SerializeAsBaz = 0x4,
};
[JsonConverter(typeof (StringEnumConverter))]
private enum Bar
{
[EnumMember(Value = "foo_bar")]
FooBar,
Bat,
[JsonConverter(typeof(StringEnumConverter))]
private enum Bar
{
[EnumMember(Value = "foo_bar")]
FooBar,
Bat,
[EnumMember(Value = "baz")]
SerializeAsBaz
};
[EnumMember(Value = "baz")]
SerializeAsBaz
};
#endif
}
}
}
@@ -27,6 +27,7 @@ using System;
using Newtonsoft.Json.Converters;
#if !NETFX_CORE
using NUnit.Framework;
#else
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
@@ -35,96 +36,96 @@ using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAtt
namespace Newtonsoft.Json.Tests.Converters
{
public class VersionClass
{
public VersionClass(string version1, string version2)
public class VersionClass
{
this.StringProperty1 = "StringProperty1";
this.Version1 = new Version(version1);
this.Version2 = new Version(version2);
this.StringProperty2 = "StringProperty2";
public VersionClass(string version1, string version2)
{
StringProperty1 = "StringProperty1";
Version1 = new Version(version1);
Version2 = new Version(version2);
StringProperty2 = "StringProperty2";
}
public VersionClass()
{
}
public string StringProperty1 { get; set; }
public Version Version1 { get; set; }
public Version Version2 { get; set; }
public string StringProperty2 { get; set; }
}
public VersionClass()
[TestFixture]
public class VersionConverterTests : TestFixtureBase
{
}
private void SerializeVersionClass(string version1, string version2)
{
VersionClass versionClass = new VersionClass(version1, version2);
public string StringProperty1 { get; set; }
public Version Version1 { get; set; }
public Version Version2 { get; set; }
public string StringProperty2 { get; set; }
}
string json = JsonConvert.SerializeObject(versionClass, Formatting.Indented, new VersionConverter());
[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(@"{{
string expectedJson = string.Format(@"{{
""StringProperty1"": ""StringProperty1"",
""Version1"": ""{0}"",
""Version2"": ""{1}"",
""StringProperty2"": ""StringProperty2""
}}", version1, version2);
Assert.AreEqual(expectedJson, json);
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");
}
[Test]
public void RoundtripImplicitConverter()
{
var version = new Version(1, 0, 0, 0);
string reportJSON = JsonConvert.SerializeObject(version);
//Test
Version report2 = JsonConvert.DeserializeObject<Version>(reportJSON);
string reportJSON2 = JsonConvert.SerializeObject(report2);
Assert.AreEqual(reportJSON, reportJSON2);
}
}
[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");
}
[Test]
public void RoundtripImplicitConverter()
{
var version = new Version(1, 0, 0, 0);
string reportJSON = JsonConvert.SerializeObject(version);
//Test
Version report2 = JsonConvert.DeserializeObject<Version>(reportJSON);
string reportJSON2 = JsonConvert.SerializeObject(report2);
Assert.AreEqual(reportJSON, reportJSON2);
}
}
}
File diff suppressed because it is too large Load Diff