← 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/Serialization/TraceWriterTests.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/Serialization/TraceWriterTests.cs
 
1
ļ»æusing System;
 
2
using System.Collections.Generic;
 
3
using System.Diagnostics;
 
4
using System.Globalization;
 
5
using System.IO;
 
6
using System.Runtime.Serialization;
 
7
using System.Runtime.Serialization.Formatters;
 
8
using System.Text;
 
9
#if !NETFX_CORE
 
10
using NUnit.Framework;
 
11
#else
 
12
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
 
13
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
 
14
using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
 
15
#endif
 
16
using Newtonsoft.Json.Converters;
 
17
using Newtonsoft.Json.Serialization;
 
18
using Newtonsoft.Json.Tests.TestObjects;
 
19
#if NET20
 
20
using Newtonsoft.Json.Utilities.LinqBridge;
 
21
#else
 
22
using System.Linq;
 
23
#endif
 
24
 
 
25
namespace Newtonsoft.Json.Tests.Serialization
 
26
{
 
27
  public class Staff
 
28
  {
 
29
    public string Name { get; set; }
 
30
    public DateTime StartDate { get; set; }
 
31
    public IList<string> Roles { get; set; }
 
32
  }
 
33
 
 
34
  [TestFixture]
 
35
  public class TraceWriterTests : TestFixtureBase
 
36
  {
 
37
#if !(SILVERLIGHT || PORTABLE || NETFX_CORE)
 
38
    [Test]
 
39
    public void DiagnosticsTraceWriterTest()
 
40
    {
 
41
      StringWriter sw = new StringWriter();
 
42
      TextWriterTraceListener listener = new TextWriterTraceListener(sw);
 
43
 
 
44
      try
 
45
      {
 
46
        Trace.AutoFlush = true;
 
47
        Trace.Listeners.Add(listener);
 
48
 
 
49
        DiagnosticsTraceWriter traceWriter = new DiagnosticsTraceWriter();
 
50
        traceWriter.Trace(TraceLevel.Verbose, "Verbose!", null);
 
51
        traceWriter.Trace(TraceLevel.Info, "Info!", null);
 
52
        traceWriter.Trace(TraceLevel.Warning, "Warning!", null);
 
53
        traceWriter.Trace(TraceLevel.Error, "Error!", null);
 
54
        traceWriter.Trace(TraceLevel.Off, "Off!", null);
 
55
 
 
56
        Assert.AreEqual(@"Newtonsoft.Json Verbose: 0 : Verbose!
 
57
Newtonsoft.Json Information: 0 : Info!
 
58
Newtonsoft.Json Warning: 0 : Warning!
 
59
Newtonsoft.Json Error: 0 : Error!
 
60
", sw.ToString());
 
61
      }
 
62
      finally
 
63
      {
 
64
        Trace.Listeners.Remove(listener);
 
65
        Trace.AutoFlush = false;
 
66
      }
 
67
    }
 
68
#endif
 
69
 
 
70
    [Test]
 
71
    public void MemoryTraceWriterTest()
 
72
    {
 
73
      Staff staff = new Staff();
 
74
      staff.Name = "Arnie Admin";
 
75
      staff.Roles = new List<string> {"Administrator"};
 
76
      staff.StartDate = DateTime.Now;
 
77
 
 
78
      ITraceWriter traceWriter = new MemoryTraceWriter();
 
79
 
 
80
      JsonConvert.SerializeObject(
 
81
        staff,
 
82
        new JsonSerializerSettings {TraceWriter = traceWriter, Converters = {new JavaScriptDateTimeConverter()}});
 
83
 
 
84
      Console.WriteLine(traceWriter);
 
85
      // 2012-11-11T12:08:42.761 Info Started serializing Newtonsoft.Json.Tests.Serialization.Staff. Path ''.
 
86
      // 2012-11-11T12:08:42.785 Info Started serializing System.DateTime with converter Newtonsoft.Json.Converters.JavaScriptDateTimeConverter. Path 'StartDate'.
 
87
      // 2012-11-11T12:08:42.791 Info Finished serializing System.DateTime with converter Newtonsoft.Json.Converters.JavaScriptDateTimeConverter. Path 'StartDate'.
 
88
      // 2012-11-11T12:08:42.797 Info Started serializing System.Collections.Generic.List`1[System.String]. Path 'Roles'.
 
89
      // 2012-11-11T12:08:42.798 Info Finished serializing System.Collections.Generic.List`1[System.String]. Path 'Roles'.
 
90
      // 2012-11-11T12:08:42.799 Info Finished serializing Newtonsoft.Json.Tests.Serialization.Staff. Path ''.
 
91
 
 
92
      MemoryTraceWriter memoryTraceWriter = (MemoryTraceWriter)traceWriter;
 
93
 
 
94
      Assert.AreEqual(743, memoryTraceWriter.ToString().Length);
 
95
      Assert.AreEqual(6, memoryTraceWriter.GetTraceMessages().Count());
 
96
    }
 
97
 
 
98
    [Test]
 
99
    public void MemoryTraceWriterLimitTest()
 
100
    {
 
101
      MemoryTraceWriter traceWriter = new MemoryTraceWriter();
 
102
 
 
103
      for (int i = 0; i < 1005; i++)
 
104
      {
 
105
        traceWriter.Trace(TraceLevel.Verbose, (i + 1).ToString(CultureInfo.InvariantCulture), null);
 
106
      }
 
107
 
 
108
      IList<string> traceMessages = traceWriter.GetTraceMessages().ToList();
 
109
 
 
110
      Assert.AreEqual(1000, traceMessages.Count);
 
111
 
 
112
      Assert.IsTrue(traceMessages.First().EndsWith(" 6"));
 
113
      Assert.IsTrue(traceMessages.Last().EndsWith(" 1005"));
 
114
    }
 
115
 
 
116
    [Test]
 
117
    public void Serialize()
 
118
    {
 
119
      var traceWriter = new InMemoryTraceWriter
 
120
                          {
 
121
                            LevelFilter = TraceLevel.Info
 
122
                          };
 
123
 
 
124
      string json =
 
125
        JsonConvert.SerializeObject(
 
126
          new TraceTestObject
 
127
            {
 
128
              StringArray = new[] {"1", "2"},
 
129
              IntList = new List<int> {1, 2},
 
130
              Version = new Version(1, 2, 3, 4),
 
131
              StringDictionary =
 
132
                new Dictionary<string, string>
 
133
                  {
 
134
                    {"1", "!"},
 
135
                    {"Two", "!!"},
 
136
                    {"III", "!!!"}
 
137
                  }
 
138
            },
 
139
          new JsonSerializerSettings
 
140
            {
 
141
              TraceWriter = traceWriter,
 
142
              Formatting = Formatting.Indented
 
143
            });
 
144
 
 
145
      Assert.AreEqual("Started serializing Newtonsoft.Json.Tests.Serialization.TraceTestObject. Path ''.", traceWriter.TraceRecords[0].Message);
 
146
      Assert.AreEqual("Started serializing System.Collections.Generic.List`1[System.Int32]. Path 'IntList'.", traceWriter.TraceRecords[1].Message);
 
147
      Assert.AreEqual("Finished serializing System.Collections.Generic.List`1[System.Int32]. Path 'IntList'.", traceWriter.TraceRecords[2].Message);
 
148
      Assert.AreEqual("Started serializing System.String[]. Path 'StringArray'.", traceWriter.TraceRecords[3].Message);
 
149
      Assert.AreEqual("Finished serializing System.String[]. Path 'StringArray'.", traceWriter.TraceRecords[4].Message);
 
150
      Assert.AreEqual("Started serializing System.Version. Path 'Version'.", traceWriter.TraceRecords[5].Message);
 
151
      Assert.AreEqual("Finished serializing System.Version. Path 'Version'.", traceWriter.TraceRecords[6].Message);
 
152
      Assert.AreEqual("Started serializing System.Collections.Generic.Dictionary`2[System.String,System.String]. Path 'StringDictionary'.", traceWriter.TraceRecords[7].Message);
 
153
      Assert.AreEqual("Finished serializing System.Collections.Generic.Dictionary`2[System.String,System.String]. Path 'StringDictionary'.", traceWriter.TraceRecords[8].Message);
 
154
      Assert.AreEqual("Finished serializing Newtonsoft.Json.Tests.Serialization.TraceTestObject. Path ''.", traceWriter.TraceRecords[9].Message);
 
155
    }
 
156
 
 
157
    [Test]
 
158
    public void Deserialize()
 
159
    {
 
160
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
161
      {
 
162
        LevelFilter = TraceLevel.Info
 
163
      };
 
164
 
 
165
      TraceTestObject o2 = JsonConvert.DeserializeObject<TraceTestObject>(
 
166
        @"{
 
167
  ""IntList"": [
 
168
    1,
 
169
    2
 
170
  ],
 
171
  ""StringArray"": [
 
172
    ""1"",
 
173
    ""2""
 
174
  ],
 
175
  ""Version"": {
 
176
    ""Major"": 1,
 
177
    ""Minor"": 2,
 
178
    ""Build"": 3,
 
179
    ""Revision"": 4,
 
180
    ""MajorRevision"": 0,
 
181
    ""MinorRevision"": 4
 
182
  },
 
183
  ""StringDictionary"": {
 
184
    ""1"": ""!"",
 
185
    ""Two"": ""!!"",
 
186
    ""III"": ""!!!""
 
187
  }
 
188
}",
 
189
        new JsonSerializerSettings
 
190
        {
 
191
          TraceWriter = traceWriter
 
192
        });
 
193
 
 
194
      Assert.AreEqual(2, o2.IntList.Count);
 
195
      Assert.AreEqual(2, o2.StringArray.Length);
 
196
      Assert.AreEqual(1, o2.Version.Major);
 
197
      Assert.AreEqual(2, o2.Version.Minor);
 
198
      Assert.AreEqual(3, o2.StringDictionary.Count);
 
199
 
 
200
      Assert.AreEqual("Started deserializing Newtonsoft.Json.Tests.Serialization.TraceTestObject. Path 'IntList', line 2, position 13.", traceWriter.TraceRecords[0].Message);
 
201
      Assert.AreEqual("Started deserializing System.Collections.Generic.IList`1[System.Int32]. Path 'IntList', line 2, position 15.", traceWriter.TraceRecords[1].Message);
 
202
      Assert.AreEqual("Finished deserializing System.Collections.Generic.IList`1[System.Int32]. Path 'IntList', line 5, position 4.", traceWriter.TraceRecords[2].Message);
 
203
      Assert.AreEqual("Started deserializing System.String[]. Path 'StringArray', line 6, position 19.", traceWriter.TraceRecords[3].Message);
 
204
      Assert.AreEqual("Finished deserializing System.String[]. Path 'StringArray', line 9, position 4.", traceWriter.TraceRecords[4].Message);
 
205
      Assert.AreEqual("Deserializing System.Version using a non-default constructor 'Void .ctor(Int32, Int32, Int32, Int32)'. Path 'Version.Major', line 11, position 13.", traceWriter.TraceRecords[5].Message);
 
206
      Assert.AreEqual("Started deserializing System.Version. Path 'Version', line 17, position 4.", traceWriter.TraceRecords[6].Message);
 
207
      Assert.AreEqual("Finished deserializing System.Version. Path 'Version', line 17, position 4.", traceWriter.TraceRecords[7].Message);
 
208
      Assert.AreEqual("Started deserializing System.Collections.Generic.IDictionary`2[System.String,System.String]. Path 'StringDictionary.1', line 19, position 9.", traceWriter.TraceRecords[8].Message);
 
209
      Assert.AreEqual("Finished deserializing System.Collections.Generic.IDictionary`2[System.String,System.String]. Path 'StringDictionary', line 22, position 4.", traceWriter.TraceRecords[9].Message);
 
210
      Assert.AreEqual("Finished deserializing Newtonsoft.Json.Tests.Serialization.TraceTestObject. Path '', line 23, position 2.", traceWriter.TraceRecords[10].Message);
 
211
    }
 
212
 
 
213
    [Test]
 
214
    public void ErrorDeserializing()
 
215
    {
 
216
      string json = @"{""Integer"":""hi""}";
 
217
 
 
218
      var traceWriter = new InMemoryTraceWriter
 
219
                          {
 
220
                            LevelFilter = TraceLevel.Info
 
221
                          };
 
222
 
 
223
      ExceptionAssert.Throws<Exception>(
 
224
        "Could not convert string to integer: hi. Path 'Integer', line 1, position 15.",
 
225
        () =>
 
226
          {
 
227
            JsonConvert.DeserializeObject<IntegerTestClass>(
 
228
              json,
 
229
              new JsonSerializerSettings
 
230
                {
 
231
                  TraceWriter = traceWriter
 
232
                });
 
233
          });
 
234
 
 
235
      Assert.AreEqual(2, traceWriter.TraceRecords.Count);
 
236
 
 
237
      Assert.AreEqual(TraceLevel.Info, traceWriter.TraceRecords[0].Level);
 
238
      Assert.AreEqual("Started deserializing Newtonsoft.Json.Tests.Serialization.IntegerTestClass. Path 'Integer', line 1, position 11.", traceWriter.TraceRecords[0].Message);
 
239
      
 
240
      Assert.AreEqual(TraceLevel.Error, traceWriter.TraceRecords[1].Level);
 
241
      Assert.AreEqual("Error deserializing Newtonsoft.Json.Tests.Serialization.IntegerTestClass. Could not convert string to integer: hi. Path 'Integer', line 1, position 15.", traceWriter.TraceRecords[1].Message);
 
242
    }
 
243
 
 
244
    [Test]
 
245
    public void ErrorDeserializingNested()
 
246
    {
 
247
      string json = @"{""IntList"":[1, ""two""]}";
 
248
 
 
249
      var traceWriter = new InMemoryTraceWriter
 
250
      {
 
251
        LevelFilter = TraceLevel.Info
 
252
      };
 
253
 
 
254
      ExceptionAssert.Throws<Exception>(
 
255
        "Could not convert string to integer: two. Path 'IntList[1]', line 1, position 20.",
 
256
        () =>
 
257
        {
 
258
          JsonConvert.DeserializeObject<TraceTestObject>(
 
259
            json,
 
260
            new JsonSerializerSettings
 
261
            {
 
262
              TraceWriter = traceWriter
 
263
            });
 
264
        });
 
265
 
 
266
      Assert.AreEqual(3, traceWriter.TraceRecords.Count);
 
267
 
 
268
      Assert.AreEqual(TraceLevel.Info, traceWriter.TraceRecords[0].Level);
 
269
      Assert.AreEqual("Started deserializing Newtonsoft.Json.Tests.Serialization.TraceTestObject. Path 'IntList', line 1, position 11.", traceWriter.TraceRecords[0].Message);
 
270
 
 
271
      Assert.AreEqual(TraceLevel.Info, traceWriter.TraceRecords[1].Level);
 
272
      Assert.AreEqual("Started deserializing System.Collections.Generic.IList`1[System.Int32]. Path 'IntList', line 1, position 12.", traceWriter.TraceRecords[1].Message);
 
273
 
 
274
      Assert.AreEqual(TraceLevel.Error, traceWriter.TraceRecords[2].Level);
 
275
      Assert.AreEqual("Error deserializing System.Collections.Generic.IList`1[System.Int32]. Could not convert string to integer: two. Path 'IntList[1]', line 1, position 20.", traceWriter.TraceRecords[2].Message);
 
276
    }
 
277
 
 
278
    [Test]
 
279
    public void SerializeDictionarysWithPreserveObjectReferences()
 
280
    {
 
281
      PreserveReferencesHandlingTests.CircularDictionary circularDictionary = new PreserveReferencesHandlingTests.CircularDictionary();
 
282
      circularDictionary.Add("other", new PreserveReferencesHandlingTests.CircularDictionary { { "blah", null } });
 
283
      circularDictionary.Add("self", circularDictionary);
 
284
 
 
285
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
286
      {
 
287
        LevelFilter = TraceLevel.Verbose
 
288
      };
 
289
 
 
290
      JsonConvert.SerializeObject(
 
291
        circularDictionary,
 
292
        Formatting.Indented,
 
293
        new JsonSerializerSettings
 
294
          {
 
295
            PreserveReferencesHandling = PreserveReferencesHandling.All,
 
296
            TraceWriter = traceWriter
 
297
          });
 
298
 
 
299
      Assert.IsTrue(traceWriter.TraceRecords.Any(r => r.Message == "Writing object reference Id '1' for Newtonsoft.Json.Tests.Serialization.PreserveReferencesHandlingTests+CircularDictionary. Path ''."));
 
300
      Assert.IsTrue(traceWriter.TraceRecords.Any(r => r.Message == "Writing object reference Id '2' for Newtonsoft.Json.Tests.Serialization.PreserveReferencesHandlingTests+CircularDictionary. Path 'other'."));
 
301
      Assert.IsTrue(traceWriter.TraceRecords.Any(r => r.Message == "Writing object reference to Id '1' for Newtonsoft.Json.Tests.Serialization.PreserveReferencesHandlingTests+CircularDictionary. Path 'self'."));
 
302
    }
 
303
 
 
304
    [Test]
 
305
    public void DeserializeDictionarysWithPreserveObjectReferences()
 
306
    {
 
307
      string json = @"{
 
308
  ""$id"": ""1"",
 
309
  ""other"": {
 
310
    ""$id"": ""2"",
 
311
    ""blah"": null
 
312
  },
 
313
  ""self"": {
 
314
    ""$ref"": ""1""
 
315
  }
 
316
}";
 
317
 
 
318
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
319
      {
 
320
        LevelFilter = TraceLevel.Verbose
 
321
      };
 
322
 
 
323
      JsonConvert.DeserializeObject<PreserveReferencesHandlingTests.CircularDictionary>(json,
 
324
        new JsonSerializerSettings
 
325
        {
 
326
          PreserveReferencesHandling = PreserveReferencesHandling.All,
 
327
          TraceWriter = traceWriter
 
328
        });
 
329
 
 
330
      Assert.IsTrue(traceWriter.TraceRecords.Any(r => r.Message == "Read object reference Id '1' for Newtonsoft.Json.Tests.Serialization.PreserveReferencesHandlingTests+CircularDictionary. Path 'other', line 3, position 11."));
 
331
      Assert.IsTrue(traceWriter.TraceRecords.Any(r => r.Message == "Read object reference Id '2' for Newtonsoft.Json.Tests.Serialization.PreserveReferencesHandlingTests+CircularDictionary. Path 'other.blah', line 5, position 12."));
 
332
      Assert.IsTrue(traceWriter.TraceRecords.Any(r => r.Message == "Resolved object reference '1' to Newtonsoft.Json.Tests.Serialization.PreserveReferencesHandlingTests+CircularDictionary. Path 'self', line 9, position 4."));
 
333
    }
 
334
 
 
335
    [Test]
 
336
    public void WriteTypeNameForObjects()
 
337
    {
 
338
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
339
      {
 
340
        LevelFilter = TraceLevel.Verbose
 
341
      };
 
342
 
 
343
      IList<object> l = new List<object>
 
344
                          {
 
345
                            new Dictionary<string, string> { {"key!", "value!"}},
 
346
                            new Version(1, 2, 3, 4)
 
347
                          };
 
348
 
 
349
      JsonConvert.SerializeObject(l, Formatting.Indented, new JsonSerializerSettings
 
350
      {
 
351
        TypeNameHandling = TypeNameHandling.All,
 
352
        TraceWriter = traceWriter
 
353
      });
 
354
 
 
355
      Assert.AreEqual("Started serializing System.Collections.Generic.List`1[System.Object]. Path ''.", traceWriter.TraceRecords[0].Message);
 
356
      Assert.AreEqual("Writing type name 'System.Collections.Generic.List`1[[System.Object, mscorlib]], mscorlib' for System.Collections.Generic.List`1[System.Object]. Path ''.", traceWriter.TraceRecords[1].Message);
 
357
      Assert.AreEqual("Started serializing System.Collections.Generic.Dictionary`2[System.String,System.String]. Path '$values'.", traceWriter.TraceRecords[2].Message);
 
358
      Assert.AreEqual("Writing type name 'System.Collections.Generic.Dictionary`2[[System.String, mscorlib],[System.String, mscorlib]], mscorlib' for System.Collections.Generic.Dictionary`2[System.String,System.String]. Path '$values[0]'.", traceWriter.TraceRecords[3].Message);
 
359
      Assert.AreEqual("Finished serializing System.Collections.Generic.Dictionary`2[System.String,System.String]. Path '$values[0]'.", traceWriter.TraceRecords[4].Message);
 
360
      Assert.AreEqual("Started serializing System.Version. Path '$values[0]'.", traceWriter.TraceRecords[5].Message);
 
361
      Assert.AreEqual("Writing type name 'System.Version, mscorlib' for System.Version. Path '$values[1]'.", traceWriter.TraceRecords[6].Message);
 
362
      Assert.AreEqual("Finished serializing System.Version. Path '$values[1]'.", traceWriter.TraceRecords[7].Message);
 
363
      Assert.AreEqual("Finished serializing System.Collections.Generic.List`1[System.Object]. Path ''.", traceWriter.TraceRecords[8].Message);
 
364
    }
 
365
 
 
366
    [Test]
 
367
    public void SerializeConverter()
 
368
    {
 
369
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
370
      {
 
371
        LevelFilter = TraceLevel.Verbose
 
372
      };
 
373
 
 
374
      IList<DateTime> d = new List<DateTime>
 
375
                          {
 
376
                            new DateTime(2000, 12, 12, 12, 12, 12, DateTimeKind.Utc)
 
377
                          };
 
378
 
 
379
      string json = JsonConvert.SerializeObject(d, Formatting.Indented, new JsonSerializerSettings
 
380
      {
 
381
        Converters = { new JavaScriptDateTimeConverter() },
 
382
        TraceWriter = traceWriter
 
383
      });
 
384
 
 
385
      Assert.AreEqual("Started serializing System.Collections.Generic.List`1[System.DateTime]. Path ''.", traceWriter.TraceRecords[0].Message);
 
386
      Assert.AreEqual("Started serializing System.DateTime with converter Newtonsoft.Json.Converters.JavaScriptDateTimeConverter. Path ''.", traceWriter.TraceRecords[1].Message);
 
387
      Assert.AreEqual("Finished serializing System.DateTime with converter Newtonsoft.Json.Converters.JavaScriptDateTimeConverter. Path '[0]'.", traceWriter.TraceRecords[2].Message);
 
388
      Assert.AreEqual("Finished serializing System.Collections.Generic.List`1[System.DateTime]. Path ''.", traceWriter.TraceRecords[3].Message);
 
389
    }
 
390
 
 
391
    [Test]
 
392
    public void DeserializeConverter()
 
393
    {
 
394
      string json = @"[new Date(976623132000)]";
 
395
 
 
396
      InMemoryTraceWriter traceWriter =
 
397
        new InMemoryTraceWriter
 
398
          {
 
399
            LevelFilter = TraceLevel.Verbose
 
400
          };
 
401
 
 
402
      JsonConvert.DeserializeObject<List<DateTime>>(
 
403
        json,
 
404
        new JsonSerializerSettings
 
405
          {
 
406
            Converters = {new JavaScriptDateTimeConverter()},
 
407
            TraceWriter = traceWriter
 
408
          });
 
409
 
 
410
      Assert.AreEqual("Started deserializing System.Collections.Generic.List`1[System.DateTime]. Path '', line 1, position 1.", traceWriter.TraceRecords[0].Message);
 
411
      Assert.AreEqual("Started deserializing System.DateTime with converter Newtonsoft.Json.Converters.JavaScriptDateTimeConverter. Path '[0]', line 1, position 10.", traceWriter.TraceRecords[1].Message);
 
412
      Assert.AreEqual("Finished deserializing System.DateTime with converter Newtonsoft.Json.Converters.JavaScriptDateTimeConverter. Path '[0]', line 1, position 23.", traceWriter.TraceRecords[2].Message);
 
413
      Assert.AreEqual("Finished deserializing System.Collections.Generic.List`1[System.DateTime]. Path '', line 1, position 24.", traceWriter.TraceRecords[3].Message);
 
414
    }
 
415
 
 
416
    [Test]
 
417
    public void DeserializeTypeName()
 
418
    {
 
419
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
420
                                          {
 
421
                                            LevelFilter = TraceLevel.Verbose
 
422
                                          };
 
423
 
 
424
      string json = @"{
 
425
  ""$type"": ""System.Collections.Generic.List`1[[System.Object, mscorlib]], mscorlib"",
 
426
  ""$values"": [
 
427
    {
 
428
      ""$type"": ""System.Collections.Generic.Dictionary`2[[System.String, mscorlib],[System.String, mscorlib]], mscorlib"",
 
429
      ""key!"": ""value!""
 
430
    },
 
431
    {
 
432
      ""$type"": ""System.Version, mscorlib"",
 
433
      ""Major"": 1,
 
434
      ""Minor"": 2,
 
435
      ""Build"": 3,
 
436
      ""Revision"": 4,
 
437
      ""MajorRevision"": 0,
 
438
      ""MinorRevision"": 4
 
439
    }
 
440
  ]
 
