← 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/JsonValidatingReaderTests.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/JsonValidatingReaderTests.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
#if NET20
 
30
using Newtonsoft.Json.Utilities.LinqBridge;
 
31
#endif
 
32
using System.Text;
 
33
#if !NETFX_CORE
 
34
using NUnit.Framework;
 
35
#else
 
36
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
 
37
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
 
38
using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
 
39
#endif
 
40
using System.Xml;
 
41
using System.Xml.Schema;
 
42
using Newtonsoft.Json.Schema;
 
43
using Newtonsoft.Json.Utilities;
 
44
using ValidationEventArgs = Newtonsoft.Json.Schema.ValidationEventArgs;
 
45
 
 
46
namespace Newtonsoft.Json.Tests
 
47
{
 
48
  [TestFixture]
 
49
  public class JsonValidatingReaderTests : TestFixtureBase
 
50
  {
 
51
    [Test]
 
52
    public void CheckInnerReader()
 
53
    {
 
54
      string json = "{'name':'James','hobbies':['pie','cake']}";
 
55
      JsonReader reader = new JsonTextReader(new StringReader(json));
 
56
 
 
57
      JsonValidatingReader validatingReader = new JsonValidatingReader(reader);
 
58
      Assert.AreEqual(reader, validatingReader.Reader);
 
59
    }
 
60
 
 
61
    [Test]
 
62
    public void ValidateTypes()
 
63
    {
 
64
      string schemaJson = @"{
 
65
  ""description"":""A person"",
 
66
  ""type"":""object"",
 
67
  ""properties"":
 
68
  {
 
69
    ""name"":{""type"":""string""},
 
70
    ""hobbies"":
 
71
    {
 
72
      ""type"":""array"",
 
73
      ""items"": {""type"":""string""}
 
74
    }
 
75
  }
 
76
}";
 
77
 
 
78
      string json = @"{'name':""James"",'hobbies':[""pie"",'cake']}";
 
79
 
 
80
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
81
 
 
82
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
83
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
84
      JsonSchema schema = JsonSchema.Parse(schemaJson);
 
85
      reader.Schema = schema;
 
86
      Assert.AreEqual(schema, reader.Schema);
 
87
      Assert.AreEqual(0, reader.Depth);
 
88
      Assert.AreEqual("", reader.Path);
 
89
 
 
90
      Assert.IsTrue(reader.Read());
 
91
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
92
      Assert.AreEqual("", reader.Path);
 
93
 
 
94
      Assert.IsTrue(reader.Read());
 
95
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
96
      Assert.AreEqual("name", reader.Value.ToString());
 
97
      Assert.AreEqual("name", reader.Path);
 
98
      Assert.AreEqual(1, reader.Depth);
 
99
 
 
100
      Assert.IsTrue(reader.Read());
 
101
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
102
      Assert.AreEqual("James", reader.Value.ToString());
 
103
      Assert.AreEqual(typeof (string), reader.ValueType);
 
104
      Assert.AreEqual('"', reader.QuoteChar);
 
105
      Assert.AreEqual("name", reader.Path);
 
106
 
 
107
      Assert.IsTrue(reader.Read());
 
108
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
109
      Assert.AreEqual("hobbies", reader.Value.ToString());
 
110
      Assert.AreEqual('\'', reader.QuoteChar);
 
111
      Assert.AreEqual("hobbies", reader.Path);
 
112
 
 
113
      Assert.IsTrue(reader.Read());
 
114
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
115
      Assert.AreEqual("hobbies", reader.Path);
 
116
 
 
117
      Assert.IsTrue(reader.Read());
 
118
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
119
      Assert.AreEqual("pie", reader.Value.ToString());
 
120
      Assert.AreEqual('"', reader.QuoteChar);
 
121
      Assert.AreEqual("hobbies[0]", reader.Path);
 
122
 
 
123
      Assert.IsTrue(reader.Read());
 
124
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
125
      Assert.AreEqual("cake", reader.Value.ToString());
 
126
      Assert.AreEqual("hobbies[1]", reader.Path);
 
127
 
 
128
      Assert.IsTrue(reader.Read());
 
129
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
130
      Assert.AreEqual("hobbies", reader.Path);
 
131
 
 
132
      Assert.IsTrue(reader.Read());
 
133
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
134
      Assert.AreEqual("", reader.Path);
 
135
 
 
136
      Assert.IsFalse(reader.Read());
 
137
      
 
138
      Assert.IsNull(validationEventArgs);
 
139
    }
 
140
 
 
141
    [Test]
 
142
    public void ValidateUnrestrictedArray()
 
143
    {
 
144
      string schemaJson = @"{
 
145
  ""type"":""array""
 
146
}";
 
147
 
 
148
      string json = "['pie','cake',['nested1','nested2'],{'nestedproperty1':1.1,'nestedproperty2':[null]}]";
 
149
 
 
150
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
151
 
 
152
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
153
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
154
      reader.Schema = JsonSchema.Parse(schemaJson);
 
155
 
 
156
      Assert.IsTrue(reader.Read());
 
157
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
158
 
 
159
      Assert.IsTrue(reader.Read());
 
160
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
161
      Assert.AreEqual("pie", reader.Value.ToString());
 
162
 
 
163
      Assert.IsTrue(reader.Read());
 
164
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
165
      Assert.AreEqual("cake", reader.Value.ToString());
 
166
 
 
167
      Assert.IsTrue(reader.Read());
 
168
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
169
 
 
170
      Assert.IsTrue(reader.Read());
 
171
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
172
      Assert.AreEqual("nested1", reader.Value.ToString());
 
173
 
 
174
      Assert.IsTrue(reader.Read());
 
175
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
176
      Assert.AreEqual("nested2", reader.Value.ToString());
 
177
 
 
178
      Assert.IsTrue(reader.Read());
 
179
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
180
 
 
181
      Assert.IsTrue(reader.Read());
 
182
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
183
 
 
184
      Assert.IsTrue(reader.Read());
 
185
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
186
      Assert.AreEqual("nestedproperty1", reader.Value.ToString());
 
187
 
 
188
      Assert.IsTrue(reader.Read());
 
189
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
190
      Assert.AreEqual(1.1, reader.Value);
 
191
 
 
192
      Assert.IsTrue(reader.Read());
 
193
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
194
      Assert.AreEqual("nestedproperty2", reader.Value.ToString());
 
195
 
 
196
      Assert.IsTrue(reader.Read());
 
197
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
198
 
 
199
      Assert.IsTrue(reader.Read());
 
200
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
201
 
 
202
      Assert.IsTrue(reader.Read());
 
203
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
204
 
 
205
      Assert.IsTrue(reader.Read());
 
206
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
207
 
 
208
      Assert.IsTrue(reader.Read());
 
209
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
210
 
 
211
      Assert.IsNull(validationEventArgs);
 
212
    }
 
213
 
 
214
    [Test]
 
215
    public void StringLessThanMinimumLength()
 
216
    {
 
217
      string schemaJson = @"{
 
218
  ""type"":""string"",
 
219
  ""minLength"":5,
 
220
  ""maxLength"":50,
 
221
}";
 
222
 
 
223
      string json = "'pie'";
 
