Code Coverage Statistics for Source File

Newtonsoft.Json.Tests\Converters\IsoDateTimeConverterTests.cs

Symbol Coverage: 99.20% (124 of 125)

Branch Coverage: 93.75% (15 of 16)

Cyclomatic Complexity Avg: 1.00 Max:1

Code Lines: 145

Symbol Coverage Trend

View:


#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Newtonsoft.Json.Tests.TestObjects;
using NUnit.Framework;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Utilities;
using System.Globalization;
using System.Xml;

namespace Newtonsoft.Json.Tests.Converters
{
  public class IsoDateTimeConverterTests : TestFixtureBase
  {
    [Test]
    public void PropertiesShouldBeSet()
    {
      IsoDateTimeConverter converter = new IsoDateTimeConverter();
      Assert.AreEqual(CultureInfo.CurrentCulture, converter.Culture);
      Assert.AreEqual(string.Empty, converter.DateTimeFormat);
      Assert.AreEqual(DateTimeStyles.RoundtripKind, converter.DateTimeStyles);

      converter = new IsoDateTimeConverter()
      {
        DateTimeFormat = "F",
        Culture = CultureInfo.InvariantCulture,
        DateTimeStyles = DateTimeStyles.None
      };

      Assert.AreEqual(CultureInfo.InvariantCulture, converter.Culture);
      Assert.AreEqual("F", converter.DateTimeFormat);
      Assert.AreEqual(DateTimeStyles.None, converter.DateTimeStyles);
    }

    [Test]
    public void SerializeDateTime()
    {
      IsoDateTimeConverter converter = new IsoDateTimeConverter();

      DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
      string result;

      result = JsonConvert.SerializeObject(d, converter);
      Assert.AreEqual(@"""2000-12-15T22:11:03.055Z""", result);

      Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));

      d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Local);
      result = JsonConvert.SerializeObject(d, converter);
      Assert.AreEqual(@"""2000-12-15T22:11:03.055" + d.GetLocalOffset() + @"""", result);
    }

    [Test]
    public void SerializeFormattedDateTimeInvariantCulture()
    {
      IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.InvariantCulture };

      DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
      string result;

      result = JsonConvert.SerializeObject(d, converter);
      Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);

      Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));

      d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
      result = JsonConvert.SerializeObject(d, converter);
      Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
    }

    [Test]
    public void SerializeCustomFormattedDateTime()
    {
      IsoDateTimeConverter converter = new IsoDateTimeConverter
                                         {
                                           DateTimeFormat = "dd/MM/yyyy",
                                           Culture = CultureInfo.InvariantCulture
                                         };

      string json = @"""09/12/2006""";

      DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);

      Assert.AreEqual(9, d.Day);
      Assert.AreEqual(12, d.Month);
      Assert.AreEqual(2006, d.Year);
    }

#if !SILVERLIGHT
    [Test]
    public void SerializeFormattedDateTimeNewZealandCulture()
    {
      IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.GetCultureInfo("en-NZ") };

      DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
      string result;

      result = JsonConvert.SerializeObject(d, converter);
      Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);

      Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));

      d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
      result = JsonConvert.SerializeObject(d, converter);
      Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
    }

    [Test]
    public void SerializeDateTimeCulture()
    {
      IsoDateTimeConverter converter = new IsoDateTimeConverter() { Culture = CultureInfo.GetCultureInfo("en-NZ") };

      string json = @"""09/12/2006""";

      DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);

      Assert.AreEqual(9, d.Day);
      Assert.AreEqual(12, d.Month);
      Assert.AreEqual(2006, d.Year);
    }
#endif

