← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/Newtonsoft.Json/Src/Newtonsoft.Json.Tests/Converters/IsoDateTimeConverterTests.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
ImportĀ upstreamĀ versionĀ 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/Newtonsoft.Json/Src/Newtonsoft.Json.Tests/Converters/IsoDateTimeConverterTests.cs
 
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 Newtonsoft.Json.Tests.TestObjects;
 
28
#if !NETFX_CORE
 
29
using NUnit.Framework;
 
30
#else
 
31
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
 
32
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
 
33
using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
 
34
#endif
 
35
using Newtonsoft.Json.Converters;
 
36
using Newtonsoft.Json.Utilities;
 
37
using System.Globalization;
 
38
 
 
39
namespace Newtonsoft.Json.Tests.Converters
 
40
{
 
41
  [TestFixture]
 
42
  public class IsoDateTimeConverterTests : TestFixtureBase
 
43
  {
 
44
    [Test]
 
45
    public void PropertiesShouldBeSet()
 
46
    {
 
47
      IsoDateTimeConverter converter = new IsoDateTimeConverter();
 
48
      Assert.AreEqual(CultureInfo.CurrentCulture, converter.Culture);
 
49
      Assert.AreEqual(string.Empty, converter.DateTimeFormat);
 
50
      Assert.AreEqual(DateTimeStyles.RoundtripKind, converter.DateTimeStyles);
 
51
 
 
52
      converter = new IsoDateTimeConverter()
 
53
      {
 
54
        DateTimeFormat = "F",
 
55
        Culture = CultureInfo.InvariantCulture,
 
56
        DateTimeStyles = DateTimeStyles.None
 
57
      };
 
58
 
 
59
      Assert.AreEqual(CultureInfo.InvariantCulture, converter.Culture);
 
60
      Assert.AreEqual("F", converter.DateTimeFormat);
 
61
      Assert.AreEqual(DateTimeStyles.None, converter.DateTimeStyles);
 
62
    }
 
63
 
 
64
    [Test]
 
65
    public void SerializeDateTime()
 
66
    {
 
67
      IsoDateTimeConverter converter = new IsoDateTimeConverter();
 
68
 
 
69
      DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Utc);
 
70
      string result;
 
71
 
 
72
      result = JsonConvert.SerializeObject(d, converter);
 
73
      Assert.AreEqual(@"""2000-12-15T22:11:03.055Z""", result);
 
74
 
 
75
      Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
 
76
 
 
77
      d = new DateTime(2000, 12, 15, 22, 11, 3, 55, DateTimeKind.Local);
 
78
      result = JsonConvert.SerializeObject(d, converter);
 
79
      Assert.AreEqual(@"""2000-12-15T22:11:03.055" + d.GetUtcOffsetText() + @"""", result);
 
80
    }
 
81
 
 
82
    [Test]
 
83
    public void SerializeFormattedDateTimeInvariantCulture()
 
84
    {
 
85
      IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.InvariantCulture };
 
86
 
 
87
      DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
 
88
      string result;
 
89
 
 
90
      result = JsonConvert.SerializeObject(d, converter);
 
91
      Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
 
92
 
 
93
      Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
 
94
 
 
95
      d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
 
96
      result = JsonConvert.SerializeObject(d, converter);
 
97
      Assert.AreEqual(@"""Friday, 15 December 2000 22:11:03""", result);
 
98
    }
 
99
 
 
100
    [Test]
 
101
    public void SerializeCustomFormattedDateTime()
 
102
    {
 
103
      IsoDateTimeConverter converter = new IsoDateTimeConverter
 
104
                                         {
 
105
                                           DateTimeFormat = "dd/MM/yyyy",
 
106
                                           Culture = CultureInfo.InvariantCulture
 
107
                                         };
 
108
 
 
109
      string json = @"""09/12/2006""";
 
110
 
 
111
      DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
 
112
 
 
113
      Assert.AreEqual(9, d.Day);
 
114
      Assert.AreEqual(12, d.Month);
 
115
      Assert.AreEqual(2006, d.Year);
 
116
    }
 
117
 
 
118
#if !SILVERLIGHT && !NETFX_CORE
 
119
    [Test]
 
120
    public void SerializeFormattedDateTimeNewZealandCulture()
 
121
    {
 
122
      IsoDateTimeConverter converter = new IsoDateTimeConverter() { DateTimeFormat = "F", Culture = CultureInfo.GetCultureInfo("en-NZ") };
 
123
 
 
124
      DateTime d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Utc);
 
125
      string result;
 
126
 
 
127
      result = JsonConvert.SerializeObject(d, converter);
 
128
      Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
 
129
 
 
130
      Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTime>(result, converter));
 
131
 
 
132
      d = new DateTime(2000, 12, 15, 22, 11, 3, 0, DateTimeKind.Local);
 
133
      result = JsonConvert.SerializeObject(d, converter);
 
134
      Assert.AreEqual(@"""Friday, 15 December 2000 10:11:03 p.m.""", result);
 
135
    }
 
136
 
 
137
    [Test]
 
138
    public void SerializeDateTimeCulture()
 
139
    {
 
140
      IsoDateTimeConverter converter = new IsoDateTimeConverter() { Culture = CultureInfo.GetCultureInfo("en-NZ") };
 
141
 
 
142
      string json = @"""09/12/2006""";
 
143
 
 
144
      DateTime d = JsonConvert.DeserializeObject<DateTime>(json, converter);
 
145
 
 
146
      Assert.AreEqual(9, d.Day);
 
147
      Assert.AreEqual(12, d.Month);
 
148
      Assert.AreEqual(2006, d.Year);
 
149
    }
 