441
}";
 
442
 
 
443
      JsonConvert.DeserializeObject(json, null, new JsonSerializerSettings
 
444
                                                  {
 
445
                                                    TypeNameHandling = TypeNameHandling.All,
 
446
                                                    TraceWriter = traceWriter
 
447
                                                  });
 
448
 
 
449
      Assert.AreEqual("Resolved type 'System.Collections.Generic.List`1[[System.Object, mscorlib]], mscorlib' to System.Collections.Generic.List`1[System.Object]. Path '$type', line 2, position 84.", traceWriter.TraceRecords[0].Message);
 
450
      Assert.AreEqual("Started deserializing System.Collections.Generic.List`1[System.Object]. Path '$values', line 3, position 15.", traceWriter.TraceRecords[1].Message);
 
451
      Assert.AreEqual("Resolved type 'System.Collections.Generic.Dictionary`2[[System.String, mscorlib],[System.String, mscorlib]], mscorlib' to System.Collections.Generic.Dictionary`2[System.String,System.String]. Path '$values[0].$type', line 5, position 120.", traceWriter.TraceRecords[2].Message);
 
452
      Assert.AreEqual("Started deserializing System.Collections.Generic.Dictionary`2[System.String,System.String]. Path '$values[0].key!', line 6, position 14.", traceWriter.TraceRecords[3].Message);
 
