1 // Copyright 2007-2010 Baptiste Lepilleur
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 #include "jsontest.h"
7 #include <json/config.h>
8 #include <json/json.h>
9 #include <stdexcept>
10
11 // Make numeric limits more convenient to talk about.
12 // Assumes int type in 32 bits.
13 #define kint32max Json::Value::maxInt
14 #define kint32min Json::Value::minInt
15 #define kuint32max Json::Value::maxUInt
16 #define kint64max Json::Value::maxInt64
17 #define kint64min Json::Value::minInt64
18 #define kuint64max Json::Value::maxUInt64
19
20 static const double kdint64max = double(kint64max);
21 static const float kfint64max = float(kint64max);
22 static const float kfint32max = float(kint32max);
23 static const float kfuint32max = float(kuint32max);
24
25 // //////////////////////////////////////////////////////////////////
26 // //////////////////////////////////////////////////////////////////
27 // Json Library test cases
28 // //////////////////////////////////////////////////////////////////
29 // //////////////////////////////////////////////////////////////////
30
31 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
uint64ToDouble(Json::UInt64 value)32 static inline double uint64ToDouble(Json::UInt64 value) {
33 return static_cast<double>(value);
34 }
35 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
uint64ToDouble(Json::UInt64 value)36 static inline double uint64ToDouble(Json::UInt64 value) {
37 return static_cast<double>(Json::Int64(value / 2)) * 2.0 +
38 Json::Int64(value & 1);
39 }
40 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
41
42 struct ValueTest : JsonTest::TestCase {
43 Json::Value null_;
44 Json::Value emptyArray_;
45 Json::Value emptyObject_;
46 Json::Value integer_;
47 Json::Value unsignedInteger_;
48 Json::Value smallUnsignedInteger_;
49 Json::Value real_;
50 Json::Value float_;
51 Json::Value array1_;
52 Json::Value object1_;
53 Json::Value emptyString_;
54 Json::Value string1_;
55 Json::Value string_;
56 Json::Value true_;
57 Json::Value false_;
58
ValueTestValueTest59 ValueTest()
60 : emptyArray_(Json::arrayValue), emptyObject_(Json::objectValue),
61 integer_(123456789), unsignedInteger_(34567890u),
62 smallUnsignedInteger_(Json::Value::UInt(Json::Value::maxInt)),
63 real_(1234.56789), float_(0.00390625f), emptyString_(""), string1_("a"),
64 string_("sometext with space"), true_(true), false_(false) {
65 array1_.append(1234);
66 object1_["id"] = 1234;
67 }
68
69 struct IsCheck {
70 /// Initialize all checks to \c false by default.
71 IsCheck();
72
73 bool isObject_;
74 bool isArray_;
75 bool isBool_;
76 bool isString_;
77 bool isNull_;
78
79 bool isInt_;
80 bool isInt64_;
81 bool isUInt_;
82 bool isUInt64_;
83 bool isIntegral_;
84 bool isDouble_;
85 bool isNumeric_;
86 };
87
88 void checkConstMemberCount(const Json::Value& value,
89 unsigned int expectedCount);
90
91 void checkMemberCount(Json::Value& value, unsigned int expectedCount);
92
93 void checkIs(const Json::Value& value, const IsCheck& check);
94
95 void checkIsLess(const Json::Value& x, const Json::Value& y);
96
97 void checkIsEqual(const Json::Value& x, const Json::Value& y);
98
99 /// Normalize the representation of floating-point number by stripped leading
100 /// 0 in exponent.
101 static std::string normalizeFloatingPointStr(const std::string& s);
102 };
103
normalizeFloatingPointStr(const std::string & s)104 std::string ValueTest::normalizeFloatingPointStr(const std::string& s) {
105 std::string::size_type index = s.find_last_of("eE");
106 if (index != std::string::npos) {
107 std::string::size_type hasSign =
108 (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
109 std::string::size_type exponentStartIndex = index + 1 + hasSign;
110 std::string normalized = s.substr(0, exponentStartIndex);
111 std::string::size_type indexDigit =
112 s.find_first_not_of('0', exponentStartIndex);
113 std::string exponent = "0";
114 if (indexDigit !=
115 std::string::npos) // There is an exponent different from 0
116 {
117 exponent = s.substr(indexDigit);
118 }
119 return normalized + exponent;
120 }
121 return s;
122 }
123
JSONTEST_FIXTURE(ValueTest,checkNormalizeFloatingPointStr)124 JSONTEST_FIXTURE(ValueTest, checkNormalizeFloatingPointStr) {
125 JSONTEST_ASSERT_STRING_EQUAL("0.0", normalizeFloatingPointStr("0.0"));
126 JSONTEST_ASSERT_STRING_EQUAL("0e0", normalizeFloatingPointStr("0e0"));
127 JSONTEST_ASSERT_STRING_EQUAL("1234.0", normalizeFloatingPointStr("1234.0"));
128 JSONTEST_ASSERT_STRING_EQUAL("1234.0e0",
129 normalizeFloatingPointStr("1234.0e0"));
130 JSONTEST_ASSERT_STRING_EQUAL("1234.0e+0",
131 normalizeFloatingPointStr("1234.0e+0"));
132 JSONTEST_ASSERT_STRING_EQUAL("1234e-1", normalizeFloatingPointStr("1234e-1"));
133 JSONTEST_ASSERT_STRING_EQUAL("1234e10", normalizeFloatingPointStr("1234e10"));
134 JSONTEST_ASSERT_STRING_EQUAL("1234e10",
135 normalizeFloatingPointStr("1234e010"));
136 JSONTEST_ASSERT_STRING_EQUAL("1234e+10",
137 normalizeFloatingPointStr("1234e+010"));
138 JSONTEST_ASSERT_STRING_EQUAL("1234e-10",
139 normalizeFloatingPointStr("1234e-010"));
140 JSONTEST_ASSERT_STRING_EQUAL("1234e+100",
141 normalizeFloatingPointStr("1234e+100"));
142 JSONTEST_ASSERT_STRING_EQUAL("1234e-100",
143 normalizeFloatingPointStr("1234e-100"));
144 JSONTEST_ASSERT_STRING_EQUAL("1234e+1",
145 normalizeFloatingPointStr("1234e+001"));
146 }
147
JSONTEST_FIXTURE(ValueTest,memberCount)148 JSONTEST_FIXTURE(ValueTest, memberCount) {
149 JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));
150 JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));
151 JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));
152 JSONTEST_ASSERT_PRED(checkMemberCount(object1_, 1));
153 JSONTEST_ASSERT_PRED(checkMemberCount(null_, 0));
154 JSONTEST_ASSERT_PRED(checkMemberCount(integer_, 0));
155 JSONTEST_ASSERT_PRED(checkMemberCount(unsignedInteger_, 0));
156 JSONTEST_ASSERT_PRED(checkMemberCount(smallUnsignedInteger_, 0));
157 JSONTEST_ASSERT_PRED(checkMemberCount(real_, 0));
158 JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));
159 JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));
160 JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));
161 }
162
JSONTEST_FIXTURE(ValueTest,objects)163 JSONTEST_FIXTURE(ValueTest, objects) {
164 // Types
165 IsCheck checks;
166 checks.isObject_ = true;
167 JSONTEST_ASSERT_PRED(checkIs(emptyObject_, checks));
168 JSONTEST_ASSERT_PRED(checkIs(object1_, checks));
169
170 JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
171
172 // Empty object okay
173 JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
174
175 // Non-empty object not okay
176 JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
177
178 // Always okay
179 JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
180
181 // Never okay
182 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
183 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
184 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
185 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
186 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
187 JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
188
189 // Access through const reference
190 const Json::Value& constObject = object1_;
191
192 JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
193 JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
194
195 // Access through non-const reference
196 JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
197 JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
198
199 object1_["some other id"] = "foo";
200 JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
201 }
202
JSONTEST_FIXTURE(ValueTest,arrays)203 JSONTEST_FIXTURE(ValueTest, arrays) {
204 const unsigned int index0 = 0;
205
206 // Types
207 IsCheck checks;
208 checks.isArray_ = true;
209 JSONTEST_ASSERT_PRED(checkIs(emptyArray_, checks));
210 JSONTEST_ASSERT_PRED(checkIs(array1_, checks));
211
212 JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
213
214 // Empty array okay
215 JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
216
217 // Non-empty array not okay
218 JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
219
220 // Always okay
221 JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
222
223 // Never okay
224 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
225 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
226 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
227 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
228 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
229 JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
230
231 // Access through const reference
232 const Json::Value& constArray = array1_;
233 JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
234 JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
235
236 // Access through non-const reference
237 JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
238 JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
239
240 array1_[2] = Json::Value(17);
241 JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
242 JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
243 }
244
JSONTEST_FIXTURE(ValueTest,null)245 JSONTEST_FIXTURE(ValueTest, null) {
246 JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
247
248 IsCheck checks;
249 checks.isNull_ = true;
250 JSONTEST_ASSERT_PRED(checkIs(null_, checks));
251
252 JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
253 JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
254 JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
255 JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
256 JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
257 JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
258 JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
259 JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
260
261 JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
262 JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
263 JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
264 JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
265 JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
266 JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
267 JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
268 }
269
JSONTEST_FIXTURE(ValueTest,strings)270 JSONTEST_FIXTURE(ValueTest, strings) {
271 JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
272
273 IsCheck checks;
274 checks.isString_ = true;
275 JSONTEST_ASSERT_PRED(checkIs(emptyString_, checks));
276 JSONTEST_ASSERT_PRED(checkIs(string_, checks));
277 JSONTEST_ASSERT_PRED(checkIs(string1_, checks));
278
279 // Empty string okay
280 JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
281
282 // Non-empty string not okay
283 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
284
285 // Always okay
286 JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
287
288 // Never okay
289 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
290 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
291 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
292 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
293 JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
294
295 JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
296 JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
297 }
298
JSONTEST_FIXTURE(ValueTest,bools)299 JSONTEST_FIXTURE(ValueTest, bools) {
300 JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
301
302 IsCheck checks;
303 checks.isBool_ = true;
304 JSONTEST_ASSERT_PRED(checkIs(false_, checks));
305 JSONTEST_ASSERT_PRED(checkIs(true_, checks));
306
307 // False okay
308 JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
309
310 // True not okay
311 JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
312
313 // Always okay
314 JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
315 JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
316 JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
317 JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
318 JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
319
320 // Never okay
321 JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
322 JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
323
324 JSONTEST_ASSERT_EQUAL(true, true_.asBool());
325 JSONTEST_ASSERT_EQUAL(1, true_.asInt());
326 JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
327 JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
328 JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
329 JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
330 JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
331
332 JSONTEST_ASSERT_EQUAL(false, false_.asBool());
333 JSONTEST_ASSERT_EQUAL(0, false_.asInt());
334 JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
335 JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
336 JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
337 JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
338 JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
339 }
340
JSONTEST_FIXTURE(ValueTest,integers)341 JSONTEST_FIXTURE(ValueTest, integers) {
342 IsCheck checks;
343 Json::Value val;
344
345 // Conversions that don't depend on the value.
346 JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
347 JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
348 JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
349 JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
350 JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
351
352 JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
353 JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
354 JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
355 JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
356 JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
357
358 JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
359 JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
360 JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
361 JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
362 JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
363
364 // Default int
365 val = Json::Value(Json::intValue);
366
367 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
368
369 checks = IsCheck();
370 checks.isInt_ = true;
371 checks.isInt64_ = true;
372 checks.isUInt_ = true;
373 checks.isUInt64_ = true;
374 checks.isIntegral_ = true;
375 checks.isDouble_ = true;
376 checks.isNumeric_ = true;
377 JSONTEST_ASSERT_PRED(checkIs(val, checks));
378
379 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
380 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
381 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
382
383 JSONTEST_ASSERT_EQUAL(0, val.asInt());
384 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
385 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
386 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
387 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
388 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
389 JSONTEST_ASSERT_EQUAL(false, val.asBool());
390 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
391
392 // Default uint
393 val = Json::Value(Json::uintValue);
394
395 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
396
397 checks = IsCheck();
398 checks.isInt_ = true;
399 checks.isInt64_ = true;
400 checks.isUInt_ = true;
401 checks.isUInt64_ = true;
402 checks.isIntegral_ = true;
403 checks.isDouble_ = true;
404 checks.isNumeric_ = true;
405 JSONTEST_ASSERT_PRED(checkIs(val, checks));
406
407 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
408 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
409 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
410
411 JSONTEST_ASSERT_EQUAL(0, val.asInt());
412 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
413 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
414 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
415 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
416 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
417 JSONTEST_ASSERT_EQUAL(false, val.asBool());
418 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
419
420 // Default real
421 val = Json::Value(Json::realValue);
422
423 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
424
425 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
426 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
427 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
428
429 checks = IsCheck();
430 checks.isInt_ = true;
431 checks.isInt64_ = true;
432 checks.isUInt_ = true;
433 checks.isUInt64_ = true;
434 checks.isIntegral_ = true;
435 checks.isDouble_ = true;
436 checks.isNumeric_ = true;
437 JSONTEST_ASSERT_PRED(checkIs(val, checks));
438
439 JSONTEST_ASSERT_EQUAL(0, val.asInt());
440 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
441 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
442 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
443 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
444 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
445 JSONTEST_ASSERT_EQUAL(false, val.asBool());
446 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
447
448 // Zero (signed constructor arg)
449 val = Json::Value(0);
450
451 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
452
453 checks = IsCheck();
454 checks.isInt_ = true;
455 checks.isInt64_ = true;
456 checks.isUInt_ = true;
457 checks.isUInt64_ = true;
458 checks.isIntegral_ = true;
459 checks.isDouble_ = true;
460 checks.isNumeric_ = true;
461 JSONTEST_ASSERT_PRED(checkIs(val, checks));
462
463 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
464 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
465 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
466
467 JSONTEST_ASSERT_EQUAL(0, val.asInt());
468 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
469 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
470 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
471 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
472 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
473 JSONTEST_ASSERT_EQUAL(false, val.asBool());
474 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
475
476 // Zero (unsigned constructor arg)
477 val = Json::Value(0u);
478
479 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
480
481 checks = IsCheck();
482 checks.isInt_ = true;
483 checks.isInt64_ = true;
484 checks.isUInt_ = true;
485 checks.isUInt64_ = true;
486 checks.isIntegral_ = true;
487 checks.isDouble_ = true;
488 checks.isNumeric_ = true;
489 JSONTEST_ASSERT_PRED(checkIs(val, checks));
490
491 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
492 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
493 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
494
495 JSONTEST_ASSERT_EQUAL(0, val.asInt());
496 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
497 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
498 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
499 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
500 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
501 JSONTEST_ASSERT_EQUAL(false, val.asBool());
502 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
503
504 // Zero (floating-point constructor arg)
505 val = Json::Value(0.0);
506
507 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
508
509 checks = IsCheck();
510 checks.isInt_ = true;
511 checks.isInt64_ = true;
512 checks.isUInt_ = true;
513 checks.isUInt64_ = true;
514 checks.isIntegral_ = true;
515 checks.isDouble_ = true;
516 checks.isNumeric_ = true;
517 JSONTEST_ASSERT_PRED(checkIs(val, checks));
518
519 JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
520 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
521 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
522
523 JSONTEST_ASSERT_EQUAL(0, val.asInt());
524 JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
525 JSONTEST_ASSERT_EQUAL(0, val.asUInt());
526 JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
527 JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
528 JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
529 JSONTEST_ASSERT_EQUAL(false, val.asBool());
530 JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
531
532 // 2^20 (signed constructor arg)
533 val = Json::Value(1 << 20);
534
535 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
536 checks = IsCheck();
537 checks.isInt_ = true;
538 checks.isInt64_ = true;
539 checks.isUInt_ = true;
540 checks.isUInt64_ = true;
541 checks.isIntegral_ = true;
542 checks.isDouble_ = true;
543 checks.isNumeric_ = true;
544 JSONTEST_ASSERT_PRED(checkIs(val, checks));
545
546 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
547 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
548 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
549
550 JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
551 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
552 JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
553 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
554 JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
555 JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
556 JSONTEST_ASSERT_EQUAL(true, val.asBool());
557 JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
558
559 // 2^20 (unsigned constructor arg)
560 val = Json::Value(Json::UInt(1 << 20));
561
562 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
563
564 checks = IsCheck();
565 checks.isInt_ = true;
566 checks.isInt64_ = true;
567 checks.isUInt_ = true;
568 checks.isUInt64_ = true;
569 checks.isIntegral_ = true;
570 checks.isDouble_ = true;
571 checks.isNumeric_ = true;
572 JSONTEST_ASSERT_PRED(checkIs(val, checks));
573
574 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
575 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
576 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
577
578 JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
579 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
580 JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
581 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
582 JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
583 JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
584 JSONTEST_ASSERT_EQUAL(true, val.asBool());
585 JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
586
587 // 2^20 (floating-point constructor arg)
588 val = Json::Value((1 << 20) / 1.0);
589
590 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
591
592 checks = IsCheck();
593 checks.isInt_ = true;
594 checks.isInt64_ = true;
595 checks.isUInt_ = true;
596 checks.isUInt64_ = true;
597 checks.isIntegral_ = true;
598 checks.isDouble_ = true;
599 checks.isNumeric_ = true;
600 JSONTEST_ASSERT_PRED(checkIs(val, checks));
601
602 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
603 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
604 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
605
606 JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
607 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
608 JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
609 JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
610 JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
611 JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
612 JSONTEST_ASSERT_EQUAL(true, val.asBool());
613 JSONTEST_ASSERT_STRING_EQUAL("1048576",
614 normalizeFloatingPointStr(val.asString()));
615
616 // -2^20
617 val = Json::Value(-(1 << 20));
618
619 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
620
621 checks = IsCheck();
622 checks.isInt_ = true;
623 checks.isInt64_ = true;
624 checks.isIntegral_ = true;
625 checks.isDouble_ = true;
626 checks.isNumeric_ = true;
627 JSONTEST_ASSERT_PRED(checkIs(val, checks));
628
629 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
630 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
631 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
632
633 JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
634 JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
635 JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
636 JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
637 JSONTEST_ASSERT_EQUAL(true, val.asBool());
638 JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
639
640 // int32 max
641 val = Json::Value(kint32max);
642
643 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
644
645 checks = IsCheck();
646 checks.isInt_ = true;
647 checks.isInt64_ = true;
648 checks.isUInt_ = true;
649 checks.isUInt64_ = true;
650 checks.isIntegral_ = true;
651 checks.isDouble_ = true;
652 checks.isNumeric_ = true;
653 JSONTEST_ASSERT_PRED(checkIs(val, checks));
654
655 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
656 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
657 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
658
659 JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
660 JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
661 JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
662 JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
663 JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
664 JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
665 JSONTEST_ASSERT_EQUAL(true, val.asBool());
666 JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
667
668 // int32 min
669 val = Json::Value(kint32min);
670
671 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
672
673 checks = IsCheck();
674 checks.isInt_ = true;
675 checks.isInt64_ = 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(kint32min, val.asInt());
686 JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
687 JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
688 JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
689 JSONTEST_ASSERT_EQUAL(true, val.asBool());
690 JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
691
692 // uint32 max
693 val = Json::Value(kuint32max);
694
695 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
696
697 checks = IsCheck();
698 checks.isInt64_ = true;
699 checks.isUInt_ = true;
700 checks.isUInt64_ = true;
701 checks.isIntegral_ = true;
702 checks.isDouble_ = true;
703 checks.isNumeric_ = true;
704 JSONTEST_ASSERT_PRED(checkIs(val, checks));
705
706 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
707 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
708 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
709
710 #ifndef JSON_NO_INT64
711 JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
712 #endif
713 JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
714 JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
715 JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
716 JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
717 JSONTEST_ASSERT_EQUAL(true, val.asBool());
718 JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
719
720 #ifdef JSON_NO_INT64
721 // int64 max
722 val = Json::Value(double(kint64max));
723
724 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
725
726 checks = IsCheck();
727 checks.isDouble_ = true;
728 checks.isNumeric_ = true;
729 JSONTEST_ASSERT_PRED(checkIs(val, checks));
730
731 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
732 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
733 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
734
735 JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
736 JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
737 JSONTEST_ASSERT_EQUAL(true, val.asBool());
738 JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
739
740 // int64 min
741 val = Json::Value(double(kint64min));
742
743 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
744
745 checks = IsCheck();
746 checks.isDouble_ = true;
747 checks.isNumeric_ = true;
748 JSONTEST_ASSERT_PRED(checkIs(val, checks));
749
750 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
751 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
752 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
753
754 JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
755 JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
756 JSONTEST_ASSERT_EQUAL(true, val.asBool());
757 JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
758
759 // uint64 max
760 val = Json::Value(double(kuint64max));
761
762 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
763
764 checks = IsCheck();
765 checks.isDouble_ = true;
766 checks.isNumeric_ = true;
767 JSONTEST_ASSERT_PRED(checkIs(val, checks));
768
769 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
770 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
771 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
772
773 JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
774 JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
775 JSONTEST_ASSERT_EQUAL(true, val.asBool());
776 JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
777 #else // ifdef JSON_NO_INT64
778 // 2^40 (signed constructor arg)
779 val = Json::Value(Json::Int64(1) << 40);
780
781 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
782
783 checks = IsCheck();
784 checks.isInt64_ = true;
785 checks.isUInt64_ = true;
786 checks.isIntegral_ = true;
787 checks.isDouble_ = true;
788 checks.isNumeric_ = true;
789 JSONTEST_ASSERT_PRED(checkIs(val, checks));
790
791 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
792 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
793 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
794
795 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
796 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
797 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
798 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
799 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
800 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
801 JSONTEST_ASSERT_EQUAL(true, val.asBool());
802 JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
803
804 // 2^40 (unsigned constructor arg)
805 val = Json::Value(Json::UInt64(1) << 40);
806
807 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
808
809 checks = IsCheck();
810 checks.isInt64_ = true;
811 checks.isUInt64_ = true;
812 checks.isIntegral_ = true;
813 checks.isDouble_ = true;
814 checks.isNumeric_ = true;
815 JSONTEST_ASSERT_PRED(checkIs(val, checks));
816
817 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
818 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
819 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
820
821 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
822 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
823 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
824 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
825 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
826 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
827 JSONTEST_ASSERT_EQUAL(true, val.asBool());
828 JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
829
830 // 2^40 (floating-point constructor arg)
831 val = Json::Value((Json::Int64(1) << 40) / 1.0);
832
833 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
834
835 checks = IsCheck();
836 checks.isInt64_ = true;
837 checks.isUInt64_ = true;
838 checks.isIntegral_ = true;
839 checks.isDouble_ = true;
840 checks.isNumeric_ = true;
841 JSONTEST_ASSERT_PRED(checkIs(val, checks));
842
843 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
844 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
845 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
846
847 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
848 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
849 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
850 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
851 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
852 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
853 JSONTEST_ASSERT_EQUAL(true, val.asBool());
854 JSONTEST_ASSERT_STRING_EQUAL("1099511627776",
855 normalizeFloatingPointStr(val.asString()));
856
857 // -2^40
858 val = Json::Value(-(Json::Int64(1) << 40));
859
860 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
861
862 checks = IsCheck();
863 checks.isInt64_ = true;
864 checks.isIntegral_ = true;
865 checks.isDouble_ = true;
866 checks.isNumeric_ = true;
867 JSONTEST_ASSERT_PRED(checkIs(val, checks));
868
869 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
870 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
871 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
872
873 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
874 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
875 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
876 JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
877 JSONTEST_ASSERT_EQUAL(true, val.asBool());
878 JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
879
880 // int64 max
881 val = Json::Value(Json::Int64(kint64max));
882
883 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
884
885 checks = IsCheck();
886 checks.isInt64_ = true;
887 checks.isUInt64_ = true;
888 checks.isIntegral_ = true;
889 checks.isDouble_ = true;
890 checks.isNumeric_ = true;
891 JSONTEST_ASSERT_PRED(checkIs(val, checks));
892
893 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
894 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
895 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
896
897 JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
898 JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
899 JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
900 JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
901 JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
902 JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
903 JSONTEST_ASSERT_EQUAL(true, val.asBool());
904 JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
905
906 // int64 max (floating point constructor). Note that kint64max is not exactly
907 // representable as a double, and will be rounded up to be higher.
908 val = Json::Value(double(kint64max));
909
910 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
911
912 checks = IsCheck();
913 checks.isUInt64_ = true;
914 checks.isIntegral_ = true;
915 checks.isDouble_ = true;
916 checks.isNumeric_ = true;
917 JSONTEST_ASSERT_PRED(checkIs(val, checks));
918
919 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
920 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
921 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
922
923 JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
924 JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
925 JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
926 JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(Json::UInt64(1) << 63)),
927 val.asFloat());
928 JSONTEST_ASSERT_EQUAL(true, val.asBool());
929 JSONTEST_ASSERT_STRING_EQUAL("9.223372036854776e+18",
930 normalizeFloatingPointStr(val.asString()));
931
932 // int64 min
933 val = Json::Value(Json::Int64(kint64min));
934
935 JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
936
937 checks = IsCheck();
938 checks.isInt64_ = true;
939 checks.isIntegral_ = true;
940 checks.isDouble_ = true;
941 checks.isNumeric_ = true;
942 JSONTEST_ASSERT_PRED(checkIs(val, checks));
943
944 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
945 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
946 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
947
948 JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
949 JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
950 JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
951 JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
952 JSONTEST_ASSERT_EQUAL(true, val.asBool());
953 JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
954
955 // int64 min (floating point constructor). Note that kint64min *is* exactly
956 // representable as a double.
957 val = Json::Value(double(kint64min));
958
959 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
960
961 checks = IsCheck();
962 checks.isInt64_ = true;
963 checks.isIntegral_ = true;
964 checks.isDouble_ = true;
965 checks.isNumeric_ = true;
966 JSONTEST_ASSERT_PRED(checkIs(val, checks));
967
968 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
969 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
970 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
971
972 JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
973 JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
974 JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
975 JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
976 JSONTEST_ASSERT_EQUAL(true, val.asBool());
977 JSONTEST_ASSERT_STRING_EQUAL("-9.223372036854776e+18",
978 normalizeFloatingPointStr(val.asString()));
979
980 // 10^19
981 const Json::UInt64 ten_to_19 = static_cast<Json::UInt64>(1e19);
982 val = Json::Value(Json::UInt64(ten_to_19));
983
984 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
985
986 checks = IsCheck();
987 checks.isUInt64_ = true;
988 checks.isIntegral_ = true;
989 checks.isDouble_ = true;
990 checks.isNumeric_ = true;
991 JSONTEST_ASSERT_PRED(checkIs(val, checks));
992
993 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
994 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
995 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
996
997 JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
998 JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
999 JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
1000 JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
1001 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1002 JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
1003
1004 // 10^19 (double constructor). Note that 10^19 is not exactly representable
1005 // as a double.
1006 val = Json::Value(uint64ToDouble(ten_to_19));
1007
1008 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1009
1010 checks = IsCheck();
1011 checks.isUInt64_ = true;
1012 checks.isIntegral_ = true;
1013 checks.isDouble_ = true;
1014 checks.isNumeric_ = true;
1015 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1016
1017 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1018 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1019 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1020
1021 JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
1022 JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
1023 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1024 JSONTEST_ASSERT_STRING_EQUAL("1e+19",
1025 normalizeFloatingPointStr(val.asString()));
1026
1027 // uint64 max
1028 val = Json::Value(Json::UInt64(kuint64max));
1029
1030 JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
1031
1032 checks = IsCheck();
1033 checks.isUInt64_ = true;
1034 checks.isIntegral_ = true;
1035 checks.isDouble_ = true;
1036 checks.isNumeric_ = true;
1037 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1038
1039 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1040 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1041 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1042
1043 JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
1044 JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
1045 JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
1046 JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
1047 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1048 JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
1049
1050 // uint64 max (floating point constructor). Note that kuint64max is not
1051 // exactly representable as a double, and will be rounded up to be higher.
1052 val = Json::Value(uint64ToDouble(kuint64max));
1053
1054 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1055
1056 checks = IsCheck();
1057 checks.isDouble_ = true;
1058 checks.isNumeric_ = true;
1059 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1060
1061 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1062 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1063 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1064
1065 JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
1066 JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
1067 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1068 JSONTEST_ASSERT_STRING_EQUAL("1.844674407370955e+19",
1069 normalizeFloatingPointStr(val.asString()));
1070 #endif
1071 }
1072
JSONTEST_FIXTURE(ValueTest,nonIntegers)1073 JSONTEST_FIXTURE(ValueTest, nonIntegers) {
1074 IsCheck checks;
1075 Json::Value val;
1076
1077 // Small positive number
1078 val = Json::Value(1.5);
1079
1080 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1081
1082 checks = IsCheck();
1083 checks.isDouble_ = true;
1084 checks.isNumeric_ = true;
1085 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1086
1087 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
1088 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
1089 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1090 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1091 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1092 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1093 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1094 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1095
1096 JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
1097 JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
1098 JSONTEST_ASSERT_EQUAL(1, val.asInt());
1099 JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
1100 JSONTEST_ASSERT_EQUAL(1, val.asUInt());
1101 JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
1102 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1103 JSONTEST_ASSERT_EQUAL("1.5", val.asString());
1104
1105 // Small negative number
1106 val = Json::Value(-1.5);
1107
1108 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1109
1110 checks = IsCheck();
1111 checks.isDouble_ = true;
1112 checks.isNumeric_ = true;
1113 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1114
1115 JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
1116 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1117 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1118 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1119 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1120 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1121 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1122 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1123
1124 JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
1125 JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
1126 JSONTEST_ASSERT_EQUAL(-1, val.asInt());
1127 JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
1128 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1129 JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
1130
1131 // A bit over int32 max
1132 val = Json::Value(kint32max + 0.5);
1133
1134 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1135
1136 checks = IsCheck();
1137 checks.isDouble_ = true;
1138 checks.isNumeric_ = true;
1139 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1140
1141 JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
1142 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1143 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1144 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1145 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1146 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1147 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1148 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1149
1150 JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
1151 JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
1152 JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
1153 #ifdef JSON_HAS_INT64
1154 JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
1155 JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
1156 #endif
1157 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1158 JSONTEST_ASSERT_EQUAL("2147483647.5",
1159 normalizeFloatingPointStr(val.asString()));
1160
1161 // A bit under int32 min
1162 val = Json::Value(kint32min - 0.5);
1163
1164 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1165
1166 checks = IsCheck();
1167 checks.isDouble_ = true;
1168 checks.isNumeric_ = true;
1169 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1170
1171 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1172 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1173 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1174 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1175 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1176 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1177 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1178 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1179
1180 JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
1181 JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
1182 #ifdef JSON_HAS_INT64
1183 JSONTEST_ASSERT_EQUAL(-Json::Int64(1) << 31, val.asLargestInt());
1184 #endif
1185 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1186 JSONTEST_ASSERT_EQUAL("-2147483648.5",
1187 normalizeFloatingPointStr(val.asString()));
1188
1189 // A bit over uint32 max
1190 val = Json::Value(kuint32max + 0.5);
1191
1192 JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1193
1194 checks = IsCheck();
1195 checks.isDouble_ = true;
1196 checks.isNumeric_ = true;
1197 JSONTEST_ASSERT_PRED(checkIs(val, checks));
1198
1199 JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1200 JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1201 JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1202 JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1203 JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1204 JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1205 JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1206 JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1207
1208 JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
1209 JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
1210 #ifdef JSON_HAS_INT64
1211 JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32) - 1, val.asLargestInt());
1212 JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32) - Json::UInt64(1),
1213 val.asLargestUInt());
1214 #endif
1215 JSONTEST_ASSERT_EQUAL(true, val.asBool());
1216 JSONTEST_ASSERT_EQUAL("4294967295.5",
1217 normalizeFloatingPointStr(val.asString()));
1218
1219 val = Json::Value(1.2345678901234);
1220 JSONTEST_ASSERT_STRING_EQUAL("1.2345678901234",
1221 normalizeFloatingPointStr(val.asString()));
1222
1223 // A 16-digit floating point number.
1224 val = Json::Value(2199023255552000.0f);
1225 JSONTEST_ASSERT_EQUAL(float(2199023255552000), val.asFloat());
1226 JSONTEST_ASSERT_STRING_EQUAL("2199023255552000",
1227 normalizeFloatingPointStr(val.asString()));
1228
1229 // A very large floating point number.
1230 val = Json::Value(3.402823466385289e38);
1231 JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
1232 JSONTEST_ASSERT_STRING_EQUAL("3.402823466385289e+38",
1233 normalizeFloatingPointStr(val.asString()));
1234
1235 // An even larger floating point number.
1236 val = Json::Value(1.2345678e300);
1237 JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
1238 JSONTEST_ASSERT_STRING_EQUAL("1.2345678e+300",
1239 normalizeFloatingPointStr(val.asString()));
1240 }
1241
checkConstMemberCount(const Json::Value & value,unsigned int expectedCount)1242 void ValueTest::checkConstMemberCount(const Json::Value& value,
1243 unsigned int expectedCount) {
1244 unsigned int count = 0;
1245 Json::Value::const_iterator itEnd = value.end();
1246 for (Json::Value::const_iterator it = value.begin(); it != itEnd; ++it) {
1247 ++count;
1248 }
1249 JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::const_iterator";
1250 }
1251
checkMemberCount(Json::Value & value,unsigned int expectedCount)1252 void ValueTest::checkMemberCount(Json::Value& value,
1253 unsigned int expectedCount) {
1254 JSONTEST_ASSERT_EQUAL(expectedCount, value.size());
1255
1256 unsigned int count = 0;
1257 Json::Value::iterator itEnd = value.end();
1258 for (Json::Value::iterator it = value.begin(); it != itEnd; ++it) {
1259 ++count;
1260 }
1261 JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::iterator";
1262
1263 JSONTEST_ASSERT_PRED(checkConstMemberCount(value, expectedCount));
1264 }
1265
IsCheck()1266 ValueTest::IsCheck::IsCheck()
1267 : isObject_(false), isArray_(false), isBool_(false), isString_(false),
1268 isNull_(false), isInt_(false), isInt64_(false), isUInt_(false),
1269 isUInt64_(false), isIntegral_(false), isDouble_(false),
1270 isNumeric_(false) {}
1271
checkIs(const Json::Value & value,const IsCheck & check)1272 void ValueTest::checkIs(const Json::Value& value, const IsCheck& check) {
1273 JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject());
1274 JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray());
1275 JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool());
1276 JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble());
1277 JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt());
1278 JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt());
1279 JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral());
1280 JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric());
1281 JSONTEST_ASSERT_EQUAL(check.isString_, value.isString());
1282 JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull());
1283
1284 #ifdef JSON_HAS_INT64
1285 JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64());
1286 JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64());
1287 #else
1288 JSONTEST_ASSERT_EQUAL(false, value.isInt64());
1289 JSONTEST_ASSERT_EQUAL(false, value.isUInt64());
1290 #endif
1291 }
1292
JSONTEST_FIXTURE(ValueTest,compareNull)1293 JSONTEST_FIXTURE(ValueTest, compareNull) {
1294 JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value()));
1295 }
1296
JSONTEST_FIXTURE(ValueTest,compareInt)1297 JSONTEST_FIXTURE(ValueTest, compareInt) {
1298 JSONTEST_ASSERT_PRED(checkIsLess(0, 10));
1299 JSONTEST_ASSERT_PRED(checkIsEqual(10, 10));
1300 JSONTEST_ASSERT_PRED(checkIsEqual(-10, -10));
1301 JSONTEST_ASSERT_PRED(checkIsLess(-10, 0));
1302 }
1303
JSONTEST_FIXTURE(ValueTest,compareUInt)1304 JSONTEST_FIXTURE(ValueTest, compareUInt) {
1305 JSONTEST_ASSERT_PRED(checkIsLess(0u, 10u));
1306 JSONTEST_ASSERT_PRED(checkIsLess(0u, Json::Value::maxUInt));
1307 JSONTEST_ASSERT_PRED(checkIsEqual(10u, 10u));
1308 }
1309
JSONTEST_FIXTURE(ValueTest,compareDouble)1310 JSONTEST_FIXTURE(ValueTest, compareDouble) {
1311 JSONTEST_ASSERT_PRED(checkIsLess(0.0, 10.0));
1312 JSONTEST_ASSERT_PRED(checkIsEqual(10.0, 10.0));
1313 JSONTEST_ASSERT_PRED(checkIsEqual(-10.0, -10.0));
1314 JSONTEST_ASSERT_PRED(checkIsLess(-10.0, 0.0));
1315 }
1316
JSONTEST_FIXTURE(ValueTest,compareString)1317 JSONTEST_FIXTURE(ValueTest, compareString) {
1318 JSONTEST_ASSERT_PRED(checkIsLess("", " "));
1319 JSONTEST_ASSERT_PRED(checkIsLess("", "a"));
1320 JSONTEST_ASSERT_PRED(checkIsLess("abcd", "zyui"));
1321 JSONTEST_ASSERT_PRED(checkIsLess("abc", "abcd"));
1322 JSONTEST_ASSERT_PRED(checkIsEqual("abcd", "abcd"));
1323 JSONTEST_ASSERT_PRED(checkIsEqual(" ", " "));
1324 JSONTEST_ASSERT_PRED(checkIsLess("ABCD", "abcd"));
1325 JSONTEST_ASSERT_PRED(checkIsEqual("ABCD", "ABCD"));
1326 }
1327
JSONTEST_FIXTURE(ValueTest,compareBoolean)1328 JSONTEST_FIXTURE(ValueTest, compareBoolean) {
1329 JSONTEST_ASSERT_PRED(checkIsLess(false, true));
1330 JSONTEST_ASSERT_PRED(checkIsEqual(false, false));
1331 JSONTEST_ASSERT_PRED(checkIsEqual(true, true));
1332 }
1333
JSONTEST_FIXTURE(ValueTest,compareArray)1334 JSONTEST_FIXTURE(ValueTest, compareArray) {
1335 // array compare size then content
1336 Json::Value emptyArray(Json::arrayValue);
1337 Json::Value l1aArray;
1338 l1aArray.append(0);
1339 Json::Value l1bArray;
1340 l1bArray.append(10);
1341 Json::Value l2aArray;
1342 l2aArray.append(0);
1343 l2aArray.append(0);
1344 Json::Value l2bArray;
1345 l2bArray.append(0);
1346 l2bArray.append(10);
1347 JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l1aArray));
1348 JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l2aArray));
1349 JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l2aArray));
1350 JSONTEST_ASSERT_PRED(checkIsLess(l2aArray, l2bArray));
1351 JSONTEST_ASSERT_PRED(checkIsEqual(emptyArray, Json::Value(emptyArray)));
1352 JSONTEST_ASSERT_PRED(checkIsEqual(l1aArray, Json::Value(l1aArray)));
1353 JSONTEST_ASSERT_PRED(checkIsEqual(l2bArray, Json::Value(l2bArray)));
1354 }
1355
JSONTEST_FIXTURE(ValueTest,compareObject)1356 JSONTEST_FIXTURE(ValueTest, compareObject) {
1357 // object compare size then content
1358 Json::Value emptyObject(Json::objectValue);
1359 Json::Value l1aObject;
1360 l1aObject["key1"] = 0;
1361 Json::Value l1bObject;
1362 l1aObject["key1"] = 10;
1363 Json::Value l2aObject;
1364 l2aObject["key1"] = 0;
1365 l2aObject["key2"] = 0;
1366 JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l1aObject));
1367 JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l2aObject));
1368 JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l2aObject));
1369 JSONTEST_ASSERT_PRED(checkIsEqual(emptyObject, Json::Value(emptyObject)));
1370 JSONTEST_ASSERT_PRED(checkIsEqual(l1aObject, Json::Value(l1aObject)));
1371 JSONTEST_ASSERT_PRED(checkIsEqual(l2aObject, Json::Value(l2aObject)));
1372 }
1373
JSONTEST_FIXTURE(ValueTest,compareType)1374 JSONTEST_FIXTURE(ValueTest, compareType) {
1375 // object of different type are ordered according to their type
1376 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(), Json::Value(1)));
1377 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1), Json::Value(1u)));
1378 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1u), Json::Value(1.0)));
1379 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1.0), Json::Value("a")));
1380 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value("a"), Json::Value(true)));
1381 JSONTEST_ASSERT_PRED(
1382 checkIsLess(Json::Value(true), Json::Value(Json::arrayValue)));
1383 JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(Json::arrayValue),
1384 Json::Value(Json::objectValue)));
1385 }
1386
checkIsLess(const Json::Value & x,const Json::Value & y)1387 void ValueTest::checkIsLess(const Json::Value& x, const Json::Value& y) {
1388 JSONTEST_ASSERT(x < y);
1389 JSONTEST_ASSERT(y > x);
1390 JSONTEST_ASSERT(x <= y);
1391 JSONTEST_ASSERT(y >= x);
1392 JSONTEST_ASSERT(!(x == y));
1393 JSONTEST_ASSERT(!(y == x));
1394 JSONTEST_ASSERT(!(x >= y));
1395 JSONTEST_ASSERT(!(y <= x));
1396 JSONTEST_ASSERT(!(x > y));
1397 JSONTEST_ASSERT(!(y < x));
1398 JSONTEST_ASSERT(x.compare(y) < 0);
1399 JSONTEST_ASSERT(y.compare(x) >= 0);
1400 }
1401
checkIsEqual(const Json::Value & x,const Json::Value & y)1402 void ValueTest::checkIsEqual(const Json::Value& x, const Json::Value& y) {
1403 JSONTEST_ASSERT(x == y);
1404 JSONTEST_ASSERT(y == x);
1405 JSONTEST_ASSERT(x <= y);
1406 JSONTEST_ASSERT(y <= x);
1407 JSONTEST_ASSERT(x >= y);
1408 JSONTEST_ASSERT(y >= x);
1409 JSONTEST_ASSERT(!(x < y));
1410 JSONTEST_ASSERT(!(y < x));
1411 JSONTEST_ASSERT(!(x > y));
1412 JSONTEST_ASSERT(!(y > x));
1413 JSONTEST_ASSERT(x.compare(y) == 0);
1414 JSONTEST_ASSERT(y.compare(x) == 0);
1415 }
1416
JSONTEST_FIXTURE(ValueTest,typeChecksThrowExceptions)1417 JSONTEST_FIXTURE(ValueTest, typeChecksThrowExceptions) {
1418 #if JSON_USE_EXCEPTION
1419
1420 Json::Value intVal(1);
1421 Json::Value strVal("Test");
1422 Json::Value objVal(Json::objectValue);
1423 Json::Value arrVal(Json::arrayValue);
1424
1425 JSONTEST_ASSERT_THROWS(intVal["test"]);
1426 JSONTEST_ASSERT_THROWS(strVal["test"]);
1427 JSONTEST_ASSERT_THROWS(arrVal["test"]);
1428
1429 JSONTEST_ASSERT_THROWS(intVal.removeMember("test"));
1430 JSONTEST_ASSERT_THROWS(strVal.removeMember("test"));
1431 JSONTEST_ASSERT_THROWS(arrVal.removeMember("test"));
1432
1433 JSONTEST_ASSERT_THROWS(intVal.getMemberNames());
1434 JSONTEST_ASSERT_THROWS(strVal.getMemberNames());
1435 JSONTEST_ASSERT_THROWS(arrVal.getMemberNames());
1436
1437 JSONTEST_ASSERT_THROWS(intVal[0]);
1438 JSONTEST_ASSERT_THROWS(objVal[0]);
1439 JSONTEST_ASSERT_THROWS(strVal[0]);
1440
1441 JSONTEST_ASSERT_THROWS(intVal.clear());
1442
1443 JSONTEST_ASSERT_THROWS(intVal.resize(1));
1444 JSONTEST_ASSERT_THROWS(strVal.resize(1));
1445 JSONTEST_ASSERT_THROWS(objVal.resize(1));
1446
1447 JSONTEST_ASSERT_THROWS(intVal.asCString());
1448
1449 JSONTEST_ASSERT_THROWS(objVal.asString());
1450 JSONTEST_ASSERT_THROWS(arrVal.asString());
1451
1452 JSONTEST_ASSERT_THROWS(strVal.asInt());
1453 JSONTEST_ASSERT_THROWS(objVal.asInt());
1454 JSONTEST_ASSERT_THROWS(arrVal.asInt());
1455
1456 JSONTEST_ASSERT_THROWS(strVal.asUInt());
1457 JSONTEST_ASSERT_THROWS(objVal.asUInt());
1458 JSONTEST_ASSERT_THROWS(arrVal.asUInt());
1459
1460 JSONTEST_ASSERT_THROWS(strVal.asInt64());
1461 JSONTEST_ASSERT_THROWS(objVal.asInt64());
1462 JSONTEST_ASSERT_THROWS(arrVal.asInt64());
1463
1464 JSONTEST_ASSERT_THROWS(strVal.asUInt64());
1465 JSONTEST_ASSERT_THROWS(objVal.asUInt64());
1466 JSONTEST_ASSERT_THROWS(arrVal.asUInt64());
1467
1468 JSONTEST_ASSERT_THROWS(strVal.asDouble());
1469 JSONTEST_ASSERT_THROWS(objVal.asDouble());
1470 JSONTEST_ASSERT_THROWS(arrVal.asDouble());
1471
1472 JSONTEST_ASSERT_THROWS(strVal.asFloat());
1473 JSONTEST_ASSERT_THROWS(objVal.asFloat());
1474 JSONTEST_ASSERT_THROWS(arrVal.asFloat());
1475
1476 JSONTEST_ASSERT_THROWS(strVal.asBool());
1477 JSONTEST_ASSERT_THROWS(objVal.asBool());
1478 JSONTEST_ASSERT_THROWS(arrVal.asBool());
1479
1480 #endif
1481 }
1482
JSONTEST_FIXTURE(ValueTest,offsetAccessors)1483 JSONTEST_FIXTURE(ValueTest, offsetAccessors) {
1484 Json::Value x;
1485 JSONTEST_ASSERT(x.getOffsetStart() == 0);
1486 JSONTEST_ASSERT(x.getOffsetLimit() == 0);
1487 x.setOffsetStart(10);
1488 x.setOffsetLimit(20);
1489 JSONTEST_ASSERT(x.getOffsetStart() == 10);
1490 JSONTEST_ASSERT(x.getOffsetLimit() == 20);
1491 Json::Value y(x);
1492 JSONTEST_ASSERT(y.getOffsetStart() == 10);
1493 JSONTEST_ASSERT(y.getOffsetLimit() == 20);
1494 Json::Value z;
1495 z.swap(y);
1496 JSONTEST_ASSERT(z.getOffsetStart() == 10);
1497 JSONTEST_ASSERT(z.getOffsetLimit() == 20);
1498 JSONTEST_ASSERT(y.getOffsetStart() == 0);
1499 JSONTEST_ASSERT(y.getOffsetLimit() == 0);
1500 }
1501
1502 struct WriterTest : JsonTest::TestCase {};
1503
JSONTEST_FIXTURE(WriterTest,dropNullPlaceholders)1504 JSONTEST_FIXTURE(WriterTest, dropNullPlaceholders) {
1505 Json::FastWriter writer;
1506 Json::Value nullValue;
1507 JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
1508
1509 writer.dropNullPlaceholders();
1510 JSONTEST_ASSERT(writer.write(nullValue) == "\n");
1511 }
1512
1513 struct ReaderTest : JsonTest::TestCase {};
1514
JSONTEST_FIXTURE(ReaderTest,parseWithNoErrors)1515 JSONTEST_FIXTURE(ReaderTest, parseWithNoErrors) {
1516 Json::Reader reader;
1517 Json::Value root;
1518 bool ok = reader.parse("{ \"property\" : \"value\" }", root);
1519 JSONTEST_ASSERT(ok);
1520 JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
1521 JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
1522 }
1523
JSONTEST_FIXTURE(ReaderTest,parseWithNoErrorsTestingOffsets)1524 JSONTEST_FIXTURE(ReaderTest, parseWithNoErrorsTestingOffsets) {
1525 Json::Reader reader;
1526 Json::Value root;
1527 bool ok = reader.parse("{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
1528 "{ \"nested\" : 123, \"bool\" : true}, \"null\" : "
1529 "null, \"false\" : false }",
1530 root);
1531 JSONTEST_ASSERT(ok);
1532 JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
1533 JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
1534 JSONTEST_ASSERT(root["property"].getOffsetStart() == 15);
1535 JSONTEST_ASSERT(root["property"].getOffsetLimit() == 34);
1536 JSONTEST_ASSERT(root["property"][0].getOffsetStart() == 16);
1537 JSONTEST_ASSERT(root["property"][0].getOffsetLimit() == 23);
1538 JSONTEST_ASSERT(root["property"][1].getOffsetStart() == 25);
1539 JSONTEST_ASSERT(root["property"][1].getOffsetLimit() == 33);
1540 JSONTEST_ASSERT(root["obj"].getOffsetStart() == 44);
1541 JSONTEST_ASSERT(root["obj"].getOffsetLimit() == 76);
1542 JSONTEST_ASSERT(root["obj"]["nested"].getOffsetStart() == 57);
1543 JSONTEST_ASSERT(root["obj"]["nested"].getOffsetLimit() == 60);
1544 JSONTEST_ASSERT(root["obj"]["bool"].getOffsetStart() == 71);
1545 JSONTEST_ASSERT(root["obj"]["bool"].getOffsetLimit() == 75);
1546 JSONTEST_ASSERT(root["null"].getOffsetStart() == 87);
1547 JSONTEST_ASSERT(root["null"].getOffsetLimit() == 91);
1548 JSONTEST_ASSERT(root["false"].getOffsetStart() == 103);
1549 JSONTEST_ASSERT(root["false"].getOffsetLimit() == 108);
1550 JSONTEST_ASSERT(root.getOffsetStart() == 0);
1551 JSONTEST_ASSERT(root.getOffsetLimit() == 110);
1552 }
1553
JSONTEST_FIXTURE(ReaderTest,parseWithOneError)1554 JSONTEST_FIXTURE(ReaderTest, parseWithOneError) {
1555 Json::Reader reader;
1556 Json::Value root;
1557 bool ok = reader.parse("{ \"property\" :: \"value\" }", root);
1558 JSONTEST_ASSERT(!ok);
1559 JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1560 "* Line 1, Column 15\n Syntax error: value, object or array "
1561 "expected.\n");
1562 std::vector<Json::Reader::StructuredError> errors =
1563 reader.getStructuredErrors();
1564 JSONTEST_ASSERT(errors.size() == 1);
1565 JSONTEST_ASSERT(errors.at(0).offset_start == 14);
1566 JSONTEST_ASSERT(errors.at(0).offset_limit == 15);
1567 JSONTEST_ASSERT(errors.at(0).message ==
1568 "Syntax error: value, object or array expected.");
1569 }
1570
JSONTEST_FIXTURE(ReaderTest,parseChineseWithOneError)1571 JSONTEST_FIXTURE(ReaderTest, parseChineseWithOneError) {
1572 Json::Reader reader;
1573 Json::Value root;
1574 bool ok = reader.parse("{ \"pr佐藤erty\" :: \"value\" }", root);
1575 JSONTEST_ASSERT(!ok);
1576 JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1577 "* Line 1, Column 19\n Syntax error: value, object or array "
1578 "expected.\n");
1579 std::vector<Json::Reader::StructuredError> errors =
1580 reader.getStructuredErrors();
1581 JSONTEST_ASSERT(errors.size() == 1);
1582 JSONTEST_ASSERT(errors.at(0).offset_start == 18);
1583 JSONTEST_ASSERT(errors.at(0).offset_limit == 19);
1584 JSONTEST_ASSERT(errors.at(0).message ==
1585 "Syntax error: value, object or array expected.");
1586 }
1587
JSONTEST_FIXTURE(ReaderTest,parseWithDetailError)1588 JSONTEST_FIXTURE(ReaderTest, parseWithDetailError) {
1589 Json::Reader reader;
1590 Json::Value root;
1591 bool ok = reader.parse("{ \"property\" : \"v\\alue\" }", root);
1592 JSONTEST_ASSERT(!ok);
1593 JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1594 "* Line 1, Column 16\n Bad escape sequence in string\nSee "
1595 "Line 1, Column 20 for detail.\n");
1596 std::vector<Json::Reader::StructuredError> errors =
1597 reader.getStructuredErrors();
1598 JSONTEST_ASSERT(errors.size() == 1);
1599 JSONTEST_ASSERT(errors.at(0).offset_start == 15);
1600 JSONTEST_ASSERT(errors.at(0).offset_limit == 23);
1601 JSONTEST_ASSERT(errors.at(0).message == "Bad escape sequence in string");
1602 }
1603
main(int argc,const char * argv[])1604 int main(int argc, const char* argv[]) {
1605 JsonTest::Runner runner;
1606 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkNormalizeFloatingPointStr);
1607 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, memberCount);
1608 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, objects);
1609 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, arrays);
1610 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, null);
1611 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, strings);
1612 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, bools);
1613 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, integers);
1614 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, nonIntegers);
1615 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareNull);
1616 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareInt);
1617 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareUInt);
1618 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareDouble);
1619 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareString);
1620 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareBoolean);
1621 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareArray);
1622 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareObject);
1623 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareType);
1624 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, offsetAccessors);
1625 JSONTEST_REGISTER_FIXTURE(runner, ValueTest, typeChecksThrowExceptions);
1626
1627 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithNoErrors);
1628 JSONTEST_REGISTER_FIXTURE(
1629 runner, ReaderTest, parseWithNoErrorsTestingOffsets);
1630 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithOneError);
1631 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseChineseWithOneError);
1632 JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithDetailError);
1633
1634 JSONTEST_REGISTER_FIXTURE(runner, WriterTest, dropNullPlaceholders);
1635
1636 return runner.runCommandLine(argc, argv);
1637 }
1638