224
 
 
225
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
226
 
 
227
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
228
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
229
      reader.Schema = JsonSchema.Parse(schemaJson);
 
230
 
 
231
      Assert.IsTrue(reader.Read());
 
232
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
233
      Assert.AreEqual("String 'pie' is less than minimum length of 5. Line 1, position 5.", validationEventArgs.Message);
 
234
 
 
235
      Assert.IsNotNull(validationEventArgs);
 
236
    }
 
237
 
 
238
    [Test]
 
239
    public void StringGreaterThanMaximumLength()
 
240
    {
 
241
      string schemaJson = @"{
 
242
  ""type"":""string"",
 
243
  ""minLength"":5,
 
244
  ""maxLength"":10
 
245
}";
 
246
 
 
247
      string json = "'The quick brown fox jumps over the lazy dog.'";
 
248
 
 
249
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
250
 
 
251
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
252
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
253
      reader.Schema = JsonSchema.Parse(schemaJson);
 
254
 
 
255
      Assert.IsTrue(reader.Read());
 
256
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
257
      Assert.AreEqual("String 'The quick brown fox jumps over the lazy dog.' exceeds maximum length of 10. Line 1, position 46.", validationEventArgs.Message);
 
258
 
 
259
      Assert.IsNotNull(validationEventArgs);
 
260
    }
 
261
 
 
262
    [Test]
 
263
    public void StringIsNotInEnum()
 
264
    {
 
265
      string schemaJson = @"{
 
266
  ""type"":""array"",
 
267
  ""items"":{
 
268
    ""type"":""string"",
 
269
    ""enum"":[""one"",""two""]
 
270
  },
 
271
  ""maxItems"":3
 
272
}";
 
273
 
 
274
      string json = "['one','two','THREE']";
 
275
 
 
276
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
277
 
 
278
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
279
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
280
      reader.Schema = JsonSchema.Parse(schemaJson);
 
281
 
 
282
      Assert.IsTrue(reader.Read());
 
283
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
284
 
 
285
      Assert.IsTrue(reader.Read());
 
286
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
287
 
 
288
      Assert.IsTrue(reader.Read());
 
289
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
290
      Assert.AreEqual(null, validationEventArgs);
 
291
 
 
292
      Assert.IsTrue(reader.Read());
 
293
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
294
      Assert.AreEqual(@"Value ""THREE"" is not defined in enum. Line 1, position 20.", validationEventArgs.Message);
 
295
      Assert.AreEqual("[2]", validationEventArgs.Path);
 
296
 
 
297
      Assert.IsTrue(reader.Read());
 
298
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
299
 
 
300
      Assert.IsNotNull(validationEventArgs);
 
301
    }
 
302
 
 
303
    [Test]
 
304
    public void StringDoesNotMatchPattern()
 
305
    {
 
306
      string schemaJson = @"{
 
307
  ""type"":""string"",
 
308
  ""pattern"":""foo""
 
309
}";
 
310
 
 
311
      string json = "'The quick brown fox jumps over the lazy dog.'";
 
312
 
 
313
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
314
 
 
315
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
316
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
317
      reader.Schema = JsonSchema.Parse(schemaJson);
 
318
 
 
319
      Assert.IsTrue(reader.Read());
 
320
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
321
      Assert.AreEqual("String 'The quick brown fox jumps over the lazy dog.' does not match regex pattern 'foo'. Line 1, position 46.", validationEventArgs.Message);
 
322
      Assert.AreEqual("", validationEventArgs.Path);
 
323
 
 
324
      Assert.IsNotNull(validationEventArgs);
 
325
    }
 
326
 
 
327
    [Test]
 
328
    public void IntegerGreaterThanMaximumValue()
 
329
    {
 
330
      string schemaJson = @"{
 
331
  ""type"":""integer"",
 
332
  ""maximum"":5
 
333
}";
 
334
 
 
335
      string json = "10";
 
336
 
 
337
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
338
 
 
339
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
340
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
341
      reader.Schema = JsonSchema.Parse(schemaJson);
 
342
 
 
343
      Assert.IsTrue(reader.Read());
 
344
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
345
      Assert.AreEqual("Integer 10 exceeds maximum value of 5. Line 1, position 2.", validationEventArgs.Message);
 
346
      Assert.AreEqual("", validationEventArgs.Path);
 
347
 
 
348
      Assert.IsNotNull(validationEventArgs);
 
349
    }
 
350
 
 
351
    [Test]
 
352
    public void ThrowExceptionWhenNoValidationEventHandler()
 
353
    {
 
354
      ExceptionAssert.Throws<JsonSchemaException>("Integer 10 exceeds maximum value of 5. Line 1, position 2.",
 
355
      () =>
 
356
      {
 
357
        string schemaJson = @"{
 
358
  ""type"":""integer"",
 
359
  ""maximum"":5
 
360
}";
 
361
 
 
362
        JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader("10")));
 
363
        reader.Schema = JsonSchema.Parse(schemaJson);
 
364
 
 
365
        Assert.IsTrue(reader.Read());
 
366
      });
 
367
    }
 
368
 
 
369
    [Test]
 
370
    public void IntegerLessThanMinimumValue()
 
371
    {
 
372
      string schemaJson = @"{
 
373
  ""type"":""integer"",
 
374
  ""minimum"":5
 
375
}";
 
376
 
 
377
      string json = "1";
 
378
 
 
379
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
380
 
 
381
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
382
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
383
      reader.Schema = JsonSchema.Parse(schemaJson);
 
384
 
 
385
      Assert.IsTrue(reader.Read());
 
386
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
387
      Assert.AreEqual("Integer 1 is less than minimum value of 5. Line 1, position 1.", validationEventArgs.Message);
 
388
 
 
389
      Assert.IsNotNull(validationEventArgs);
 
390
    }
 
391
 
 
392
    [Test]
 
393
    public void IntegerIsNotInEnum()
 
394
    {
 
395
      string schemaJson = @"{
 
396
  ""type"":""array"",
 
397
  ""items"":{
 
398
    ""type"":""integer"",
 
399
    ""enum"":[1,2]
 
400
  },
 
401
  ""maxItems"":3
 
402
}";
 
403
 
 
404
      string json = "[1,2,3]";
 
405
 
 
406
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
407
 
 
408
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
409
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
410
      reader.Schema = JsonSchema.Parse(schemaJson);
 
411
 
 
412
      Assert.IsTrue(reader.Read());
 
413
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
414
 
 
415
      Assert.IsTrue(reader.Read());
 
416
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
417
 
 
418
      Assert.IsTrue(reader.Read());
 
419
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
420
      Assert.AreEqual(null, validationEventArgs);
 
421
 
 
422
      Assert.IsTrue(reader.Read());
 
423
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
424
      Assert.AreEqual(@"Value 3 is not defined in enum. Line 1, position 6.", validationEventArgs.Message);
 
425
      Assert.AreEqual("[2]", validationEventArgs.Path);
 
426
 
 
427
      Assert.IsTrue(reader.Read());
 
428
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
429
 
 
430
      Assert.IsNotNull(validationEventArgs);
 
431
    }
 
432
 
 
433
    [Test]
 
434
    public void FloatGreaterThanMaximumValue()
 