#if !PocketPC && !NET20
    [Test]
    public void SerializeDateTimeOffset()
    {
      IsoDateTimeConverter converter = new IsoDateTimeConverter();

      DateTimeOffset d = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
      string result;

      result = JsonConvert.SerializeObject(d, converter);
      Assert.AreEqual(@"""2000-12-15T22:11:03.055+00:00""", result);

      Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTimeOffset>(result, converter));
    }

    [Test]
    public void SerializeUTC()
    {
      DateTimeTestClass c = new DateTimeTestClass();
      c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
      c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
      c.PreField = "Pre";
      c.PostField = "Post";
      string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
      Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);

      //test the other edge case too
      c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
      c.DateTimeOffsetField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
      c.PreField = "Pre";
      c.PostField = "Post";
      json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
      Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-01-01T01:01:01Z"",""DateTimeOffsetField"":""2008-01-01T01:01:01+00:00"",""PostField"":""Post""}", json);
    }

    [Test]
    public void NullableSerializeUTC()
    {
      NullableDateTimeTestClass c = new NullableDateTimeTestClass();
      c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
      c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
      c.PreField = "Pre";
      c.PostField = "Post";
      string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
      Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);

      //test the other edge case too
      c.DateTimeField = null;
      c.DateTimeOffsetField = null;
      c.PreField = "Pre";
      c.PostField = "Post";
      json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
      Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", json);
    }

    [Test]
    public void DeserializeUTC()
    {
      DateTimeTestClass c =
        JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12Z"",""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });

      Assert.AreEqual(new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime(), c.DateTimeField);
      Assert.AreEqual(new DateTimeOffset(2008, 12, 12, 12, 12, 12, 0, TimeSpan.Zero), c.DateTimeOffsetField);
      Assert.AreEqual("Pre", c.PreField);
      Assert.AreEqual("Post", c.PostField);

      DateTimeTestClass c2 =
       JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":""2008-01-01T01:01:01Z"",""DateTimeOffsetField"":""2008-01-01T01:01:01Z"",""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });

      Assert.AreEqual(new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime(), c2.DateTimeField);
      Assert.AreEqual(new DateTimeOffset(2008, 1, 1, 1, 1, 1, 0, TimeSpan.Zero), c2.DateTimeOffsetField);
      Assert.AreEqual("Pre", c2.PreField);
      Assert.AreEqual("Post", c2.PostField);
    }

    [Test]
    public void NullableDeserializeUTC()
    {
      NullableDateTimeTestClass c =
        JsonConvert.DeserializeObject<NullableDateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12Z"",""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });

      Assert.AreEqual(new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime(), c.DateTimeField);
      Assert.AreEqual(new DateTimeOffset(2008, 12, 12, 12, 12, 12, 0, TimeSpan.Zero), c.DateTimeOffsetField);
      Assert.AreEqual("Pre", c.PreField);
      Assert.AreEqual("Post", c.PostField);

      NullableDateTimeTestClass c2 =
       JsonConvert.DeserializeObject<NullableDateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });

      Assert.AreEqual(null, c2.DateTimeField);
      Assert.AreEqual(null, c2.DateTimeOffsetField);
      Assert.AreEqual("Pre", c2.PreField);
      Assert.AreEqual("Post", c2.PostField);
    }

    [Test]
    public void NullableDeserializeEmptyString()
    {
      string json = @"{""DateTimeField"":""""}";

      NullableDateTimeTestClass c = JsonConvert.DeserializeObject<NullableDateTimeTestClass>(json,
        new JsonSerializerSettings { Converters = new [] {new IsoDateTimeConverter()}});
      Assert.AreEqual(null, c.DateTimeField);
    }

    [Test]
    [ExpectedException(typeof(Exception), ExpectedMessage = "Cannot convert null value to System.DateTime.")]
    public void DeserializeNullToNonNullable()
    {
      DateTimeTestClass c2 =
       JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
    }

    [Test]
    public void SerializeShouldChangeNonUTCDates()
    {
      DateTimeTestClass c = new DateTimeTestClass();
      c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Local);
      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 });
      Assert.AreNotEqual(json, json2);
    }
#endif

    [Test]
    public void BlogCodeSample()
    {
      Person p = new Person
                   {
                     Name = "Keith",
                     BirthDate = new DateTime(1980, 3, 8),
                     LastModified = new DateTime(2009, 4, 12, 20, 44, 55),
                   };

      string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());
      // {
      //   "Name": "Keith",
      //   "BirthDate": "1980-03-08T00:00:00",
      //   "LastModified": "2009-04-12T20:44:55"
      // }

      Console.WriteLine(jsonText);

    }
  }
}

L	V	Source
1		#region License
2		// Copyright (c) 2007 James Newton-King
3		//
4		// Permission is hereby granted, free of charge, to any person
5		// obtaining a copy of this software and associated documentation
6		// files (the "Software"), to deal in the Software without
7		// restriction, including without limitation the rights to use,
8		// copy, modify, merge, publish, distribute, sublicense, and/or sell
9		// copies of the Software, and to permit persons to whom the
10		// Software is furnished to do so, subject to the following
11		// conditions:
12		//
13		// The above copyright notice and this permission notice shall be
14		// included in all copies or substantial portions of the Software.
15		//
16		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17		// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18		// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19		// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20		// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21		// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22		// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23		// OTHER DEALINGS IN THE SOFTWARE.
24		#endregion
25
26		using System;
27		using System.Collections.Generic;
28		using System.Linq;
29		using System.Text;
30		using Newtonsoft.Json.Tests.TestObjects;
31		using NUnit.Framework;
32		using Newtonsoft.Json.Converters;
33		using Newtonsoft.Json.Utilities;
34		using System.Globalization;
35		using System.Xml;
36
37		namespace Newtonsoft.Json.Tests.Converters
38		{
39		public class IsoDateTimeConverterTests : TestFixtureBase
40		{
41		[Test]
42		public void PropertiesShouldBeSet()
43		{
44	1	IsoDateTimeConverter converter = new IsoDateTimeConverter();
45	1	Assert.AreEqual(CultureInfo.CurrentCulture, converter.Culture);
46	1	Assert.AreEqual(string.Empty, converter.DateTimeFormat);
47	1	Assert.AreEqual(DateTimeStyles.RoundtripKind, converter.DateTimeStyles);
48
49	1	converter = new IsoDateTimeConverter()
50	1	{
51	1	DateTimeFormat = "F",
52	1	Culture = CultureInfo.InvariantCulture,
53	1	DateTimeStyles = DateTimeStyles.None
54	1	};
55
56	1	Assert.AreEqual(CultureInfo.InvariantCulture, converter.Culture);
57	1	Assert.AreEqual("F", converter.DateTimeFormat);
58	1	Assert.AreEqual(DateTimeStyles.None, converter.DateTimeStyles);
59	1	}
60
61		[Test]
62		public void SerializeDateTime()
63		{
64	1	IsoDateTimeConverter converter = new IsoDateTimeConverter();
65
66	1	DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
67		string result;
68
69	1	result = JsonConvert.SerializeObject(d, converter);
70	1	Assert.AreEqual(@"""2000-12-15T22:11:03.055Z""", result);
71
72	1	Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
73
74	1	d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Local);
75	1	result = JsonConvert.SerializeObject(d, converter);
76	1	Assert.AreEqual(@"""2000-12-15T22:11:03.055" + d.GetLocalOffset() + @"""", result);
77	1	}
78
79		[Test]
80		public void SerializeFormattedDateTimeInvariantCulture()
81		{
82	1	IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.InvariantCulture };
83
84	1	DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
85		string result;
86
87	1	result = JsonConvert.SerializeObject(d, converter);
88	1	Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
89
90	1	Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
91
92	1	d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
93	1	result = JsonConvert.SerializeObject(d, converter);
94	1	Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
95	1	}
96
97		[Test]
98		public void SerializeCustomFormattedDateTime()
99		{
100	1	IsoDateTimeConverter converter = new IsoDateTimeConverter
101	1	{
102	1	DateTimeFormat = "dd/MM/yyyy",
103	1	Culture = CultureInfo.InvariantCulture
104	1	};
105
106	1	string json = @"""09/12/2006""";
107
108	1	DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
109
110	1	Assert.AreEqual(9, d.Day);
111	1	Assert.AreEqual(12, d.Month);
112	1	Assert.AreEqual(2006, d.Year);
113	1	}
114
115		#if !SILVERLIGHT
116		[Test]
117		public void SerializeFormattedDateTimeNewZealandCulture()
118		{
119	1	IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.GetCultureInfo("en-NZ") };
120
121	1	DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
122		string result;
123
124	1	result = JsonConvert.SerializeObject(d, converter);
125	1	Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
126
127	1	Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
128
129	1	d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
130	1	result = JsonConvert.SerializeObject(d, converter);
131	1	Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
132	1	}
133
134		[Test]
135		public void SerializeDateTimeCulture()
136		{
137	1	IsoDateTimeConverter converter = new IsoDateTimeConverter() { Culture = CultureInfo.GetCultureInfo("en-NZ") };
138
139	1	string json = @"""09/12/2006""";
140
141	1	DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
142
143	1	Assert.AreEqual(9, d.Day);
144	1	Assert.AreEqual(12, d.Month);
145	1	Assert.AreEqual(2006, d.Year);
146	1	}
147		#endif
148
149		#if !PocketPC && !NET20
150		[Test]
151		public void SerializeDateTimeOffset()
152		{
153	1	IsoDateTimeConverter converter = new IsoDateTimeConverter();
154
155	1	DateTimeOffset d = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
156		string result;
157
158	1	result = JsonConvert.SerializeObject(d, converter);
159	1	Assert.AreEqual(@"""2000-12-15T22:11:03.055+00:00""", result);
160
161	1	Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTimeOffset>(result, converter));
162	1	}
163
164		[Test]
165		public void SerializeUTC()
166		{
167	1	DateTimeTestClass c = new DateTimeTestClass();
168	1	c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
169	1	c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
170	1	c.PreField = "Pre";
171	1	c.PostField = "Post";
172	1	string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
173	1	Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);
174
175		//test the other edge case too
176	1	c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
177	1	c.DateTimeOffsetField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
178	1	c.PreField = "Pre";
179	1	c.PostField = "Post";
180	1	json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
181	1	Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-01-01T01:01:01Z"",""DateTimeOffsetField"":""2008-01-01T01:01:01+00:00"",""PostField"":""Post""}", json);
182	1	}
183
184		[Test]
185		public void NullableSerializeUTC()
186		{
187	1	NullableDateTimeTestClass c = new NullableDateTimeTestClass();
188	1	c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
189	1	c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
190	1	c.PreField = "Pre";
191	1	c.PostField = "Post";
192	1	string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
193	1	Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);
194
195		//test the other edge case too
196	1	c.DateTimeField = null;
197	1	c.DateTimeOffsetField = null;
198	1	c.PreField = "Pre";
199	1	c.PostField = "Post";
200	1	json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
201	1	Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", json);
202	1	}
203
204		[Test]
205		public void DeserializeUTC()
206		{
207	1	DateTimeTestClass c =
208	1	JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12Z"",""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
209
210	1	Assert.AreEqual(new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime(), c.DateTimeField);
211	1	Assert.AreEqual(new DateTimeOffset(2008, 12, 12, 12, 12, 12, 0, TimeSpan.Zero), c.DateTimeOffsetField);
212	1	Assert.AreEqual("Pre", c.PreField);
213	1	Assert.AreEqual("Post", c.PostField);
214
215	1	DateTimeTestClass c2 =
216	1	JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":""2008-01-01T01:01:01Z"",""DateTimeOffsetField"":""2008-01-01T01:01:01Z"",""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
217
218	1	Assert.AreEqual(new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime(), c2.DateTimeField);
219	1	Assert.AreEqual(new DateTimeOffset(2008, 1, 1, 1, 1, 1, 0, TimeSpan.Zero), c2.DateTimeOffsetField);
220	1	Assert.AreEqual("Pre", c2.PreField);
221	1	Assert.AreEqual("Post", c2.PostField);
222	1	}
223
224		[Test]
225		public void NullableDeserializeUTC()
226		{
227	1	NullableDateTimeTestClass c =
228	1	JsonConvert.DeserializeObject<NullableDateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12Z"",""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
229
230	1	Assert.AreEqual(new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime(), c.DateTimeField);
231	1	Assert.AreEqual(new DateTimeOffset(2008, 12, 12, 12, 12, 12, 0, TimeSpan.Zero), c.DateTimeOffsetField);
232	1	Assert.AreEqual("Pre", c.PreField);
233	1	Assert.AreEqual("Post", c.PostField);
234
235	1	NullableDateTimeTestClass c2 =
236	1	JsonConvert.DeserializeObject<NullableDateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
237
238	1	Assert.AreEqual(null, c2.DateTimeField);
239	1	Assert.AreEqual(null, c2.DateTimeOffsetField);
240	1	Assert.AreEqual("Pre", c2.PreField);
241	1	Assert.AreEqual("Post", c2.PostField);
242	1	}
243
244		[Test]
245		public void NullableDeserializeEmptyString()
246		{
247	1	string json = @"{""DateTimeField"":""""}";
248
249	1	NullableDateTimeTestClass c = JsonConvert.DeserializeObject<NullableDateTimeTestClass>(json,
250	1	new JsonSerializerSettings { Converters = new [] {new IsoDateTimeConverter()}});
251	1	Assert.AreEqual(null, c.DateTimeField);
252	1	}
253
254		[Test]
255		[ExpectedException(typeof(Exception), ExpectedMessage = "Cannot convert null value to System.DateTime.")]
256		public void DeserializeNullToNonNullable()
257		{
258	1	DateTimeTestClass c2 =
259	1	JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
260	0	}
261
262		[Test]
263		public void SerializeShouldChangeNonUTCDates()
264		{
265	1	DateTimeTestClass c = new DateTimeTestClass();
266	1	c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Local);
267	1	c.PreField = "Pre";
268	1	c.PostField = "Post";
269	1	string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal }); //note that this fails without the Utc converter...
270	1	c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc);
271	1	string json2 = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
272	1	Assert.AreNotEqual(json, json2);
273	1	}
274		#endif
275
276		[Test]
277		public void BlogCodeSample()
278		{
279	1	Person p = new Person
280	1	{
281	1	Name = "Keith",
282	1	BirthDate = new DateTime(1980, 3, 8),
283	1	LastModified = new DateTime(2009, 4, 12, 20, 44, 55),
284	1	};
285
286	1	string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());
287		// {
288		// "Name": "Keith",
289		// "BirthDate": "1980-03-08T00:00:00",
290		// "LastModified": "2009-04-12T20:44:55"
291		// }
292
293	1	Console.WriteLine(jsonText);
294
295	1	}
296		}
297		}