150
#endif
 
151
 
 
152
#if !PocketPC && !NET20
 
153
    [Test]
 
154
    public void SerializeDateTimeOffset()
 
155
    {
 
156
      IsoDateTimeConverter converter = new IsoDateTimeConverter();
 
157
 
 
158
      DateTimeOffset d = new DateTimeOffset(2000, 12, 15, 22, 11, 3, 55, TimeSpan.Zero);
 
159
      string result;
 
160
 
 
161
      result = JsonConvert.SerializeObject(d, converter);
 
162
      Assert.AreEqual(@"""2000-12-15T22:11:03.055+00:00""", result);
 
163
 
 
164
      Assert.AreEqual(d, JsonConvert.DeserializeObject<DateTimeOffset>(result, converter));
 
165
    }
 
166
 
 
167
    [Test]
 
168
    public void SerializeUTC()
 
169
    {
 
170
      DateTimeTestClass c = new DateTimeTestClass();
 
171
      c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
 
172
      c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
 
173
      c.PreField = "Pre";
 
174
      c.PostField = "Post";
 
175
      string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
 
176
      Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);
 
177
 
 
178
      //test the other edge case too
 
179
      c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
 
180
      c.DateTimeOffsetField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc).ToLocalTime();
 
181
      c.PreField = "Pre";
 
182
      c.PostField = "Post";
 
183
      json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
 
184
      Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-01-01T01:01:01Z"",""DateTimeOffsetField"":""2008-01-01T01:01:01+00:00"",""PostField"":""Post""}", json);
 
185
    }
 
186
 
 
187
    [Test]
 
188
    public void NullableSerializeUTC()
 
189
    {
 
190
      NullableDateTimeTestClass c = new NullableDateTimeTestClass();
 
191
      c.DateTimeField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
 
192
      c.DateTimeOffsetField = new DateTime(2008, 12, 12, 12, 12, 12, 0, DateTimeKind.Utc).ToLocalTime();
 
193
      c.PreField = "Pre";
 
194
      c.PostField = "Post";
 
195
      string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
 
196
      Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":""2008-12-12T12:12:12Z"",""DateTimeOffsetField"":""2008-12-12T12:12:12+00:00"",""PostField"":""Post""}", json);
 
197
 
 
198
      //test the other edge case too
 
199
      c.DateTimeField = null;
 
200
      c.DateTimeOffsetField = null;
 
201
      c.PreField = "Pre";
 
202
      c.PostField = "Post";
 
203
      json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
 
204
      Assert.AreEqual(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", json);
 
205
    }
 
206
 
 
207
    [Test]
 
208
    public void NullableDeserializeEmptyString()
 
209
    {
 
210
      string json = @"{""DateTimeField"":""""}";
 
211
 
 
212
      NullableDateTimeTestClass c = JsonConvert.DeserializeObject<NullableDateTimeTestClass>(json,
 
213
        new JsonSerializerSettings { Converters = new [] {new IsoDateTimeConverter()}});
 
214
      Assert.AreEqual(null, c.DateTimeField);
 
215
    }
 
216
 
 
217
    [Test]
 
218
    public void DeserializeNullToNonNullable()
 
219
    {
 
220
      ExceptionAssert.Throws<JsonSerializationException>("Cannot convert null value to System.DateTime. Path 'DateTimeField', line 1, position 38.",
 
221
      () =>
 
222
      {
 
223
        DateTimeTestClass c2 =
 
224
         JsonConvert.DeserializeObject<DateTimeTestClass>(@"{""PreField"":""Pre"",""DateTimeField"":null,""DateTimeOffsetField"":null,""PostField"":""Post""}", new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
 
225
      });
 
226
    }
 
227
 
 
228
    [Test]
 
229
    public void SerializeShouldChangeNonUTCDates()
 
230
    {
 
231
      DateTime localDateTime = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Local);
 
232
 
 
233
      DateTimeTestClass c = new DateTimeTestClass();
 
234
      c.DateTimeField = localDateTime;
 
235
      c.PreField = "Pre";
 
236
      c.PostField = "Post";
 
237
      string json = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal }); //note that this fails without the Utc converter...
 
238
      c.DateTimeField = new DateTime(2008, 1, 1, 1, 1, 1, 0, DateTimeKind.Utc);
 
239
      string json2 = JsonConvert.SerializeObject(c, new IsoDateTimeConverter() { DateTimeStyles = DateTimeStyles.AssumeUniversal });
 
240
 
 
241
      TimeSpan offset = localDateTime.GetUtcOffset();
 
242
 
 
243
      // if the current timezone is utc then local already equals utc
 
244
      if (offset == TimeSpan.Zero)
 
245
        Assert.AreEqual(json, json2);
 
246
      else
 
247
        Assert.AreNotEqual(json, json2);
 
248
    }
 
249
#endif
 
250
 
 
251
    [Test]
 
252
    public void BlogCodeSample()
 
253
    {
 
254
      Person p = new Person
 
255
                   {
 
256
                     Name = "Keith",
 
257
                     BirthDate = new DateTime(1980, 3, 8),
 
258
                     LastModified = new DateTime(2009, 4, 12, 20, 44, 55),
 
259
                   };
 
260
 
 
261
      string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());
 
262
      // {
 
263
      //   "Name": "Keith",
 
264
      //   "BirthDate": "1980-03-08T00:00:00",
 
265
      //   "LastModified": "2009-04-12T20:44:55"
 
266
      // }
 
267
 
 
268
      Console.WriteLine(jsonText);
 
269
 
 
270
    }
 
271
  }
 
272
}
 
 
b'\\ No newline at end of file'