435
    {
 
436
      string schemaJson = @"{
 
437
  ""type"":""number"",
 
438
  ""maximum"":5
 
439
}";
 
440
 
 
441
      string json = "10.0";
 
442
 
 
443
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
444
 
 
445
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
446
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
447
      reader.Schema = JsonSchema.Parse(schemaJson);
 
448
 
 
449
      Assert.IsTrue(reader.Read());
 
450
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
451
      Assert.AreEqual("Float 10.0 exceeds maximum value of 5. Line 1, position 4.", validationEventArgs.Message);
 
452
 
 
453
      Assert.IsNotNull(validationEventArgs);
 
454
    }
 
455
 
 
456
    [Test]
 
457
    public void FloatLessThanMinimumValue()
 
458
    {
 
459
      string schemaJson = @"{
 
460
  ""type"":""number"",
 
461
  ""minimum"":5
 
462
}";
 
463
 
 
464
      string json = "1.1";
 
465
 
 
466
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
467
 
 
468
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
469
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
470
      reader.Schema = JsonSchema.Parse(schemaJson);
 
471
 
 
472
      Assert.IsTrue(reader.Read());
 
473
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
474
      Assert.AreEqual("Float 1.1 is less than minimum value of 5. Line 1, position 3.", validationEventArgs.Message);
 
475
 
 
476
      Assert.IsNotNull(validationEventArgs);
 
477
    }
 
478
 
 
479
    [Test]
 
480
    public void FloatIsNotInEnum()
 
481
    {
 
482
      string schemaJson = @"{
 
483
  ""type"":""array"",
 
484
  ""items"":{
 
485
    ""type"":""number"",
 
486
    ""enum"":[1.1,2.2]
 
487
  },
 
488
  ""maxItems"":3
 
489
}";
 
490
 
 
491
      string json = "[1.1,2.2,3.0]";
 
492
 
 
493
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
494
 
 
495
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
496
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
497
      reader.Schema = JsonSchema.Parse(schemaJson);
 
498
 
 
499
      Assert.IsTrue(reader.Read());
 
500
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
501
 
 
502
      Assert.IsTrue(reader.Read());
 
503
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
504
 
 
505
      Assert.IsTrue(reader.Read());
 
506
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
507
      Assert.AreEqual(null, validationEventArgs);
 
508
 
 
509
      Assert.IsTrue(reader.Read());
 
510
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
511
      Assert.AreEqual(@"Value 3.0 is not defined in enum. Line 1, position 12.", validationEventArgs.Message);
 
512
      Assert.AreEqual("[2]", validationEventArgs.Path);
 
513
 
 
514
      Assert.IsTrue(reader.Read());
 
515
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
516
 
 
517
      Assert.IsNotNull(validationEventArgs);
 
518
    }
 
519
 
 
520
    [Test]
 
521
    public void FloatExceedsMaxDecimalPlaces()
 
522
    {
 
523
      string schemaJson = @"{
 
524
  ""type"":""array"",
 
525
  ""items"":{
 
526
    ""type"":""number"",
 
527
    ""divisibleBy"":0.1
 
528
  }
 
529
}";
 
530
 
 
531
      string json = "[1.1,2.2,4.001]";
 
532
 
 
533
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
534
 
 
535
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
536
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
537
      reader.Schema = JsonSchema.Parse(schemaJson);
 
538
 
 
539
      Assert.IsTrue(reader.Read());
 
540
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
541
 
 
542
      Assert.IsTrue(reader.Read());
 
543
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
544
 
 
545
      Assert.IsTrue(reader.Read());
 
546
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
547
      Assert.AreEqual(null, validationEventArgs);
 
548
 
 
549
      Assert.IsTrue(reader.Read());
 
550
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
551
      Assert.AreEqual(@"Float 4.001 is not evenly divisible by 0.1. Line 1, position 14.", validationEventArgs.Message);
 
552
      Assert.AreEqual("[2]", validationEventArgs.Path);
 
553
 
 
554
      Assert.IsTrue(reader.Read());
 
555
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
556
 
 
557
      Assert.IsNotNull(validationEventArgs);
 
558
    }
 
559
 
 
560
    [Test]
 
561
    public void IntValidForNumber()
 
562
    {
 
563
      string schemaJson = @"{
 
564
  ""type"":""array"",
 
565
  ""items"":{
 
566
    ""type"":""number""
 
567
  }
 
568
}";
 
569
 
 
570
      string json = "[1]";
 
571
 
 
572
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
573
 
 
574
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
575
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
576
      reader.Schema = JsonSchema.Parse(schemaJson);
 
577
 
 
578
      Assert.IsTrue(reader.Read());
 
579
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
580
 
 
581
      Assert.IsTrue(reader.Read());
 
582
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
583
 
 
584
      Assert.IsTrue(reader.Read());
 
585
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
586
 
 
587
      Assert.IsNull(validationEventArgs);
 
588
    }
 
589
 
 
590
    [Test]
 
591
    public void NullNotInEnum()
 
592
    {
 
593
      string schemaJson = @"{
 
594
  ""type"":""array"",
 
595
  ""items"":{
 
596
    ""type"":""null"",
 
597
    ""enum"":[]
 
598
  },
 
599
  ""maxItems"":3
 
600
}";
 
601
 
 
602
      string json = "[null]";
 
603
 
 
604
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
605
 
 
606
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
607
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
608
      reader.Schema = JsonSchema.Parse(schemaJson);
 
609
 
 
610
      Assert.IsTrue(reader.Read());
 
611
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
612
 
 
613
      Assert.IsTrue(reader.Read());
 
614
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
615
      Assert.AreEqual(@"Value null is not defined in enum. Line 1, position 5.", validationEventArgs.Message);
 
616
      Assert.AreEqual("[0]", validationEventArgs.Path);
 
617
 
 
618
      Assert.IsTrue(reader.Read());
 
619
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
620
 
 
621
      Assert.IsNotNull(validationEventArgs);
 
622
    }
 
623
 
 
624
    [Test]
 
625
    public void BooleanNotInEnum()
 
626
    {
 
627
      string schemaJson = @"{
 
628
  ""type"":""array"",
 
629
  ""items"":{
 
630
    ""type"":""boolean"",
 
631
    ""enum"":[true]
 
632
  },
 
633
  ""maxItems"":3
 
634
}";
 
635
 
 
636
      string json = "[true,false]";
 
637
 
 
638
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
639
 
 
640
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
641
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
642
      reader.Schema = JsonSchema.Parse(schemaJson);
 
643
 
 
644
      Assert.IsTrue(reader.Read());
 
645
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
646
 
 
647
      Assert.IsTrue(reader.Read());
 
648
      Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
 
649
      Assert.AreEqual(null, validationEventArgs);
 
650
 
 
651
      Assert.IsTrue(reader.Read());
 
652
      Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
 
653
      Assert.AreEqual(@"Value false is not defined in enum. Line 1, position 11.", validationEventArgs.Message);
 
654
      Assert.AreEqual("[1]", validationEventArgs.Path);
 
655
 
 
656
      Assert.IsTrue(reader.Read());
 
657
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
658
 
 
659
      Assert.IsNotNull(validationEventArgs);
 
660
    }
 
