← 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/Linq/JTokenReaderTest.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/Linq/JTokenReaderTest.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.Text;
 
29
#if !NETFX_CORE
 
30
using NUnit.Framework;
 
31
#else
 
32
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
 
33
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
 
34
using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
 
35
#endif
 
36
using Newtonsoft.Json;
 
37
using System.IO;
 
38
using Newtonsoft.Json.Linq;
 
39
using Newtonsoft.Json.Tests.Serialization;
 
40
using Newtonsoft.Json.Tests.TestObjects;
 
41
 
 
42
namespace Newtonsoft.Json.Tests.Linq
 
43
{
 
44
  [TestFixture]
 
45
  public class JTokenReaderTest : TestFixtureBase
 
46
  {
 
47
#if !PocketPC && !NET20
 
48
    [Test]
 
49
    public void YahooFinance()
 
50
    {
 
51
      JObject o =
 
52
        new JObject(
 
53
          new JProperty("Test1", new DateTime(2000, 10, 15, 5, 5, 5, DateTimeKind.Utc)),
 
54
          new JProperty("Test2", new DateTimeOffset(2000, 10, 15, 5, 5, 5, new TimeSpan(11, 11, 0))),
 
55
          new JProperty("Test3", "Test3Value"),
 
56
          new JProperty("Test4", null)
 
57
        );
 
58
 
 
59
      using (JTokenReader jsonReader = new JTokenReader(o))
 
60
      {
 
61
        IJsonLineInfo lineInfo = jsonReader;
 
62
 
 
63
        jsonReader.Read();
 
64
        Assert.AreEqual(JsonToken.StartObject, jsonReader.TokenType);
 
65
        Assert.AreEqual(false, lineInfo.HasLineInfo());
 
66
 
 
67
        jsonReader.Read();
 
68
        Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);
 
69
        Assert.AreEqual("Test1", jsonReader.Value);
 
70
        Assert.AreEqual(false, lineInfo.HasLineInfo());
 
71
 
 
72
        jsonReader.Read();
 
73
        Assert.AreEqual(JsonToken.Date, jsonReader.TokenType);
 
74
        Assert.AreEqual(new DateTime(2000, 10, 15, 5, 5, 5, DateTimeKind.Utc), jsonReader.Value);
 
75
        Assert.AreEqual(false, lineInfo.HasLineInfo());
 
76
        Assert.AreEqual(0, lineInfo.LinePosition);
 
77
        Assert.AreEqual(0, lineInfo.LineNumber);
 
78
 
 
79
        jsonReader.Read();
 
80
        Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);
 
81
        Assert.AreEqual("Test2", jsonReader.Value);
 
82
 
 
83
        jsonReader.Read();
 
84
        Assert.AreEqual(JsonToken.Date, jsonReader.TokenType);
 
85
        Assert.AreEqual(new DateTimeOffset(2000, 10, 15, 5, 5, 5, new TimeSpan(11, 11, 0)), jsonReader.Value);
 
86
 
 
87
        jsonReader.Read();
 
88
        Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);
 
89
        Assert.AreEqual("Test3", jsonReader.Value);
 
90
 
 
91
        jsonReader.Read();
 
92
        Assert.AreEqual(JsonToken.String, jsonReader.TokenType);
 
93
        Assert.AreEqual("Test3Value", jsonReader.Value);
 
94
 
 
95
        jsonReader.Read();
 
96
        Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);
 
97
        Assert.AreEqual("Test4", jsonReader.Value);
 
98
 
 
99
        jsonReader.Read();
 
100
        Assert.AreEqual(JsonToken.Null, jsonReader.TokenType);
 
101
        Assert.AreEqual(null, jsonReader.Value);
 
102
 
 
103
        Assert.IsTrue(jsonReader.Read());
 
104
        Assert.AreEqual(JsonToken.EndObject, jsonReader.TokenType);
 
105
 
 
106
        Assert.IsFalse(jsonReader.Read());
 
107
        Assert.AreEqual(JsonToken.None, jsonReader.TokenType);
 
108
      }
 
109
 
 
110
      using (JsonReader jsonReader = new JTokenReader(o.Property("Test2")))
 