453
      Assert.AreEqual("Finished deserializing System.Collections.Generic.Dictionary`2[System.String,System.String]. Path '$values[0]', line 7, position 6.", traceWriter.TraceRecords[4].Message);
 
454
      Assert.AreEqual("Resolved type 'System.Version, mscorlib' to System.Version. Path '$values[1].$type', line 9, position 42.", traceWriter.TraceRecords[5].Message);
 
455
      Assert.AreEqual("Deserializing System.Version using a non-default constructor 'Void .ctor(Int32, Int32, Int32, Int32)'. Path '$values[1].Major', line 10, position 15.", traceWriter.TraceRecords[6].Message);
 
456
      Assert.AreEqual("Started deserializing System.Version. Path '$values[1]', line 16, position 6.", traceWriter.TraceRecords[7].Message);
 
457
      Assert.AreEqual("Finished deserializing System.Version. Path '$values[1]', line 16, position 6.", traceWriter.TraceRecords[8].Message);
 
458
      Assert.AreEqual("Finished deserializing System.Collections.Generic.List`1[System.Object]. Path '$values', line 17, position 4.", traceWriter.TraceRecords[9].Message);
 
459
    }
 
460
 
 
461
#if !(NETFX_CORE || PORTABLE || SILVERLIGHT)
 