661
 
 
662
    [Test]
 
663
    public void ArrayCountGreaterThanMaximumItems()
 
664
    {
 
665
      string schemaJson = @"{
 
666
  ""type"":""array"",
 
667
  ""minItems"":2,
 
668
  ""maxItems"":3
 
669
}";
 
670
 
 
671
      string json = "[null,null,null,null]";
 
672
 
 
673
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
674
 
 
675
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
676
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
677
      reader.Schema = JsonSchema.Parse(schemaJson);
 
678
 
 
679
      Assert.IsTrue(reader.Read());
 
680
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
681
 
 
682
      Assert.IsTrue(reader.Read());
 
683
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
684
      Assert.IsTrue(reader.Read());
 
685
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
686
      Assert.IsTrue(reader.Read());
 
687
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
688
      Assert.IsTrue(reader.Read());
 
689
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
690
 
 
691
      Assert.IsTrue(reader.Read());
 
692
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
693
      Assert.AreEqual("Array item count 4 exceeds maximum count of 3. Line 1, position 21.", validationEventArgs.Message);
 
694
 
 
695
      Assert.IsNotNull(validationEventArgs);
 
696
    }
 
697
 
 
698
    [Test]
 
699
    public void ArrayCountLessThanMinimumItems()
 
700
    {
 
701
      string schemaJson = @"{
 
702
  ""type"":""array"",
 
703
  ""minItems"":2,
 
704
  ""maxItems"":3
 
705
}";
 
706
 
 
707
      string json = "[null]";
 
708
 
 
709
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
710
 
 
711
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
712
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
713
      reader.Schema = JsonSchema.Parse(schemaJson);
 
714
 
 
715
      Assert.IsTrue(reader.Read());
 
716
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
717
 
 
718
      Assert.IsTrue(reader.Read());
 
719
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
720
 
 
721
      Assert.IsTrue(reader.Read());
 
722
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
723
      Assert.AreEqual("Array item count 1 is less than minimum count of 2. Line 1, position 6.", validationEventArgs.Message);
 
724
 
 
725
      Assert.IsNotNull(validationEventArgs);
 
726
    }
 
727
 
 
728
    [Test]
 
729
    public void InvalidDataType()
 
730
    {
 
731
      string schemaJson = @"{
 
732
  ""type"":""string"",
 
733
  ""minItems"":2,
 
734
  ""maxItems"":3,
 
735
  ""items"":{}
 
736
}";
 
737
 
 
738
      string json = "[null,null,null,null]";
 
739
 
 
740
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
741
 
 
742
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
743
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
744
      reader.Schema = JsonSchema.Parse(schemaJson);
 
745
 
 
746
      Assert.IsTrue(reader.Read());
 
747
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
748
      Assert.AreEqual(@"Invalid type. Expected String but got Array. Line 1, position 1.", validationEventArgs.Message);
 
749
 
 
750
      Assert.IsNotNull(validationEventArgs);
 
751
    }
 
752
 
 
753
    [Test]
 
754
    public void StringDisallowed()
 
755
    {
 
756
      string schemaJson = @"{
 
757
  ""type"":""array"",
 
758
  ""items"":{
 
759
    ""disallow"":[""number""]
 
760
  },
 
761
  ""maxItems"":3
 
762
}";
 
763
 
 
764
      string json = "['pie',1.1]";
 
765
 
 
766
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
767
 
 
768
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
769
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
770
      reader.Schema = JsonSchema.Parse(schemaJson);
 
771
 
 
772
      Assert.IsTrue(reader.Read());
 
773
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
774
 
 
775
      Assert.IsTrue(reader.Read());
 
776
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
777
      Assert.AreEqual(null, validationEventArgs);
 
778
 
 
779
      Assert.IsTrue(reader.Read());
 
780
      Assert.AreEqual(JsonToken.Float, reader.TokenType);
 
781
      Assert.AreEqual(@"Type Float is disallowed. Line 1, position 10.", validationEventArgs.Message);
 
782
 
 
783
      Assert.IsTrue(reader.Read());
 
784
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
785
 
 
786
      Assert.IsNotNull(validationEventArgs);
 
787
    }
 
788
 
 
789
    [Test]
 
790
    public void MissingRequiredProperties()
 
791
    {
 
792
      string schemaJson = @"{
 
793
  ""description"":""A person"",
 
794
  ""type"":""object"",
 
795
  ""properties"":
 
796
  {
 
797
    ""name"":{""type"":""string""},
 
798
    ""hobbies"":{""type"":""string"",""required"":true},
 
799
    ""age"":{""type"":""integer"",""required"":true}
 
800
  }
 
801
}";
 
802
 
 
803
      string json = "{'name':'James'}";
 
804
 
 
805
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
806
 
 
807
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
808
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
809
      reader.Schema = JsonSchema.Parse(schemaJson);
 
810
 
 
811
      Assert.IsTrue(reader.Read());
 
812
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
813
 
 
814
      Assert.IsTrue(reader.Read());
 
815
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
816
      Assert.AreEqual("name", reader.Value.ToString());
 
817
 
 
818
      Assert.IsTrue(reader.Read());
 
819
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
820
      Assert.AreEqual("James", reader.Value.ToString());
 
821
      Assert.AreEqual(null, validationEventArgs);
 
822
 
 
823
      Assert.IsTrue(reader.Read());
 
824
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
825
      Assert.AreEqual("Required properties are missing from object: hobbies, age. Line 1, position 16.", validationEventArgs.Message);
 
826
      Assert.AreEqual("", validationEventArgs.Path);
 
827
 
 
828
      Assert.IsNotNull(validationEventArgs);
 
829
    }
 
830
 
 
831
    [Test]
 
832
    public void MissingNonRequiredProperties()
 
833
    {
 
834
      string schemaJson = @"{
 
835
  ""description"":""A person"",
 
836
  ""type"":""object"",
 
837
  ""properties"":
 
838
  {
 
839
    ""name"":{""type"":""string"",""required"":true},
 
840
    ""hobbies"":{""type"":""string"",""required"":false},
 
841
    ""age"":{""type"":""integer""}
 
842
  }
 
843
}";
 
844
 
 
845
      string json = "{'name':'James'}";
 
846
 
 
847
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
848
 
 
849
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
850
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
851
      reader.Schema = JsonSchema.Parse(schemaJson);
 
852
 
 
853
      Assert.IsTrue(reader.Read());
 
854
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
855
 
 
856
      Assert.IsTrue(reader.Read());
 
857
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
858
      Assert.AreEqual("name", reader.Value.ToString());
 
859
 
 
860
      Assert.IsTrue(reader.Read());
 
861
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
862
      Assert.AreEqual("James", reader.Value.ToString());
 
863
      Assert.IsNull(validationEventArgs);
 
864
 
 
865
      Assert.IsTrue(reader.Read());
 
866
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
867
 
 
868
      Assert.IsNull(validationEventArgs);
 
869
    }
 
870
 
 
871
    [Test]
 
872
    public void DisableAdditionalProperties()
 
873
    {
 
874
      string schemaJson = @"{
 
875
  ""description"":""A person"",
 
876
  ""type"":""object"",
 
877
  ""properties"":
 
878
  {
 
879
    ""name"":{""type"":""string""}
 
880
  },
 
881
  ""additionalProperties"":false
 
882
}";
 