111
      {
 
112
        Assert.IsTrue(jsonReader.Read());
 
113
        Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);
 
114
        Assert.AreEqual("Test2", jsonReader.Value);
 
115
 
 
116
        Assert.IsTrue(jsonReader.Read());
 
117
        Assert.AreEqual(JsonToken.Date, jsonReader.TokenType);
 
118
        Assert.AreEqual(new DateTimeOffset(2000, 10, 15, 5, 5, 5, new TimeSpan(11, 11, 0)), jsonReader.Value);
 
119
 
 
120
        Assert.IsFalse(jsonReader.Read());
 
121
        Assert.AreEqual(JsonToken.None, jsonReader.TokenType);
 
122
      }
 
123
    }
 
124
 
 
125
    [Test]
 
126
    public void ReadAsDateTimeOffsetBadString()
 
127
    {
 
128
      string json = @"{""Offset"":""blablahbla""}";
 
129
 
 
130
      JObject o = JObject.Parse(json);
 
131
 
 
132
      JsonReader reader = o.CreateReader();
 
133
 
 
134
      Assert.IsTrue(reader.Read());
 
135
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
136
 
 
137
      Assert.IsTrue(reader.Read());
 
138
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
139
 
 
140
      ExceptionAssert.Throws<JsonReaderException>(
 
141
        "Could not convert string to DateTimeOffset: blablahbla. Path 'Offset', line 1, position 22.",
 
142
        () =>
 
143
          {
 
144
            reader.ReadAsDateTimeOffset();
 
145
          });
 
146
    }
 
147
 
 
148
    [Test]
 
149
    public void ReadAsDateTimeOffsetBoolean()
 
150
    {
 
151
      string json = @"{""Offset"":true}";
 
152
 
 
153
      JObject o = JObject.Parse(json);
 
154
 
 
155
      JsonReader reader = o.CreateReader();
 
156
 
 
157
      Assert.IsTrue(reader.Read());
 
158
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
159
 
 
160
      Assert.IsTrue(reader.Read());
 
161
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
162
 
 
163
      ExceptionAssert.Throws<JsonReaderException>(
 
164
        "Error reading date. Unexpected token: Boolean. Path 'Offset', line 1, position 14.",
 
165
        () =>
 
166
        {
 
167
          reader.ReadAsDateTimeOffset();
 
168
        });
 
169
    }
 
170
 
 
171
    [Test]
 
172
    public void ReadAsDateTimeOffsetString()
 
173
    {
 
174
      string json = @"{""Offset"":""2012-01-24T03:50Z""}";
 
175
 
 
176
      JObject o = JObject.Parse(json);
 
177
 
 
178
      JsonReader reader = o.CreateReader();
 
179
 
 
180
      Assert.IsTrue(reader.Read());
 
181
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
182
 
 
183
      Assert.IsTrue(reader.Read());
 
184
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
185
 
 
186
      reader.ReadAsDateTimeOffset();
 
187
      Assert.AreEqual(JsonToken.Date, reader.TokenType);
 
188
      Assert.AreEqual(typeof (DateTimeOffset), reader.ValueType);
 
189
      Assert.AreEqual(new DateTimeOffset(2012, 1, 24, 3, 50, 0, TimeSpan.Zero), reader.Value);
 
190
    }
 
191
#endif
 
192
 
 
193
    [Test]
 
194
    public void ReadLineInfo()
 
195
    {
 
196
      string input = @"{
 
197
  CPU: 'Intel',
 
198
  Drives: [
 
199
    'DVD read/writer',
 
200
    ""500 gigabyte hard drive""
 
201
  ]
 
202
}";
 
203
 
 
204
      StringReader sr = new StringReader(input);
 
205
 
 
206
      JObject o = JObject.Parse(input);
 
207
 
 
208
      using (JTokenReader jsonReader = new JTokenReader(o))
 