462
    [Test]
 
463
    public void DeserializeISerializable()
 
464
    {
 
465
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
466
                                          {
 
467
                                            LevelFilter = TraceLevel.Verbose
 
468
                                          };
 
469
 
 
470
      ExceptionAssert.Throws<SerializationException>(
 
471
        "Member 'ClassName' was not found.",
 
472
        () =>
 
473
          {
 
474
            JsonConvert.DeserializeObject<Exception>(
 
475
              "{}",
 
476
              new JsonSerializerSettings
 
477
                {
 
478
                  TraceWriter = traceWriter
 
479
                });
 
480
          });
 
481
 
 
482
      Assert.AreEqual("Deserializing System.Exception using ISerializable constructor. Path '', line 1, position 2.", traceWriter.TraceRecords[0].Message);
 
483
      Assert.AreEqual(TraceLevel.Info, traceWriter.TraceRecords[0].Level);
 
484
      Assert.AreEqual("Error deserializing System.Exception. Member 'ClassName' was not found. Path '', line 1, position 2.", traceWriter.TraceRecords[1].Message);
 
485
      Assert.AreEqual(TraceLevel.Error, traceWriter.TraceRecords[1].Level);
 
486
    }
 
487
#endif
 
488
 
 
489
    [Test]
 
490
    public void DeserializeMissingMember()
 