883
 
 
884
      string json = "{'name':'James','additionalProperty1':null,'additionalProperty2':null}";
 
885
 
 
886
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
887
 
 
888
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
889
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
890
      reader.Schema = JsonSchema.Parse(schemaJson);
 
891
 
 
892
      Assert.IsTrue(reader.Read());
 
893
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
894
 
 
895
      Assert.IsTrue(reader.Read());
 
896
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
897
      Assert.AreEqual("name", reader.Value.ToString());
 
898
 
 
899
      Assert.IsTrue(reader.Read());
 
900
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
901
      Assert.AreEqual("James", reader.Value.ToString());
 
902
      Assert.AreEqual(null, validationEventArgs);
 
903
 
 
904
      Assert.IsTrue(reader.Read());
 
905
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
906
      Assert.AreEqual("additionalProperty1", reader.Value.ToString());
 
907
 
 
908
      Assert.IsTrue(reader.Read());
 
909
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
910
      Assert.AreEqual(null, reader.Value);
 
911
      Assert.AreEqual("Property 'additionalProperty1' has not been defined and the schema does not allow additional properties. Line 1, position 38.", validationEventArgs.Message);
 
912
 
 
913
      Assert.IsTrue(reader.Read());
 
914
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
915
      Assert.AreEqual("additionalProperty2", reader.Value.ToString());
 
916
 
 
917
      Assert.IsTrue(reader.Read());
 
918
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
919
      Assert.AreEqual(null, reader.Value);
 
920
      Assert.AreEqual("Property 'additionalProperty2' has not been defined and the schema does not allow additional properties. Line 1, position 65.", validationEventArgs.Message);
 
921
 
 
922
      Assert.IsTrue(reader.Read());
 
923
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
924
 
 
925
      Assert.IsNotNull(validationEventArgs);
 
926
    }
 
927
 
 
928
    [Test]
 
929
    public void ExtendsStringGreaterThanMaximumLength()
 
930
    {
 
931
      string schemaJson = @"{
 
932
  ""extends"":{
 
933
    ""type"":""string"",
 
934
    ""minLength"":5,
 
935
    ""maxLength"":10
 
936
  },
 
937
  ""maxLength"":9
 
938
}";
 
939
 
 
940
      List<string> errors = new List<string>();
 
941
      string json = "'The quick brown fox jumps over the lazy dog.'";
 
942
 
 
943
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
944
 
 
945
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
946
      reader.ValidationEventHandler += (sender, args) =>
 
947
        {
 
948
          validationEventArgs = args;
 
949
          errors.Add(validationEventArgs.Message);
 
950
        };
 
951
      reader.Schema = JsonSchema.Parse(schemaJson);
 
952
 
 
953
      Assert.IsTrue(reader.Read());
 
954
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
955
      Assert.AreEqual(1, errors.Count);
 
956
      Assert.AreEqual("String 'The quick brown fox jumps over the lazy dog.' exceeds maximum length of 9. Line 1, position 46.", errors[0]);
 
957
 
 
958
      Assert.IsNotNull(validationEventArgs);
 
959
    }
 
960
 
 
961
    private JsonSchema GetExtendedSchema()
 
962
    {
 
963
      string first = @"{
 
964
  ""id"":""first"",
 
965
  ""type"":""object"",
 
966
  ""properties"":
 
967
  {
 
968
    ""firstproperty"":{""type"":""string"",""required"":true}
 
969
  },
 
970
  ""additionalProperties"":{}
 
971
}";
 
972
 
 
973
      string second = @"{
 
974
  ""id"":""second"",
 
975
  ""type"":""object"",
 
976
  ""extends"":{""$ref"":""first""},
 
977
  ""properties"":
 
978
  {
 
979
    ""secondproperty"":{""type"":""string"",""required"":true}
 
980
  },
 
981
  ""additionalProperties"":false
 
982
}";
 
983
 
 
984
      JsonSchemaResolver resolver = new JsonSchemaResolver();
 
985
      JsonSchema firstSchema = JsonSchema.Parse(first, resolver);
 
986
      JsonSchema secondSchema = JsonSchema.Parse(second, resolver);
 
987
 
 
988
      return secondSchema;
 
989
    }
 
990
 
 
991
    [Test]
 
992
    public void ExtendsDisallowAdditionProperties()
 
993
    {
 
994
      string json = "{'firstproperty':'blah','secondproperty':'blah2','additional':'blah3','additional2':'blah4'}";
 
995
 
 
996
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
997
 
 
998
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
999
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
1000
      reader.Schema = GetExtendedSchema();
 
1001
 
 
1002
      Assert.IsTrue(reader.Read());
 
1003
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
1004
 
 
1005
      Assert.IsTrue(reader.Read());
 
1006
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1007
      Assert.AreEqual("firstproperty", reader.Value.ToString());
 
1008
      Assert.AreEqual(null, validationEventArgs);
 
1009
 
 
1010
      Assert.IsTrue(reader.Read());
 
1011
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1012
      Assert.AreEqual("blah", reader.Value.ToString());
 
1013
      Assert.AreEqual(null, validationEventArgs);
 
1014
 
 
1015
      Assert.IsTrue(reader.Read());
 
1016
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1017
      Assert.AreEqual("secondproperty", reader.Value.ToString());
 
1018
      Assert.AreEqual(null, validationEventArgs);
 
1019
 
 
1020
      Assert.IsTrue(reader.Read());
 
1021
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1022
      Assert.AreEqual("blah2", reader.Value.ToString());
 
1023
      Assert.AreEqual(null, validationEventArgs);
 
1024
 
 
1025
      Assert.IsTrue(reader.Read());
 
1026
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1027
      Assert.AreEqual("additional", reader.Value.ToString());
 
1028
      Assert.AreEqual("Property 'additional' has not been defined and the schema does not allow additional properties. Line 1, position 62.", validationEventArgs.Message);
 
1029
 
 
1030
      Assert.IsTrue(reader.Read());
 
1031
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1032
      Assert.AreEqual("blah3", reader.Value.ToString());
 
1033
 
 
1034
      Assert.IsTrue(reader.Read());
 
1035
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1036
      Assert.AreEqual("additional2", reader.Value.ToString());
 
1037
      Assert.AreEqual("Property 'additional2' has not been defined and the schema does not allow additional properties. Line 1, position 84.", validationEventArgs.Message);
 
1038
 
 
1039
      Assert.IsTrue(reader.Read());
 
1040
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1041
      Assert.AreEqual("blah4", reader.Value.ToString());
 
1042
 
 
1043
      Assert.IsTrue(reader.Read());
 
1044
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
1045
 
 
1046
      Assert.IsFalse(reader.Read());
 
1047
    }
 
1048
 
 
1049
    [Test]
 
1050
    public void ExtendsMissingRequiredProperties()
 