209
      {
 
210
        IJsonLineInfo lineInfo = jsonReader;
 
211
 
 
212
        Assert.AreEqual(jsonReader.TokenType, JsonToken.None);
 
213
        Assert.AreEqual(0, lineInfo.LineNumber);
 
214
        Assert.AreEqual(0, lineInfo.LinePosition);
 
215
        Assert.AreEqual(false, lineInfo.HasLineInfo());
 
216
 
 
217
        jsonReader.Read();
 
218
        Assert.AreEqual(jsonReader.TokenType, JsonToken.StartObject);
 
219
        Assert.AreEqual(1, lineInfo.LineNumber);
 
220
        Assert.AreEqual(1, lineInfo.LinePosition);
 
221
        Assert.AreEqual(true, lineInfo.HasLineInfo());
 
222
 
 
223
        jsonReader.Read();
 
224
        Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);
 
225
        Assert.AreEqual(jsonReader.Value, "CPU");
 
226
        Assert.AreEqual(2, lineInfo.LineNumber);
 
227
        Assert.AreEqual(7, lineInfo.LinePosition);
 
228
        Assert.AreEqual(true, lineInfo.HasLineInfo());
 
229
 
 
230
        jsonReader.Read();
 
231
        Assert.AreEqual(jsonReader.TokenType, JsonToken.String);
 
232
        Assert.AreEqual(jsonReader.Value, "Intel");
 
233
        Assert.AreEqual(2, lineInfo.LineNumber);
 
234
        Assert.AreEqual(15, lineInfo.LinePosition);
 
235
        Assert.AreEqual(true, lineInfo.HasLineInfo());
 
236
 
 
237
        jsonReader.Read();
 
238
        Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);
 
239
        Assert.AreEqual(jsonReader.Value, "Drives");
 
240
        Assert.AreEqual(3, lineInfo.LineNumber);
 
241
        Assert.AreEqual(10, lineInfo.LinePosition);
 
242
        Assert.AreEqual(true, lineInfo.HasLineInfo());
 
243
 
 
244
        jsonReader.Read();
 
245
        Assert.AreEqual(jsonReader.TokenType, JsonToken.StartArray);
 
246
        Assert.AreEqual(3, lineInfo.LineNumber);
 
247
        Assert.AreEqual(12, lineInfo.LinePosition);
 
248
        Assert.AreEqual(true, lineInfo.HasLineInfo());
 
249
 
 
250
        jsonReader.Read();
 
251
        Assert.AreEqual(jsonReader.TokenType, JsonToken.String);
 
252
        Assert.AreEqual(jsonReader.Value, "DVD read/writer");
 
253
        Assert.AreEqual(4, lineInfo.LineNumber);
 
254
        Assert.AreEqual(22, lineInfo.LinePosition);
 
255
        Assert.AreEqual(true, lineInfo.HasLineInfo());
 
256
 
 
257
        jsonReader.Read();
 
258
        Assert.AreEqual(jsonReader.TokenType, JsonToken.String);
 
259
        Assert.AreEqual(jsonReader.Value, "500 gigabyte hard drive");
 
260
        Assert.AreEqual(5, lineInfo.LineNumber);
 
261
        Assert.AreEqual(30, lineInfo.LinePosition);
 
262
        Assert.AreEqual(true, lineInfo.HasLineInfo());
 
263
 
 
264
        jsonReader.Read();
 
265
        Assert.AreEqual(jsonReader.TokenType, JsonToken.EndArray);
 
266
        Assert.AreEqual(0, lineInfo.LineNumber);
 
267
        Assert.AreEqual(0, lineInfo.LinePosition);
 
268
        Assert.AreEqual(false, lineInfo.HasLineInfo());
 
269
 
 
270
        jsonReader.Read();
 
271
        Assert.AreEqual(jsonReader.TokenType, JsonToken.EndObject);
 
272
        Assert.AreEqual(0, lineInfo.LineNumber);
 
273
        Assert.AreEqual(0, lineInfo.LinePosition);
 
274
        Assert.AreEqual(false, lineInfo.HasLineInfo());
 
275
 
 
276
        jsonReader.Read();
 
277
        Assert.AreEqual(jsonReader.TokenType, JsonToken.None);
 
278
      }
 
279
    }
 
280
 
 
281
    [Test]
 
282
    public void ReadBytes()
 
