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