1051
    {
 
1052
      string json = "{}";
 
1053
 
 
1054
      List<string> errors = new List<string>();
 
1055
 
 
1056
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
1057
      reader.ValidationEventHandler += (sender, args) => { errors.Add(args.Message); };
 
1058
      reader.Schema = GetExtendedSchema();
 
1059
 
 
1060
      Assert.IsTrue(reader.Read());
 
1061
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
1062
 
 
1063
      Assert.IsTrue(reader.Read());
 
1064
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
1065
 
 
1066
      Assert.AreEqual(1, errors.Count);
 
1067
      Assert.AreEqual("Required properties are missing from object: secondproperty, firstproperty. Line 1, position 2.", errors[0]);
 
1068
    }
 
1069
 
 
1070
    [Test]
 
1071
    public void NoAdditionalProperties()
 
1072
    {
 
1073
      string schemaJson = @"{
 
1074
  ""type"":""array"",
 
1075
  ""items"": [{""type"":""string""},{""type"":""integer""}],
 
1076
  ""additionalProperties"": false
 
1077
}";
 
1078
 
 
1079
      string json = @"[1, 'a', null]";
 
1080
 
 
1081
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
1082
 
 
1083
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
1084
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
1085
      reader.Schema = JsonSchema.Parse(schemaJson);
 
1086
 
 
1087
      Assert.IsTrue(reader.Read());
 
1088
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
1089
 
 
1090
      Assert.IsTrue(reader.Read());
 
1091
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
1092
      Assert.AreEqual("Invalid type. Expected String but got Integer. Line 1, position 2.", validationEventArgs.Message);
 
1093
 
 
1094
      Assert.IsTrue(reader.Read());
 
1095
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1096
      Assert.AreEqual("Invalid type. Expected Integer but got String. Line 1, position 7.", validationEventArgs.Message);
 
1097
 
 
1098
      Assert.IsTrue(reader.Read());
 
1099
      Assert.AreEqual(JsonToken.Null, reader.TokenType);
 
1100
      Assert.AreEqual("Index 3 has not been defined and the schema does not allow additional items. Line 1, position 13.", validationEventArgs.Message);
 
1101
 
 
1102
      Assert.IsTrue(reader.Read());
 
1103
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
1104
 
 
1105
      Assert.IsFalse(reader.Read());
 
1106
    }
 
1107
 
 
1108
    [Test]
 
1109
    public void PatternPropertiesNoAdditionalProperties()
 
1110
    {
 
1111
      string schemaJson = @"{
 
1112
  ""type"":""object"",
 
1113
  ""patternProperties"": {
 
1114
     ""hi"": {""type"":""string""},
 
1115
     ""ho"": {""type"":""string""}
 
1116
  },
 
1117
  ""additionalProperties"": false
 
1118
}";
 
1119
 
 
1120
      string json = @"{
 
1121
  ""hi"": ""A string!"",
 
1122
  ""hide"": ""A string!"",
 
1123
  ""ho"": 1,
 
1124
  ""hey"": ""A string!""
 
1125
}";
 
1126
 
 
1127
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
1128
 
 
1129
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
1130
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
1131
      reader.Schema = JsonSchema.Parse(schemaJson);
 
1132
 
 
1133
      Assert.IsTrue(reader.Read());
 
1134
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
1135
 
 
1136
      Assert.IsTrue(reader.Read());
 
1137
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1138
      Assert.AreEqual(null, validationEventArgs);
 
1139
 
 
1140
      Assert.IsTrue(reader.Read());
 
1141
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1142
 
 
1143
      Assert.IsTrue(reader.Read());
 
1144
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1145
      Assert.AreEqual(null, validationEventArgs);
 
1146
 
 
1147
      Assert.IsTrue(reader.Read());
 
1148
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1149
 
 
1150
      Assert.IsTrue(reader.Read());
 
1151
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1152
      Assert.AreEqual(null, validationEventArgs);
 
1153
 
 
1154
      Assert.IsTrue(reader.Read());
 
1155
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
1156
      Assert.AreEqual("Invalid type. Expected String but got Integer. Line 4, position 10.", validationEventArgs.Message);
 
1157
 
 
1158
      Assert.IsTrue(reader.Read());
 
1159
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1160
      Assert.AreEqual("Property 'hey' has not been defined and the schema does not allow additional properties. Line 5, position 9.", validationEventArgs.Message);
 
1161
 
 
1162
      Assert.IsTrue(reader.Read());
 
1163
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1164
 
 
1165
      Assert.IsTrue(reader.Read());
 
1166
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
1167
 
 
1168
      Assert.IsFalse(reader.Read());
 
1169
    }
 
1170
 
 
1171
    [Test]
 
1172
    public void ExtendedComplex()
 
1173
    {
 
1174
      string first = @"{
 
1175
  ""id"":""first"",
 
1176
  ""type"":""object"",
 
1177
  ""properties"":
 
1178
  {
 
1179
    ""firstproperty"":{""type"":""string""},
 
1180
    ""secondproperty"":{""type"":""string"",""maxLength"":10},
 
1181
    ""thirdproperty"":{
 
1182
      ""type"":""object"",
 
1183
      ""properties"":
 
1184
      {
 
1185
        ""thirdproperty_firstproperty"":{""type"":""string"",""maxLength"":10,""minLength"":7}
 
1186
      }
 
1187
    }
 
1188
  },
 
1189
  ""additionalProperties"":{}
 
1190
}";
 
1191
 
 
1192
      string second = @"{
 
1193
  ""id"":""second"",
 
1194
  ""type"":""object"",
 
1195
  ""extends"":{""$ref"":""first""},
 
1196
  ""properties"":
 
1197
  {
 
1198
    ""secondproperty"":{""type"":""any""},
 
1199
    ""thirdproperty"":{
 
1200
      ""extends"":{
 
1201
        ""properties"":
 
1202
        {
 
1203
          ""thirdproperty_firstproperty"":{""maxLength"":9,""minLength"":6,""pattern"":""hi2u""}
 
1204
        },
 
1205
        ""additionalProperties"":{""maxLength"":9,""minLength"":6,""enum"":[""one"",""two""]}
 
1206
      },
 
1207
      ""type"":""object"",
 
1208
      ""properties"":
 
1209
      {
 
1210
        ""thirdproperty_firstproperty"":{""pattern"":""hi""}
 
1211
      },
 
1212
      ""additionalProperties"":{""type"":""string"",""enum"":[""two"",""three""]}
 
1213
    },
 
1214
    ""fourthproperty"":{""type"":""string""}
 
1215
  },
 
1216
  ""additionalProperties"":false
 
1217
}";
 
1218
 
 
1219
      JsonSchemaResolver resolver = new JsonSchemaResolver();
 
1220
      JsonSchema firstSchema = JsonSchema.Parse(first, resolver);
 
1221
      JsonSchema secondSchema = JsonSchema.Parse(second, resolver);
 
1222
 
 
1223
      JsonSchemaModelBuilder modelBuilder = new JsonSchemaModelBuilder();
 
1224
 
 
1225
      string json = @"{
 
1226
  'firstproperty':'blahblahblahblahblahblah',
 
1227
  'secondproperty':'secasecasecasecaseca',
 
1228
  'thirdproperty':{
 
1229
    'thirdproperty_firstproperty':'aaa',
 
1230
    'additional':'three'
 
1231
  }
 
1232
}";
 
1233
 
 
1234
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
1235
      List<string> errors = new List<string>();
 