283
    {
 
284
      byte[] data = Encoding.UTF8.GetBytes("Hello world!");
 
285
 
 
286
      JObject o =
 
287
        new JObject(
 
288
          new JProperty("Test1", data)
 
289
        );
 
290
 
 
291
      using (JTokenReader jsonReader = new JTokenReader(o))
 
292
      {
 
293
        jsonReader.Read();
 
294
        Assert.AreEqual(JsonToken.StartObject, jsonReader.TokenType);
 
295
 
 
296
        jsonReader.Read();
 
297
        Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);
 
298
        Assert.AreEqual("Test1", jsonReader.Value);
 
299
 
 
300
        byte[] readBytes = jsonReader.ReadAsBytes();
 
301
        Assert.AreEqual(data, readBytes);
 
302
 
 
303
        Assert.IsTrue(jsonReader.Read());
 
304
        Assert.AreEqual(JsonToken.EndObject, jsonReader.TokenType);
 
305
 
 
306
        Assert.IsFalse(jsonReader.Read());
 
307
        Assert.AreEqual(JsonToken.None, jsonReader.TokenType);
 
308
      }
 
309
    }
 
310
 
 
311
    [Test]
 
312
    public void ReadBytesFailure()
 
313
    {
 
314
      ExceptionAssert.Throws<JsonReaderException>(
 
315
        "Error reading bytes. Unexpected token: Integer. Path 'Test1'.",
 
316
        () =>
 
317
          {
 
318
            JObject o =
 
319
              new JObject(
 
320
                new JProperty("Test1", 1)
 
321
                );
 
322
 
 
323
            using (JTokenReader jsonReader = new JTokenReader(o))
 
324
            {
 
325
              jsonReader.Read();
 
326
              Assert.AreEqual(JsonToken.StartObject, jsonReader.TokenType);
 
327
 
 
328
              jsonReader.Read();
 
329
              Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);
 
330
              Assert.AreEqual("Test1", jsonReader.Value);
 
331
 
 
332
              jsonReader.ReadAsBytes();
 
333
            }
 
334
          });
 
335
    }
 
336
 
 
337
    public class HasBytes
 
338
    {
 
339
      public byte[] Bytes { get; set; }
 
340
    }
 
341
 
 
342
    [Test]
 
343
    public void ReadBytesFromString()
 
344
    {
 
345
      var bytes = new HasBytes { Bytes = new byte[] { 1, 2, 3, 4 } };
 
346
      var json = JsonConvert.SerializeObject(bytes);
 
347
 
 
348
      TextReader textReader = new StringReader(json);
 
349
      JsonReader jsonReader = new JsonTextReader(textReader);
 
350
 
 
351
      var jToken = JToken.ReadFrom(jsonReader);
 
352
 
 
353
      jsonReader = new JTokenReader(jToken);
 
354
 
 
355
      var result2 = (HasBytes)JsonSerializer.Create(null)
 
356
                 .Deserialize(jsonReader, typeof(HasBytes));
 
357
 
 
358
      CollectionAssert.AreEqual(new byte[] { 1, 2, 3, 4 }, result2.Bytes);
 
359
    }
 
360
 
 
361
    [Test]
 
362
    public void ReadBytesFromEmptyString()
 
363
    {
 
364
      var bytes = new HasBytes { Bytes = new byte[0] };
 
365
      var json = JsonConvert.SerializeObject(bytes);
 
366
 
 
367
      TextReader textReader = new StringReader(json);
 
368
      JsonReader jsonReader = new JsonTextReader(textReader);
 
369
 
 
370
      var jToken = JToken.ReadFrom(jsonReader);
 
371
 
 
372
      jsonReader = new JTokenReader(jToken);
 
373
 
 
374
      var result2 = (HasBytes)JsonSerializer.Create(null)
 
375
                 .Deserialize(jsonReader, typeof(HasBytes));
 
376
 
 
377
      CollectionAssert.AreEquivalent(new byte[0], result2.Bytes);
 
378
    }
 
379
 
 
380
    public class ReadAsBytesTestObject
 
381
    {
 
382
      public byte[] Data;
 
383
    }
 
384
 
 
385
    [Test]
 
386
    public void ReadAsBytesNull()
 