491
    {
 
492
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
493
                                          {
 
494
                                            LevelFilter = TraceLevel.Verbose
 
495
                                          };
 
496
 
 
497
      JsonConvert.DeserializeObject<Person>(
 
498
        "{'MissingMemberProperty':'!!'}",
 
499
        new JsonSerializerSettings
 
500
          {
 
501
            TraceWriter = traceWriter
 
502
          });
 
503
 
 
504
      Assert.AreEqual("Started deserializing Newtonsoft.Json.Tests.TestObjects.Person. Path 'MissingMemberProperty', line 1, position 25.", traceWriter.TraceRecords[0].Message);
 
505
      Assert.AreEqual("Could not find member 'MissingMemberProperty' on Newtonsoft.Json.Tests.TestObjects.Person. Path 'MissingMemberProperty', line 1, position 25.", traceWriter.TraceRecords[1].Message);
 
506
      Assert.AreEqual("Finished deserializing Newtonsoft.Json.Tests.TestObjects.Person. Path '', line 1, position 30.", traceWriter.TraceRecords[2].Message);
 
507
    }
 
508
 
 
509
    [Test]
 
510
    public void DeserializeMissingMemberConstructor()
 
511
    {
 
512
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
513
      {
 
514
        LevelFilter = TraceLevel.Verbose
 
515
      };
 
516
 
 
517
      string json = @"{
 
518
  ""Major"": 1,
 
519
  ""Minor"": 2,
 
520
  ""Build"": 3,
 
521
  ""Revision"": 4,
 
522
  ""MajorRevision"": 0,
 
523
  ""MinorRevision"": 4,
 
524
  ""MissingMemberProperty"": null
 
525
}";
 