1236
 
 
1237
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
1238
      reader.ValidationEventHandler += (sender, args) =>
 
1239
        {
 
1240
          validationEventArgs = args;
 
1241
          errors.Add(validationEventArgs.Path + " - " + validationEventArgs.Message);
 
1242
        };
 
1243
      reader.Schema = secondSchema;
 
1244
 
 
1245
      Assert.IsTrue(reader.Read());
 
1246
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
1247
 
 
1248
      Assert.IsTrue(reader.Read());
 
1249
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1250
      Assert.AreEqual("firstproperty", reader.Value.ToString());
 
1251
      Assert.AreEqual(null, validationEventArgs);
 
1252
 
 
1253
      Assert.IsTrue(reader.Read());
 
1254
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1255
      Assert.AreEqual("blahblahblahblahblahblah", reader.Value.ToString());
 
1256
 
 
1257
      Assert.IsTrue(reader.Read());
 
1258
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1259
      Assert.AreEqual("secondproperty", reader.Value.ToString());
 
1260
 
 
1261
      Assert.IsTrue(reader.Read());
 
1262
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1263
      Assert.AreEqual("secasecasecasecaseca", reader.Value.ToString());
 
1264
      Assert.AreEqual(1, errors.Count);
 
1265
      Assert.AreEqual("secondproperty - String 'secasecasecasecaseca' exceeds maximum length of 10. Line 3, position 42.", errors[0]);
 
1266
 
 
1267
      Assert.IsTrue(reader.Read());
 
1268
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1269
      Assert.AreEqual("thirdproperty", reader.Value.ToString());
 
1270
      Assert.AreEqual(1, errors.Count);
 
1271
 
 
1272
      Assert.IsTrue(reader.Read());
 
1273
      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
 
1274
      Assert.AreEqual(1, errors.Count);
 
1275
 
 
1276
      Assert.IsTrue(reader.Read());
 
1277
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1278
      Assert.AreEqual("thirdproperty_firstproperty", reader.Value.ToString());
 
1279
      Assert.AreEqual(1, errors.Count);
 
1280
 
 
1281
      Assert.IsTrue(reader.Read());
 
1282
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1283
      Assert.AreEqual("aaa", reader.Value.ToString());
 
1284
      Assert.AreEqual(4, errors.Count);
 
1285
      Assert.AreEqual("thirdproperty.thirdproperty_firstproperty - String 'aaa' is less than minimum length of 7. Line 5, position 40.", errors[1]);
 
1286
      Assert.AreEqual("thirdproperty.thirdproperty_firstproperty - String 'aaa' does not match regex pattern 'hi'. Line 5, position 40.", errors[2]);
 
1287
      Assert.AreEqual("thirdproperty.thirdproperty_firstproperty - String 'aaa' does not match regex pattern 'hi2u'. Line 5, position 40.", errors[3]);
 
1288
 
 
1289
      Assert.IsTrue(reader.Read());
 
1290
      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
 
1291
      Assert.AreEqual("additional", reader.Value.ToString());
 
1292
      Assert.AreEqual(4, errors.Count);
 
1293
 
 
1294
      Assert.IsTrue(reader.Read());
 
1295
      Assert.AreEqual(JsonToken.String, reader.TokenType);
 
1296
      Assert.AreEqual("three", reader.Value.ToString());
 
1297
      Assert.AreEqual(5, errors.Count);
 
1298
      Assert.AreEqual("thirdproperty.additional - String 'three' is less than minimum length of 6. Line 6, position 25.", errors[4]);
 
1299
 
 
1300
      Assert.IsTrue(reader.Read());
 
1301
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
1302
 
 
1303
      Assert.IsTrue(reader.Read());
 
1304
      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
 
1305
 
 
1306
      Assert.IsFalse(reader.Read());
 
1307
    }
 
1308
 
 
1309
    [Test]
 
1310
    public void DuplicateErrorsTest()
 
1311
    {
 
1312
      string schema = @"{
 
1313
  ""id"":""ErrorDemo.Database"",
 
1314
  ""properties"":{
 
1315
    ""ErrorDemoDatabase"":{
 
1316
      ""type"":""object"",
 
1317
      ""required"":true,
 
1318
      ""properties"":{
 
1319
        ""URL"":{
 
1320
          ""type"":""string"",
 
1321
          ""required"":true
 
1322
        },
 
1323
        ""Version"":{
 
1324
          ""type"":""string"",
 
1325
          ""required"":true
 
1326
        },
 
1327
        ""Date"":{
 
1328
          ""type"":""string"",
 
1329
          ""format"":""date-time"",
 
1330
          ""required"":true
 
1331
        },
 
1332
        ""MACLevels"":{
 
1333
          ""type"":""object"",
 
1334
          ""required"":true,
 
1335
          ""properties"":{
 
1336
            ""MACLevel"":{
 
1337
              ""type"":""array"",
 
1338
              ""required"":true,
 
1339
              ""items"":[
 
1340
                {
 
1341
                  ""required"":true,
 
1342
                  ""properties"":{
 
1343
                    ""IDName"":{
 
1344
                      ""type"":""string"",
 
1345
                      ""required"":true
 
1346
                    },
 
1347
                    ""Order"":{
 
1348
                      ""type"":""string"",
 
1349
                      ""required"":true
 
1350
                    },
 
1351
                    ""IDDesc"":{
 
1352
                      ""type"":""string"",
 
1353
                      ""required"":true
 
1354
                    },
 
1355
                    ""IsActive"":{
 
1356
                      ""type"":""string"",
 
1357
                      ""required"":true
 
1358
                    }
 
1359
                  }
 
1360
                }
 
1361
              ]
 
1362
            }
 
1363
          }
 
1364
        }
 
1365
      }
 
1366
    }
 
1367
  }
 
1368
}";
 
1369
 
 
1370
      string json = @"{
 
1371
  ""ErrorDemoDatabase"":{
 
1372
    ""URL"":""localhost:3164"",
 
1373
    ""Version"":""1.0"",
 
1374
    ""Date"":""6.23.2010, 9:35:18.121"",
 
1375
    ""MACLevels"":{
 
1376
      ""MACLevel"":[
 
1377
        {
 
1378
          ""@IDName"":""Developer"",
 
1379
          ""Order"":""0"",
 
1380
          ""IDDesc"":""DeveloperDesc"",
 
1381
          ""IsActive"":""True""
 
1382
        },
 
1383
        {
 
1384
          ""IDName"":""Technician"",
 
1385
          ""Order"":""1"",
 
1386
          ""IDDesc"":""TechnicianDesc"",
 
1387
          ""IsActive"":""True""
 
1388
        },
 
1389
        {
 
1390
          ""IDName"":""Administrator"",
 
1391
          ""Order"":""2"",
 
1392
          ""IDDesc"":""AdministratorDesc"",
 
1393
          ""IsActive"":""True""
 
1394
        },
 
1395
        {
 
1396
          ""IDName"":""PowerUser"",
 
1397
          ""Order"":""3"",
 
1398
          ""IDDesc"":""PowerUserDesc"",
 
1399
          ""IsActive"":""True""
 
1400
        },
 
1401
        {
 
1402
          ""IDName"":""Operator"",
 
1403
          ""Order"":""4"",
 
1404
          ""IDDesc"":""OperatorDesc"",
 
1405
          ""IsActive"":""True""
 
1406
        }
 
1407
      ]
 
1408
    }
 
1409
  }
 