387
    {
 
388
      JsonSerializer s = new JsonSerializer();
 
389
 
 
390
      JToken nullToken = JToken.ReadFrom(new JsonTextReader(new StringReader("{ Data: null }")));
 
391
      ReadAsBytesTestObject x = s.Deserialize<ReadAsBytesTestObject>(new JTokenReader(nullToken));
 
392
      Assert.IsNull(x.Data);
 
393
    }
 
394
 
 
395
    [Test]
 
396
    public void DeserializeByteArrayWithTypeNameHandling()
 
397
    {
 
398
      TestObject test = new TestObject("Test", new byte[] { 72, 63, 62, 71, 92, 55 });
 
399
 
 
400
      string json = JsonConvert.SerializeObject(test, Formatting.Indented, new JsonSerializerSettings
 
401
        {
 
402
          TypeNameHandling = TypeNameHandling.All
 
403
        });
 
404
 
 
405
      JObject o = JObject.Parse(json);
 
406
 
 
407
      JsonSerializer serializer = new JsonSerializer();
 
408
      serializer.TypeNameHandling = TypeNameHandling.All;
 
409
 
 
410
      using (JsonReader nodeReader = o.CreateReader())
 
411
      {
 
412
        // Get exception here
 
413
        TestObject newObject = (TestObject)serializer.Deserialize(nodeReader);
 
414
 
 
415
        Assert.AreEqual("Test", newObject.Name);
 
416
        CollectionAssert.AreEquivalent(new byte[] { 72, 63, 62, 71, 92, 55 }, newObject.Data);
 
417
      }
 
418
    }
 
419
 
 
420
    [Test]
 
421
    public void DeserializeStringInt()
 
422
    {
 
423
      string json = @"{
 
424
  ""PreProperty"": ""99"",
 
425
  ""PostProperty"": ""-1""
 
426
}";
 
427
 
 
428
      JObject o = JObject.Parse(json);
 
429
 
 
430
      JsonSerializer serializer = new JsonSerializer();
 
431
 
 
432
      using (JsonReader nodeReader = o.CreateReader())
 
433
      {
 
434
        MyClass c = serializer.Deserialize<MyClass>(nodeReader);
 
435
 
 
436
        Assert.AreEqual(99, c.PreProperty);
 
437
        Assert.AreEqual(-1, c.PostProperty);
 
438
      }
 
439
    }
 
440
 
 
441
    [Test]
 
442
    public void ReadAsDecimalInt()
 
443
    {
 
444
      string json = @"{""Name"":1}";
 
445
 
 
446
      JObject o = JObject.Parse(json);
 
447
      
 
448
      JsonReader reader = o.CreateReader();
 
449
 
 
450
      Assert.IsTrue(reader.Read());
 
451
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
452
 
 
453
      Assert.IsTrue(reader.Read());
 
454
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
455
 
 
456
      reader.ReadAsDecimal();
 
457
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
458
      Assert.AreEqual(typeof(decimal), reader.ValueType);
 
459
      Assert.AreEqual(1m, reader.Value);
 
460
    }
 
461
 
 
462
    [Test]
 
463
    public void ReadAsInt32Int()
 
464
    {
 
465
      string json = @"{""Name"":1}";
 
466
 
 
467
      JObject o = JObject.Parse(json);
 
468
 
 
469
      JsonReader reader = o.CreateReader();
 
470
 
 
471
      Assert.IsTrue(reader.Read());
 
472
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
473
 
 
474
      Assert.IsTrue(reader.Read());
 
475
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
476
 
 
477
      reader.ReadAsInt32();
 
478
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
479
      Assert.AreEqual(typeof(int), reader.ValueType);
 
480
      Assert.AreEqual(1, reader.Value);
 
481
    }
 
482
 
 
483
    [Test]
 
484
    public void ReadAsInt32BadString()
 
