1 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
2 // Distributed under MIT license, or public domain if desired and
3 // recognized in your jurisdiction.
4 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
5
6 #if defined(__GNUC__)
7 #pragma GCC diagnostic push
8 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
9 #elif defined(_MSC_VER)
10 #pragma warning(disable : 4996)
11 #endif
12
13 #include "fuzz.h"
14 #include "jsontest.h"
15 #include <cmath>
16 #include <cstring>
17 #include <iomanip>
18 #include <iostream>
19 #include <json/config.h>
20 #include <json/json.h>
21 #include <limits>
22 #include <sstream>
23 #include <string>
24
25 // Make numeric limits more convenient to talk about.
26 // Assumes int type in 32 bits.
27 #define kint32max Json::Value::maxInt
28 #define kint32min Json::Value::minInt
29 #define kuint32max Json::Value::maxUInt
30 #define kint64max Json::Value::maxInt64
31 #define kint64min Json::Value::minInt64
32 #define kuint64max Json::Value::maxUInt64
33
34 // static const double kdint64max = double(kint64max);
35 // static const float kfint64max = float(kint64max);
36 static const float kfint32max = float(kint32max);
37 static const float kfuint32max = float(kuint32max);
38
39 // //////////////////////////////////////////////////////////////////
40 // //////////////////////////////////////////////////////////////////
41 // Json Library test cases
42 // //////////////////////////////////////////////////////////////////
43 // //////////////////////////////////////////////////////////////////
44
45 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
uint64ToDouble(Json::UInt64 value)46 static inline double uint64ToDouble(Json::UInt64 value) {
47 return static_cast<double>(value);
48 }
49 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
uint64ToDouble(Json::UInt64 value)50 static inline double uint64ToDouble(Json::UInt64 value) {
51 return static_cast<double>(Json::Int64(value / 2)) * 2.0 +
52 static_cast<double>(Json::Int64(value & 1));
53 }
54 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
55
56 struct ValueTest : JsonTest::TestCase {
57 Json::Value null_;
58 Json::Value emptyArray_;
59 Json::Value emptyObject_;
60 Json::Value integer_;
61 Json::Value unsignedInteger_;
62 Json::Value smallUnsignedInteger_;
63 Json::Value real_;
64 Json::Value float_;
65 Json::Value array1_;
66 Json::Value object1_;
67 Json::Value emptyString_;
68 Json::Value string1_;
69 Json::Value string_;
70 Json::Value true_;
71 Json::Value false_;
72
ValueTestValueTest73 ValueTest()
74 : emptyArray_(Json::arrayValue), emptyObject_(Json::objectValue),
75 integer_(123456789), unsignedInteger_(34567890u),
76 smallUnsignedInteger_(Json::Value::UInt(Json::Value::maxInt)),
77 real_(1234.56789), float_(0.00390625f), emptyString_(""), string1_("a"),
78 string_("sometext with space"), true_(true), false_(false) {
79 array1_.append(1234);
80 object1_["id"] = 1234;
81 }
82
83 struct IsCheck {
84 /// Initialize all checks to \c false by default.
85 IsCheck();
86
87 bool isObject_{false};
88 bool isArray_{false};
89 bool isBool_{false};
90 bool isString_{false};
91 bool isNull_{false};
92
93 bool isInt_{false};
94 bool isInt64_{false};
95 bool isUInt_{false};
96 bool isUInt64_{false};
97 bool isIntegral_{false};
98 bool isDouble_{false};
99 bool isNumeric_{false};
100 };
101
102 void checkConstMemberCount(const Json::Value& value,
103 unsigned int expectedCount);
104
105 void checkMemberCount(Json::Value& value, unsigned int expectedCount);
106
107 void checkIs(const Json::Value& value, const IsCheck& check);
108
109 void checkIsLess(const Json::Value& x, const Json::Value& y);
110
111 void checkIsEqual(const Json::Value& x, const Json::Value& y);
112
113 /// Normalize the representation of floating-point number by stripped leading
114 /// 0 in exponent.
115 static Json::String normalizeFloatingPointStr(const Json::String& s);
116 };
117
normalizeFloatingPointStr(const Json::String & s)118 Json::String ValueTest::normalizeFloatingPointStr(const Json::String& s) {
119 Json::String::size_type index = s.find_last_of("eE");
120 if (index != Json::String::npos) {
121 Json::String::size_type hasSign =
122 (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
123 Json::String::size_type exponentStartIndex = index + 1 + hasSign;
124 Json::String normalized = s.substr(0, exponentStartIndex);
125 Json::String::size_type indexDigit =
126 s.find_first_not_of('0', exponentStartIndex);
127 Json::String exponent = "0";
128 if (indexDigit != Json::String::npos) // There is an exponent different
129 // from 0
130 {
131 exponent = s.substr(indexDigit);
132 }
133 return normalized + exponent;
134 }
135 return s;
136 }
137
JSONTEST_FIXTURE(ValueTest,checkNormalizeFloatingPointStr)138 JSONTEST_FIXTURE(ValueTest, checkNormalizeFloatingPointStr) {
139 JSONTEST_ASSERT_STRING_EQUAL("0.0", normalizeFloatingPointStr("0.0"));
140 JSONTEST_ASSERT_STRING_EQUAL("0e0", normalizeFloatingPointStr("0e0"));
141 JSONTEST_ASSERT_STRING_EQUAL("1234.0", normalizeFloatingPointStr("1234.0"));
142 JSONTEST_ASSERT_STRING_EQUAL("1234.0e0",
143 normalizeFloatingPointStr("1234.0e0"));
144 JSONTEST_ASSERT_STRING_EQUAL("1234.0e+0",
145 normalizeFloatingPointStr("1234.0e+0"));
146 JSONTEST_ASSERT_STRING_EQUAL("1234e-1", normalizeFloatingPointStr("1234e-1"));
147 JSONTEST_ASSERT_STRING_EQUAL("1234e10", normalizeFloatingPointStr("1234e10"));
148 JSONTEST_ASSERT_STRING_EQUAL("1234e10",
149 normalizeFloatingPointStr("1234e010"));
150 JSONTEST_ASSERT_STRING_EQUAL("1234e+10",
151 normalizeFloatingPointStr("1234e+010"));
152 JSONTEST_ASSERT_STRING_EQUAL("1234e-10",
153 normalizeFloatingPointStr("1234e-010"));
154 JSONTEST_ASSERT_STRING_EQUAL("1234e+100",
155 normalizeFloatingPointStr("1234e+100"));
156 JSONTEST_ASSERT_STRING_EQUAL("1234e-100",
157 normalizeFloatingPointStr("1234e-100"));
158 JSONTEST_ASSERT_STRING_EQUAL("1234e+1",
159 normalizeFloatingPointStr("1234e+001"));
160 }
161
JSONTEST_FIXTURE(ValueTest,memberCount)162 JSONTEST_FIXTURE(ValueTest, memberCount) {
163 JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));
164 JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));
165 JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));
166 JSONTEST_ASSERT_PRED(checkMemberCount(object1_, 1));
167 JSONTEST_ASSERT_PRED(checkMemberCount(null_, 0));
168 JSONTEST_ASSERT_PRED(checkMemberCount(integer_, 0));
169 JSONTEST_ASSERT_PRED(checkMemberCount(unsignedInteger_, 0));
170 JSONTEST_ASSERT_PRED(checkMemberCount(smallUnsignedInteger_, 0));
171 JSONTEST_ASSERT_PRED(checkMemberCount(real_, 0));
172 JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));
173 JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));
174 JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));
175 }
176
JSONTEST_FIXTURE(ValueTest,objects)177 JSONTEST_FIXTURE(ValueTest, objects) {
178 // Types
179 IsCheck checks;
180 checks.isObject_ = true;
181 JSONTEST_ASSERT_PRED(checkIs(emptyObject_, checks));
182 JSONTEST_ASSERT_PRED(checkIs(object1_, checks));
183
184 JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
185
186 // Empty object okay
187 JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
188
189 // Non-empty object not okay
190 JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
191
192 // Always okay
193 JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
194
195 // Never okay
196 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
197 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
198 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
199 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
200 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
201 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
202
203 // Access through const reference
204 const Json::Value& constObject = object1_;
205
206 JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
207 JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
208
209 // Access through find()
210 const char idKey[] = "id";
211 const Json::Value* foundId = object1_.find(idKey, idKey + strlen(idKey));
212 JSONTEST_ASSERT(foundId != nullptr);
213 JSONTEST_ASSERT_EQUAL(Json::Value(1234), *foundId);
214
215 const char unknownIdKey[] = "unknown id";
216 const Json::Value* foundUnknownId =
217 object1_.find(unknownIdKey, unknownIdKey + strlen(unknownIdKey));
218 JSONTEST_ASSERT_EQUAL(nullptr, foundUnknownId);
219
220 // Access through demand()
221 const char yetAnotherIdKey[] = "yet another id";
222 const Json::Value* foundYetAnotherId =
223 object1_.find(yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));
224 JSONTEST_ASSERT_EQUAL(nullptr, foundYetAnotherId);
225 Json::Value* demandedYetAnotherId = object1_.demand(
226 yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));
227 JSONTEST_ASSERT(demandedYetAnotherId != nullptr);
228 *demandedYetAnotherId = "baz";
229
230 JSONTEST_ASSERT_EQUAL(Json::Value("baz"), object1_["yet another id"]);
231
232 // Access through non-const reference
233 JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
234 JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
235
236 object1_["some other id"] = "foo";
237 JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
238 JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
239
240 // Remove.
241 Json::Value got;
242 bool did;
243 did = object1_.removeMember("some other id", &got);
244 JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);
245 JSONTEST_ASSERT_EQUAL(true, did);
246 got = Json::Value("bar");
247 did = object1_.removeMember("some other id", &got);
248 JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);
249 JSONTEST_ASSERT_EQUAL(false, did);
250
251 object1_["some other id"] = "foo";
252 Json::Value* gotPtr = nullptr;
253 did = object1_.removeMember("some other id", gotPtr);
254 JSONTEST_ASSERT_EQUAL(nullptr, gotPtr);
255 JSONTEST_ASSERT_EQUAL(true, did);
256 }
257
JSONTEST_FIXTURE(ValueTest,arrays)258 JSONTEST_FIXTURE(ValueTest, arrays) {
259 const unsigned int index0 = 0;
260
261 // Types
262 IsCheck checks;
263 checks.isArray_ = true;
264 JSONTEST_ASSERT_PRED(checkIs(emptyArray_, checks));
265 JSONTEST_ASSERT_PRED(checkIs(array1_, checks));
266
267 JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
268
269 // Empty array okay
270 JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
271
272 // Non-empty array not okay
273 JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
274
275 // Always okay
276 JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
277
278 // Never okay
279 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
280 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
281 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
282 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
283 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
284 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
285
286 // Access through const reference
287 const Json::Value& constArray = array1_;
288 JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
289 JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
290
291 // Access through non-const reference
292 JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
293 JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
294
295 array1_[2] = Json::Value(17);
296 JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
297 JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
298 Json::Value got;
299 JSONTEST_ASSERT_EQUAL(true, array1_.removeIndex(2, &got));
300 JSONTEST_ASSERT_EQUAL(Json::Value(17), got);
301 JSONTEST_ASSERT_EQUAL(false, array1_.removeIndex(2, &got)); // gone now
302 }
JSONTEST_FIXTURE(ValueTest,arrayIssue252)303 JSONTEST_FIXTURE(ValueTest, arrayIssue252) {
304 int count = 5;
305 Json::Value root;
306 Json::Value item;
307 root["array"] = Json::Value::nullRef;
308 for (int i = 0; i < count; i++) {
309 item["a"] = i;
310 item["b"] = i;
311 root["array"][i] = item;
312 }
313 // JSONTEST_ASSERT_EQUAL(5, root["array"].size());
314 }
315
JSONTEST_FIXTURE(ValueTest,null)316 JSONTEST_FIXTURE(ValueTest, null) {
317 JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
318
319 IsCheck checks;
320 checks.isNull_ = true;
321 JSONTEST_ASSERT_PRED(checkIs(null_, checks));
322
323 JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
324 JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
325 JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
326 JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
327 JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
328 JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
329 JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
330 JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
331
332 JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
333 JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
334 JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
335 JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
336 JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
337 JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
338 JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
339
340 JSONTEST_ASSERT_EQUAL(Json::Value::null, null_);
341
342 // Test using a Value in a boolean context (false iff null)
343 JSONTEST_ASSERT_EQUAL(null_, false);
344 JSONTEST_ASSERT_EQUAL(object1_, true);
345 JSONTEST_ASSERT_EQUAL(!null_, true);
346 JSONTEST_ASSERT_EQUAL(!object1_, false);
347 }
348
JSONTEST_FIXTURE(ValueTest,strings)349 JSONTEST_FIXTURE(ValueTest, strings) {
350 JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
351
352 IsCheck checks;
353 checks.isString_ = true;
354 JSONTEST_ASSERT_PRED(checkIs(emptyString_, checks));
355 JSONTEST_ASSERT_PRED(checkIs(string_, checks));
356 JSONTEST_ASSERT_PRED(checkIs(string1_, checks));
357
358 // Empty string okay
359 JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
360
361 // Non-empty string not okay
362 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
363
364 // Always okay
365 JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
366
367 // Never okay
368 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
369 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
370 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
371 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
372 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
373
374 JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
375 JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
376 }
377
JSONTEST_FIXTURE(ValueTest,bools)378 JSONTEST_FIXTURE(ValueTest, bools) {
379 JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
380
381 IsCheck checks;
382 checks.isBool_ = true;
383 JSONTEST_ASSERT_PRED(checkIs(false_, checks));
384 JSONTEST_ASSERT_PRED(checkIs(true_, checks));
385
386 // False okay
387 JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
388
389 // True not okay
390 JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
391
392 // Always okay
393 JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
394 JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
395 JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
396 JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
397 JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
398
399 // Never okay
400 JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
401 JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
402
403 JSONTEST_ASSERT_EQUAL(true, true_.asBool());
404 JSONTEST_ASSERT_EQUAL(1, true_.asInt());
405 JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
406 JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
407 JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
408 JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
409 JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
410
411 JSONTEST_ASSERT_EQUAL(false, false_.asBool());
412 JSONTEST_ASSERT_EQUAL(0, false_.asInt());
413 JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
414 JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
415 JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
416 JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
417 JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
418 }
419
JSONTEST_FIXTURE(ValueTest,integers)420 JSONTEST_FIXTURE(ValueTest, integers) {
421 IsCheck checks;
422 Json::Value val;
423
424 // Conversions that don't depend on the value.
425 JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
426 JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
427 JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
428 JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
429 JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
430
431 JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
432 JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
433 JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
434 JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
435 JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
436
437 JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
438 JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
439 JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
440 JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
441 JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
442
443 // Default int
444 val = Json::Value(Json::intValue);
445
446 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
447
448 checks = IsCheck();
449 checks.isInt_ = true;
450 checks.isInt64_ = true;
451 checks.isUInt_ = true;
452 checks.isUInt64_ = true;
453 checks.isIntegral_ = true;
454 checks.isDouble_ = true;
455 checks.isNumeric_ = true;
456 JSONTEST_ASSERT_PRED(checkIs(val, checks));
457
458 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
459 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
460 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
461
462 JSONTEST_ASSERT_EQUAL(0, val.asInt());
463 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
464 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
465 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
466 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
467 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
468 JSONTEST_ASSERT_EQUAL(false, val.asBool());
469 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
470
471 // Default uint
472 val = Json::Value(Json::uintValue);
473
474 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
475
476 checks = IsCheck();
477 checks.isInt_ = true;
478 checks.isInt64_ = true;
479 checks.isUInt_ = true;
480 checks.isUInt64_ = true;
481 checks.isIntegral_ = true;
482 checks.isDouble_ = true;
483 checks.isNumeric_ = true;
484 JSONTEST_ASSERT_PRED(checkIs(val, checks));
485
486 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
487 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
488 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
489
490 JSONTEST_ASSERT_EQUAL(0, val.asInt());
491 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
492 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
493 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
494 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
495 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
496 JSONTEST_ASSERT_EQUAL(false, val.asBool());
497 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
498
499 // Default real
500 val = Json::Value(Json::realValue);
501
502 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
503
504 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
505 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
506 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
507
508 checks = IsCheck();
509 checks.isInt_ = true;
510 checks.isInt64_ = true;
511 checks.isUInt_ = true;
512 checks.isUInt64_ = true;
513 checks.isIntegral_ = true;
514 checks.isDouble_ = true;
515 checks.isNumeric_ = true;
516 JSONTEST_ASSERT_PRED(checkIs(val, checks));
517
518 JSONTEST_ASSERT_EQUAL(0, val.asInt());
519 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
520 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
521 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
522 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
523 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
524 JSONTEST_ASSERT_EQUAL(false, val.asBool());
525 JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
526
527 // Zero (signed constructor arg)
528 val = Json::Value(0);
529
530 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
531
532 checks = IsCheck();
533 checks.isInt_ = true;
534 checks.isInt64_ = true;
535 checks.isUInt_ = true;
536 checks.isUInt64_ = true;
537 checks.isIntegral_ = true;
538 checks.isDouble_ = true;
539 checks.isNumeric_ = true;
540 JSONTEST_ASSERT_PRED(checkIs(val, checks));
541
542 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
543 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
544 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
545
546 JSONTEST_ASSERT_EQUAL(0, val.asInt());
547 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
548 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
549 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
550 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
551 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
552 JSONTEST_ASSERT_EQUAL(false, val.asBool());
553 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
554
555 // Zero (unsigned constructor arg)
556 val = Json::Value(0u);
557
558 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
559
560 checks = IsCheck();
561 checks.isInt_ = true;
562 checks.isInt64_ = true;
563 checks.isUInt_ = true;
564 checks.isUInt64_ = true;
565 checks.isIntegral_ = true;
566 checks.isDouble_ = true;
567 checks.isNumeric_ = true;
568 JSONTEST_ASSERT_PRED(checkIs(val, checks));
569
570 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
571 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
572 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
573
574 JSONTEST_ASSERT_EQUAL(0, val.asInt());
575 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
576 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
577 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
578 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
579 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
580 JSONTEST_ASSERT_EQUAL(false, val.asBool());
581 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
582
583 // Zero (floating-point constructor arg)
584 val = Json::Value(0.0);
585
586 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
587
588 checks = IsCheck();
589 checks.isInt_ = true;
590 checks.isInt64_ = true;
591 checks.isUInt_ = true;
592 checks.isUInt64_ = true;
593 checks.isIntegral_ = true;
594 checks.isDouble_ = true;
595 checks.isNumeric_ = true;
596 JSONTEST_ASSERT_PRED(checkIs(val, checks));
597
598 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
599 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
600 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
601
602 JSONTEST_ASSERT_EQUAL(0, val.asInt());
603 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
604 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
605 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
606 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
607 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
608 JSONTEST_ASSERT_EQUAL(false, val.asBool());
609 JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
610
611 // 2^20 (signed constructor arg)
612 val = Json::Value(1 << 20);
613
614 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
615 checks = IsCheck();
616 checks.isInt_ = true;
617 checks.isInt64_ = true;
618 checks.isUInt_ = true;
619 checks.isUInt64_ = true;
620 checks.isIntegral_ = true;
621 checks.isDouble_ = true;
622 checks.isNumeric_ = true;
623 JSONTEST_ASSERT_PRED(checkIs(val, checks));
624
625 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
626 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
627 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
628
629 JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
630 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
631 JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
632 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
633 JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
634 JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
635 JSONTEST_ASSERT_EQUAL(true, val.asBool());
636 JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
637
638 // 2^20 (unsigned constructor arg)
639 val = Json::Value(Json::UInt(1 << 20));
640
641 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
642
643 checks = IsCheck();
644 checks.isInt_ = true;
645 checks.isInt64_ = true;
646 checks.isUInt_ = true;
647 checks.isUInt64_ = true;
648 checks.isIntegral_ = true;
649 checks.isDouble_ = true;
650 checks.isNumeric_ = true;
651 JSONTEST_ASSERT_PRED(checkIs(val, checks));
652
653 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
654 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
655 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
656
657 JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
658 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
659 JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
660 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
661 JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
662 JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
663 JSONTEST_ASSERT_EQUAL(true, val.asBool());
664 JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
665
666 // 2^20 (floating-point constructor arg)
667 val = Json::Value((1 << 20) / 1.0);
668
669 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
670
671 checks = IsCheck();
672 checks.isInt_ = true;
673 checks.isInt64_ = true;
674 checks.isUInt_ = true;
675 checks.isUInt64_ = true;
676 checks.isIntegral_ = true;
677 checks.isDouble_ = true;
678 checks.isNumeric_ = true;
679 JSONTEST_ASSERT_PRED(checkIs(val, checks));
680
681 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
682 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
683 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
684
685 JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
686 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
687 JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
688 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
689 JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
690 JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
691 JSONTEST_ASSERT_EQUAL(true, val.asBool());
692 JSONTEST_ASSERT_STRING_EQUAL(
693 "1048576.0",
694 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
695
696 // -2^20
697 val = Json::Value(-(1 << 20));
698
699 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
700
701 checks = IsCheck();
702 checks.isInt_ = true;
703 checks.isInt64_ = true;
704 checks.isIntegral_ = true;
705 checks.isDouble_ = true;
706 checks.isNumeric_ = true;
707 JSONTEST_ASSERT_PRED(checkIs(val, checks));
708
709 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
710 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
711 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
712
713 JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
714 JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
715 JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
716 JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
717 JSONTEST_ASSERT_EQUAL(true, val.asBool());
718 JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
719
720 // int32 max
721 val = Json::Value(kint32max);
722
723 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
724
725 checks = IsCheck();
726 checks.isInt_ = true;
727 checks.isInt64_ = true;
728 checks.isUInt_ = true;
729 checks.isUInt64_ = true;
730 checks.isIntegral_ = true;
731 checks.isDouble_ = true;
732 checks.isNumeric_ = true;
733 JSONTEST_ASSERT_PRED(checkIs(val, checks));
734
735 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
736 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
737 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
738
739 JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
740 JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
741 JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
742 JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
743 JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
744 JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
745 JSONTEST_ASSERT_EQUAL(true, val.asBool());
746 JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
747
748 // int32 min
749 val = Json::Value(kint32min);
750
751 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
752
753 checks = IsCheck();
754 checks.isInt_ = true;
755 checks.isInt64_ = true;
756 checks.isIntegral_ = true;
757 checks.isDouble_ = true;
758 checks.isNumeric_ = true;
759 JSONTEST_ASSERT_PRED(checkIs(val, checks));
760
761 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
762 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
763 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
764
765 JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
766 JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
767 JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
768 JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
769 JSONTEST_ASSERT_EQUAL(true, val.asBool());
770 JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
771
772 // uint32 max
773 val = Json::Value(kuint32max);
774
775 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
776
777 checks = IsCheck();
778 checks.isInt64_ = true;
779 checks.isUInt_ = true;
780 checks.isUInt64_ = true;
781 checks.isIntegral_ = true;
782 checks.isDouble_ = true;
783 checks.isNumeric_ = true;
784 JSONTEST_ASSERT_PRED(checkIs(val, checks));
785
786 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
787 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
788 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
789
790 #ifndef JSON_NO_INT64
791 JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
792 #endif
793 JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
794 JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
795 JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
796 JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
797 JSONTEST_ASSERT_EQUAL(true, val.asBool());
798 JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
799
800 #ifdef JSON_NO_INT64
801 // int64 max
802 val = Json::Value(double(kint64max));
803
804 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
805
806 checks = IsCheck();
807 checks.isDouble_ = true;
808 checks.isNumeric_ = true;
809 JSONTEST_ASSERT_PRED(checkIs(val, checks));
810
811 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
812 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
813 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
814
815 JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
816 JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
817 JSONTEST_ASSERT_EQUAL(true, val.asBool());
818 JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
819
820 // int64 min
821 val = Json::Value(double(kint64min));
822
823 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
824
825 checks = IsCheck();
826 checks.isDouble_ = true;
827 checks.isNumeric_ = true;
828 JSONTEST_ASSERT_PRED(checkIs(val, checks));
829
830 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
831 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
832 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
833
834 JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
835 JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
836 JSONTEST_ASSERT_EQUAL(true, val.asBool());
837 JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
838
839 // uint64 max
840 val = Json::Value(double(kuint64max));
841
842 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
843
844 checks = IsCheck();
845 checks.isDouble_ = true;
846 checks.isNumeric_ = true;
847 JSONTEST_ASSERT_PRED(checkIs(val, checks));
848
849 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
850 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
851 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
852
853 JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
854 JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
855 JSONTEST_ASSERT_EQUAL(true, val.asBool());
856 JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
857 #else // ifdef JSON_NO_INT64
858 // 2^40 (signed constructor arg)
859 val = Json::Value(Json::Int64(1) << 40);
860
861 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
862
863 checks = IsCheck();
864 checks.isInt64_ = true;
865 checks.isUInt64_ = true;
866 checks.isIntegral_ = true;
867 checks.isDouble_ = true;
868 checks.isNumeric_ = true;
869 JSONTEST_ASSERT_PRED(checkIs(val, checks));
870
871 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
872 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
873 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
874
875 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
876 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
877 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
878 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
879 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
880 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
881 JSONTEST_ASSERT_EQUAL(true, val.asBool());
882 JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
883
884 // 2^40 (unsigned constructor arg)
885 val = Json::Value(Json::UInt64(1) << 40);
886
887 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
888
889 checks = IsCheck();
890 checks.isInt64_ = true;
891 checks.isUInt64_ = true;
892 checks.isIntegral_ = true;
893 checks.isDouble_ = true;
894 checks.isNumeric_ = true;
895 JSONTEST_ASSERT_PRED(checkIs(val, checks));
896
897 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
898 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
899 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
900
901 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
902 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
903 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
904 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
905 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
906 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
907 JSONTEST_ASSERT_EQUAL(true, val.asBool());
908 JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
909
910 // 2^40 (floating-point constructor arg)
911 val = Json::Value((Json::Int64(1) << 40) / 1.0);
912
913 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
914
915 checks = IsCheck();
916 checks.isInt64_ = true;
917 checks.isUInt64_ = true;
918 checks.isIntegral_ = true;
919 checks.isDouble_ = true;
920 checks.isNumeric_ = true;
921 JSONTEST_ASSERT_PRED(checkIs(val, checks));
922
923 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
924 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
925 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
926
927 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
928 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
929 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
930 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
931 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
932 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
933 JSONTEST_ASSERT_EQUAL(true, val.asBool());
934 JSONTEST_ASSERT_STRING_EQUAL(
935 "1099511627776.0",
936 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
937
938 // -2^40
939 val = Json::Value(-(Json::Int64(1) << 40));
940
941 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
942
943 checks = IsCheck();
944 checks.isInt64_ = true;
945 checks.isIntegral_ = true;
946 checks.isDouble_ = true;
947 checks.isNumeric_ = true;
948 JSONTEST_ASSERT_PRED(checkIs(val, checks));
949
950 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
951 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
952 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
953
954 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
955 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
956 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
957 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
958 JSONTEST_ASSERT_EQUAL(true, val.asBool());
959 JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
960
961 // int64 max
962 val = Json::Value(Json::Int64(kint64max));
963
964 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
965
966 checks = IsCheck();
967 checks.isInt64_ = true;
968 checks.isUInt64_ = true;
969 checks.isIntegral_ = true;
970 checks.isDouble_ = true;
971 checks.isNumeric_ = true;
972 JSONTEST_ASSERT_PRED(checkIs(val, checks));
973
974 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
975 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
976 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
977
978 JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
979 JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
980 JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
981 JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
982 JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
983 JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
984 JSONTEST_ASSERT_EQUAL(true, val.asBool());
985 JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
986
987 // int64 max (floating point constructor). Note that kint64max is not exactly
988 // representable as a double, and will be rounded up to be higher.
989 val = Json::Value(double(kint64max));
990
991 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
992
993 checks = IsCheck();
994 checks.isUInt64_ = true;
995 checks.isIntegral_ = true;
996 checks.isDouble_ = true;
997 checks.isNumeric_ = true;
998 JSONTEST_ASSERT_PRED(checkIs(val, checks));
999
1000 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1001 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1002 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1003
1004 JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
1005 JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
1006 JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
1007 JSONTEST_ASSERT_EQUAL(float(Json::UInt64(1) << 63), val.asFloat());
1008
1009 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1010 JSONTEST_ASSERT_STRING_EQUAL(
1011 "9.2233720368547758e+18",
1012 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1013
1014 // int64 min
1015 val = Json::Value(Json::Int64(kint64min));
1016
1017 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
1018
1019 checks = IsCheck();
1020 checks.isInt64_ = true;
1021 checks.isIntegral_ = true;
1022 checks.isDouble_ = true;
1023 checks.isNumeric_ = true;
1024 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1025
1026 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1027 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1028 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1029
1030 JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
1031 JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
1032 JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
1033 JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
1034 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1035 JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
1036
1037 // int64 min (floating point constructor). Note that kint64min *is* exactly
1038 // representable as a double.
1039 val = Json::Value(double(kint64min));
1040
1041 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1042
1043 checks = IsCheck();
1044 checks.isInt64_ = true;
1045 checks.isIntegral_ = true;
1046 checks.isDouble_ = true;
1047 checks.isNumeric_ = true;
1048 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1049
1050 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1051 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1052 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1053
1054 JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
1055 JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
1056 JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
1057 JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
1058 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1059 JSONTEST_ASSERT_STRING_EQUAL(
1060 "-9.2233720368547758e+18",
1061 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1062
1063 // 10^19
1064 const auto ten_to_19 = static_cast<Json::UInt64>(1e19);
1065 val = Json::Value(Json::UInt64(ten_to_19));
1066
1067 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
1068
1069 checks = IsCheck();
1070 checks.isUInt64_ = true;
1071 checks.isIntegral_ = true;
1072 checks.isDouble_ = true;
1073 checks.isNumeric_ = true;
1074 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1075
1076 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1077 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1078 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1079
1080 JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
1081 JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
1082 JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
1083 JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
1084 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1085 JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
1086
1087 // 10^19 (double constructor). Note that 10^19 is not exactly representable
1088 // as a double.
1089 val = Json::Value(uint64ToDouble(ten_to_19));
1090
1091 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1092
1093 checks = IsCheck();
1094 checks.isUInt64_ = true;
1095 checks.isIntegral_ = true;
1096 checks.isDouble_ = true;
1097 checks.isNumeric_ = true;
1098 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1099
1100 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1101 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1102 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1103
1104 JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
1105 JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
1106 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1107 JSONTEST_ASSERT_STRING_EQUAL(
1108 "1e+19",
1109 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1110
1111 // uint64 max
1112 val = Json::Value(Json::UInt64(kuint64max));
1113
1114 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
1115
1116 checks = IsCheck();
1117 checks.isUInt64_ = true;
1118 checks.isIntegral_ = true;
1119 checks.isDouble_ = true;
1120 checks.isNumeric_ = true;
1121 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1122
1123 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1124 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1125 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1126
1127 JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
1128 JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
1129 JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
1130 JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
1131 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1132 JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
1133
1134 // uint64 max (floating point constructor). Note that kuint64max is not
1135 // exactly representable as a double, and will be rounded up to be higher.
1136 val = Json::Value(uint64ToDouble(kuint64max));
1137
1138 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1139
1140 checks = IsCheck();
1141 checks.isDouble_ = true;
1142 checks.isNumeric_ = true;
1143 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1144
1145 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1146 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1147 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1148
1149 JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
1150 JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
1151 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1152 JSONTEST_ASSERT_STRING_EQUAL(
1153 "1.8446744073709552e+19",
1154 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1155 #endif
1156 }
1157
JSONTEST_FIXTURE(ValueTest,nonIntegers)1158 JSONTEST_FIXTURE(ValueTest, nonIntegers) {
1159 IsCheck checks;
1160 Json::Value val;
1161
1162 // Small positive number
1163 val = Json::Value(1.5);
1164
1165 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1166
1167 checks = IsCheck();
1168 checks.isDouble_ = true;
1169 checks.isNumeric_ = true;
1170 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1171
1172 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
1173 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
1174 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1175 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1176 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1177 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1178 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1179 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1180
1181 JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
1182 JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
1183 JSONTEST_ASSERT_EQUAL(1, val.asInt());
1184 JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
1185 JSONTEST_ASSERT_EQUAL(1, val.asUInt());
1186 JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
1187 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1188 JSONTEST_ASSERT_EQUAL("1.5", val.asString());
1189
1190 // Small negative number
1191 val = Json::Value(-1.5);
1192
1193 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1194
1195 checks = IsCheck();
1196 checks.isDouble_ = true;
1197 checks.isNumeric_ = true;
1198 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1199
1200 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
1201 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1202 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1203 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1204 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1205 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1206 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1207 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1208
1209 JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
1210 JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
1211 JSONTEST_ASSERT_EQUAL(-1, val.asInt());
1212 JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
1213 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1214 JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
1215
1216 // A bit over int32 max
1217 val = Json::Value(kint32max + 0.5);
1218
1219 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1220
1221 checks = IsCheck();
1222 checks.isDouble_ = true;
1223 checks.isNumeric_ = true;
1224 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1225
1226 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
1227 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1228 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1229 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1230 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1231 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1232 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1233 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1234
1235 JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
1236 JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
1237 JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
1238 #ifdef JSON_HAS_INT64
1239 JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
1240 JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
1241 #endif
1242 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1243 JSONTEST_ASSERT_EQUAL(
1244 "2147483647.5",
1245 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1246
1247 // A bit under int32 min
1248 val = Json::Value(kint32min - 0.5);
1249
1250 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1251
1252 checks = IsCheck();
1253 checks.isDouble_ = true;
1254 checks.isNumeric_ = true;
1255 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1256
1257 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1258 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1259 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1260 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1261 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1262 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1263 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1264 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1265
1266 JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
1267 JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
1268 #ifdef JSON_HAS_INT64
1269 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 31), val.asLargestInt());
1270 #endif
1271 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1272 JSONTEST_ASSERT_EQUAL(
1273 "-2147483648.5",
1274 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1275
1276 // A bit over uint32 max
1277 val = Json::Value(kuint32max + 0.5);
1278
1279 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1280
1281 checks = IsCheck();
1282 checks.isDouble_ = true;
1283 checks.isNumeric_ = true;
1284 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1285
1286 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1287 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1288 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1289 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1290 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1291 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1292 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1293 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1294
1295 JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
1296 JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
1297 #ifdef JSON_HAS_INT64
1298 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32) - 1, val.asLargestInt());
1299 JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32) - Json::UInt64(1),
1300 val.asLargestUInt());
1301 #endif
1302 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1303 JSONTEST_ASSERT_EQUAL(
1304 "4294967295.5",
1305 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1306
1307 val = Json::Value(1.2345678901234);
1308 JSONTEST_ASSERT_STRING_EQUAL(
1309 "1.2345678901234001",
1310 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1311
1312 // A 16-digit floating point number.
1313 val = Json::Value(2199023255552000.0f);
1314 JSONTEST_ASSERT_EQUAL(float(2199023255552000.0f), val.asFloat());
1315 JSONTEST_ASSERT_STRING_EQUAL(
1316 "2199023255552000.0",
1317 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1318
1319 // A very large floating point number.
1320 val = Json::Value(3.402823466385289e38);
1321 JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
1322 JSONTEST_ASSERT_STRING_EQUAL(
1323 "3.402823466385289e+38",
1324 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1325
1326 // An even larger floating point number.
1327 val = Json::Value(1.2345678e300);
1328 JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
1329 JSONTEST_ASSERT_STRING_EQUAL(
1330 "1.2345678e+300",
1331 normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
1332 }
1333
checkConstMemberCount(const Json::Value & value,unsigned int expectedCount)1334 void ValueTest::checkConstMemberCount(const Json::Value& value,
1335 unsigned int expectedCount) {
1336 unsigned int count = 0;
1337 Json::Value::const_iterator itEnd = value.end();
1338 for (Json::Value::const_iterator it = value.begin(); it != itEnd; ++it) {
1339 ++count;
1340 }
1341 JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::const_iterator";
1342 }
1343
checkMemberCount(Json::Value & value,unsigned int expectedCount)1344 void ValueTest::checkMemberCount(Json::Value& value,
1345 unsigned int expectedCount) {
1346 JSONTEST_ASSERT_EQUAL(expectedCount, value.size());
1347
1348 unsigned int count = 0;
1349 Json::Value::iterator itEnd = value.end();
1350 for (Json::Value::iterator it = value.begin(); it != itEnd; ++it) {
1351 ++count;
1352 }
1353 JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::iterator";
1354
1355 JSONTEST_ASSERT_PRED(checkConstMemberCount(value, expectedCount));
1356 }
1357
1358 ValueTest::IsCheck::IsCheck()
1359
1360 = default;
1361
checkIs(const Json::Value & value,const IsCheck & check)1362 void ValueTest::checkIs(const Json::Value& value, const IsCheck& check) {
1363 JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject());
1364 JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray());
1365 JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool());
1366 JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble());
1367 JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt());
1368 JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt());
1369 JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral());
1370 JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric());
1371 JSONTEST_ASSERT_EQUAL(check.isString_, value.isString());
1372 JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull());
1373
1374 #ifdef JSON_HAS_INT64
1375 JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64());
1376 JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64());
1377 #else
1378 JSONTEST_ASSERT_EQUAL(false, value.isInt64());
1379 JSONTEST_ASSERT_EQUAL(false, value.isUInt64());
1380 #endif
1381 }
1382
JSONTEST_FIXTURE(ValueTest,compareNull)1383 JSONTEST_FIXTURE(ValueTest, compareNull) {
1384 JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value()));
1385 }
1386
JSONTEST_FIXTURE(ValueTest,compareInt)1387 JSONTEST_FIXTURE(ValueTest, compareInt) {
1388 JSONTEST_ASSERT_PRED(checkIsLess(0, 10));
1389 JSONTEST_ASSERT_PRED(checkIsEqual(10, 10));
1390 JSONTEST_ASSERT_PRED(checkIsEqual(-10, -10));
1391 JSONTEST_ASSERT_PRED(checkIsLess(-10, 0));
1392 }
1393
JSONTEST_FIXTURE(ValueTest,compareUInt)1394 JSONTEST_FIXTURE(ValueTest, compareUInt) {
1395 JSONTEST_ASSERT_PRED(checkIsLess(0u, 10u));
1396 JSONTEST_ASSERT_PRED(checkIsLess(0u, Json::Value::maxUInt));
1397 JSONTEST_ASSERT_PRED(checkIsEqual(10u, 10u));
1398 }
1399
JSONTEST_FIXTURE(ValueTest,compareDouble)1400 JSONTEST_FIXTURE(ValueTest, compareDouble) {
1401 JSONTEST_ASSERT_PRED(checkIsLess(0.0, 10.0));
1402 JSONTEST_ASSERT_PRED(checkIsEqual(10.0, 10.0));
1403 JSONTEST_ASSERT_PRED(checkIsEqual(-10.0, -10.0));
1404 JSONTEST_ASSERT_PRED(checkIsLess(-10.0, 0.0));
1405 }
1406
JSONTEST_FIXTURE(ValueTest,compareString)1407 JSONTEST_FIXTURE(ValueTest, compareString) {
1408 JSONTEST_ASSERT_PRED(checkIsLess("", " "));
1409 JSONTEST_ASSERT_PRED(checkIsLess("", "a"));
1410 JSONTEST_ASSERT_PRED(checkIsLess("abcd", "zyui"));
1411 JSONTEST_ASSERT_PRED(checkIsLess("abc", "abcd"));
1412 JSONTEST_ASSERT_PRED(checkIsEqual("abcd", "abcd"));
1413 JSONTEST_ASSERT_PRED(checkIsEqual(" ", " "));
1414 JSONTEST_ASSERT_PRED(checkIsLess("ABCD", "abcd"));
1415 JSONTEST_ASSERT_PRED(checkIsEqual("ABCD", "ABCD"));
1416 }
1417
JSONTEST_FIXTURE(ValueTest,compareBoolean)1418 JSONTEST_FIXTURE(ValueTest, compareBoolean) {
1419 JSONTEST_ASSERT_PRED(checkIsLess(false, true));
1420 JSONTEST_ASSERT_PRED(checkIsEqual(false, false));
1421 JSONTEST_ASSERT_PRED(checkIsEqual(true, true));
1422 }
1423
JSONTEST_FIXTURE(ValueTest,compareArray)1424 JSONTEST_FIXTURE(ValueTest, compareArray) {
1425 // array compare size then content
1426 Json::Value emptyArray(Json::arrayValue);
1427 Json::Value l1aArray;
1428 l1aArray.append(0);
1429 Json::Value l1bArray;
1430 l1bArray.append(10);
1431 Json::Value l2aArray;
1432 l2aArray.append(0);
1433 l2aArray.append(0);
1434 Json::Value l2bArray;
1435 l2bArray.append(0);
1436 l2bArray.append(10);
1437 JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l1aArray));
1438 JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l2aArray));
1439 JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l2aArray));
1440 JSONTEST_ASSERT_PRED(checkIsLess(l2aArray, l2bArray));
1441 JSONTEST_ASSERT_PRED(checkIsEqual(emptyArray, Json::Value(emptyArray)));
1442 JSONTEST_ASSERT_PRED(checkIsEqual(l1aArray, Json::Value(l1aArray)));
1443 JSONTEST_ASSERT_PRED(checkIsEqual(l2bArray, Json::Value(l2bArray)));
1444 }
1445
JSONTEST_FIXTURE(ValueTest,compareObject)1446 JSONTEST_FIXTURE(ValueTest, compareObject) {
1447 // object compare size then content
1448 Json::Value emptyObject(Json::objectValue);
1449 Json::Value l1aObject;
1450 l1aObject["key1"] = 0;
1451 Json::Value l1bObject;
1452 l1aObject["key1"] = 10;
1453 Json::Value l2aObject;
1454 l2aObject["key1"] = 0;
1455 l2aObject["key2"] = 0;
1456 JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l1aObject));
1457 JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l2aObject));
1458 JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l2aObject));
1459 JSONTEST_ASSERT_PRED(checkIsEqual(emptyObject, Json::Value(emptyObject)));
1460 JSONTEST_ASSERT_PRED(checkIsEqual(l1aObject, Json::Value(l1aObject)));
1461 JSONTEST_ASSERT_PRED(checkIsEqual(l2aObject, Json::Value(l2aObject)));
1462 }
1463
JSONTEST_FIXTURE(ValueTest,compareType)1464 JSONTEST_FIXTURE(ValueTest, compareType) {
1465 // object of different type are ordered according to their type
1466 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(), Json::Value(1)));
1467 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1), Json::Value(1u)));
1468 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1u), Json::Value(1.0)));
1469 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1.0), Json::Value("a")));
1470 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value("a"), Json::Value(true)));
1471 JSONTEST_ASSERT_PRED(
1472 checkIsLess(Json::Value(true), Json::Value(Json::arrayValue)));
1473 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(Json::arrayValue),
1474 Json::Value(Json::objectValue)));
1475 }
1476
JSONTEST_FIXTURE(ValueTest,CopyObject)1477 JSONTEST_FIXTURE(ValueTest, CopyObject) {
1478 Json::Value arrayVal;
1479 arrayVal.append("val1");
1480 arrayVal.append("val2");
1481 arrayVal.append("val3");
1482 Json::Value stringVal("string value");
1483 Json::Value copy1, copy2;
1484 {
1485 Json::Value arrayCopy, stringCopy;
1486 arrayCopy.copy(arrayVal);
1487 stringCopy.copy(stringVal);
1488 JSONTEST_ASSERT_PRED(checkIsEqual(arrayCopy, arrayVal));
1489 JSONTEST_ASSERT_PRED(checkIsEqual(stringCopy, stringVal));
1490 arrayCopy.append("val4");
1491 JSONTEST_ASSERT(arrayCopy.size() == 4);
1492 arrayVal.append("new4");
1493 arrayVal.append("new5");
1494 JSONTEST_ASSERT(arrayVal.size() == 5);
1495 JSONTEST_ASSERT(!(arrayCopy == arrayVal));
1496 stringCopy = "another string";
1497 JSONTEST_ASSERT(!(stringCopy == stringVal));
1498 copy1.copy(arrayCopy);
1499 copy2.copy(stringCopy);
1500 }
1501 JSONTEST_ASSERT(arrayVal.size() == 5);
1502 JSONTEST_ASSERT(stringVal == "string value");
1503 JSONTEST_ASSERT(copy1.size() == 4);
1504 JSONTEST_ASSERT(copy2 == "another string");
1505 copy1.copy(stringVal);
1506 JSONTEST_ASSERT(copy1 == "string value");
1507 copy2.copy(arrayVal);
1508 JSONTEST_ASSERT(copy2.size() == 5);
1509 }
1510
checkIsLess(const Json::Value & x,const Json::Value & y)1511 void ValueTest::checkIsLess(const Json::Value& x, const Json::Value& y) {
1512 JSONTEST_ASSERT(x < y);
1513 JSONTEST_ASSERT(y > x);
1514 JSONTEST_ASSERT(x <= y);
1515 JSONTEST_ASSERT(y >= x);
1516 JSONTEST_ASSERT(!(x == y));
1517 JSONTEST_ASSERT(!(y == x));
1518 JSONTEST_ASSERT(!(x >= y));
1519 JSONTEST_ASSERT(!(y <= x));
1520 JSONTEST_ASSERT(!(x > y));
1521 JSONTEST_ASSERT(!(y < x));
1522 JSONTEST_ASSERT(x.compare(y) < 0);
1523 JSONTEST_ASSERT(y.compare(x) >= 0);
1524 }
1525
checkIsEqual(const Json::Value & x,const Json::Value & y)1526 void ValueTest::checkIsEqual(const Json::Value& x, const Json::Value& y) {
1527 JSONTEST_ASSERT(x == y);
1528 JSONTEST_ASSERT(y == x);
1529 JSONTEST_ASSERT(x <= y);
1530 JSONTEST_ASSERT(y <= x);
1531 JSONTEST_ASSERT(x >= y);
1532 JSONTEST_ASSERT(y >= x);
1533 JSONTEST_ASSERT(!(x < y));
1534 JSONTEST_ASSERT(!(y < x));
1535 JSONTEST_ASSERT(!(x > y));
1536 JSONTEST_ASSERT(!(y > x));
1537 JSONTEST_ASSERT(x.compare(y) == 0);
1538 JSONTEST_ASSERT(y.compare(x) == 0);
1539 }
1540
JSONTEST_FIXTURE(ValueTest,typeChecksThrowExceptions)1541 JSONTEST_FIXTURE(ValueTest, typeChecksThrowExceptions) {
1542 #if JSON_USE_EXCEPTION
1543
1544 Json::Value intVal(1);
1545 Json::Value strVal("Test");
1546 Json::Value objVal(Json::objectValue);
1547 Json::Value arrVal(Json::arrayValue);
1548
1549 JSONTEST_ASSERT_THROWS(intVal["test"]);
1550 JSONTEST_ASSERT_THROWS(strVal["test"]);
1551 JSONTEST_ASSERT_THROWS(arrVal["test"]);
1552
1553 JSONTEST_ASSERT_THROWS(intVal.removeMember("test"));
1554 JSONTEST_ASSERT_THROWS(strVal.removeMember("test"));
1555 JSONTEST_ASSERT_THROWS(arrVal.removeMember("test"));
1556
1557 JSONTEST_ASSERT_THROWS(intVal.getMemberNames());
1558 JSONTEST_ASSERT_THROWS(strVal.getMemberNames());
1559 JSONTEST_ASSERT_THROWS(arrVal.getMemberNames());
1560
1561 JSONTEST_ASSERT_THROWS(intVal[0]);
1562 JSONTEST_ASSERT_THROWS(objVal[0]);
1563 JSONTEST_ASSERT_THROWS(strVal[0]);
1564
1565 JSONTEST_ASSERT_THROWS(intVal.clear());
1566
1567 JSONTEST_ASSERT_THROWS(intVal.resize(1));
1568 JSONTEST_ASSERT_THROWS(strVal.resize(1));
1569 JSONTEST_ASSERT_THROWS(objVal.resize(1));
1570
1571 JSONTEST_ASSERT_THROWS(intVal.asCString());
1572
1573 JSONTEST_ASSERT_THROWS(objVal.asString());
1574 JSONTEST_ASSERT_THROWS(arrVal.asString());
1575
1576 JSONTEST_ASSERT_THROWS(strVal.asInt());
1577 JSONTEST_ASSERT_THROWS(objVal.asInt());
1578 JSONTEST_ASSERT_THROWS(arrVal.asInt());
1579
1580 JSONTEST_ASSERT_THROWS(strVal.asUInt());
1581 JSONTEST_ASSERT_THROWS(objVal.asUInt());
1582 JSONTEST_ASSERT_THROWS(arrVal.asUInt());
1583
1584 JSONTEST_ASSERT_THROWS(strVal.asInt64());
1585 JSONTEST_ASSERT_THROWS(objVal.asInt64());
1586 JSONTEST_ASSERT_THROWS(arrVal.asInt64());
1587
1588 JSONTEST_ASSERT_THROWS(strVal.asUInt64());
1589 JSONTEST_ASSERT_THROWS(objVal.asUInt64());
1590 JSONTEST_ASSERT_THROWS(arrVal.asUInt64());
1591
1592 JSONTEST_ASSERT_THROWS(strVal.asDouble());
1593 JSONTEST_ASSERT_THROWS(objVal.asDouble());
1594 JSONTEST_ASSERT_THROWS(arrVal.asDouble());
1595
1596 JSONTEST_ASSERT_THROWS(strVal.asFloat());
1597 JSONTEST_ASSERT_THROWS(objVal.asFloat());
1598 JSONTEST_ASSERT_THROWS(arrVal.asFloat());
1599
1600 JSONTEST_ASSERT_THROWS(strVal.asBool());
1601 JSONTEST_ASSERT_THROWS(objVal.asBool());
1602 JSONTEST_ASSERT_THROWS(arrVal.asBool());
1603
1604 #endif
1605 }
1606
JSONTEST_FIXTURE(ValueTest,offsetAccessors)1607 JSONTEST_FIXTURE(ValueTest, offsetAccessors) {
1608 Json::Value x;
1609 JSONTEST_ASSERT(x.getOffsetStart() == 0);
1610 JSONTEST_ASSERT(x.getOffsetLimit() == 0);
1611 x.setOffsetStart(10);
1612 x.setOffsetLimit(20);
1613 JSONTEST_ASSERT(x.getOffsetStart() == 10);
1614 JSONTEST_ASSERT(x.getOffsetLimit() == 20);
1615 Json::Value y(x);
1616 JSONTEST_ASSERT(y.getOffsetStart() == 10);
1617 JSONTEST_ASSERT(y.getOffsetLimit() == 20);
1618 Json::Value z;
1619 z.swap(y);
1620 JSONTEST_ASSERT(z.getOffsetStart() == 10);
1621 JSONTEST_ASSERT(z.getOffsetLimit() == 20);
1622 JSONTEST_ASSERT(y.getOffsetStart() == 0);
1623 JSONTEST_ASSERT(y.getOffsetLimit() == 0);
1624 }
1625
JSONTEST_FIXTURE(ValueTest,StaticString)1626 JSONTEST_FIXTURE(ValueTest, StaticString) {
1627 char mutant[] = "hello";
1628 Json::StaticString ss(mutant);
1629 Json::String regular(mutant);
1630 mutant[1] = 'a';
1631 JSONTEST_ASSERT_STRING_EQUAL("hallo", ss.c_str());
1632 JSONTEST_ASSERT_STRING_EQUAL("hello", regular.c_str());
1633 {
1634 Json::Value root;
1635 root["top"] = ss;
1636 JSONTEST_ASSERT_STRING_EQUAL("hallo", root["top"].asString());
1637 mutant[1] = 'u';
1638 JSONTEST_ASSERT_STRING_EQUAL("hullo", root["top"].asString());
1639 }
1640 {
1641 Json::Value root;
1642 root["top"] = regular;
1643 JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
1644 mutant[1] = 'u';
1645 JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
1646 }
1647 }
1648
JSONTEST_FIXTURE(ValueTest,WideString)1649 JSONTEST_FIXTURE(ValueTest, WideString) {
1650 // https://github.com/open-source-parsers/jsoncpp/issues/756
1651 const std::string uni = u8"式，进"; // "\u5f0f\uff0c\u8fdb"
1652 std::string styled;
1653 {
1654 Json::Value v;
1655 v["abc"] = uni;
1656 styled = v.toStyledString();
1657 }
1658 Json::Value root;
1659 {
1660 JSONCPP_STRING errs;
1661 std::istringstream iss(styled);
1662 bool ok = parseFromStream(Json::CharReaderBuilder(), iss, &root, &errs);
1663 JSONTEST_ASSERT(ok);
1664 if (!ok) {
1665 std::cerr << "errs: " << errs << std::endl;
1666 }
1667 }
1668 JSONTEST_ASSERT_STRING_EQUAL(root["abc"].asString(), uni);
1669 }
1670
JSONTEST_FIXTURE(ValueTest,CommentBefore)1671 JSONTEST_FIXTURE(ValueTest, CommentBefore) {
1672 Json::Value val; // fill val
1673 val.setComment(Json::String("// this comment should appear before"),
1674 Json::commentBefore);
1675 Json::StreamWriterBuilder wbuilder;
1676 wbuilder.settings_["commentStyle"] = "All";
1677 {
1678 char const expected[] = "// this comment should appear before\nnull";
1679 Json::String result = Json::writeString(wbuilder, val);
1680 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1681 Json::String res2 = val.toStyledString();
1682 Json::String exp2 = "\n";
1683 exp2 += expected;
1684 exp2 += "\n";
1685 JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
1686 }
1687 Json::Value other = "hello";
1688 val.swapPayload(other);
1689 {
1690 char const expected[] = "// this comment should appear before\n\"hello\"";
1691 Json::String result = Json::writeString(wbuilder, val);
1692 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1693 Json::String res2 = val.toStyledString();
1694 Json::String exp2 = "\n";
1695 exp2 += expected;
1696 exp2 += "\n";
1697 JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
1698 JSONTEST_ASSERT_STRING_EQUAL("null\n", other.toStyledString());
1699 }
1700 val = "hello";
1701 // val.setComment("// this comment should appear before",
1702 // Json::CommentPlacement::commentBefore); Assignment over-writes comments.
1703 {
1704 char const expected[] = "\"hello\"";
1705 Json::String result = Json::writeString(wbuilder, val);
1706 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1707 Json::String res2 = val.toStyledString();
1708 Json::String exp2 = "";
1709 exp2 += expected;
1710 exp2 += "\n";
1711 JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
1712 }
1713 }
1714
JSONTEST_FIXTURE(ValueTest,zeroes)1715 JSONTEST_FIXTURE(ValueTest, zeroes) {
1716 char const cstr[] = "h\0i";
1717 Json::String binary(cstr, sizeof(cstr)); // include trailing 0
1718 JSONTEST_ASSERT_EQUAL(4U, binary.length());
1719 Json::StreamWriterBuilder b;
1720 {
1721 Json::Value root;
1722 root = binary;
1723 JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
1724 }
1725 {
1726 char const top[] = "top";
1727 Json::Value root;
1728 root[top] = binary;
1729 JSONTEST_ASSERT_STRING_EQUAL(binary, root[top].asString());
1730 Json::Value removed;
1731 bool did;
1732 did = root.removeMember(top, top + sizeof(top) - 1U, &removed);
1733 JSONTEST_ASSERT(did);
1734 JSONTEST_ASSERT_STRING_EQUAL(binary, removed.asString());
1735 did = root.removeMember(top, top + sizeof(top) - 1U, &removed);
1736 JSONTEST_ASSERT(!did);
1737 JSONTEST_ASSERT_STRING_EQUAL(binary, removed.asString()); // still
1738 }
1739 }
1740
JSONTEST_FIXTURE(ValueTest,zeroesInKeys)1741 JSONTEST_FIXTURE(ValueTest, zeroesInKeys) {
1742 char const cstr[] = "h\0i";
1743 Json::String binary(cstr, sizeof(cstr)); // include trailing 0
1744 JSONTEST_ASSERT_EQUAL(4U, binary.length());
1745 {
1746 Json::Value root;
1747 root[binary] = "there";
1748 JSONTEST_ASSERT_STRING_EQUAL("there", root[binary].asString());
1749 JSONTEST_ASSERT(!root.isMember("h"));
1750 JSONTEST_ASSERT(root.isMember(binary));
1751 JSONTEST_ASSERT_STRING_EQUAL(
1752 "there", root.get(binary, Json::Value::nullRef).asString());
1753 Json::Value removed;
1754 bool did;
1755 did = root.removeMember(binary.data(), binary.data() + binary.length(),
1756 &removed);
1757 JSONTEST_ASSERT(did);
1758 JSONTEST_ASSERT_STRING_EQUAL("there", removed.asString());
1759 did = root.removeMember(binary.data(), binary.data() + binary.length(),
1760 &removed);
1761 JSONTEST_ASSERT(!did);
1762 JSONTEST_ASSERT_STRING_EQUAL("there", removed.asString()); // still
1763 JSONTEST_ASSERT(!root.isMember(binary));
1764 JSONTEST_ASSERT_STRING_EQUAL(
1765 "", root.get(binary, Json::Value::nullRef).asString());
1766 }
1767 }
1768
JSONTEST_FIXTURE(ValueTest,specialFloats)1769 JSONTEST_FIXTURE(ValueTest, specialFloats) {
1770 Json::StreamWriterBuilder b;
1771 b.settings_["useSpecialFloats"] = true;
1772
1773 Json::Value v = std::numeric_limits<double>::quiet_NaN();
1774 Json::String expected = "NaN";
1775 Json::String result = Json::writeString(b, v);
1776 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1777
1778 v = std::numeric_limits<double>::infinity();
1779 expected = "Infinity";
1780 result = Json::writeString(b, v);
1781 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1782
1783 v = -std::numeric_limits<double>::infinity();
1784 expected = "-Infinity";
1785 result = Json::writeString(b, v);
1786 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1787 }
1788
JSONTEST_FIXTURE(ValueTest,precision)1789 JSONTEST_FIXTURE(ValueTest, precision) {
1790 Json::StreamWriterBuilder b;
1791 b.settings_["precision"] = 5;
1792
1793 Json::Value v = 100.0 / 3;
1794 Json::String expected = "33.333";
1795 Json::String result = Json::writeString(b, v);
1796 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1797
1798 v = 0.25000000;
1799 expected = "0.25";
1800 result = Json::writeString(b, v);
1801 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1802
1803 v = 0.2563456;
1804 expected = "0.25635";
1805 result = Json::writeString(b, v);
1806 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1807
1808 b.settings_["precision"] = 1;
1809 expected = "0.3";
1810 result = Json::writeString(b, v);
1811 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1812
1813 b.settings_["precision"] = 17;
1814 v = 1234857476305.256345694873740545068;
1815 expected = "1234857476305.2563";
1816 result = Json::writeString(b, v);
1817 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1818
1819 b.settings_["precision"] = 24;
1820 v = 0.256345694873740545068;
1821 expected = "0.25634569487374054";
1822 result = Json::writeString(b, v);
1823 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1824
1825 b.settings_["precision"] = 5;
1826 b.settings_["precisionType"] = "decimal";
1827 v = 0.256345694873740545068;
1828 expected = "0.25635";
1829 result = Json::writeString(b, v);
1830 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1831
1832 b.settings_["precision"] = 1;
1833 b.settings_["precisionType"] = "decimal";
1834 v = 0.256345694873740545068;
1835 expected = "0.3";
1836 result = Json::writeString(b, v);
1837 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1838
1839 b.settings_["precision"] = 10;
1840 b.settings_["precisionType"] = "decimal";
1841 v = 0.23300000;
1842 expected = "0.233";
1843 result = Json::writeString(b, v);
1844 JSONTEST_ASSERT_STRING_EQUAL(expected, result);
1845 }
1846
1847 struct WriterTest : JsonTest::TestCase {};
1848
JSONTEST_FIXTURE(WriterTest,dropNullPlaceholders)1849 JSONTEST_FIXTURE(WriterTest, dropNullPlaceholders) {
1850 Json::FastWriter writer;
1851 Json::Value nullValue;
1852 JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
1853
1854 writer.dropNullPlaceholders();
1855 JSONTEST_ASSERT(writer.write(nullValue) == "\n");
1856 }
1857
1858 struct StreamWriterTest : JsonTest::TestCase {};
1859
JSONTEST_FIXTURE(StreamWriterTest,dropNullPlaceholders)1860 JSONTEST_FIXTURE(StreamWriterTest, dropNullPlaceholders) {
1861 Json::StreamWriterBuilder b;
1862 Json::Value nullValue;
1863 b.settings_["dropNullPlaceholders"] = false;
1864 JSONTEST_ASSERT(Json::writeString(b, nullValue) == "null");
1865 b.settings_["dropNullPlaceholders"] = true;
1866 JSONTEST_ASSERT(Json::writeString(b, nullValue).empty());
1867 }
1868
JSONTEST_FIXTURE(StreamWriterTest,writeZeroes)1869 JSONTEST_FIXTURE(StreamWriterTest, writeZeroes) {
1870 Json::String binary("hi", 3); // include trailing 0
1871 JSONTEST_ASSERT_EQUAL(3, binary.length());
1872 Json::String expected("\"hi\\u0000\""); // unicoded zero
1873 Json::StreamWriterBuilder b;
1874 {
1875 Json::Value root;
1876 root = binary;
1877 JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
1878 Json::String out = Json::writeString(b, root);
1879 JSONTEST_ASSERT_EQUAL(expected.size(), out.size());
1880 JSONTEST_ASSERT_STRING_EQUAL(expected, out);
1881 }
1882 {
1883 Json::Value root;
1884 root["top"] = binary;
1885 JSONTEST_ASSERT_STRING_EQUAL(binary, root["top"].asString());
1886 Json::String out = Json::writeString(b, root["top"]);
1887 JSONTEST_ASSERT_STRING_EQUAL(expected, out);
1888 }
1889 }
1890
1891 struct ReaderTest : JsonTest::TestCase {};
1892
JSONTEST_FIXTURE(ReaderTest,parseWithNoErrors)1893 JSONTEST_FIXTURE(ReaderTest, parseWithNoErrors) {
1894 Json::Reader reader;
1895 Json::Value root;
1896 bool ok = reader.parse("{ \"property\" : \"value\" }", root);
1897 JSONTEST_ASSERT(ok);
1898 JSONTEST_ASSERT(reader.getFormattedErrorMessages().empty());
1899 JSONTEST_ASSERT(reader.getStructuredErrors().empty());
1900 }
1901
JSONTEST_FIXTURE(ReaderTest,parseWithNoErrorsTestingOffsets)1902 JSONTEST_FIXTURE(ReaderTest, parseWithNoErrorsTestingOffsets) {
1903 Json::Reader reader;
1904 Json::Value root;
1905 bool ok = reader.parse("{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
1906 "{ \"nested\" : 123, \"bool\" : true}, \"null\" : "
1907 "null, \"false\" : false }",
1908 root);
1909 JSONTEST_ASSERT(ok);
1910 JSONTEST_ASSERT(reader.getFormattedErrorMessages().empty());
1911 JSONTEST_ASSERT(reader.getStructuredErrors().empty());
1912 JSONTEST_ASSERT(root["property"].getOffsetStart() == 15);
1913 JSONTEST_ASSERT(root["property"].getOffsetLimit() == 34);
1914 JSONTEST_ASSERT(root["property"][0].getOffsetStart() == 16);
1915 JSONTEST_ASSERT(root["property"][0].getOffsetLimit() == 23);
1916 JSONTEST_ASSERT(root["property"][1].getOffsetStart() == 25);
1917 JSONTEST_ASSERT(root["property"][1].getOffsetLimit() == 33);
1918 JSONTEST_ASSERT(root["obj"].getOffsetStart() == 44);
1919 JSONTEST_ASSERT(root["obj"].getOffsetLimit() == 76);
1920 JSONTEST_ASSERT(root["obj"]["nested"].getOffsetStart() == 57);
1921 JSONTEST_ASSERT(root["obj"]["nested"].getOffsetLimit() == 60);
1922 JSONTEST_ASSERT(root["obj"]["bool"].getOffsetStart() == 71);
1923 JSONTEST_ASSERT(root["obj"]["bool"].getOffsetLimit() == 75);
1924 JSONTEST_ASSERT(root["null"].getOffsetStart() == 87);
1925 JSONTEST_ASSERT(root["null"].getOffsetLimit() == 91);
1926 JSONTEST_ASSERT(root["false"].getOffsetStart() == 103);
1927 JSONTEST_ASSERT(root["false"].getOffsetLimit() == 108);
1928 JSONTEST_ASSERT(root.getOffsetStart() == 0);
1929 JSONTEST_ASSERT(root.getOffsetLimit() == 110);
1930 }
1931
JSONTEST_FIXTURE(ReaderTest,parseWithOneError)1932 JSONTEST_FIXTURE(ReaderTest, parseWithOneError) {
1933 Json::Reader reader;
1934 Json::Value root;
1935 bool ok = reader.parse("{ \"property\" :: \"value\" }", root);
1936 JSONTEST_ASSERT(!ok);
1937 JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1938 "* Line 1, Column 15\n Syntax error: value, object or array "
1939 "expected.\n");
1940 std::vector<Json::Reader::StructuredError> errors =
1941 reader.getStructuredErrors();
1942 JSONTEST_ASSERT(errors.size() == 1);
1943 JSONTEST_ASSERT(errors.at(0).offset_start == 14);
1944 JSONTEST_ASSERT(errors.at(0).offset_limit == 15);
1945 JSONTEST_ASSERT(errors.at(0).message ==
1946 "Syntax error: value, object or array expected.");
1947 }
1948
JSONTEST_FIXTURE(ReaderTest,parseChineseWithOneError)1949 JSONTEST_FIXTURE(ReaderTest, parseChineseWithOneError) {
1950 Json::Reader reader;
1951 Json::Value root;
1952 bool ok = reader.parse("{ \"pr佐藤erty\" :: \"value\" }", root);
1953 JSONTEST_ASSERT(!ok);
1954 JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1955 "* Line 1, Column 19\n Syntax error: value, object or array "
1956 "expected.\n");
1957 std::vector<Json::Reader::StructuredError> errors =
1958 reader.getStructuredErrors();
1959 JSONTEST_ASSERT(errors.size() == 1);
1960 JSONTEST_ASSERT(errors.at(0).offset_start == 18);
1961 JSONTEST_ASSERT(errors.at(0).offset_limit == 19);
1962 JSONTEST_ASSERT(errors.at(0).message ==
1963 "Syntax error: value, object or array expected.");
1964 }
1965
JSONTEST_FIXTURE(ReaderTest,parseWithDetailError)1966 JSONTEST_FIXTURE(ReaderTest, parseWithDetailError) {
1967 Json::Reader reader;
1968 Json::Value root;
1969 bool ok = reader.parse("{ \"property\" : \"v\\alue\" }", root);
1970 JSONTEST_ASSERT(!ok);
1971 JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1972 "* Line 1, Column 16\n Bad escape sequence in string\nSee "
1973 "Line 1, Column 20 for detail.\n");
1974 std::vector<Json::Reader::StructuredError> errors =
1975 reader.getStructuredErrors();
1976 JSONTEST_ASSERT(errors.size() == 1);
1977 JSONTEST_ASSERT(errors.at(0).offset_start == 15);
1978 JSONTEST_ASSERT(errors.at(0).offset_limit == 23);
1979 JSONTEST_ASSERT(errors.at(0).message == "Bad escape sequence in string");
1980 }
1981
1982 struct CharReaderTest : JsonTest::TestCase {};
1983
JSONTEST_FIXTURE(CharReaderTest,parseWithNoErrors)1984 JSONTEST_FIXTURE(CharReaderTest, parseWithNoErrors) {
1985 Json::CharReaderBuilder b;
1986 Json::CharReader* reader(b.newCharReader());
1987 Json::String errs;
1988 Json::Value root;
1989 char const doc[] = "{ \"property\" : \"value\" }";
1990 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
1991 JSONTEST_ASSERT(ok);
1992 JSONTEST_ASSERT(errs.empty());
1993 delete reader;
1994 }
1995
JSONTEST_FIXTURE(CharReaderTest,parseWithNoErrorsTestingOffsets)1996 JSONTEST_FIXTURE(CharReaderTest, parseWithNoErrorsTestingOffsets) {
1997 Json::CharReaderBuilder b;
1998 Json::CharReader* reader(b.newCharReader());
1999 Json::String errs;
2000 Json::Value root;
2001 char const doc[] = "{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
2002 "{ \"nested\" : 123, \"bool\" : true}, \"null\" : "
2003 "null, \"false\" : false }";
2004 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2005 JSONTEST_ASSERT(ok);
2006 JSONTEST_ASSERT(errs.empty());
2007 delete reader;
2008 }
2009
JSONTEST_FIXTURE(CharReaderTest,parseWithOneError)2010 JSONTEST_FIXTURE(CharReaderTest, parseWithOneError) {
2011 Json::CharReaderBuilder b;
2012 Json::CharReader* reader(b.newCharReader());
2013 Json::String errs;
2014 Json::Value root;
2015 char const doc[] = "{ \"property\" :: \"value\" }";
2016 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2017 JSONTEST_ASSERT(!ok);
2018 JSONTEST_ASSERT(errs ==
2019 "* Line 1, Column 15\n Syntax error: value, object or array "
2020 "expected.\n");
2021 delete reader;
2022 }
2023
JSONTEST_FIXTURE(CharReaderTest,parseChineseWithOneError)2024 JSONTEST_FIXTURE(CharReaderTest, parseChineseWithOneError) {
2025 Json::CharReaderBuilder b;
2026 Json::CharReader* reader(b.newCharReader());
2027 Json::String errs;
2028 Json::Value root;
2029 char const doc[] = "{ \"pr佐藤erty\" :: \"value\" }";
2030 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2031 JSONTEST_ASSERT(!ok);
2032 JSONTEST_ASSERT(errs ==
2033 "* Line 1, Column 19\n Syntax error: value, object or array "
2034 "expected.\n");
2035 delete reader;
2036 }
2037
JSONTEST_FIXTURE(CharReaderTest,parseWithDetailError)2038 JSONTEST_FIXTURE(CharReaderTest, parseWithDetailError) {
2039 Json::CharReaderBuilder b;
2040 Json::CharReader* reader(b.newCharReader());
2041 Json::String errs;
2042 Json::Value root;
2043 char const doc[] = "{ \"property\" : \"v\\alue\" }";
2044 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2045 JSONTEST_ASSERT(!ok);
2046 JSONTEST_ASSERT(errs ==
2047 "* Line 1, Column 16\n Bad escape sequence in string\nSee "
2048 "Line 1, Column 20 for detail.\n");
2049 delete reader;
2050 }
2051
JSONTEST_FIXTURE(CharReaderTest,parseWithStackLimit)2052 JSONTEST_FIXTURE(CharReaderTest, parseWithStackLimit) {
2053 Json::CharReaderBuilder b;
2054 Json::Value root;
2055 char const doc[] = "{ \"property\" : \"value\" }";
2056 {
2057 b.settings_["stackLimit"] = 2;
2058 Json::CharReader* reader(b.newCharReader());
2059 Json::String errs;
2060 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2061 JSONTEST_ASSERT(ok);
2062 JSONTEST_ASSERT(errs.empty());
2063 JSONTEST_ASSERT_EQUAL("value", root["property"]);
2064 delete reader;
2065 }
2066 {
2067 b.settings_["stackLimit"] = 1;
2068 Json::CharReader* reader(b.newCharReader());
2069 Json::String errs;
2070 JSONTEST_ASSERT_THROWS(
2071 reader->parse(doc, doc + std::strlen(doc), &root, &errs));
2072 delete reader;
2073 }
2074 }
2075
2076 struct CharReaderStrictModeTest : JsonTest::TestCase {};
2077
JSONTEST_FIXTURE(CharReaderStrictModeTest,dupKeys)2078 JSONTEST_FIXTURE(CharReaderStrictModeTest, dupKeys) {
2079 Json::CharReaderBuilder b;
2080 Json::Value root;
2081 char const doc[] =
2082 "{ \"property\" : \"value\", \"key\" : \"val1\", \"key\" : \"val2\" }";
2083 {
2084 b.strictMode(&b.settings_);
2085 Json::CharReader* reader(b.newCharReader());
2086 Json::String errs;
2087 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2088 JSONTEST_ASSERT(!ok);
2089 JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 41\n"
2090 " Duplicate key: 'key'\n",
2091 errs);
2092 JSONTEST_ASSERT_EQUAL("val1", root["key"]); // so far
2093 delete reader;
2094 }
2095 }
2096 struct CharReaderFailIfExtraTest : JsonTest::TestCase {};
2097
JSONTEST_FIXTURE(CharReaderFailIfExtraTest,issue164)2098 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, issue164) {
2099 // This is interpreted as a string value followed by a colon.
2100 Json::CharReaderBuilder b;
2101 Json::Value root;
2102 char const doc[] = " \"property\" : \"value\" }";
2103 {
2104 b.settings_["failIfExtra"] = false;
2105 Json::CharReader* reader(b.newCharReader());
2106 Json::String errs;
2107 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2108 JSONTEST_ASSERT(ok);
2109 JSONTEST_ASSERT(errs.empty());
2110 JSONTEST_ASSERT_EQUAL("property", root);
2111 delete reader;
2112 }
2113 {
2114 b.settings_["failIfExtra"] = true;
2115 Json::CharReader* reader(b.newCharReader());
2116 Json::String errs;
2117 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2118 JSONTEST_ASSERT(!ok);
2119 JSONTEST_ASSERT_STRING_EQUAL(errs,
2120 "* Line 1, Column 13\n"
2121 " Extra non-whitespace after JSON value.\n");
2122 JSONTEST_ASSERT_EQUAL("property", root);
2123 delete reader;
2124 }
2125 {
2126 b.settings_["failIfExtra"] = false;
2127 b.strictMode(&b.settings_);
2128 Json::CharReader* reader(b.newCharReader());
2129 Json::String errs;
2130 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2131 JSONTEST_ASSERT(!ok);
2132 JSONTEST_ASSERT_STRING_EQUAL(errs,
2133 "* Line 1, Column 13\n"
2134 " Extra non-whitespace after JSON value.\n");
2135 JSONTEST_ASSERT_EQUAL("property", root);
2136 delete reader;
2137 }
2138 }
JSONTEST_FIXTURE(CharReaderFailIfExtraTest,issue107)2139 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, issue107) {
2140 // This is interpreted as an int value followed by a colon.
2141 Json::CharReaderBuilder b;
2142 Json::Value root;
2143 char const doc[] = "1:2:3";
2144 b.settings_["failIfExtra"] = true;
2145 Json::CharReader* reader(b.newCharReader());
2146 Json::String errs;
2147 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2148 JSONTEST_ASSERT(!ok);
2149 JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 2\n"
2150 " Extra non-whitespace after JSON value.\n",
2151 errs);
2152 JSONTEST_ASSERT_EQUAL(1, root.asInt());
2153 delete reader;
2154 }
JSONTEST_FIXTURE(CharReaderFailIfExtraTest,commentAfterObject)2155 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterObject) {
2156 Json::CharReaderBuilder b;
2157 Json::Value root;
2158 {
2159 char const doc[] = "{ \"property\" : \"value\" } //trailing\n//comment\n";
2160 b.settings_["failIfExtra"] = true;
2161 Json::CharReader* reader(b.newCharReader());
2162 Json::String errs;
2163 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2164 JSONTEST_ASSERT(ok);
2165 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2166 JSONTEST_ASSERT_EQUAL("value", root["property"]);
2167 delete reader;
2168 }
2169 }
JSONTEST_FIXTURE(CharReaderFailIfExtraTest,commentAfterArray)2170 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterArray) {
2171 Json::CharReaderBuilder b;
2172 Json::Value root;
2173 char const doc[] = "[ \"property\" , \"value\" ] //trailing\n//comment\n";
2174 b.settings_["failIfExtra"] = true;
2175 Json::CharReader* reader(b.newCharReader());
2176 Json::String errs;
2177 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2178 JSONTEST_ASSERT(ok);
2179 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2180 JSONTEST_ASSERT_EQUAL("value", root[1u]);
2181 delete reader;
2182 }
JSONTEST_FIXTURE(CharReaderFailIfExtraTest,commentAfterBool)2183 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterBool) {
2184 Json::CharReaderBuilder b;
2185 Json::Value root;
2186 char const doc[] = " true /*trailing\ncomment*/";
2187 b.settings_["failIfExtra"] = true;
2188 Json::CharReader* reader(b.newCharReader());
2189 Json::String errs;
2190 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2191 JSONTEST_ASSERT(ok);
2192 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2193 JSONTEST_ASSERT_EQUAL(true, root.asBool());
2194 delete reader;
2195 }
2196 struct CharReaderAllowDropNullTest : JsonTest::TestCase {};
2197
JSONTEST_FIXTURE(CharReaderAllowDropNullTest,issue178)2198 JSONTEST_FIXTURE(CharReaderAllowDropNullTest, issue178) {
2199 Json::CharReaderBuilder b;
2200 b.settings_["allowDroppedNullPlaceholders"] = true;
2201 Json::Value root;
2202 Json::String errs;
2203 Json::CharReader* reader(b.newCharReader());
2204 {
2205 char const doc[] = "{\"a\":,\"b\":true}";
2206 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2207 JSONTEST_ASSERT(ok);
2208 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2209 JSONTEST_ASSERT_EQUAL(2u, root.size());
2210 JSONTEST_ASSERT_EQUAL(Json::nullValue, root.get("a", true));
2211 }
2212 {
2213 char const doc[] = "{\"a\":}";
2214 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2215 JSONTEST_ASSERT(ok);
2216 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2217 JSONTEST_ASSERT_EQUAL(1u, root.size());
2218 JSONTEST_ASSERT_EQUAL(Json::nullValue, root.get("a", true));
2219 }
2220 {
2221 char const doc[] = "[]";
2222 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2223 JSONTEST_ASSERT(ok);
2224 JSONTEST_ASSERT(errs.empty());
2225 JSONTEST_ASSERT_EQUAL(0u, root.size());
2226 JSONTEST_ASSERT_EQUAL(Json::arrayValue, root);
2227 }
2228 {
2229 char const doc[] = "[null]";
2230 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2231 JSONTEST_ASSERT(ok);
2232 JSONTEST_ASSERT(errs.empty());
2233 JSONTEST_ASSERT_EQUAL(1u, root.size());
2234 }
2235 {
2236 char const doc[] = "[,]";
2237 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2238 JSONTEST_ASSERT(ok);
2239 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2240 JSONTEST_ASSERT_EQUAL(2u, root.size());
2241 }
2242 {
2243 char const doc[] = "[,,,]";
2244 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2245 JSONTEST_ASSERT(ok);
2246 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2247 JSONTEST_ASSERT_EQUAL(4u, root.size());
2248 }
2249 {
2250 char const doc[] = "[null,]";
2251 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2252 JSONTEST_ASSERT(ok);
2253 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2254 JSONTEST_ASSERT_EQUAL(2u, root.size());
2255 }
2256 {
2257 char const doc[] = "[,null]";
2258 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2259 JSONTEST_ASSERT(ok);
2260 JSONTEST_ASSERT(errs.empty());
2261 JSONTEST_ASSERT_EQUAL(2u, root.size());
2262 }
2263 {
2264 char const doc[] = "[,,]";
2265 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2266 JSONTEST_ASSERT(ok);
2267 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2268 JSONTEST_ASSERT_EQUAL(3u, root.size());
2269 }
2270 {
2271 char const doc[] = "[null,,]";
2272 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2273 JSONTEST_ASSERT(ok);
2274 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2275 JSONTEST_ASSERT_EQUAL(3u, root.size());
2276 }
2277 {
2278 char const doc[] = "[,null,]";
2279 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2280 JSONTEST_ASSERT(ok);
2281 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2282 JSONTEST_ASSERT_EQUAL(3u, root.size());
2283 }
2284 {
2285 char const doc[] = "[,,null]";
2286 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2287 JSONTEST_ASSERT(ok);
2288 JSONTEST_ASSERT(errs.empty());
2289 JSONTEST_ASSERT_EQUAL(3u, root.size());
2290 }
2291 {
2292 char const doc[] = "[[],,,]";
2293 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2294 JSONTEST_ASSERT(ok);
2295 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2296 JSONTEST_ASSERT_EQUAL(4u, root.size());
2297 JSONTEST_ASSERT_EQUAL(Json::arrayValue, root[0u]);
2298 }
2299 {
2300 char const doc[] = "[,[],,]";
2301 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2302 JSONTEST_ASSERT(ok);
2303 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2304 JSONTEST_ASSERT_EQUAL(4u, root.size());
2305 JSONTEST_ASSERT_EQUAL(Json::arrayValue, root[1u]);
2306 }
2307 {
2308 char const doc[] = "[,,,[]]";
2309 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2310 JSONTEST_ASSERT(ok);
2311 JSONTEST_ASSERT(errs.empty());
2312 JSONTEST_ASSERT_EQUAL(4u, root.size());
2313 JSONTEST_ASSERT_EQUAL(Json::arrayValue, root[3u]);
2314 }
2315 delete reader;
2316 }
2317
2318 struct CharReaderAllowSingleQuotesTest : JsonTest::TestCase {};
2319
JSONTEST_FIXTURE(CharReaderAllowSingleQuotesTest,issue182)2320 JSONTEST_FIXTURE(CharReaderAllowSingleQuotesTest, issue182) {
2321 Json::CharReaderBuilder b;
2322 b.settings_["allowSingleQuotes"] = true;
2323 Json::Value root;
2324 Json::String errs;
2325 Json::CharReader* reader(b.newCharReader());
2326 {
2327 char const doc[] = "{'a':true,\"b\":true}";
2328 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2329 JSONTEST_ASSERT(ok);
2330 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2331 JSONTEST_ASSERT_EQUAL(2u, root.size());
2332 JSONTEST_ASSERT_EQUAL(true, root.get("a", false));
2333 JSONTEST_ASSERT_EQUAL(true, root.get("b", false));
2334 }
2335 {
2336 char const doc[] = "{'a': 'x', \"b\":'y'}";
2337 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2338 JSONTEST_ASSERT(ok);
2339 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2340 JSONTEST_ASSERT_EQUAL(2u, root.size());
2341 JSONTEST_ASSERT_STRING_EQUAL("x", root["a"].asString());
2342 JSONTEST_ASSERT_STRING_EQUAL("y", root["b"].asString());
2343 }
2344 delete reader;
2345 }
2346
2347 struct CharReaderAllowZeroesTest : JsonTest::TestCase {};
2348
JSONTEST_FIXTURE(CharReaderAllowZeroesTest,issue176)2349 JSONTEST_FIXTURE(CharReaderAllowZeroesTest, issue176) {
2350 Json::CharReaderBuilder b;
2351 b.settings_["allowSingleQuotes"] = true;
2352 Json::Value root;
2353 Json::String errs;
2354 Json::CharReader* reader(b.newCharReader());
2355 {
2356 char const doc[] = "{'a':true,\"b\":true}";
2357 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2358 JSONTEST_ASSERT(ok);
2359 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2360 JSONTEST_ASSERT_EQUAL(2u, root.size());
2361 JSONTEST_ASSERT_EQUAL(true, root.get("a", false));
2362 JSONTEST_ASSERT_EQUAL(true, root.get("b", false));
2363 }
2364 {
2365 char const doc[] = "{'a': 'x', \"b\":'y'}";
2366 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2367 JSONTEST_ASSERT(ok);
2368 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2369 JSONTEST_ASSERT_EQUAL(2u, root.size());
2370 JSONTEST_ASSERT_STRING_EQUAL("x", root["a"].asString());
2371 JSONTEST_ASSERT_STRING_EQUAL("y", root["b"].asString());
2372 }
2373 delete reader;
2374 }
2375
2376 struct CharReaderAllowSpecialFloatsTest : JsonTest::TestCase {};
2377
JSONTEST_FIXTURE(CharReaderAllowSpecialFloatsTest,issue209)2378 JSONTEST_FIXTURE(CharReaderAllowSpecialFloatsTest, issue209) {
2379 Json::CharReaderBuilder b;
2380 b.settings_["allowSpecialFloats"] = true;
2381 Json::Value root;
2382 Json::String errs;
2383 Json::CharReader* reader(b.newCharReader());
2384 {
2385 char const doc[] = "{\"a\":NaN,\"b\":Infinity,\"c\":-Infinity}";
2386 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2387 JSONTEST_ASSERT(ok);
2388 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2389 JSONTEST_ASSERT_EQUAL(3u, root.size());
2390 double n = root["a"].asDouble();
2391 JSONTEST_ASSERT(std::isnan(n));
2392 JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
2393 root.get("b", 0.0));
2394 JSONTEST_ASSERT_EQUAL(-std::numeric_limits<double>::infinity(),
2395 root.get("c", 0.0));
2396 }
2397
2398 struct TestData {
2399 int line;
2400 bool ok;
2401 Json::String in;
2402 };
2403 const TestData test_data[] = {
2404 {__LINE__, true, "{\"a\":9}"}, //
2405 {__LINE__, false, "{\"a\":0Infinity}"}, //
2406 {__LINE__, false, "{\"a\":1Infinity}"}, //
2407 {__LINE__, false, "{\"a\":9Infinity}"}, //
2408 {__LINE__, false, "{\"a\":0nfinity}"}, //
2409 {__LINE__, false, "{\"a\":1nfinity}"}, //
2410 {__LINE__, false, "{\"a\":9nfinity}"}, //
2411 {__LINE__, false, "{\"a\":nfinity}"}, //
2412 {__LINE__, false, "{\"a\":.nfinity}"}, //
2413 {__LINE__, false, "{\"a\":9nfinity}"}, //
2414 {__LINE__, false, "{\"a\":-nfinity}"}, //
2415 {__LINE__, true, "{\"a\":Infinity}"}, //
2416 {__LINE__, false, "{\"a\":.Infinity}"}, //
2417 {__LINE__, false, "{\"a\":_Infinity}"}, //
2418 {__LINE__, false, "{\"a\":_nfinity}"}, //
2419 {__LINE__, true, "{\"a\":-Infinity}"} //
2420 };
2421 for (const auto& td : test_data) {
2422 bool ok = reader->parse(&*td.in.begin(), &*td.in.begin() + td.in.size(),
2423 &root, &errs);
2424 JSONTEST_ASSERT(td.ok == ok) << "line:" << td.line << "\n"
2425 << " expected: {"
2426 << "ok:" << td.ok << ", in:\'" << td.in << "\'"
2427 << "}\n"
2428 << " actual: {"
2429 << "ok:" << ok << "}\n";
2430 }
2431
2432 {
2433 char const doc[] = "{\"posInf\": Infinity, \"NegInf\": -Infinity}";
2434 bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
2435 JSONTEST_ASSERT(ok);
2436 JSONTEST_ASSERT_STRING_EQUAL("", errs);
2437 JSONTEST_ASSERT_EQUAL(2u, root.size());
2438 JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
2439 root["posInf"].asDouble());
2440 JSONTEST_ASSERT_EQUAL(-std::numeric_limits<double>::infinity(),
2441 root["NegInf"].asDouble());
2442 }
2443 delete reader;
2444 }
2445
2446 struct BuilderTest : JsonTest::TestCase {};
2447
JSONTEST_FIXTURE(BuilderTest,settings)2448 JSONTEST_FIXTURE(BuilderTest, settings) {
2449 {
2450 Json::Value errs;
2451 Json::CharReaderBuilder rb;
2452 JSONTEST_ASSERT_EQUAL(false, rb.settings_.isMember("foo"));
2453 JSONTEST_ASSERT_EQUAL(true, rb.validate(&errs));
2454 rb["foo"] = "bar";
2455 JSONTEST_ASSERT_EQUAL(true, rb.settings_.isMember("foo"));
2456 JSONTEST_ASSERT_EQUAL(false, rb.validate(&errs));
2457 }
2458 {
2459 Json::Value errs;
2460 Json::StreamWriterBuilder wb;
2461 JSONTEST_ASSERT_EQUAL(false, wb.settings_.isMember("foo"));
2462 JSONTEST_ASSERT_EQUAL(true, wb.validate(&errs));
2463 wb["foo"] = "bar";
2464 JSONTEST_ASSERT_EQUAL(true, wb.settings_.isMember("foo"));
2465 JSONTEST_ASSERT_EQUAL(false, wb.validate(&errs));
2466 }
2467 }
2468
2469 struct IteratorTest : JsonTest::TestCase {};
2470
JSONTEST_FIXTURE(IteratorTest,distance)2471 JSONTEST_FIXTURE(IteratorTest, distance) {
2472 Json::Value json;
2473 json["k1"] = "a";
2474 json["k2"] = "b";
2475 int dist = 0;
2476 Json::String str;
2477 for (Json::ValueIterator it = json.begin(); it != json.end(); ++it) {
2478 dist = it - json.begin();
2479 str = it->asString().c_str();
2480 }
2481 JSONTEST_ASSERT_EQUAL(1, dist);
2482 JSONTEST_ASSERT_STRING_EQUAL("b", str);
2483 }
2484
JSONTEST_FIXTURE(IteratorTest,names)2485 JSONTEST_FIXTURE(IteratorTest, names) {
2486 Json::Value json;
2487 json["k1"] = "a";
2488 json["k2"] = "b";
2489 Json::ValueIterator it = json.begin();
2490 JSONTEST_ASSERT(it != json.end());
2491 JSONTEST_ASSERT_EQUAL(Json::Value("k1"), it.key());
2492 JSONTEST_ASSERT_STRING_EQUAL("k1", it.name());
2493 JSONTEST_ASSERT_EQUAL(-1, it.index());
2494 ++it;
2495 JSONTEST_ASSERT(it != json.end());
2496 JSONTEST_ASSERT_EQUAL(Json::Value("k2"), it.key());
2497 JSONTEST_ASSERT_STRING_EQUAL("k2", it.name());
2498 JSONTEST_ASSERT_EQUAL(-1, it.index());
2499 ++it;
2500 JSONTEST_ASSERT(it == json.end());
2501 }
2502
JSONTEST_FIXTURE(IteratorTest,indexes)2503 JSONTEST_FIXTURE(IteratorTest, indexes) {
2504 Json::Value json;
2505 json[0] = "a";
2506 json[1] = "b";
2507 Json::ValueIterator it = json.begin();
2508 JSONTEST_ASSERT(it != json.end());
2509 JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(0)), it.key());
2510 JSONTEST_ASSERT_STRING_EQUAL("", it.name());
2511 JSONTEST_ASSERT_EQUAL(0, it.index());
2512 ++it;
2513 JSONTEST_ASSERT(it != json.end());
2514 JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(1)), it.key());
2515 JSONTEST_ASSERT_STRING_EQUAL("", it.name());
2516 JSONTEST_ASSERT_EQUAL(1, it.index());
2517 ++it;
2518 JSONTEST_ASSERT(it == json.end());
2519 }
2520
JSONTEST_FIXTURE(IteratorTest,const)2521 JSONTEST_FIXTURE(IteratorTest, const) {
2522 Json::Value const v;
2523 JSONTEST_ASSERT_THROWS(
2524 Json::Value::iterator it(v.begin()) // Compile, but throw.
2525 );
2526
2527 Json::Value value;
2528
2529 for (int i = 9; i < 12; ++i) {
2530 Json::OStringStream out;
2531 out << std::setw(2) << i;
2532 Json::String str = out.str();
2533 value[str] = str;
2534 }
2535
2536 Json::OStringStream out;
2537 // in old code, this will get a compile error
2538 Json::Value::const_iterator iter = value.begin();
2539 for (; iter != value.end(); ++iter) {
2540 out << *iter << ',';
2541 }
2542 Json::String expected = "\" 9\",\"10\",\"11\",";
2543 JSONTEST_ASSERT_STRING_EQUAL(expected, out.str());
2544 }
2545
2546 struct RValueTest : JsonTest::TestCase {};
2547
JSONTEST_FIXTURE(RValueTest,moveConstruction)2548 JSONTEST_FIXTURE(RValueTest, moveConstruction) {
2549 Json::Value json;
2550 json["key"] = "value";
2551 Json::Value moved = std::move(json);
2552 JSONTEST_ASSERT(moved != json); // Possibly not nullValue; definitely not
2553 // equal.
2554 JSONTEST_ASSERT_EQUAL(Json::objectValue, moved.type());
2555 JSONTEST_ASSERT_EQUAL(Json::stringValue, moved["key"].type());
2556 }
2557
2558 struct FuzzTest : JsonTest::TestCase {};
2559
2560 // Build and run the fuzz test without any fuzzer, so that it's guaranteed not
2561 // go out of date, even if it's never run as an actual fuzz test.
JSONTEST_FIXTURE(FuzzTest,fuzzDoesntCrash)2562 JSONTEST_FIXTURE(FuzzTest, fuzzDoesntCrash) {
2563 const std::string example = "{}";
2564 JSONTEST_ASSERT_EQUAL(
2565 0,
2566 LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t*>(example.c_str()),
2567 example.size()));
2568 }
2569
main(int argc,const char * argv[])2570 int main(int argc, const char* argv[]) {
2571 JsonTest::Runner runner;
2572 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkNormalizeFloatingPointStr);
2573 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, memberCount);
2574 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, objects);
2575 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, arrays);
2576 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, arrayIssue252);
2577 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, null);
2578 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, strings);
2579 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, bools);
2580 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, integers);
2581 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, nonIntegers);
2582 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareNull);
2583 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareInt);
2584 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareUInt);
2585 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareDouble);
2586 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareString);
2587 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareBoolean);
2588 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareArray);
2589 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareObject);
2590 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareType);
2591 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, CopyObject);
2592 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, offsetAccessors);
2593 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, typeChecksThrowExceptions);
2594 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, StaticString);
2595 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, WideString);
2596 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, CommentBefore);
2597 // JSONTEST_REGISTER_FIXTURE(runner, ValueTest, nulls);
2598 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, zeroes);
2599 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, zeroesInKeys);
2600 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, specialFloats);
2601 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, precision);
2602
2603 JSONTEST_REGISTER_FIXTURE(runner, WriterTest, dropNullPlaceholders);
2604 JSONTEST_REGISTER_FIXTURE(runner, StreamWriterTest, dropNullPlaceholders);
2605 JSONTEST_REGISTER_FIXTURE(runner, StreamWriterTest, writeZeroes);
2606
2607 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithNoErrors);
2608 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest,
2609 parseWithNoErrorsTestingOffsets);
2610 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithOneError);
2611 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseChineseWithOneError);
2612 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithDetailError);
2613
2614 JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithNoErrors);
2615 JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest,
2616 parseWithNoErrorsTestingOffsets);
2617 JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithOneError);
2618 JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseChineseWithOneError);
2619 JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithDetailError);
2620 JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithStackLimit);
2621
2622 JSONTEST_REGISTER_FIXTURE(runner, CharReaderStrictModeTest, dupKeys);
2623
2624 JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, issue164);
2625 JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, issue107);
2626 JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest,
2627 commentAfterObject);
2628 JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest,
2629 commentAfterArray);
2630 JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest,
2631 commentAfterBool);
2632
2633 JSONTEST_REGISTER_FIXTURE(runner, CharReaderAllowDropNullTest, issue178);
2634
2635 JSONTEST_REGISTER_FIXTURE(runner, CharReaderAllowSingleQuotesTest, issue182);
2636
2637 JSONTEST_REGISTER_FIXTURE(runner, CharReaderAllowZeroesTest, issue176);
2638
2639 JSONTEST_REGISTER_FIXTURE(runner, CharReaderAllowSpecialFloatsTest, issue209);
2640
2641 JSONTEST_REGISTER_FIXTURE(runner, BuilderTest, settings);
2642
2643 JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, distance);
2644 JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, names);
2645 JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, indexes);
2646 JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, const);
2647
2648 JSONTEST_REGISTER_FIXTURE(runner, RValueTest, moveConstruction);
2649
2650 JSONTEST_REGISTER_FIXTURE(runner, FuzzTest, fuzzDoesntCrash);
2651
2652 return runner.runCommandLine(argc, argv);
2653 }
2654
2655 #if defined(__GNUC__)
2656 #pragma GCC diagnostic pop
2657 #endif
2658