← 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/JsonConvertTest.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/JsonConvertTest.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 System.Collections.Generic;
 
28
using System.IO;
 
29
using System.Runtime.Serialization;
 
30
using System.Text;
 
31
#if !(NET20 || NET35 || SILVERLIGHT)
 
32
using System.Threading.Tasks;
 
33
#endif
 
34
using System.Xml;
 
35
using Newtonsoft.Json.Converters;
 
36
using Newtonsoft.Json.Linq;
 
37
using Newtonsoft.Json.Tests.Serialization;
 
38
using Newtonsoft.Json.Tests.TestObjects;
 
39
using Newtonsoft.Json.Utilities;
 
40
#if !NETFX_CORE
 
41
using NUnit.Framework;
 
42
#else
 
43
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
 
44
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
 
45
using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
 
46
#endif
 
47
 
 
48
namespace Newtonsoft.Json.Tests
 
49
{
 
50
  [TestFixture]
 
51
  public class JsonConvertTest : TestFixtureBase
 
52
  {
 
53
    [Test]
 
54
    public void DeserializeObject_EmptyString()
 
55
    {
 
56
      object result = JsonConvert.DeserializeObject(string.Empty);
 
57
      Assert.IsNull(result);
 
58
    }
 
59
 
 
60
    [Test]
 
61
    public void DeserializeObject_Integer()
 
62
    {
 
63
      object result = JsonConvert.DeserializeObject("1");
 
64
      Assert.AreEqual(1L, result);
 
65
    }
 
66
 
 
67
    [Test]
 
68
    public void DeserializeObject_Integer_EmptyString()
 
69
    {
 
70
      int? value = JsonConvert.DeserializeObject<int?>("");
 
71
      Assert.IsNull(value);
 
72
    }
 
73
 
 
74
    [Test]
 
75
    public void DeserializeObject_Decimal_EmptyString()
 
76
    {
 
77
      decimal? value = JsonConvert.DeserializeObject<decimal?>("");
 
78
      Assert.IsNull(value);
 
79
    }
 
80
 
 
81
    [Test]
 
82
    public void DeserializeObject_DateTime_EmptyString()
 
83
    {
 
84
      DateTime? value = JsonConvert.DeserializeObject<DateTime?>("");
 
85
      Assert.IsNull(value);
 
86
    }
 
87
 
 
88
    [Test]
 
89
    public void EscapeJavaScriptString()
 
90
    {
 
91
      string result;
 
92
 
 
93
      result = JavaScriptUtils.ToEscapedJavaScriptString("How now brown cow?", '"', true);
 
94
      Assert.AreEqual(@"""How now brown cow?""", result);
 
95
 
 
96
      result = JavaScriptUtils.ToEscapedJavaScriptString("How now 'brown' cow?", '"', true);
 
97
      Assert.AreEqual(@"""How now 'brown' cow?""", result);
 
98
 
 
99
      result = JavaScriptUtils.ToEscapedJavaScriptString("How now <brown> cow?", '"', true);
 
100
      Assert.AreEqual(@"""How now <brown> cow?""", result);
 
101
 
 
102
      result = JavaScriptUtils.ToEscapedJavaScriptString(@"How 
 
103
now brown cow?", '"', true);
 
104
      Assert.AreEqual(@"""How \r\nnow brown cow?""", result);
 
105
 
 
106
      result = JavaScriptUtils.ToEscapedJavaScriptString("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007", '"', true);
 
107
      Assert.AreEqual(@"""\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007""", result);
 
108
 
 
109
      result =
 
110
        JavaScriptUtils.ToEscapedJavaScriptString("\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013", '"', true);
 
111
      Assert.AreEqual(@"""\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013""", result);
 
112
 
 
113
      result =
 
114
        JavaScriptUtils.ToEscapedJavaScriptString(
 
115
          "\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f ", '"', true);
 
116
      Assert.AreEqual(@"""\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f """, result);
 
117
 
 
118
      result =
 
119
        JavaScriptUtils.ToEscapedJavaScriptString(
 
120
          "!\"#$%&\u0027()*+,-./0123456789:;\u003c=\u003e?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]", '"', true);
 
121
      Assert.AreEqual(@"""!\""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]""", result);
 
122
 
 
123
      result = JavaScriptUtils.ToEscapedJavaScriptString("^_`abcdefghijklmnopqrstuvwxyz{|}~", '"', true);
 
124
      Assert.AreEqual(@"""^_`abcdefghijklmnopqrstuvwxyz{|}~""", result);
 
125
 
 
126
      string data =
 
127
        "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f !\"#$%&\u0027()*+,-./0123456789:;\u003c=\u003e?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
 
128
      string expected =
 
129
        @"""\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f !\""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~""";
 
130
 
 
131
      result = JavaScriptUtils.ToEscapedJavaScriptString(data, '"', true);
 
132
      Assert.AreEqual(expected, result);
 
133
 
 
134
      result = JavaScriptUtils.ToEscapedJavaScriptString("Fred's cat.", '\'', true);
 
135
      Assert.AreEqual(result, @"'Fred\'s cat.'");
 
136
 
 
137
      result = JavaScriptUtils.ToEscapedJavaScriptString(@"""How are you gentlemen?"" said Cats.", '"', true);
 
138
      Assert.AreEqual(result, @"""\""How are you gentlemen?\"" said Cats.""");
 
139
 
 
140
      result = JavaScriptUtils.ToEscapedJavaScriptString(@"""How are' you gentlemen?"" said Cats.", '"', true);
 
141
      Assert.AreEqual(result, @"""\""How are' you gentlemen?\"" said Cats.""");
 
142
 
 
143
      result = JavaScriptUtils.ToEscapedJavaScriptString(@"Fred's ""cat"".", '\'', true);
 
144
      Assert.AreEqual(result, @"'Fred\'s ""cat"".'");
 
145
 
 
146
      result = JavaScriptUtils.ToEscapedJavaScriptString("\u001farray\u003caddress");
 
147
      Assert.AreEqual(result, @"""\u001farray<address""");
 
148
    }
 
149
 
 
150
    [Test]
 
151
    public void EscapeJavaScriptString_UnicodeLinefeeds()
 
152
    {
 
153
      string result;
 
154
 
 
155
      result = JavaScriptUtils.ToEscapedJavaScriptString("before" + '\u0085' + "after", '"', true);
 
156
      Assert.AreEqual(@"""before\u0085after""", result);
 
157
 
 
158
      result = JavaScriptUtils.ToEscapedJavaScriptString("before" + '\u2028' + "after", '"', true);
 
159
      Assert.AreEqual(@"""before\u2028after""", result);
 
160
 
 
161
      result = JavaScriptUtils.ToEscapedJavaScriptString("before" + '\u2029' + "after", '"', true);
 
162
      Assert.AreEqual(@"""before\u2029after""", result);
 
163
    }
 
164
 
 
165
    [Test]
 
166
    public void ToStringInvalid()
 
167
    {
 
168
      ExceptionAssert.Throws<ArgumentException>("Unsupported type: System.Version. Use the JsonSerializer class to get the object's JSON representation.",
 
169
      () =>
 
170
      {
 
171
        JsonConvert.ToString(new Version(1, 0));
 
172
      });
 
173
    }
 
174
 
 
175
    [Test]
 
176
    public void GuidToString()
 
177
    {
 
178
      Guid guid = new Guid("BED7F4EA-1A96-11d2-8F08-00A0C9A6186D");
 
179
      string json = JsonConvert.ToString(guid);
 
180
      Assert.AreEqual(@"""bed7f4ea-1a96-11d2-8f08-00a0c9a6186d""", json);
 
181
    }
 
182
 
 
183
    [Test]
 
184
    public void EnumToString()
 
185
    {
 
186
      string json = JsonConvert.ToString(StringComparison.CurrentCultureIgnoreCase);
 
187
      Assert.AreEqual("1", json);
 
188
    }
 
189
 
 
190
    [Test]
 
191
    public void ObjectToString()
 
192
    {
 
193
      object value;
 
194
 
 
195
      value = 1;
 
196
      Assert.AreEqual("1", JsonConvert.ToString(value));
 
197
 
 
198
      value = 1.1;
 
199
      Assert.AreEqual("1.1", JsonConvert.ToString(value));
 
200
 
 
201
      value = 1.1m;
 
202
      Assert.AreEqual("1.1", JsonConvert.ToString(value));
 
203
 
 
204
      value = (float)1.1;
 
205
      Assert.AreEqual("1.1", JsonConvert.ToString(value));
 
206
 
 
207
      value = (short)1;
 
208
      Assert.AreEqual("1", JsonConvert.ToString(value));
 
209
 
 
210
      value = (long)1;
 
211
      Assert.AreEqual("1", JsonConvert.ToString(value));
 
212
 
 
213
      value = (byte)1;
 
214
      Assert.AreEqual("1", JsonConvert.ToString(value));
 
215
 
 
216
      value = (uint)1;
 
217
      Assert.AreEqual("1", JsonConvert.ToString(value));
 
218
 
 
219
      value = (ushort)1;
 
220
      Assert.AreEqual("1", JsonConvert.ToString(value));
 
221
 
 
222
      value = (sbyte)1;
 
223
      Assert.AreEqual("1", JsonConvert.ToString(value));
 
224
 
 
225
      value = (ulong)1;
 
226
      Assert.AreEqual("1", JsonConvert.ToString(value));
 
227
 
 
228
      value = new DateTime(JsonConvert.InitialJavaScriptDateTicks, DateTimeKind.Utc);
 
229
      Assert.AreEqual(@"""1970-01-01T00:00:00Z""", JsonConvert.ToString(value));
 
230
 
 
231
      value = new DateTime(JsonConvert.InitialJavaScriptDateTicks, DateTimeKind.Utc);
 
232
      Assert.AreEqual(@"""\/Date(0)\/""", JsonConvert.ToString((DateTime)value, DateFormatHandling.MicrosoftDateFormat, DateTimeZoneHandling.RoundtripKind));
 
233
 
 
234
#if !PocketPC && !NET20
 
235
      value = new DateTimeOffset(JsonConvert.InitialJavaScriptDateTicks, TimeSpan.Zero);
 
236
      Assert.AreEqual(@"""1970-01-01T00:00:00+00:00""", JsonConvert.ToString(value));
 
237
 
 
238
      value = new DateTimeOffset(JsonConvert.InitialJavaScriptDateTicks, TimeSpan.Zero);
 
239
      Assert.AreEqual(@"""\/Date(0+0000)\/""", JsonConvert.ToString((DateTimeOffset)value, DateFormatHandling.MicrosoftDateFormat));
 
240
#endif
 
241
 
 
242
      value = null;
 
243
      Assert.AreEqual("null", JsonConvert.ToString(value));
 
244
 
 
245
#if !(NETFX_CORE || PORTABLE)
 
246
      value = DBNull.Value;
 
247
      Assert.AreEqual("null", JsonConvert.ToString(value));
 
248
#endif
 
249
 
 
250
      value = "I am a string";
 
251
      Assert.AreEqual(@"""I am a string""", JsonConvert.ToString(value));
 
252
 
 
253
      value = true;
 
254
      Assert.AreEqual("true", JsonConvert.ToString(value));
 
255
 
 
256
      value = 'c';
 
257
      Assert.AreEqual(@"""c""", JsonConvert.ToString(value));
 
258
    }
 
259
 
 
260
    [Test]
 
261
    public void TestInvalidStrings()
 
262
    {
 
263
      ExceptionAssert.Throws<JsonReaderException>("Additional text encountered after finished reading JSON content: t. Path '', line 1, position 19.",
 
264
      () =>
 
265
      {
 
266
        string orig = @"this is a string ""that has quotes"" ";
 
267
 
 
268
        string serialized = JsonConvert.SerializeObject(orig);
 
269
 
 
270
        // *** Make string invalid by stripping \" \"
 
271
        serialized = serialized.Replace(@"\""", "\"");
 
272
 
 
273
        JsonConvert.DeserializeObject<string>(serialized);
 
274
      });
 
275
    }
 
276
 
 
277
    [Test]
 
278
    public void DeserializeValueObjects()
 
279
    {
 
280
      int i = JsonConvert.DeserializeObject<int>("1");
 
281
      Assert.AreEqual(1, i);
 
282
 
 
283
#if !PocketPC && !NET20
 
284
      DateTimeOffset d = JsonConvert.DeserializeObject<DateTimeOffset>(@"""\/Date(-59011455539000+0000)\/""");
 
285
      Assert.AreEqual(new DateTimeOffset(new DateTime(100, 1, 1, 1, 1, 1, DateTimeKind.Utc)), d);
 
286
#endif
 
287
 
 
288
      bool b = JsonConvert.DeserializeObject<bool>("true");
 
289
      Assert.AreEqual(true, b);
 
290
 
 
291
      object n = JsonConvert.DeserializeObject<object>("null");
 
292
      Assert.AreEqual(null, n);
 
293
 
 
294
      object u = JsonConvert.DeserializeObject<object>("undefined");
 
295
      Assert.AreEqual(null, u);
 
296
    }
 
297
 
 
298
    [Test]
 
299
    public void FloatToString()
 
300
    {
 
301
      Assert.AreEqual("1.1", JsonConvert.ToString(1.1));
 
302
      Assert.AreEqual("1.11", JsonConvert.ToString(1.11));
 
303
      Assert.AreEqual("1.111", JsonConvert.ToString(1.111));
 
304
      Assert.AreEqual("1.1111", JsonConvert.ToString(1.1111));
 
305
      Assert.AreEqual("1.11111", JsonConvert.ToString(1.11111));
 
306
      Assert.AreEqual("1.111111", JsonConvert.ToString(1.111111));
 
307
      Assert.AreEqual("1.0", JsonConvert.ToString(1.0));
 
308
      Assert.AreEqual("1.0", JsonConvert.ToString(1d));
 
309
      Assert.AreEqual("-1.0", JsonConvert.ToString(-1d)); 
 
310
      Assert.AreEqual("1.01", JsonConvert.ToString(1.01));
 
311
      Assert.AreEqual("1.001", JsonConvert.ToString(1.001));
 
312
      Assert.AreEqual(JsonConvert.PositiveInfinity, JsonConvert.ToString(Double.PositiveInfinity));
 
313
      Assert.AreEqual(JsonConvert.NegativeInfinity, JsonConvert.ToString(Double.NegativeInfinity));
 
314
      Assert.AreEqual(JsonConvert.NaN, JsonConvert.ToString(Double.NaN));
 
315
    }
 
316
 
 
317
    [Test]
 
318
    public void DecimalToString()
 
319
    {
 
320
      Assert.AreEqual("1.1", JsonConvert.ToString(1.1m));
 
321
      Assert.AreEqual("1.11", JsonConvert.ToString(1.11m));
 
322
      Assert.AreEqual("1.111", JsonConvert.ToString(1.111m));
 
323
      Assert.AreEqual("1.1111", JsonConvert.ToString(1.1111m));
 
324
      Assert.AreEqual("1.11111", JsonConvert.ToString(1.11111m));
 
325
      Assert.AreEqual("1.111111", JsonConvert.ToString(1.111111m));
 
326
      Assert.AreEqual("1.0", JsonConvert.ToString(1.0m));
 
327
      Assert.AreEqual("-1.0", JsonConvert.ToString(-1.0m));
 
328
      Assert.AreEqual("-1.0", JsonConvert.ToString(-1m));
 
329
      Assert.AreEqual("1.0", JsonConvert.ToString(1m));
 
330
      Assert.AreEqual("1.01", JsonConvert.ToString(1.01m));
 
331
      Assert.AreEqual("1.001", JsonConvert.ToString(1.001m));
 
332
      Assert.AreEqual("79228162514264337593543950335.0", JsonConvert.ToString(Decimal.MaxValue));
 
333
      Assert.AreEqual("-79228162514264337593543950335.0", JsonConvert.ToString(Decimal.MinValue));
 
334
    }
 
335
 
 
336
    [Test]
 
337
    public void StringEscaping()
 
338
    {
 
339
      string v = @"It's a good day
 
340
""sunshine""";
 
341
 
 
342
      string json = JsonConvert.ToString(v);
 
343
      Assert.AreEqual(@"""It's a good day\r\n\""sunshine\""""", json);
 
344
    }
 
345
 
 
346
    [Test]
 
347
    public void WriteDateTime()
 
348
    {
 
349
      DateTimeResult result = null;
 
350
 
 
351
      result = TestDateTime("DateTime Max", DateTime.MaxValue);
 
352
      Assert.AreEqual("9999-12-31T23:59:59.9999999", result.IsoDateRoundtrip);
 
353
      Assert.AreEqual("9999-12-31T23:59:59.9999999" + GetOffset(DateTime.MaxValue, DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
354
      Assert.AreEqual("9999-12-31T23:59:59.9999999", result.IsoDateUnspecified);
 
355
      Assert.AreEqual("9999-12-31T23:59:59.9999999Z", result.IsoDateUtc);
 
356
      Assert.AreEqual(@"\/Date(253402300799999)\/", result.MsDateRoundtrip);
 
357
      Assert.AreEqual(@"\/Date(253402300799999" + GetOffset(DateTime.MaxValue, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
358
      Assert.AreEqual(@"\/Date(253402300799999)\/", result.MsDateUnspecified);
 
359
      Assert.AreEqual(@"\/Date(253402300799999)\/", result.MsDateUtc);
 
360
 
 
361
      DateTime year2000local = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Local);
 
362
      string localToUtcDate = year2000local.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.FFFFFFFK");
 
363
 
 
364
      result = TestDateTime("DateTime Local", year2000local);
 
365
      Assert.AreEqual("2000-01-01T01:01:01" + GetOffset(year2000local, DateFormatHandling.IsoDateFormat), result.IsoDateRoundtrip);
 
366
      Assert.AreEqual("2000-01-01T01:01:01" + GetOffset(year2000local, DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
367
      Assert.AreEqual("2000-01-01T01:01:01", result.IsoDateUnspecified);
 
368
      Assert.AreEqual(localToUtcDate, result.IsoDateUtc);
 
369
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(year2000local) + GetOffset(year2000local, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateRoundtrip);
 
370
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(year2000local) + GetOffset(year2000local, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
371
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(year2000local) + GetOffset(year2000local, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateUnspecified);
 
372
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(year2000local) + @")\/", result.MsDateUtc);
 
373
 
 
374
      DateTime millisecondsLocal = new DateTime(2000, 1, 1, 1, 1, 1, 999, DateTimeKind.Local);
 
375
      localToUtcDate = millisecondsLocal.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.FFFFFFFK");
 
376
 
 
377
      result = TestDateTime("DateTime Local with milliseconds", millisecondsLocal);
 
378
      Assert.AreEqual("2000-01-01T01:01:01.999" + GetOffset(millisecondsLocal, DateFormatHandling.IsoDateFormat), result.IsoDateRoundtrip);
 
379
      Assert.AreEqual("2000-01-01T01:01:01.999" + GetOffset(millisecondsLocal, DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
380
      Assert.AreEqual("2000-01-01T01:01:01.999", result.IsoDateUnspecified);
 
381
      Assert.AreEqual(localToUtcDate, result.IsoDateUtc);
 
382
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(millisecondsLocal) + GetOffset(millisecondsLocal, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateRoundtrip);
 
383
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(millisecondsLocal) + GetOffset(millisecondsLocal, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
384
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(millisecondsLocal) + GetOffset(millisecondsLocal, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateUnspecified);
 
385
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(millisecondsLocal) + @")\/", result.MsDateUtc);
 
386
 
 
387
      DateTime ticksLocal = new DateTime(634663873826822481, DateTimeKind.Local);
 
388
      localToUtcDate = ticksLocal.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.FFFFFFFK");
 
389
      
 
390
      result = TestDateTime("DateTime Local with ticks", ticksLocal);
 
391
      Assert.AreEqual("2012-03-03T16:03:02.6822481" + GetOffset(ticksLocal, DateFormatHandling.IsoDateFormat), result.IsoDateRoundtrip);
 
392
      Assert.AreEqual("2012-03-03T16:03:02.6822481" + GetOffset(ticksLocal, DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
393
      Assert.AreEqual("2012-03-03T16:03:02.6822481", result.IsoDateUnspecified);
 
394
      Assert.AreEqual(localToUtcDate, result.IsoDateUtc);
 
395
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(ticksLocal) + GetOffset(ticksLocal, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateRoundtrip);
 
396
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(ticksLocal) + GetOffset(ticksLocal, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
397
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(ticksLocal) + GetOffset(ticksLocal, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateUnspecified);
 
398
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(ticksLocal) + @")\/", result.MsDateUtc);
 
399
 
 
400
      DateTime year2000Unspecified = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Unspecified);
 
401
 
 
402
      result = TestDateTime("DateTime Unspecified", year2000Unspecified);
 
403
      Assert.AreEqual("2000-01-01T01:01:01", result.IsoDateRoundtrip);
 
404
      Assert.AreEqual("2000-01-01T01:01:01" + GetOffset(year2000Unspecified, DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
405
      Assert.AreEqual("2000-01-01T01:01:01", result.IsoDateUnspecified);
 
406
      Assert.AreEqual("2000-01-01T01:01:01Z", result.IsoDateUtc);
 
407
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(year2000Unspecified) + GetOffset(year2000Unspecified, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateRoundtrip);
 
408
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(year2000Unspecified) + GetOffset(year2000Unspecified, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
409
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(year2000Unspecified) + GetOffset(year2000Unspecified, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateUnspecified);
 
410
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(year2000Unspecified.ToLocalTime()) + @")\/", result.MsDateUtc);
 
411
 
 
412
      DateTime year2000Utc = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc);
 
413
      string utcTolocalDate = year2000Utc.ToLocalTime().ToString("yyyy-MM-ddTHH:mm:ss");
 
414
 
 
415
      result = TestDateTime("DateTime Utc", year2000Utc);
 
416
      Assert.AreEqual("2000-01-01T01:01:01Z", result.IsoDateRoundtrip);
 
417
      Assert.AreEqual(utcTolocalDate + GetOffset(year2000Utc, DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
418
      Assert.AreEqual("2000-01-01T01:01:01", result.IsoDateUnspecified);
 
419
      Assert.AreEqual("2000-01-01T01:01:01Z", result.IsoDateUtc);
 
420
      Assert.AreEqual(@"\/Date(946688461000)\/", result.MsDateRoundtrip);
 
421
      Assert.AreEqual(@"\/Date(946688461000" + GetOffset(year2000Utc, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
422
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(DateTime.SpecifyKind(year2000Utc, DateTimeKind.Unspecified)) + GetOffset(year2000Utc, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateUnspecified);
 
423
      Assert.AreEqual(@"\/Date(946688461000)\/", result.MsDateUtc);
 
424
 
 
425
      DateTime unixEpoc = new DateTime(621355968000000000, DateTimeKind.Utc);
 
426
      utcTolocalDate = unixEpoc.ToLocalTime().ToString("yyyy-MM-ddTHH:mm:ss");
 
427
 
 
428
      result = TestDateTime("DateTime Unix Epoc", unixEpoc);
 
429
      Assert.AreEqual("1970-01-01T00:00:00Z", result.IsoDateRoundtrip);
 
430
      Assert.AreEqual(utcTolocalDate + GetOffset(unixEpoc, DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
431
      Assert.AreEqual("1970-01-01T00:00:00", result.IsoDateUnspecified);
 
432
      Assert.AreEqual("1970-01-01T00:00:00Z", result.IsoDateUtc);
 
433
      Assert.AreEqual(@"\/Date(0)\/", result.MsDateRoundtrip);
 
434
      Assert.AreEqual(@"\/Date(0" + GetOffset(unixEpoc, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
435
      Assert.AreEqual(@"\/Date(" + JsonConvert.ConvertDateTimeToJavaScriptTicks(DateTime.SpecifyKind(unixEpoc, DateTimeKind.Unspecified)) + GetOffset(unixEpoc, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateUnspecified);
 
436
      Assert.AreEqual(@"\/Date(0)\/", result.MsDateUtc);
 
437
 
 
438
      result = TestDateTime("DateTime Min", DateTime.MinValue);
 
439
      Assert.AreEqual("0001-01-01T00:00:00", result.IsoDateRoundtrip);
 
440
      Assert.AreEqual("0001-01-01T00:00:00" + GetOffset(DateTime.MinValue, DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
441
      Assert.AreEqual("0001-01-01T00:00:00", result.IsoDateUnspecified);
 
442
      Assert.AreEqual("0001-01-01T00:00:00Z", result.IsoDateUtc);
 
443
      Assert.AreEqual(@"\/Date(-62135596800000)\/", result.MsDateRoundtrip);
 
444
      Assert.AreEqual(@"\/Date(-62135596800000" + GetOffset(DateTime.MinValue, DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
445
      Assert.AreEqual(@"\/Date(-62135596800000)\/", result.MsDateUnspecified);
 
446
      Assert.AreEqual(@"\/Date(-62135596800000)\/", result.MsDateUtc);
 
447
 
 
448
      result = TestDateTime("DateTime Default", default(DateTime));
 
449
      Assert.AreEqual("0001-01-01T00:00:00", result.IsoDateRoundtrip);
 
450
      Assert.AreEqual("0001-01-01T00:00:00" + GetOffset(default(DateTime), DateFormatHandling.IsoDateFormat), result.IsoDateLocal);
 
451
      Assert.AreEqual("0001-01-01T00:00:00", result.IsoDateUnspecified);
 
452
      Assert.AreEqual("0001-01-01T00:00:00Z", result.IsoDateUtc);
 
453
      Assert.AreEqual(@"\/Date(-62135596800000)\/", result.MsDateRoundtrip);
 
454
      Assert.AreEqual(@"\/Date(-62135596800000" + GetOffset(default(DateTime), DateFormatHandling.MicrosoftDateFormat) + @")\/", result.MsDateLocal);
 
455
      Assert.AreEqual(@"\/Date(-62135596800000)\/", result.MsDateUnspecified);
 
456
      Assert.AreEqual(@"\/Date(-62135596800000)\/", result.MsDateUtc);
 
457
 
 
458
#if !NET20
 
459
      result = TestDateTime("DateTimeOffset TimeSpan Zero", new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.Zero));
 
460
      Assert.AreEqual("2000-01-01T01:01:01+00:00", result.IsoDateRoundtrip);
 
461
      Assert.AreEqual(@"\/Date(946688461000+0000)\/", result.MsDateRoundtrip);
 
462
 
 
463
      result = TestDateTime("DateTimeOffset TimeSpan 1 hour", new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.FromHours(1)));
 
464
      Assert.AreEqual("2000-01-01T01:01:01+01:00", result.IsoDateRoundtrip);
 
465
      Assert.AreEqual(@"\/Date(946684861000+0100)\/", result.MsDateRoundtrip);
 
466
 
 
467
      result = TestDateTime("DateTimeOffset TimeSpan 1.5 hour", new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.FromHours(1.5)));
 
468
      Assert.AreEqual("2000-01-01T01:01:01+01:30", result.IsoDateRoundtrip);
 
469
      Assert.AreEqual(@"\/Date(946683061000+0130)\/", result.MsDateRoundtrip);
 
470
 
 
471
      result = TestDateTime("DateTimeOffset TimeSpan 13 hour", new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.FromHours(13)));
 
472
      Assert.AreEqual("2000-01-01T01:01:01+13:00", result.IsoDateRoundtrip);
 
473
      Assert.AreEqual(@"\/Date(946641661000+1300)\/", result.MsDateRoundtrip);
 
474
 
 
475
      result = TestDateTime("DateTimeOffset TimeSpan with ticks", new DateTimeOffset(634663873826822481, TimeSpan.Zero));
 
476
      Assert.AreEqual("2012-03-03T16:03:02.6822481+00:00", result.IsoDateRoundtrip);
 
477
      Assert.AreEqual(@"\/Date(1330790582682+0000)\/", result.MsDateRoundtrip);
 
478
 
 
479
      result = TestDateTime("DateTimeOffset Min", DateTimeOffset.MinValue);
 
480
      Assert.AreEqual("0001-01-01T00:00:00+00:00", result.IsoDateRoundtrip);
 
481
      Assert.AreEqual(@"\/Date(-62135596800000+0000)\/", result.MsDateRoundtrip);
 
482
 
 
483
      result = TestDateTime("DateTimeOffset Max", DateTimeOffset.MaxValue);
 
484
      Assert.AreEqual("9999-12-31T23:59:59.9999999+00:00", result.IsoDateRoundtrip);
 
485
      Assert.AreEqual(@"\/Date(253402300799999+0000)\/", result.MsDateRoundtrip);
 
486
 
 
487
      result = TestDateTime("DateTimeOffset Default", default(DateTimeOffset));
 
488
      Assert.AreEqual("0001-01-01T00:00:00+00:00", result.IsoDateRoundtrip);
 
489
      Assert.AreEqual(@"\/Date(-62135596800000+0000)\/", result.MsDateRoundtrip);
 
490
#endif
 
491
    }
 
492
 
 
493
    public class DateTimeResult
 
494
    {
 
495
      public string IsoDateRoundtrip { get; set; }
 
496
      public string IsoDateLocal { get; set; }
 
497
      public string IsoDateUnspecified { get; set; }
 
498
      public string IsoDateUtc { get; set; }
 
499
 
 
500
      public string MsDateRoundtrip { get; set; }
 
501
      public string MsDateLocal { get; set; }
 
502
      public string MsDateUnspecified { get; set; }
 
503
      public string MsDateUtc { get; set; }
 
504
    }
 
505
 
 
506
    private DateTimeResult TestDateTime<T>(string name, T value)
 
507
    {
 
508
      Console.WriteLine(name);
 
509
 
 
510
      DateTimeResult result = new DateTimeResult();
 
511
 
 
512
      result.IsoDateRoundtrip = TestDateTimeFormat(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind);
 
513
      if (value is DateTime)
 
514
      {
 
515
        result.IsoDateLocal = TestDateTimeFormat(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.Local);
 
516
        result.IsoDateUnspecified = TestDateTimeFormat(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.Unspecified);
 
517
        result.IsoDateUtc = TestDateTimeFormat(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.Utc);
 
518
      }
 
519
 
 
520
      result.MsDateRoundtrip = TestDateTimeFormat(value, DateFormatHandling.MicrosoftDateFormat, DateTimeZoneHandling.RoundtripKind);
 
521
      if (value is DateTime)
 
522
      {
 
523
        result.MsDateLocal = TestDateTimeFormat(value, DateFormatHandling.MicrosoftDateFormat, DateTimeZoneHandling.Local);
 
524
        result.MsDateUnspecified = TestDateTimeFormat(value, DateFormatHandling.MicrosoftDateFormat, DateTimeZoneHandling.Unspecified);
 
525
        result.MsDateUtc = TestDateTimeFormat(value, DateFormatHandling.MicrosoftDateFormat, DateTimeZoneHandling.Utc);
 
526
      }
 
527
 
 
528
      TestDateTimeFormat(value, new IsoDateTimeConverter());
 
529
 
 
530
#if !NETFX_CORE
 
531
      if (value is DateTime)
 
532
      {
 
533
        Console.WriteLine(XmlConvert.ToString((DateTime)(object)value, XmlDateTimeSerializationMode.RoundtripKind));
 
534
      }
 
535
      else
 
536
      {
 
537
        Console.WriteLine(XmlConvert.ToString((DateTimeOffset)(object)value));
 
538
      }
 
539
#endif
 
540
 
 
541
#if !NET20
 
542
      MemoryStream ms = new MemoryStream();
 
543
      DataContractSerializer s = new DataContractSerializer(typeof(T));
 
544
      s.WriteObject(ms, value);
 
545
      string json = Encoding.UTF8.GetString(ms.ToArray(), 0, Convert.ToInt32(ms.Length));
 
546
      Console.WriteLine(json);
 
547
#endif
 
548
 
 
549
      Console.WriteLine();
 
550
 
 
551
      return result;
 
552
    }
 
553
 
 
554
    private static string TestDateTimeFormat<T>(T value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling)
 
555
    {
 
556
      string date = null;
 
557
 
 
558
      if (value is DateTime)
 
559
      {
 
560
        date = JsonConvert.ToString((DateTime)(object)value, format, timeZoneHandling);
 
561
      }
 
562
      else
 
563
      {
 
564
#if !NET20
 
565
        date = JsonConvert.ToString((DateTimeOffset)(object)value, format);
 
566
#endif
 
567
      }
 
568
 
 
569
      Console.WriteLine(format.ToString("g") + "-" + timeZoneHandling.ToString("g") + ": " + date);
 
570
 
 
571
      if (timeZoneHandling == DateTimeZoneHandling.RoundtripKind)
 
572
      {
 
573
        T parsed = JsonConvert.DeserializeObject<T>(date);
 
574
        try
 
575
        {
 
576
          Assert.AreEqual(value, parsed);
 
577
        }
 
578
        catch (Exception)
 
579
        {
 
580
          long valueTicks = GetTicks(value);
 
581
          long parsedTicks = GetTicks(parsed);
 
582
 
 
583
          valueTicks = (valueTicks/10000)*10000;
 
584
 
 
585
          Assert.AreEqual(valueTicks, parsedTicks);
 
586
        }
 
587
      }
 
588
 
 
589
      return date.Trim('"');
 
590
    }
 
591
 
 
592
    private static void TestDateTimeFormat<T>(T value, JsonConverter converter)
 
593
    {
 
594
      string date = Write(value, converter);
 
595
 
 
596
      Console.WriteLine(converter.GetType().Name + ": " + date);
 
597
 
 
598
      T parsed = Read<T>(date, converter);
 
599
 
 
600
      try
 
601
      {
 
602
        Assert.AreEqual(value, parsed);
 
603
      }
 
604
      catch (Exception)
 
605
      {
 
606
        // JavaScript ticks aren't as precise, recheck after rounding
 
607
        long valueTicks = GetTicks(value);
 
608
        long parsedTicks = GetTicks(parsed);
 
609
 
 
610
        valueTicks = (valueTicks / 10000) * 10000;
 
611
 
 
612
        Assert.AreEqual(valueTicks, parsedTicks);
 
613
      }
 
614
    }
 
615
 
 
616
    public static long GetTicks(object value)
 
617
    {
 
618
      return (value is DateTime) ? ((DateTime)value).Ticks : ((DateTimeOffset)value).Ticks;
 
619
    }
 
620
 
 
621
    public static string Write(object value, JsonConverter converter)
 
622
    {
 
623
      StringWriter sw = new StringWriter();
 
624
      JsonTextWriter writer = new JsonTextWriter(sw);
 
625
      converter.WriteJson(writer, value, null);
 
626
 
 
627
      writer.Flush();
 
628
      return sw.ToString();
 
629
    }
 
630
 
 
631
    public static T Read<T>(string text, JsonConverter converter)
 
632
    {
 
633
      JsonTextReader reader = new JsonTextReader(new StringReader(text));
 
634
      reader.ReadAsString();
 
635
 
 
636
      return (T)converter.ReadJson(reader, typeof(T), null, null);
 
637
    }
 
638
 
 
639
#if !(NET20 || NET35 || SILVERLIGHT || PORTABLE)
 
640
    [Test]
 
641
    public void Async()
 
642
    {
 
643
      Task<string> task = null;
 
644
      
 
645
      task = JsonConvert.SerializeObjectAsync(42);
 
646
      task.Wait();
 
647
 
 
648
      Assert.AreEqual("42", task.Result);
 
649
 
 
650
      task = JsonConvert.SerializeObjectAsync(new[] {1, 2, 3, 4, 5}, Formatting.Indented);
 
651
      task.Wait();
 
652
 
 
653
      Assert.AreEqual(@"[
 
654
  1,
 
655
  2,
 
656
  3,
 
657
  4,
 
658
  5
 
659
]", task.Result);
 
660
 
 
661
      task = JsonConvert.SerializeObjectAsync(DateTime.MaxValue, Formatting.None, new JsonSerializerSettings
 
662
        {
 
663
          DateFormatHandling = DateFormatHandling.MicrosoftDateFormat
 
664
        });
 
665
      task.Wait();
 
666
 
 
667
      Assert.AreEqual(@"""\/Date(253402300799999)\/""", task.Result);
 
668
 
 
669
      var taskObject = JsonConvert.DeserializeObjectAsync("[]");
 
670
      taskObject.Wait();
 
671
 
 
672
      CollectionAssert.AreEquivalent(new JArray(), (JArray)taskObject.Result);
 
673
 
 
674
      Task<object> taskVersionArray = JsonConvert.DeserializeObjectAsync("['2.0']", typeof(Version[]), new JsonSerializerSettings
 
675
        {
 
676
          Converters = {new VersionConverter()}
 
677
        });
 
678
      taskVersionArray.Wait();
 
679
 
 
680
      Version[] versionArray = (Version[])taskVersionArray.Result;
 
681
 
 
682
      Assert.AreEqual(1, versionArray.Length);
 
683
      Assert.AreEqual(2, versionArray[0].Major);
 
684
 
 
685
      Task<int> taskInt = JsonConvert.DeserializeObjectAsync<int>("5");
 
686
      taskInt.Wait();
 
687
 
 
688
      Assert.AreEqual(5, taskInt.Result);
 
689
 
 
690
      var taskVersion = JsonConvert.DeserializeObjectAsync<Version>("'2.0'", new JsonSerializerSettings
 
691
        {
 
692
          Converters = {new VersionConverter()}
 
693
        });
 
694
      taskVersion.Wait();
 
695
 
 
696
      Assert.AreEqual(2, taskVersion.Result.Major);
 
697
 
 
698
      Movie p = new Movie();
 
699
      p.Name = "Existing,";
 
700
 
 
701
      Task taskVoid = JsonConvert.PopulateObjectAsync("{'Name':'Appended'}", p, new JsonSerializerSettings
 
702
      {
 
703
        Converters = new List<JsonConverter> { new JsonSerializerTest.StringAppenderConverter() }
 
704
      });
 
705
 
 
706
      taskVoid.Wait();
 
707
 
 
708
      Assert.AreEqual("Existing,Appended", p.Name);
 
709
    }
 
710
#endif
 
711
 
 
712
    [Test]
 
713
    public void SerializeObjectDateTimeZoneHandling()
 
714
    {
 
715
      string json = JsonConvert.SerializeObject(
 
716
        new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Unspecified),
 
717
        new JsonSerializerSettings
 
718
        {
 
719
          DateTimeZoneHandling = DateTimeZoneHandling.Utc
 
720
        });
 
721
 
 
722
      Assert.AreEqual(@"""2000-01-01T01:01:01Z""", json);
 
723
    }
 
724
 
 
725
    //[Test]
 
726
    public void StackOverflowTest()
 
727
    {
 
728
      StringBuilder sb = new StringBuilder();
 
729
 
 
730
      int depth = 900;
 
731
      for (int i = 0; i < depth; i++)
 
732
      {
 
733
        sb.Append("{'A':");
 
734
      }
 
735
 
 
736
      // invalid json
 
737
      sb.Append("{***}");
 
738
      for (int i = 0; i < depth; i++)
 
739
      {
 
740
        sb.Append("}");
 
741
      }
 
742
 
 
743
      string json = sb.ToString();
 
744
      JsonSerializer serializer = new JsonSerializer() { };
 
745
      serializer.Deserialize<Nest>(new JsonTextReader(new StringReader(json)));
 
746
    }
 
747
 
 
748
    public class Nest
 
749
    {
 
750
      public Nest A { get; set; }
 
751
    }
 
752
  }
 
753
}
 
 
b'\\ No newline at end of file'