526
 
 
527
      JsonConvert.DeserializeObject<Version>(json, new JsonSerializerSettings
 
528
      {
 
529
        TraceWriter = traceWriter
 
530
      });
 
531
 
 
532
      Assert.AreEqual("Deserializing System.Version using a non-default constructor 'Void .ctor(Int32, Int32, Int32, Int32)'. Path 'Major', line 2, position 11.", traceWriter.TraceRecords[0].Message);
 
533
      Assert.AreEqual("Could not find member 'MissingMemberProperty' on System.Version. Path 'MissingMemberProperty', line 8, position 32.", traceWriter.TraceRecords[1].Message);
 
534
      Assert.AreEqual("Started deserializing System.Version. Path '', line 9, position 2.", traceWriter.TraceRecords[2].Message);
 
535
      Assert.AreEqual("Finished deserializing System.Version. Path '', line 9, position 2.", traceWriter.TraceRecords[3].Message);
 
536
    }
 
537
 
 
538
    [Test]
 
539
    public void ShouldSerializeTestClass()
 
540
    {
 
541
      ShouldSerializeTestClass c = new ShouldSerializeTestClass();
 
542
      c.Age = 29;
 
543
      c.Name = "Jim";
 
544
      c._shouldSerializeName = true;
 
545
 
 
546
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter 
 
547
      {
 
548
        LevelFilter = TraceLevel.Verbose
 
549
      };
 
550
 
 
551
      JsonConvert.SerializeObject(c, new JsonSerializerSettings {TraceWriter = traceWriter});
 
552
 
 
553
      Assert.AreEqual("ShouldSerialize result for property 'Name' on Newtonsoft.Json.Tests.Serialization.ShouldSerializeTestClass: True. Path ''.", traceWriter.TraceRecords[1].Message);
 
554
      Assert.AreEqual(TraceLevel.Verbose, traceWriter.TraceRecords[1].Level);
 
555
 
 
556
      traceWriter = new InMemoryTraceWriter
 
557
      {
 
558
        LevelFilter = TraceLevel.Verbose
 
559
      };
 
560
 
 
561
      c._shouldSerializeName = false;
 
562
 
 
563
      JsonConvert.SerializeObject(c, new JsonSerializerSettings { TraceWriter = traceWriter });
 
564
 
 
565
      Assert.AreEqual("ShouldSerialize result for property 'Name' on Newtonsoft.Json.Tests.Serialization.ShouldSerializeTestClass: False. Path ''.", traceWriter.TraceRecords[1].Message);
 
566
      Assert.AreEqual(TraceLevel.Verbose, traceWriter.TraceRecords[1].Level);
 
567
    }
 