1410
}";
 
1411
 
 
1412
      IList<ValidationEventArgs> validationEventArgs = new List<ValidationEventArgs>();
 
1413
 
 
1414
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
1415
      reader.ValidationEventHandler += (sender, args) =>
 
1416
        {
 
1417
          validationEventArgs.Add(args);
 
1418
        };
 
1419
      reader.Schema = JsonSchema.Parse(schema);
 
1420
 
 
1421
      while (reader.Read())
 
1422
      {
 
1423
      }
 
1424
 
 
1425
      Assert.AreEqual(1, validationEventArgs.Count);
 
1426
    }
 
1427
 
 
1428
    [Test]
 
1429
    public void ReadAsBytes()
 
1430
    {
 
1431
      JsonSchema s = new JsonSchemaGenerator().Generate(typeof (byte[]));
 
1432
 
 
1433
      byte[] data = Encoding.UTF8.GetBytes("Hello world");
 
1434
 
 
1435
      JsonReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(@"""" + Convert.ToBase64String(data) + @"""")))
 
1436
        {
 
1437
          Schema = s
 
1438
        };
 
1439
      byte[] bytes = reader.ReadAsBytes();
 
1440
 
 
1441
      CollectionAssert.AreEquivalent(data, bytes);
 
1442
    }
 
1443
 
 
1444
    [Test]
 
1445
    public void ReadAsInt32()
 
1446
    {
 
1447
      JsonSchema s = new JsonSchemaGenerator().Generate(typeof (int));
 
1448
 
 
1449
      JsonReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(@"1")))
 
1450
        {
 
1451
          Schema = s
 
1452
        };
 
1453
      int? i = reader.ReadAsInt32();
 
1454
 
 
1455
      Assert.AreEqual(1, i);
 
1456
    }
 
1457
 
 
1458
    [Test]
 
1459
    public void ReadAsInt32Failure()
 
1460
    {
 
1461
      ExceptionAssert.Throws<JsonSchemaException>("Integer 5 exceeds maximum value of 2. Line 1, position 1.",
 
1462
      () =>
 
1463
      {
 
1464
        JsonSchema s = new JsonSchemaGenerator().Generate(typeof(int));
 
1465
        s.Maximum = 2;
 
1466
 
 
1467
        JsonReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(@"5")))
 
1468
        {
 
1469
          Schema = s
 
1470
        };
 
1471
        reader.ReadAsInt32();
 
1472
      });
 
1473
    }
 
1474
 
 
1475
    [Test]
 
1476
    public void ReadAsDecimal()
 
1477
    {
 
1478
      JsonSchema s = new JsonSchemaGenerator().Generate(typeof (decimal));
 
1479
 
 
1480
      JsonReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(@"1.5")))
 
1481
        {
 
1482
          Schema = s
 
1483
        };
 
1484
      decimal? d = reader.ReadAsDecimal();
 
1485
 
 
1486
      Assert.AreEqual(1.5m, d);
 
1487
    }
 
1488
 
 
1489
    [Test]
 
1490
    public void ReadAsDecimalFailure()
 
1491
    {
 
1492
      ExceptionAssert.Throws<JsonSchemaException>("Float 5.5 is not evenly divisible by 1. Line 1, position 3.",
 
1493
      () =>
 
1494
      {
 
1495
        JsonSchema s = new JsonSchemaGenerator().Generate(typeof(decimal));
 
1496
        s.DivisibleBy = 1;
 
1497
 
 
1498
        JsonReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(@"5.5")))
 
1499
        {
 
1500
          Schema = s
 
1501
        };
 
1502
        reader.ReadAsDecimal();
 
1503
      });
 
1504
    }
 
1505
 
 
1506
    [Test]
 
1507
    public void ReadAsInt32FromSerializer()
 
1508
    {
 
1509
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader("[1,2,3]")));
 
1510
      reader.Schema = new JsonSchemaGenerator().Generate(typeof(int[]));
 
1511
      int[] values = new JsonSerializer().Deserialize<int[]>(reader);
 
1512
 
 
1513
      Assert.AreEqual(3, values.Length);
 
1514
      Assert.AreEqual(1, values[0]);
 
1515
      Assert.AreEqual(2, values[1]);
 
1516
      Assert.AreEqual(3, values[2]);
 
1517
    }
 
1518
 
 
1519
    [Test]
 
1520
    public void ReadAsInt32InArray()
 
1521
    {
 
1522
      string schemaJson = @"{
 
1523
  ""type"":""array"",
 
1524
  ""items"":{
 
1525
    ""type"":""integer""
 
1526
  },
 
1527
  ""maxItems"":1
 
1528
}";
 
1529
 
 
1530
      string json = "[1,2]";
 
1531
 
 
1532
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
1533
 
 
1534
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
1535
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
1536
      reader.Schema = JsonSchema.Parse(schemaJson);
 
1537
 
 
1538
      reader.Read();
 
1539
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
1540
 
 
1541
      reader.ReadAsInt32();
 
1542
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
1543
      Assert.AreEqual(null, validationEventArgs);
 
1544
 
 
1545
      reader.ReadAsInt32();
 
1546
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
1547
      Assert.AreEqual(null, validationEventArgs);
 
1548
 
 
1549
      reader.ReadAsInt32();
 
1550
      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
 
1551
      Assert.AreEqual("Array item count 2 exceeds maximum count of 1. Line 1, position 5.", validationEventArgs.Message);
 
1552
      Assert.AreEqual("", validationEventArgs.Path);
 
1553
    }
 
1554
 
 
1555
    [Test]
 
1556
    public void ReadAsInt32InArrayIncomplete()
 
1557
    {
 
1558
      string schemaJson = @"{
 
1559
  ""type"":""array"",
 
1560
  ""items"":{
 
1561
    ""type"":""integer""
 
1562
  },
 
1563
  ""maxItems"":1
 
1564
}";
 
1565
 
 
1566
      string json = "[1,2";
 
1567
 
 
1568
      Json.Schema.ValidationEventArgs validationEventArgs = null;
 
1569
 
 
1570
      JsonValidatingReader reader = new JsonValidatingReader(new JsonTextReader(new StringReader(json)));
 
1571
      reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
 
1572
      reader.Schema = JsonSchema.Parse(schemaJson);
 
1573
 
 
1574
      reader.Read();
 
1575
      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
 
1576
 
 
1577
      reader.ReadAsInt32();
 
1578
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
1579
      Assert.AreEqual(null, validationEventArgs);
 
1580
 
 
1581
      reader.ReadAsInt32();
 
1582
      Assert.AreEqual(JsonToken.Integer, reader.TokenType);
 
1583
      Assert.AreEqual(null, validationEventArgs);
 
1584
 
 
1585
      reader.ReadAsInt32();
 
1586
      Assert.AreEqual(JsonToken.None, reader.TokenType);
 
1587
      Assert.AreEqual(null, validationEventArgs);
 
1588
    }
 
1589
  }
 
1590
}
 
 
b'\\ No newline at end of file'