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) 32 static inline double uint64ToDouble(Json::UInt64 value) { 33 return static_cast<double>(value); 34 } 35 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 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 59 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 1293 JSONTEST_FIXTURE(ValueTest, compareNull) { 1294 JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value())); 1295 } 1296 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 1571 JSONTEST_FIXTURE(ReaderTest, parseChineseWithOneError) { 1572 Json::Reader reader; 1573 Json::Value root; 1574 bool ok = reader.parse("{ \"prerty\" :: \"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 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 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