568
 
 
569
    [Test]
 
570
    public void SpecifiedTest()
 
571
    {
 
572
      SpecifiedTestClass c = new SpecifiedTestClass();
 
573
      c.Name = "James";
 
574
      c.Age = 27;
 
575
      c.NameSpecified = false;
 
576
 
 
577
      InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
 
578
      {
 
579
        LevelFilter = TraceLevel.Verbose
 
580
      };
 
581
 
 
582
      string json = JsonConvert.SerializeObject(c, Formatting.Indented, new JsonSerializerSettings { TraceWriter = traceWriter });
 
583
 
 
584
      Assert.AreEqual("Started serializing Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass. Path ''.", traceWriter.TraceRecords[0].Message);
 
585
      Assert.AreEqual("IsSpecified result for property 'Name' on Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass: False. Path ''.", traceWriter.TraceRecords[1].Message);
 
586
      Assert.AreEqual("IsSpecified result for property 'Weight' on Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass: False. Path 'Age'.", traceWriter.TraceRecords[2].Message);
 
587
      Assert.AreEqual("IsSpecified result for property 'Height' on Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass: False. Path 'Age'.", traceWriter.TraceRecords[3].Message);
 
588
      Assert.AreEqual("IsSpecified result for property 'FavoriteNumber' on Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass: False. Path 'Age'.", traceWriter.TraceRecords[4].Message);
 
589
      Assert.AreEqual("Finished serializing Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass. Path ''.", traceWriter.TraceRecords[5].Message);
 
590
 
 
591
      Assert.AreEqual(@"{
 
592
  ""Age"": 27
 
593
}", json);
 
594
 
 
595
      traceWriter = new InMemoryTraceWriter
 
596
      {
 
597
        LevelFilter = TraceLevel.Verbose
 
598
      };
 
599
 
 
600
      SpecifiedTestClass deserialized = JsonConvert.DeserializeObject<SpecifiedTestClass>(json, new JsonSerializerSettings { TraceWriter = traceWriter });
 
601
 
 
602
      Assert.AreEqual("Started deserializing Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass. Path 'Age', line 2, position 9.", traceWriter.TraceRecords[0].Message);
 
603
      Assert.AreEqual("Finished deserializing Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass. Path '', line 3, position 2.", traceWriter.TraceRecords[1].Message);
 
604
 
 
605
      Assert.IsNull(deserialized.Name);
 
606
      Assert.IsFalse(deserialized.NameSpecified);
 
607
      Assert.IsFalse(deserialized.WeightSpecified);
 
608
      Assert.IsFalse(deserialized.HeightSpecified);
 
609
      Assert.IsFalse(deserialized.FavoriteNumberSpecified);
 
610
      Assert.AreEqual(27, deserialized.Age);
 
611
 
 
612
      c.NameSpecified = true;
 
613
      c.WeightSpecified = true;
 
614
      c.HeightSpecified = true;
 
615
      c.FavoriteNumber = 23;
 
616
      json = JsonConvert.SerializeObject(c, Formatting.Indented);
 
617
 
 
618
      Assert.AreEqual(@"{
 
619
  ""Name"": ""James"",
 
620
  ""Age"": 27,
 
621
  ""Weight"": 0,
 
622
  ""Height"": 0,
 
623
  ""FavoriteNumber"": 23
 
624
}", json);
 
625
 
 
626
      traceWriter = new InMemoryTraceWriter
 
627
      {
 
628
        LevelFilter = TraceLevel.Verbose
 
629
      };
 
630
 
 
631
      deserialized = JsonConvert.DeserializeObject<SpecifiedTestClass>(json, new JsonSerializerSettings { TraceWriter = traceWriter });
 
632
 
 
633
      Assert.AreEqual("Started deserializing Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass. Path 'Name', line 2, position 10.", traceWriter.TraceRecords[0].Message);
 
634
      Assert.AreEqual("IsSpecified for property 'Name' on Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass set to true. Path 'Name', line 2, position 18.", traceWriter.TraceRecords[1].Message);
 
635
      Assert.AreEqual("IsSpecified for property 'Weight' on Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass set to true. Path 'Weight', line 4, position 14.", traceWriter.TraceRecords[2].Message);
 
636
      Assert.AreEqual("IsSpecified for property 'Height' on Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass set to true. Path 'Height', line 5, position 14.", traceWriter.TraceRecords[3].Message);
 
637
      Assert.AreEqual("Finished deserializing Newtonsoft.Json.Tests.Serialization.SpecifiedTestClass. Path '', line 7, position 2.", traceWriter.TraceRecords[4].Message);
 
638
 
 
639
      Assert.AreEqual("James", deserialized.Name);
 
640
      Assert.IsTrue(deserialized.NameSpecified);
 
641
      Assert.IsTrue(deserialized.WeightSpecified);
 
642
      Assert.IsTrue(deserialized.HeightSpecified);
 
643
      Assert.IsTrue(deserialized.FavoriteNumberSpecified);
 
644
      Assert.AreEqual(27, deserialized.Age);
 
645
      Assert.AreEqual(23, deserialized.FavoriteNumber);
 
646
    }
 