485
    {
 
486
      string json = @"{""Name"":""hi""}";
 
487
 
 
488
      JObject o = JObject.Parse(json);
 
489
 
 
490
      JsonReader reader = o.CreateReader();
 
491
 
 
492
      Assert.IsTrue(reader.Read());
 
493
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
494
 
 
495
      Assert.IsTrue(reader.Read());
 
496
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
497
 
 
498
      ExceptionAssert.Throws<JsonReaderException>(
 
499
        "Could not convert string to integer: hi. Path 'Name', line 1, position 12.",
 
500
        () =>
 
501
          {
 
502
            reader.ReadAsInt32();
 
503
          });
 
504
    }
 
505
 
 
506
    [Test]
 
507
    public void ReadAsInt32Boolean()
 
508
    {
 
509
      string json = @"{""Name"":true}";
 
510
 
 
511
      JObject o = JObject.Parse(json);
 
512
 
 
513
      JsonReader reader = o.CreateReader();
 
514
 
 
515
      Assert.IsTrue(reader.Read());
 
516
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
517
 
 
518
      Assert.IsTrue(reader.Read());
 
519
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
520
 
 
521
      ExceptionAssert.Throws<JsonReaderException>(
 
522
        "Error reading integer. Unexpected token: Boolean. Path 'Name', line 1, position 12.",
 
523
        () =>
 
524
          {
 
525
            reader.ReadAsInt32();
 
526
          });
 
527
    }
 
528
 
 
529
    [Test]
 
530
    public void ReadAsDecimalString()
 
531
    {
 
532
      string json = @"{""Name"":""1.1""}";
 
533
 
 
534
      JObject o = JObject.Parse(json);
 
535
 
 
536
      JsonReader reader = o.CreateReader();
 
537
 
 
538
      Assert.IsTrue(reader.Read());
 
539
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
540
 
 
541
      Assert.IsTrue(reader.Read());
 
542
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
543
 
 
544
      reader.ReadAsDecimal();
 
545
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
546
      Assert.AreEqual(typeof(decimal), reader.ValueType);
 
547
      Assert.AreEqual(1.1m, reader.Value);
 
548
    }
 
549
 
 
550
    [Test]
 
551
    public void ReadAsDecimalBadString()
 
552
    {
 
553
      string json = @"{""Name"":""blah""}";
 
554
 
 
555
      JObject o = JObject.Parse(json);
 
556
 
 
557
      JsonReader reader = o.CreateReader();
 
558
 
 
559
      Assert.IsTrue(reader.Read());
 
560
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
561
 
 
562
      Assert.IsTrue(reader.Read());
 
563
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
564
 
 
565
      ExceptionAssert.Throws<JsonReaderException>(
 
566
        "Could not convert string to decimal: blah. Path 'Name', line 1, position 14.",
 
567
        () =>
 
568
        {
 
569
          reader.ReadAsDecimal();
 
570
        });
 
571
    }
 
572
 
 
573
    [Test]
 
574
    public void ReadAsDecimalBoolean()
 
575
    {
 
576
      string json = @"{""Name"":true}";
 
577
 
 
578
      JObject o = JObject.Parse(json);
 
579
 
 
580
      JsonReader reader = o.CreateReader();
 
581
 
 
582
      Assert.IsTrue(reader.Read());
 
583
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
584
 
 
585
      Assert.IsTrue(reader.Read());
 
586
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
587
 
 
588
      ExceptionAssert.Throws<JsonReaderException>(
 
589
        "Error reading decimal. Unexpected token: Boolean. Path 'Name', line 1, position 12.",
 
590
        () =>
 
591
          {
 
592
            reader.ReadAsDecimal();
 
593
          });
 
594
    }
 
595
 
 
596
    [Test]
 
597
    public void ReadAsDecimalNull()
 
598
    {
 
599
      string json = @"{""Name"":null}";
 
600
 
 
601
      JObject o = JObject.Parse(json);
 
602
 
 
603
      JsonReader reader = o.CreateReader();
 
604
 
 
605
      Assert.IsTrue(reader.Read());
 
606
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
607
 
 
608
      Assert.IsTrue(reader.Read());
 
609
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
610
 
 
611
      reader.ReadAsDecimal();
 
612
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
613
      Assert.AreEqual(null, reader.ValueType);
 
614
      Assert.AreEqual(null, reader.Value);
 
615
    }
 
616
  }
 
617
}
 
 
b'\\ No newline at end of file'