647
  }
 
648
 
 
649
  public class TraceRecord
 
650
  {
 
651
    public string Message { get; set; }
 
652
    public TraceLevel Level { get; set; }
 
653
    public Exception Exception { get; set; }
 
654
 
 
655
    public override string ToString()
 
656
    {
 
657
      return Level + " - " + Message;
 
658
    }
 
659
  }
 
660
 
 
661
  public class InMemoryTraceWriter : ITraceWriter
 
662
  {
 
663
    public TraceLevel LevelFilter { get; set; }
 
664
    public IList<TraceRecord> TraceRecords { get; set; }
 
665
 
 
666
    public InMemoryTraceWriter()
 
667
    {
 
668
      LevelFilter = TraceLevel.Verbose;
 
669
      TraceRecords = new List<TraceRecord>();
 
670
    }
 
671
 
 
672
    public void Trace(TraceLevel level, string message, Exception ex)
 
673
    {
 
674
      TraceRecords.Add(
 
675
        new TraceRecord
 
676
        {
 
677
          Level = level,
 
678
          Message = message,
 
679
          Exception = ex
 
680
        });
 
681
    }
 
682
 
 
683
    public override string ToString()
 
684
    {
 
685
      StringBuilder sb = new StringBuilder();
 
686
      foreach (var traceRecord in TraceRecords)
 
687
      {
 
688
        sb.AppendLine(traceRecord.Message);
 
689
      }
 
690
 
 
691
      return sb.ToString();
 
692
    }
 
693
  }
 
694
 
 
695
  public class TraceTestObject
 
696
  {
 
697
    public IList<int> IntList { get; set; }
 
698
    public string[] StringArray { get; set; }
 
699
    public Version Version { get; set; }
 
700
    public IDictionary<string, string> StringDictionary { get; set; }
 
701
  }
 
702
 
 
703
  public class IntegerTestClass
 
704
  {
 
705
    public int Integer { get; set; }
 
706
  }
 
707
}
 
 
b'\\ No newline at end of file'