src/test_lib_json/main.cpp

   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 #include <cstring>
  11
  12 // Make numeric limits more convenient to talk about.
  13 // Assumes int type in 32 bits.
  14 #define kint32max Json::Value::maxInt
  15 #define kint32min Json::Value::minInt
  16 #define kuint32max Json::Value::maxUInt
  17 #define kint64max Json::Value::maxInt64
  18 #define kint64min Json::Value::minInt64
  19 #define kuint64max Json::Value::maxUInt64
  20
  21 //static const double kdint64max = double(kint64max);
  22 //static const float kfint64max = float(kint64max);
  23 static const float kfint32max = float(kint32max);
  24 static const float kfuint32max = float(kuint32max);
  25
  26 // //////////////////////////////////////////////////////////////////
  27 // //////////////////////////////////////////////////////////////////
  28 // Json Library test cases
  29 // //////////////////////////////////////////////////////////////////
  30 // //////////////////////////////////////////////////////////////////
  31
  32 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
  33 static inline double uint64ToDouble(Json::UInt64 value) {
  34   return static_cast<double>(value);
  35 }
  36 #else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
  37 static inline double uint64ToDouble(Json::UInt64 value) {
  38   return static_cast<double>(Json::Int64(value / 2)) * 2.0 +
  39          Json::Int64(value & 1);
  40 }
  41 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
  42
  43 struct ValueTest : JsonTest::TestCase {
  44   Json::Value null_;
  45   Json::Value emptyArray_;
  46   Json::Value emptyObject_;
  47   Json::Value integer_;
  48   Json::Value unsignedInteger_;
  49   Json::Value smallUnsignedInteger_;
  50   Json::Value real_;
  51   Json::Value float_;
  52   Json::Value array1_;
  53   Json::Value object1_;
  54   Json::Value emptyString_;
  55   Json::Value string1_;
  56   Json::Value string_;
  57   Json::Value true_;
  58   Json::Value false_;
  59
  60   ValueTest()
  61       : emptyArray_(Json::arrayValue), emptyObject_(Json::objectValue),
  62         integer_(123456789), unsignedInteger_(34567890u),
  63         smallUnsignedInteger_(Json::Value::UInt(Json::Value::maxInt)),
  64         real_(1234.56789), float_(0.00390625f), emptyString_(""), string1_("a"),
  65         string_("sometext with space"), true_(true), false_(false) {
  66     array1_.append(1234);
  67     object1_["id"] = 1234;
  68   }
  69
  70   struct IsCheck {
  71     /// Initialize all checks to \c false by default.
  72     IsCheck();
  73
  74     bool isObject_;
  75     bool isArray_;
  76     bool isBool_;
  77     bool isString_;
  78     bool isNull_;
  79
  80     bool isInt_;
  81     bool isInt64_;
  82     bool isUInt_;
  83     bool isUInt64_;
  84     bool isIntegral_;
  85     bool isDouble_;
  86     bool isNumeric_;
  87   };
  88
  89   void checkConstMemberCount(const Json::Value& value,
  90                              unsigned int expectedCount);
  91
  92   void checkMemberCount(Json::Value& value, unsigned int expectedCount);
  93
  94   void checkIs(const Json::Value& value, const IsCheck& check);
  95
  96   void checkIsLess(const Json::Value& x, const Json::Value& y);
  97
  98   void checkIsEqual(const Json::Value& x, const Json::Value& y);
  99
 100   /// Normalize the representation of floating-point number by stripped leading
 101   /// 0 in exponent.
 102   static std::string normalizeFloatingPointStr(const std::string& s);
 103 };
 104
 105 std::string ValueTest::normalizeFloatingPointStr(const std::string& s) {
 106   std::string::size_type index = s.find_last_of("eE");
 107   if (index != std::string::npos) {
 108     std::string::size_type hasSign =
 109         (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
 110     std::string::size_type exponentStartIndex = index + 1 + hasSign;
 111     std::string normalized = s.substr(0, exponentStartIndex);
 112     std::string::size_type indexDigit =
 113         s.find_first_not_of('0', exponentStartIndex);
 114     std::string exponent = "0";
 115     if (indexDigit !=
 116         std::string::npos) // There is an exponent different from 0
 117     {
 118       exponent = s.substr(indexDigit);
 119     }
 120     return normalized + exponent;
 121   }
 122   return s;
 123 }
 124
 125 JSONTEST_FIXTURE(ValueTest, checkNormalizeFloatingPointStr) {
 126   JSONTEST_ASSERT_STRING_EQUAL("0.0", normalizeFloatingPointStr("0.0"));
 127   JSONTEST_ASSERT_STRING_EQUAL("0e0", normalizeFloatingPointStr("0e0"));
 128   JSONTEST_ASSERT_STRING_EQUAL("1234.0", normalizeFloatingPointStr("1234.0"));
 129   JSONTEST_ASSERT_STRING_EQUAL("1234.0e0",
 130                                normalizeFloatingPointStr("1234.0e0"));
 131   JSONTEST_ASSERT_STRING_EQUAL("1234.0e+0",
 132                                normalizeFloatingPointStr("1234.0e+0"));
 133   JSONTEST_ASSERT_STRING_EQUAL("1234e-1", normalizeFloatingPointStr("1234e-1"));
 134   JSONTEST_ASSERT_STRING_EQUAL("1234e10", normalizeFloatingPointStr("1234e10"));
 135   JSONTEST_ASSERT_STRING_EQUAL("1234e10",
 136                                normalizeFloatingPointStr("1234e010"));
 137   JSONTEST_ASSERT_STRING_EQUAL("1234e+10",
 138                                normalizeFloatingPointStr("1234e+010"));
 139   JSONTEST_ASSERT_STRING_EQUAL("1234e-10",
 140                                normalizeFloatingPointStr("1234e-010"));
 141   JSONTEST_ASSERT_STRING_EQUAL("1234e+100",
 142                                normalizeFloatingPointStr("1234e+100"));
 143   JSONTEST_ASSERT_STRING_EQUAL("1234e-100",
 144                                normalizeFloatingPointStr("1234e-100"));
 145   JSONTEST_ASSERT_STRING_EQUAL("1234e+1",
 146                                normalizeFloatingPointStr("1234e+001"));
 147 }
 148
 149 JSONTEST_FIXTURE(ValueTest, memberCount) {
 150   JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));
 151   JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));
 152   JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));
 153   JSONTEST_ASSERT_PRED(checkMemberCount(object1_, 1));
 154   JSONTEST_ASSERT_PRED(checkMemberCount(null_, 0));
 155   JSONTEST_ASSERT_PRED(checkMemberCount(integer_, 0));
 156   JSONTEST_ASSERT_PRED(checkMemberCount(unsignedInteger_, 0));
 157   JSONTEST_ASSERT_PRED(checkMemberCount(smallUnsignedInteger_, 0));
 158   JSONTEST_ASSERT_PRED(checkMemberCount(real_, 0));
 159   JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));
 160   JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));
 161   JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));
 162 }
 163
 164 JSONTEST_FIXTURE(ValueTest, objects) {
 165   // Types
 166   IsCheck checks;
 167   checks.isObject_ = true;
 168   JSONTEST_ASSERT_PRED(checkIs(emptyObject_, checks));
 169   JSONTEST_ASSERT_PRED(checkIs(object1_, checks));
 170
 171   JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
 172
 173   // Empty object okay
 174   JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
 175
 176   // Non-empty object not okay
 177   JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
 178
 179   // Always okay
 180   JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
 181
 182   // Never okay
 183   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
 184   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
 185   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
 186   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
 187   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
 188   JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
 189
 190   // Access through const reference
 191   const Json::Value& constObject = object1_;
 192
 193   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
 194   JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
 195
 196   // Access through non-const reference
 197   JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
 198   JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
 199
 200   object1_["some other id"] = "foo";
 201   JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
 202   JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
 203
 204   // Remove.
 205   Json::Value got;
 206   bool did;
 207   did = object1_.removeMember("some other id", &got);
 208   JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);
 209   JSONTEST_ASSERT_EQUAL(true, did);
 210   got = Json::Value("bar");
 211   did = object1_.removeMember("some other id", &got);
 212   JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);
 213   JSONTEST_ASSERT_EQUAL(false, did);
 214 }
 215
 216 JSONTEST_FIXTURE(ValueTest, arrays) {
 217   const unsigned int index0 = 0;
 218
 219   // Types
 220   IsCheck checks;
 221   checks.isArray_ = true;
 222   JSONTEST_ASSERT_PRED(checkIs(emptyArray_, checks));
 223   JSONTEST_ASSERT_PRED(checkIs(array1_, checks));
 224
 225   JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
 226
 227   // Empty array okay
 228   JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
 229
 230   // Non-empty array not okay
 231   JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
 232
 233   // Always okay
 234   JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
 235
 236   // Never okay
 237   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
 238   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
 239   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
 240   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
 241   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
 242   JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
 243
 244   // Access through const reference
 245   const Json::Value& constArray = array1_;
 246   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
 247   JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
 248
 249   // Access through non-const reference
 250   JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
 251   JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
 252
 253   array1_[2] = Json::Value(17);
 254   JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
 255   JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
 256   Json::Value got;
 257   JSONTEST_ASSERT_EQUAL(true, array1_.removeIndex(2, &got));
 258   JSONTEST_ASSERT_EQUAL(Json::Value(17), got);
 259   JSONTEST_ASSERT_EQUAL(false, array1_.removeIndex(2, &got)); // gone now
 260 }
 261
 262 JSONTEST_FIXTURE(ValueTest, null) {
 263   JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
 264
 265   IsCheck checks;
 266   checks.isNull_ = true;
 267   JSONTEST_ASSERT_PRED(checkIs(null_, checks));
 268
 269   JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
 270   JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
 271   JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
 272   JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
 273   JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
 274   JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
 275   JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
 276   JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
 277
 278   JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
 279   JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
 280   JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
 281   JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
 282   JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
 283   JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
 284   JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
 285 }
 286
 287 JSONTEST_FIXTURE(ValueTest, strings) {
 288   JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
 289
 290   IsCheck checks;
 291   checks.isString_ = true;
 292   JSONTEST_ASSERT_PRED(checkIs(emptyString_, checks));
 293   JSONTEST_ASSERT_PRED(checkIs(string_, checks));
 294   JSONTEST_ASSERT_PRED(checkIs(string1_, checks));
 295
 296   // Empty string okay
 297   JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
 298
 299   // Non-empty string not okay
 300   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
 301
 302   // Always okay
 303   JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
 304
 305   // Never okay
 306   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
 307   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
 308   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
 309   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
 310   JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
 311
 312   JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
 313   JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
 314 }
 315
 316 JSONTEST_FIXTURE(ValueTest, bools) {
 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   IsCheck checks;
 360   Json::Value val;
 361
 362   // Conversions that don't depend on the value.
 363   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
 364   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
 365   JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
 366   JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
 367   JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
 368
 369   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
 370   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
 371   JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
 372   JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
 373   JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
 374
 375   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
 376   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
 377   JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
 378   JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
 379   JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
 380
 381   // Default int
 382   val = Json::Value(Json::intValue);
 383
 384   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 385
 386   checks = IsCheck();
 387   checks.isInt_ = true;
 388   checks.isInt64_ = true;
 389   checks.isUInt_ = true;
 390   checks.isUInt64_ = true;
 391   checks.isIntegral_ = true;
 392   checks.isDouble_ = true;
 393   checks.isNumeric_ = true;
 394   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 395
 396   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
 397   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 398   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 399
 400   JSONTEST_ASSERT_EQUAL(0, val.asInt());
 401   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
 402   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
 403   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
 404   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
 405   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
 406   JSONTEST_ASSERT_EQUAL(false, val.asBool());
 407   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 408
 409   // Default uint
 410   val = Json::Value(Json::uintValue);
 411
 412   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 413
 414   checks = IsCheck();
 415   checks.isInt_ = true;
 416   checks.isInt64_ = true;
 417   checks.isUInt_ = true;
 418   checks.isUInt64_ = true;
 419   checks.isIntegral_ = true;
 420   checks.isDouble_ = true;
 421   checks.isNumeric_ = true;
 422   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 423
 424   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
 425   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 426   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 427
 428   JSONTEST_ASSERT_EQUAL(0, val.asInt());
 429   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
 430   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
 431   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
 432   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
 433   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
 434   JSONTEST_ASSERT_EQUAL(false, val.asBool());
 435   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 436
 437   // Default real
 438   val = Json::Value(Json::realValue);
 439
 440   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 441
 442   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
 443   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 444   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 445
 446   checks = IsCheck();
 447   checks.isInt_ = true;
 448   checks.isInt64_ = true;
 449   checks.isUInt_ = true;
 450   checks.isUInt64_ = true;
 451   checks.isIntegral_ = true;
 452   checks.isDouble_ = true;
 453   checks.isNumeric_ = true;
 454   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 455
 456   JSONTEST_ASSERT_EQUAL(0, val.asInt());
 457   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
 458   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
 459   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
 460   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
 461   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
 462   JSONTEST_ASSERT_EQUAL(false, val.asBool());
 463   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 464
 465   // Zero (signed constructor arg)
 466   val = Json::Value(0);
 467
 468   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 469
 470   checks = IsCheck();
 471   checks.isInt_ = true;
 472   checks.isInt64_ = true;
 473   checks.isUInt_ = true;
 474   checks.isUInt64_ = true;
 475   checks.isIntegral_ = true;
 476   checks.isDouble_ = true;
 477   checks.isNumeric_ = true;
 478   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 479
 480   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
 481   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 482   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 483
 484   JSONTEST_ASSERT_EQUAL(0, val.asInt());
 485   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
 486   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
 487   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
 488   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
 489   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
 490   JSONTEST_ASSERT_EQUAL(false, val.asBool());
 491   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 492
 493   // Zero (unsigned constructor arg)
 494   val = Json::Value(0u);
 495
 496   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 497
 498   checks = IsCheck();
 499   checks.isInt_ = true;
 500   checks.isInt64_ = true;
 501   checks.isUInt_ = true;
 502   checks.isUInt64_ = true;
 503   checks.isIntegral_ = true;
 504   checks.isDouble_ = true;
 505   checks.isNumeric_ = true;
 506   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 507
 508   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
 509   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 510   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 511
 512   JSONTEST_ASSERT_EQUAL(0, val.asInt());
 513   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
 514   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
 515   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
 516   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
 517   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
 518   JSONTEST_ASSERT_EQUAL(false, val.asBool());
 519   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 520
 521   // Zero (floating-point constructor arg)
 522   val = Json::Value(0.0);
 523
 524   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 525
 526   checks = IsCheck();
 527   checks.isInt_ = true;
 528   checks.isInt64_ = true;
 529   checks.isUInt_ = true;
 530   checks.isUInt64_ = true;
 531   checks.isIntegral_ = true;
 532   checks.isDouble_ = true;
 533   checks.isNumeric_ = true;
 534   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 535
 536   JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
 537   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 538   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 539
 540   JSONTEST_ASSERT_EQUAL(0, val.asInt());
 541   JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
 542   JSONTEST_ASSERT_EQUAL(0, val.asUInt());
 543   JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
 544   JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
 545   JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
 546   JSONTEST_ASSERT_EQUAL(false, val.asBool());
 547   JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
 548
 549   // 2^20 (signed constructor arg)
 550   val = Json::Value(1 << 20);
 551
 552   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 553   checks = IsCheck();
 554   checks.isInt_ = true;
 555   checks.isInt64_ = true;
 556   checks.isUInt_ = true;
 557   checks.isUInt64_ = true;
 558   checks.isIntegral_ = true;
 559   checks.isDouble_ = true;
 560   checks.isNumeric_ = true;
 561   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 562
 563   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 564   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 565   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 566
 567   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
 568   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
 569   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
 570   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
 571   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
 572   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
 573   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 574   JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
 575
 576   // 2^20 (unsigned constructor arg)
 577   val = Json::Value(Json::UInt(1 << 20));
 578
 579   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 580
 581   checks = IsCheck();
 582   checks.isInt_ = true;
 583   checks.isInt64_ = true;
 584   checks.isUInt_ = true;
 585   checks.isUInt64_ = true;
 586   checks.isIntegral_ = true;
 587   checks.isDouble_ = true;
 588   checks.isNumeric_ = true;
 589   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 590
 591   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 592   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 593   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 594
 595   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
 596   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
 597   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
 598   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
 599   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
 600   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
 601   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 602   JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
 603
 604   // 2^20 (floating-point constructor arg)
 605   val = Json::Value((1 << 20) / 1.0);
 606
 607   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 608
 609   checks = IsCheck();
 610   checks.isInt_ = true;
 611   checks.isInt64_ = true;
 612   checks.isUInt_ = true;
 613   checks.isUInt64_ = true;
 614   checks.isIntegral_ = true;
 615   checks.isDouble_ = true;
 616   checks.isNumeric_ = true;
 617   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 618
 619   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 620   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 621   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 622
 623   JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
 624   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
 625   JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
 626   JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
 627   JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
 628   JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
 629   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 630   JSONTEST_ASSERT_STRING_EQUAL("1048576",
 631                                normalizeFloatingPointStr(val.asString()));
 632
 633   // -2^20
 634   val = Json::Value(-(1 << 20));
 635
 636   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 637
 638   checks = IsCheck();
 639   checks.isInt_ = true;
 640   checks.isInt64_ = true;
 641   checks.isIntegral_ = true;
 642   checks.isDouble_ = true;
 643   checks.isNumeric_ = true;
 644   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 645
 646   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 647   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 648   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 649
 650   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
 651   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
 652   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
 653   JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
 654   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 655   JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
 656
 657   // int32 max
 658   val = Json::Value(kint32max);
 659
 660   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 661
 662   checks = IsCheck();
 663   checks.isInt_ = true;
 664   checks.isInt64_ = true;
 665   checks.isUInt_ = true;
 666   checks.isUInt64_ = true;
 667   checks.isIntegral_ = true;
 668   checks.isDouble_ = true;
 669   checks.isNumeric_ = true;
 670   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 671
 672   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 673   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 674   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 675
 676   JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
 677   JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
 678   JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
 679   JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
 680   JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
 681   JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
 682   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 683   JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
 684
 685   // int32 min
 686   val = Json::Value(kint32min);
 687
 688   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 689
 690   checks = IsCheck();
 691   checks.isInt_ = true;
 692   checks.isInt64_ = true;
 693   checks.isIntegral_ = true;
 694   checks.isDouble_ = true;
 695   checks.isNumeric_ = true;
 696   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 697
 698   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 699   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
 700   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 701
 702   JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
 703   JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
 704   JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
 705   JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
 706   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 707   JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
 708
 709   // uint32 max
 710   val = Json::Value(kuint32max);
 711
 712   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 713
 714   checks = IsCheck();
 715   checks.isInt64_ = true;
 716   checks.isUInt_ = true;
 717   checks.isUInt64_ = true;
 718   checks.isIntegral_ = true;
 719   checks.isDouble_ = true;
 720   checks.isNumeric_ = true;
 721   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 722
 723   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 724   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 725   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
 726
 727 #ifndef JSON_NO_INT64
 728   JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
 729 #endif
 730   JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
 731   JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
 732   JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
 733   JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
 734   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 735   JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
 736
 737 #ifdef JSON_NO_INT64
 738   // int64 max
 739   val = Json::Value(double(kint64max));
 740
 741   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 742
 743   checks = IsCheck();
 744   checks.isDouble_ = true;
 745   checks.isNumeric_ = true;
 746   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 747
 748   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 749   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 750   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 751
 752   JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
 753   JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
 754   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 755   JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
 756
 757   // int64 min
 758   val = Json::Value(double(kint64min));
 759
 760   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 761
 762   checks = IsCheck();
 763   checks.isDouble_ = true;
 764   checks.isNumeric_ = true;
 765   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 766
 767   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 768   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 769   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 770
 771   JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
 772   JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
 773   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 774   JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
 775
 776   // uint64 max
 777   val = Json::Value(double(kuint64max));
 778
 779   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 780
 781   checks = IsCheck();
 782   checks.isDouble_ = true;
 783   checks.isNumeric_ = true;
 784   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 785
 786   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 787   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 788   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 789
 790   JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
 791   JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
 792   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 793   JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
 794 #else // ifdef JSON_NO_INT64
 795   // 2^40 (signed constructor arg)
 796   val = Json::Value(Json::Int64(1) << 40);
 797
 798   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 799
 800   checks = IsCheck();
 801   checks.isInt64_ = true;
 802   checks.isUInt64_ = true;
 803   checks.isIntegral_ = true;
 804   checks.isDouble_ = true;
 805   checks.isNumeric_ = true;
 806   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 807
 808   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 809   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 810   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 811
 812   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
 813   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
 814   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
 815   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
 816   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
 817   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
 818   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 819   JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
 820
 821   // 2^40 (unsigned constructor arg)
 822   val = Json::Value(Json::UInt64(1) << 40);
 823
 824   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
 825
 826   checks = IsCheck();
 827   checks.isInt64_ = true;
 828   checks.isUInt64_ = true;
 829   checks.isIntegral_ = true;
 830   checks.isDouble_ = true;
 831   checks.isNumeric_ = true;
 832   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 833
 834   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 835   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 836   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 837
 838   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
 839   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
 840   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
 841   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
 842   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
 843   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
 844   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 845   JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
 846
 847   // 2^40 (floating-point constructor arg)
 848   val = Json::Value((Json::Int64(1) << 40) / 1.0);
 849
 850   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 851
 852   checks = IsCheck();
 853   checks.isInt64_ = true;
 854   checks.isUInt64_ = true;
 855   checks.isIntegral_ = true;
 856   checks.isDouble_ = true;
 857   checks.isNumeric_ = true;
 858   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 859
 860   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 861   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 862   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 863
 864   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
 865   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
 866   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
 867   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
 868   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
 869   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
 870   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 871   JSONTEST_ASSERT_STRING_EQUAL("1099511627776",
 872                                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)),
 944                         val.asFloat());
 945   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 946   JSONTEST_ASSERT_STRING_EQUAL("9.2233720368547758e+18",
 947                                normalizeFloatingPointStr(val.asString()));
 948
 949   // int64 min
 950   val = Json::Value(Json::Int64(kint64min));
 951
 952   JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
 953
 954   checks = IsCheck();
 955   checks.isInt64_ = true;
 956   checks.isIntegral_ = true;
 957   checks.isDouble_ = true;
 958   checks.isNumeric_ = true;
 959   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 960
 961   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 962   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 963   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 964
 965   JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
 966   JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
 967   JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
 968   JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
 969   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 970   JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
 971
 972   // int64 min (floating point constructor). Note that kint64min *is* exactly
 973   // representable as a double.
 974   val = Json::Value(double(kint64min));
 975
 976   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
 977
 978   checks = IsCheck();
 979   checks.isInt64_ = true;
 980   checks.isIntegral_ = true;
 981   checks.isDouble_ = true;
 982   checks.isNumeric_ = true;
 983   JSONTEST_ASSERT_PRED(checkIs(val, checks));
 984
 985   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
 986   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
 987   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
 988
 989   JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
 990   JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
 991   JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
 992   JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
 993   JSONTEST_ASSERT_EQUAL(true, val.asBool());
 994   JSONTEST_ASSERT_STRING_EQUAL("-9.2233720368547758e+18",
 995                                normalizeFloatingPointStr(val.asString()));
 996
 997   // 10^19
 998   const Json::UInt64 ten_to_19 = static_cast<Json::UInt64>(1e19);
 999   val = Json::Value(Json::UInt64(ten_to_19));
1000
1001   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
1002
1003   checks = IsCheck();
1004   checks.isUInt64_ = true;
1005   checks.isIntegral_ = true;
1006   checks.isDouble_ = true;
1007   checks.isNumeric_ = true;
1008   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1009
1010   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1011   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1012   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1013
1014   JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
1015   JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
1016   JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
1017   JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
1018   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1019   JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
1020
1021   // 10^19 (double constructor). Note that 10^19 is not exactly representable
1022   // as a double.
1023   val = Json::Value(uint64ToDouble(ten_to_19));
1024
1025   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1026
1027   checks = IsCheck();
1028   checks.isUInt64_ = true;
1029   checks.isIntegral_ = true;
1030   checks.isDouble_ = true;
1031   checks.isNumeric_ = true;
1032   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1033
1034   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1035   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1036   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1037
1038   JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
1039   JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
1040   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1041   JSONTEST_ASSERT_STRING_EQUAL("1e+19",
1042                                normalizeFloatingPointStr(val.asString()));
1043
1044   // uint64 max
1045   val = Json::Value(Json::UInt64(kuint64max));
1046
1047   JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
1048
1049   checks = IsCheck();
1050   checks.isUInt64_ = true;
1051   checks.isIntegral_ = true;
1052   checks.isDouble_ = true;
1053   checks.isNumeric_ = true;
1054   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1055
1056   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1057   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1058   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1059
1060   JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
1061   JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
1062   JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
1063   JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
1064   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1065   JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
1066
1067   // uint64 max (floating point constructor). Note that kuint64max is not
1068   // exactly representable as a double, and will be rounded up to be higher.
1069   val = Json::Value(uint64ToDouble(kuint64max));
1070
1071   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1072
1073   checks = IsCheck();
1074   checks.isDouble_ = true;
1075   checks.isNumeric_ = true;
1076   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1077
1078   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1079   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1080   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1081
1082   JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
1083   JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
1084   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1085   JSONTEST_ASSERT_STRING_EQUAL("1.8446744073709552e+19",
1086                                normalizeFloatingPointStr(val.asString()));
1087 #endif
1088 }
1089
1090 JSONTEST_FIXTURE(ValueTest, nonIntegers) {
1091   IsCheck checks;
1092   Json::Value val;
1093
1094   // Small positive number
1095   val = Json::Value(1.5);
1096
1097   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1098
1099   checks = IsCheck();
1100   checks.isDouble_ = true;
1101   checks.isNumeric_ = true;
1102   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1103
1104   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
1105   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
1106   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1107   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1108   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1109   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1110   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1111   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1112
1113   JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
1114   JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
1115   JSONTEST_ASSERT_EQUAL(1, val.asInt());
1116   JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
1117   JSONTEST_ASSERT_EQUAL(1, val.asUInt());
1118   JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
1119   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1120   JSONTEST_ASSERT_EQUAL("1.5", val.asString());
1121
1122   // Small negative number
1123   val = Json::Value(-1.5);
1124
1125   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1126
1127   checks = IsCheck();
1128   checks.isDouble_ = true;
1129   checks.isNumeric_ = true;
1130   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1131
1132   JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
1133   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1134   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1135   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1136   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1137   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1138   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1139   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1140
1141   JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
1142   JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
1143   JSONTEST_ASSERT_EQUAL(-1, val.asInt());
1144   JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
1145   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1146   JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
1147
1148   // A bit over int32 max
1149   val = Json::Value(kint32max + 0.5);
1150
1151   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1152
1153   checks = IsCheck();
1154   checks.isDouble_ = true;
1155   checks.isNumeric_ = true;
1156   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1157
1158   JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
1159   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1160   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1161   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1162   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1163   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1164   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1165   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1166
1167   JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
1168   JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
1169   JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
1170 #ifdef JSON_HAS_INT64
1171   JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
1172   JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
1173 #endif
1174   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1175   JSONTEST_ASSERT_EQUAL("2147483647.5",
1176                         normalizeFloatingPointStr(val.asString()));
1177
1178   // A bit under int32 min
1179   val = Json::Value(kint32min - 0.5);
1180
1181   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1182
1183   checks = IsCheck();
1184   checks.isDouble_ = true;
1185   checks.isNumeric_ = true;
1186   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1187
1188   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1189   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1190   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1191   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1192   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1193   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1194   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1195   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1196
1197   JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
1198   JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
1199 #ifdef JSON_HAS_INT64
1200   JSONTEST_ASSERT_EQUAL(-Json::Int64(1) << 31, val.asLargestInt());
1201 #endif
1202   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1203   JSONTEST_ASSERT_EQUAL("-2147483648.5",
1204                         normalizeFloatingPointStr(val.asString()));
1205
1206   // A bit over uint32 max
1207   val = Json::Value(kuint32max + 0.5);
1208
1209   JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
1210
1211   checks = IsCheck();
1212   checks.isDouble_ = true;
1213   checks.isNumeric_ = true;
1214   JSONTEST_ASSERT_PRED(checkIs(val, checks));
1215
1216   JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
1217   JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
1218   JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
1219   JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
1220   JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
1221   JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
1222   JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
1223   JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
1224
1225   JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
1226   JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
1227 #ifdef JSON_HAS_INT64
1228   JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32) - 1, val.asLargestInt());
1229   JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32) - Json::UInt64(1),
1230                         val.asLargestUInt());
1231 #endif
1232   JSONTEST_ASSERT_EQUAL(true, val.asBool());
1233   JSONTEST_ASSERT_EQUAL("4294967295.5",
1234                         normalizeFloatingPointStr(val.asString()));
1235
1236   val = Json::Value(1.2345678901234);
1237   JSONTEST_ASSERT_STRING_EQUAL("1.2345678901234001",
1238                                normalizeFloatingPointStr(val.asString()));
1239
1240   // A 16-digit floating point number.
1241   val = Json::Value(2199023255552000.0f);
1242   JSONTEST_ASSERT_EQUAL(float(2199023255552000), val.asFloat());
1243   JSONTEST_ASSERT_STRING_EQUAL("2199023255552000",
1244                                normalizeFloatingPointStr(val.asString()));
1245
1246   // A very large floating point number.
1247   val = Json::Value(3.402823466385289e38);
1248   JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
1249   JSONTEST_ASSERT_STRING_EQUAL("3.402823466385289e+38",
1250                                normalizeFloatingPointStr(val.asString()));
1251
1252   // An even larger floating point number.
1253   val = Json::Value(1.2345678e300);
1254   JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
1255   JSONTEST_ASSERT_STRING_EQUAL("1.2345678e+300",
1256                                normalizeFloatingPointStr(val.asString()));
1257 }
1258
1259 void ValueTest::checkConstMemberCount(const Json::Value& value,
1260                                       unsigned int expectedCount) {
1261   unsigned int count = 0;
1262   Json::Value::const_iterator itEnd = value.end();
1263   for (Json::Value::const_iterator it = value.begin(); it != itEnd; ++it) {
1264     ++count;
1265   }
1266   JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::const_iterator";
1267 }
1268
1269 void ValueTest::checkMemberCount(Json::Value& value,
1270                                  unsigned int expectedCount) {
1271   JSONTEST_ASSERT_EQUAL(expectedCount, value.size());
1272
1273   unsigned int count = 0;
1274   Json::Value::iterator itEnd = value.end();
1275   for (Json::Value::iterator it = value.begin(); it != itEnd; ++it) {
1276     ++count;
1277   }
1278   JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::iterator";
1279
1280   JSONTEST_ASSERT_PRED(checkConstMemberCount(value, expectedCount));
1281 }
1282
1283 ValueTest::IsCheck::IsCheck()
1284     : isObject_(false), isArray_(false), isBool_(false), isString_(false),
1285       isNull_(false), isInt_(false), isInt64_(false), isUInt_(false),
1286       isUInt64_(false), isIntegral_(false), isDouble_(false),
1287       isNumeric_(false) {}
1288
1289 void ValueTest::checkIs(const Json::Value& value, const IsCheck& check) {
1290   JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject());
1291   JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray());
1292   JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool());
1293   JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble());
1294   JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt());
1295   JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt());
1296   JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral());
1297   JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric());
1298   JSONTEST_ASSERT_EQUAL(check.isString_, value.isString());
1299   JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull());
1300
1301 #ifdef JSON_HAS_INT64
1302   JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64());
1303   JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64());
1304 #else
1305   JSONTEST_ASSERT_EQUAL(false, value.isInt64());
1306   JSONTEST_ASSERT_EQUAL(false, value.isUInt64());
1307 #endif
1308 }
1309
1310 JSONTEST_FIXTURE(ValueTest, compareNull) {
1311   JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value()));
1312 }
1313
1314 JSONTEST_FIXTURE(ValueTest, compareInt) {
1315   JSONTEST_ASSERT_PRED(checkIsLess(0, 10));
1316   JSONTEST_ASSERT_PRED(checkIsEqual(10, 10));
1317   JSONTEST_ASSERT_PRED(checkIsEqual(-10, -10));
1318   JSONTEST_ASSERT_PRED(checkIsLess(-10, 0));
1319 }
1320
1321 JSONTEST_FIXTURE(ValueTest, compareUInt) {
1322   JSONTEST_ASSERT_PRED(checkIsLess(0u, 10u));
1323   JSONTEST_ASSERT_PRED(checkIsLess(0u, Json::Value::maxUInt));
1324   JSONTEST_ASSERT_PRED(checkIsEqual(10u, 10u));
1325 }
1326
1327 JSONTEST_FIXTURE(ValueTest, compareDouble) {
1328   JSONTEST_ASSERT_PRED(checkIsLess(0.0, 10.0));
1329   JSONTEST_ASSERT_PRED(checkIsEqual(10.0, 10.0));
1330   JSONTEST_ASSERT_PRED(checkIsEqual(-10.0, -10.0));
1331   JSONTEST_ASSERT_PRED(checkIsLess(-10.0, 0.0));
1332 }
1333
1334 JSONTEST_FIXTURE(ValueTest, compareString) {
1335   JSONTEST_ASSERT_PRED(checkIsLess("", " "));
1336   JSONTEST_ASSERT_PRED(checkIsLess("", "a"));
1337   JSONTEST_ASSERT_PRED(checkIsLess("abcd", "zyui"));
1338   JSONTEST_ASSERT_PRED(checkIsLess("abc", "abcd"));
1339   JSONTEST_ASSERT_PRED(checkIsEqual("abcd", "abcd"));
1340   JSONTEST_ASSERT_PRED(checkIsEqual(" ", " "));
1341   JSONTEST_ASSERT_PRED(checkIsLess("ABCD", "abcd"));
1342   JSONTEST_ASSERT_PRED(checkIsEqual("ABCD", "ABCD"));
1343 }
1344
1345 JSONTEST_FIXTURE(ValueTest, compareBoolean) {
1346   JSONTEST_ASSERT_PRED(checkIsLess(false, true));
1347   JSONTEST_ASSERT_PRED(checkIsEqual(false, false));
1348   JSONTEST_ASSERT_PRED(checkIsEqual(true, true));
1349 }
1350
1351 JSONTEST_FIXTURE(ValueTest, compareArray) {
1352   // array compare size then content
1353   Json::Value emptyArray(Json::arrayValue);
1354   Json::Value l1aArray;
1355   l1aArray.append(0);
1356   Json::Value l1bArray;
1357   l1bArray.append(10);
1358   Json::Value l2aArray;
1359   l2aArray.append(0);
1360   l2aArray.append(0);
1361   Json::Value l2bArray;
1362   l2bArray.append(0);
1363   l2bArray.append(10);
1364   JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l1aArray));
1365   JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l2aArray));
1366   JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l2aArray));
1367   JSONTEST_ASSERT_PRED(checkIsLess(l2aArray, l2bArray));
1368   JSONTEST_ASSERT_PRED(checkIsEqual(emptyArray, Json::Value(emptyArray)));
1369   JSONTEST_ASSERT_PRED(checkIsEqual(l1aArray, Json::Value(l1aArray)));
1370   JSONTEST_ASSERT_PRED(checkIsEqual(l2bArray, Json::Value(l2bArray)));
1371 }
1372
1373 JSONTEST_FIXTURE(ValueTest, compareObject) {
1374   // object compare size then content
1375   Json::Value emptyObject(Json::objectValue);
1376   Json::Value l1aObject;
1377   l1aObject["key1"] = 0;
1378   Json::Value l1bObject;
1379   l1aObject["key1"] = 10;
1380   Json::Value l2aObject;
1381   l2aObject["key1"] = 0;
1382   l2aObject["key2"] = 0;
1383   JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l1aObject));
1384   JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l2aObject));
1385   JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l2aObject));
1386   JSONTEST_ASSERT_PRED(checkIsEqual(emptyObject, Json::Value(emptyObject)));
1387   JSONTEST_ASSERT_PRED(checkIsEqual(l1aObject, Json::Value(l1aObject)));
1388   JSONTEST_ASSERT_PRED(checkIsEqual(l2aObject, Json::Value(l2aObject)));
1389 }
1390
1391 JSONTEST_FIXTURE(ValueTest, compareType) {
1392   // object of different type are ordered according to their type
1393   JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(), Json::Value(1)));
1394   JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1), Json::Value(1u)));
1395   JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1u), Json::Value(1.0)));
1396   JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1.0), Json::Value("a")));
1397   JSONTEST_ASSERT_PRED(checkIsLess(Json::Value("a"), Json::Value(true)));
1398   JSONTEST_ASSERT_PRED(
1399       checkIsLess(Json::Value(true), Json::Value(Json::arrayValue)));
1400   JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(Json::arrayValue),
1401                                    Json::Value(Json::objectValue)));
1402 }
1403
1404 void ValueTest::checkIsLess(const Json::Value& x, const Json::Value& y) {
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 > y));
1414   JSONTEST_ASSERT(!(y < x));
1415   JSONTEST_ASSERT(x.compare(y) < 0);
1416   JSONTEST_ASSERT(y.compare(x) >= 0);
1417 }
1418
1419 void ValueTest::checkIsEqual(const Json::Value& x, const Json::Value& y) {
1420   JSONTEST_ASSERT(x == y);
1421   JSONTEST_ASSERT(y == x);
1422   JSONTEST_ASSERT(x <= y);
1423   JSONTEST_ASSERT(y <= x);
1424   JSONTEST_ASSERT(x >= y);
1425   JSONTEST_ASSERT(y >= x);
1426   JSONTEST_ASSERT(!(x < y));
1427   JSONTEST_ASSERT(!(y < x));
1428   JSONTEST_ASSERT(!(x > y));
1429   JSONTEST_ASSERT(!(y > x));
1430   JSONTEST_ASSERT(x.compare(y) == 0);
1431   JSONTEST_ASSERT(y.compare(x) == 0);
1432 }
1433
1434 JSONTEST_FIXTURE(ValueTest, typeChecksThrowExceptions) {
1435 #if JSON_USE_EXCEPTION
1436
1437   Json::Value intVal(1);
1438   Json::Value strVal("Test");
1439   Json::Value objVal(Json::objectValue);
1440   Json::Value arrVal(Json::arrayValue);
1441
1442   JSONTEST_ASSERT_THROWS(intVal["test"]);
1443   JSONTEST_ASSERT_THROWS(strVal["test"]);
1444   JSONTEST_ASSERT_THROWS(arrVal["test"]);
1445
1446   JSONTEST_ASSERT_THROWS(intVal.removeMember("test"));
1447   JSONTEST_ASSERT_THROWS(strVal.removeMember("test"));
1448   JSONTEST_ASSERT_THROWS(arrVal.removeMember("test"));
1449
1450   JSONTEST_ASSERT_THROWS(intVal.getMemberNames());
1451   JSONTEST_ASSERT_THROWS(strVal.getMemberNames());
1452   JSONTEST_ASSERT_THROWS(arrVal.getMemberNames());
1453
1454   JSONTEST_ASSERT_THROWS(intVal[0]);
1455   JSONTEST_ASSERT_THROWS(objVal[0]);
1456   JSONTEST_ASSERT_THROWS(strVal[0]);
1457
1458   JSONTEST_ASSERT_THROWS(intVal.clear());
1459
1460   JSONTEST_ASSERT_THROWS(intVal.resize(1));
1461   JSONTEST_ASSERT_THROWS(strVal.resize(1));
1462   JSONTEST_ASSERT_THROWS(objVal.resize(1));
1463
1464   JSONTEST_ASSERT_THROWS(intVal.asCString());
1465
1466   JSONTEST_ASSERT_THROWS(objVal.asString());
1467   JSONTEST_ASSERT_THROWS(arrVal.asString());
1468
1469   JSONTEST_ASSERT_THROWS(strVal.asInt());
1470   JSONTEST_ASSERT_THROWS(objVal.asInt());
1471   JSONTEST_ASSERT_THROWS(arrVal.asInt());
1472
1473   JSONTEST_ASSERT_THROWS(strVal.asUInt());
1474   JSONTEST_ASSERT_THROWS(objVal.asUInt());
1475   JSONTEST_ASSERT_THROWS(arrVal.asUInt());
1476
1477   JSONTEST_ASSERT_THROWS(strVal.asInt64());
1478   JSONTEST_ASSERT_THROWS(objVal.asInt64());
1479   JSONTEST_ASSERT_THROWS(arrVal.asInt64());
1480
1481   JSONTEST_ASSERT_THROWS(strVal.asUInt64());
1482   JSONTEST_ASSERT_THROWS(objVal.asUInt64());
1483   JSONTEST_ASSERT_THROWS(arrVal.asUInt64());
1484
1485   JSONTEST_ASSERT_THROWS(strVal.asDouble());
1486   JSONTEST_ASSERT_THROWS(objVal.asDouble());
1487   JSONTEST_ASSERT_THROWS(arrVal.asDouble());
1488
1489   JSONTEST_ASSERT_THROWS(strVal.asFloat());
1490   JSONTEST_ASSERT_THROWS(objVal.asFloat());
1491   JSONTEST_ASSERT_THROWS(arrVal.asFloat());
1492
1493   JSONTEST_ASSERT_THROWS(strVal.asBool());
1494   JSONTEST_ASSERT_THROWS(objVal.asBool());
1495   JSONTEST_ASSERT_THROWS(arrVal.asBool());
1496
1497 #endif
1498 }
1499
1500 JSONTEST_FIXTURE(ValueTest, offsetAccessors) {
1501   Json::Value x;
1502   JSONTEST_ASSERT(x.getOffsetStart() == 0);
1503   JSONTEST_ASSERT(x.getOffsetLimit() == 0);
1504   x.setOffsetStart(10);
1505   x.setOffsetLimit(20);
1506   JSONTEST_ASSERT(x.getOffsetStart() == 10);
1507   JSONTEST_ASSERT(x.getOffsetLimit() == 20);
1508   Json::Value y(x);
1509   JSONTEST_ASSERT(y.getOffsetStart() == 10);
1510   JSONTEST_ASSERT(y.getOffsetLimit() == 20);
1511   Json::Value z;
1512   z.swap(y);
1513   JSONTEST_ASSERT(z.getOffsetStart() == 10);
1514   JSONTEST_ASSERT(z.getOffsetLimit() == 20);
1515   JSONTEST_ASSERT(y.getOffsetStart() == 0);
1516   JSONTEST_ASSERT(y.getOffsetLimit() == 0);
1517 }
1518
1519 struct WriterTest : JsonTest::TestCase {};
1520
1521 JSONTEST_FIXTURE(WriterTest, dropNullPlaceholders) {
1522   Json::FastWriter writer;
1523   Json::Value nullValue;
1524   JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
1525
1526   writer.dropNullPlaceholders();
1527   JSONTEST_ASSERT(writer.write(nullValue) == "\n");
1528 }
1529
1530 struct StreamWriterTest : JsonTest::TestCase {};
1531
1532 JSONTEST_FIXTURE(StreamWriterTest, dropNullPlaceholders) {
1533   Json::StreamWriterBuilder b;
1534   Json::Value nullValue;
1535   b.settings_["dropNullPlaceholders"] = false;
1536   JSONTEST_ASSERT(Json::writeString(b, nullValue) == "null");
1537   b.settings_["dropNullPlaceholders"] = true;
1538   JSONTEST_ASSERT(Json::writeString(b, nullValue) == "");
1539 }
1540
1541 struct ReaderTest : JsonTest::TestCase {};
1542
1543 JSONTEST_FIXTURE(ReaderTest, parseWithNoErrors) {
1544   Json::Reader reader;
1545   Json::Value root;
1546   bool ok = reader.parse("{ \"property\" : \"value\" }", root);
1547   JSONTEST_ASSERT(ok);
1548   JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
1549   JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
1550 }
1551
1552 JSONTEST_FIXTURE(ReaderTest, parseWithNoErrorsTestingOffsets) {
1553   Json::Reader reader;
1554   Json::Value root;
1555   bool ok = reader.parse("{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
1556                          "{ \"nested\" : 123, \"bool\" : true}, \"null\" : "
1557                          "null, \"false\" : false }",
1558                          root);
1559   JSONTEST_ASSERT(ok);
1560   JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
1561   JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
1562   JSONTEST_ASSERT(root["property"].getOffsetStart() == 15);
1563   JSONTEST_ASSERT(root["property"].getOffsetLimit() == 34);
1564   JSONTEST_ASSERT(root["property"][0].getOffsetStart() == 16);
1565   JSONTEST_ASSERT(root["property"][0].getOffsetLimit() == 23);
1566   JSONTEST_ASSERT(root["property"][1].getOffsetStart() == 25);
1567   JSONTEST_ASSERT(root["property"][1].getOffsetLimit() == 33);
1568   JSONTEST_ASSERT(root["obj"].getOffsetStart() == 44);
1569   JSONTEST_ASSERT(root["obj"].getOffsetLimit() == 76);
1570   JSONTEST_ASSERT(root["obj"]["nested"].getOffsetStart() == 57);
1571   JSONTEST_ASSERT(root["obj"]["nested"].getOffsetLimit() == 60);
1572   JSONTEST_ASSERT(root["obj"]["bool"].getOffsetStart() == 71);
1573   JSONTEST_ASSERT(root["obj"]["bool"].getOffsetLimit() == 75);
1574   JSONTEST_ASSERT(root["null"].getOffsetStart() == 87);
1575   JSONTEST_ASSERT(root["null"].getOffsetLimit() == 91);
1576   JSONTEST_ASSERT(root["false"].getOffsetStart() == 103);
1577   JSONTEST_ASSERT(root["false"].getOffsetLimit() == 108);
1578   JSONTEST_ASSERT(root.getOffsetStart() == 0);
1579   JSONTEST_ASSERT(root.getOffsetLimit() == 110);
1580 }
1581
1582 JSONTEST_FIXTURE(ReaderTest, parseWithOneError) {
1583   Json::Reader reader;
1584   Json::Value root;
1585   bool ok = reader.parse("{ \"property\" :: \"value\" }", root);
1586   JSONTEST_ASSERT(!ok);
1587   JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1588                   "* Line 1, Column 15\n  Syntax error: value, object or array "
1589                   "expected.\n");
1590   std::vector<Json::Reader::StructuredError> errors =
1591       reader.getStructuredErrors();
1592   JSONTEST_ASSERT(errors.size() == 1);
1593   JSONTEST_ASSERT(errors.at(0).offset_start == 14);
1594   JSONTEST_ASSERT(errors.at(0).offset_limit == 15);
1595   JSONTEST_ASSERT(errors.at(0).message ==
1596                   "Syntax error: value, object or array expected.");
1597 }
1598
1599 JSONTEST_FIXTURE(ReaderTest, parseChineseWithOneError) {
1600   Json::Reader reader;
1601   Json::Value root;
1602   bool ok = reader.parse("{ \"pr佐藤erty\" :: \"value\" }", root);
1603   JSONTEST_ASSERT(!ok);
1604   JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1605                   "* Line 1, Column 19\n  Syntax error: value, object or array "
1606                   "expected.\n");
1607   std::vector<Json::Reader::StructuredError> errors =
1608       reader.getStructuredErrors();
1609   JSONTEST_ASSERT(errors.size() == 1);
1610   JSONTEST_ASSERT(errors.at(0).offset_start == 18);
1611   JSONTEST_ASSERT(errors.at(0).offset_limit == 19);
1612   JSONTEST_ASSERT(errors.at(0).message ==
1613                   "Syntax error: value, object or array expected.");
1614 }
1615
1616 JSONTEST_FIXTURE(ReaderTest, parseWithDetailError) {
1617   Json::Reader reader;
1618   Json::Value root;
1619   bool ok = reader.parse("{ \"property\" : \"v\\alue\" }", root);
1620   JSONTEST_ASSERT(!ok);
1621   JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
1622                   "* Line 1, Column 16\n  Bad escape sequence in string\nSee "
1623                   "Line 1, Column 20 for detail.\n");
1624   std::vector<Json::Reader::StructuredError> errors =
1625       reader.getStructuredErrors();
1626   JSONTEST_ASSERT(errors.size() == 1);
1627   JSONTEST_ASSERT(errors.at(0).offset_start == 15);
1628   JSONTEST_ASSERT(errors.at(0).offset_limit == 23);
1629   JSONTEST_ASSERT(errors.at(0).message == "Bad escape sequence in string");
1630 }
1631
1632 struct CharReaderTest : JsonTest::TestCase {};
1633
1634 JSONTEST_FIXTURE(CharReaderTest, parseWithNoErrors) {
1635   Json::CharReaderBuilder b;
1636   Json::CharReader* reader(b.newCharReader());
1637   std::string errs;
1638   Json::Value root;
1639   char const doc[] = "{ \"property\" : \"value\" }";
1640   bool ok = reader->parse(
1641       doc, doc + std::strlen(doc),
1642       &root, &errs);
1643   JSONTEST_ASSERT(ok);
1644   JSONTEST_ASSERT(errs.size() == 0);
1645   delete reader;
1646 }
1647
1648 JSONTEST_FIXTURE(CharReaderTest, parseWithNoErrorsTestingOffsets) {
1649   Json::CharReaderBuilder b;
1650   Json::CharReader* reader(b.newCharReader());
1651   std::string errs;
1652   Json::Value root;
1653   char const doc[] =
1654                          "{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
1655                          "{ \"nested\" : 123, \"bool\" : true}, \"null\" : "
1656                          "null, \"false\" : false }";
1657   bool ok = reader->parse(
1658       doc, doc + std::strlen(doc),
1659       &root, &errs);
1660   JSONTEST_ASSERT(ok);
1661   JSONTEST_ASSERT(errs.size() == 0);
1662   delete reader;
1663 }
1664
1665 JSONTEST_FIXTURE(CharReaderTest, parseWithOneError) {
1666   Json::CharReaderBuilder b;
1667   Json::CharReader* reader(b.newCharReader());
1668   std::string errs;
1669   Json::Value root;
1670   char const doc[] =
1671       "{ \"property\" :: \"value\" }";
1672   bool ok = reader->parse(
1673       doc, doc + std::strlen(doc),
1674       &root, &errs);
1675   JSONTEST_ASSERT(!ok);
1676   JSONTEST_ASSERT(errs ==
1677                   "* Line 1, Column 15\n  Syntax error: value, object or array "
1678                   "expected.\n");
1679   delete reader;
1680 }
1681
1682 JSONTEST_FIXTURE(CharReaderTest, parseChineseWithOneError) {
1683   Json::CharReaderBuilder b;
1684   Json::CharReader* reader(b.newCharReader());
1685   std::string errs;
1686   Json::Value root;
1687   char const doc[] =
1688       "{ \"pr佐藤erty\" :: \"value\" }";
1689   bool ok = reader->parse(
1690       doc, doc + std::strlen(doc),
1691       &root, &errs);
1692   JSONTEST_ASSERT(!ok);
1693   JSONTEST_ASSERT(errs ==
1694                   "* Line 1, Column 19\n  Syntax error: value, object or array "
1695                   "expected.\n");
1696   delete reader;
1697 }
1698
1699 JSONTEST_FIXTURE(CharReaderTest, parseWithDetailError) {
1700   Json::CharReaderBuilder b;
1701   Json::CharReader* reader(b.newCharReader());
1702   std::string errs;
1703   Json::Value root;
1704   char const doc[] =
1705       "{ \"property\" : \"v\\alue\" }";
1706   bool ok = reader->parse(
1707       doc, doc + std::strlen(doc),
1708       &root, &errs);
1709   JSONTEST_ASSERT(!ok);
1710   JSONTEST_ASSERT(errs ==
1711                   "* Line 1, Column 16\n  Bad escape sequence in string\nSee "
1712                   "Line 1, Column 20 for detail.\n");
1713   delete reader;
1714 }
1715
1716 JSONTEST_FIXTURE(CharReaderTest, parseWithStackLimit) {
1717   Json::CharReaderBuilder b;
1718   Json::Value root;
1719   char const doc[] =
1720       "{ \"property\" : \"value\" }";
1721   {
1722   b.settings_["stackLimit"] = 2;
1723   Json::CharReader* reader(b.newCharReader());
1724   std::string errs;
1725   bool ok = reader->parse(
1726       doc, doc + std::strlen(doc),
1727       &root, &errs);
1728   JSONTEST_ASSERT(ok);
1729   JSONTEST_ASSERT(errs == "");
1730   JSONTEST_ASSERT_EQUAL("value", root["property"]);
1731   delete reader;
1732   }
1733   {
1734   b.settings_["stackLimit"] = 1;
1735   Json::CharReader* reader(b.newCharReader());
1736   std::string errs;
1737   JSONTEST_ASSERT_THROWS(reader->parse(
1738       doc, doc + std::strlen(doc),
1739       &root, &errs));
1740   delete reader;
1741   }
1742 }
1743
1744 struct CharReaderFailIfExtraTest : JsonTest::TestCase {};
1745
1746 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, issue164) {
1747   // This is interpretted as a string value followed by a colon.
1748   Json::CharReaderBuilder b;
1749   Json::Value root;
1750   char const doc[] =
1751       " \"property\" : \"value\" }";
1752   {
1753   b.settings_["failIfExtra"] = false;
1754   Json::CharReader* reader(b.newCharReader());
1755   std::string errs;
1756   bool ok = reader->parse(
1757       doc, doc + std::strlen(doc),
1758       &root, &errs);
1759   JSONTEST_ASSERT(ok);
1760   JSONTEST_ASSERT(errs == "");
1761   JSONTEST_ASSERT_EQUAL("property", root);
1762   delete reader;
1763   }
1764   {
1765   b.settings_["failIfExtra"] = true;
1766   Json::CharReader* reader(b.newCharReader());
1767   std::string errs;
1768   bool ok = reader->parse(
1769       doc, doc + std::strlen(doc),
1770       &root, &errs);
1771   JSONTEST_ASSERT(!ok);
1772   JSONTEST_ASSERT_STRING_EQUAL(errs,
1773       "* Line 1, Column 13\n"
1774       "  Extra non-whitespace after JSON value.\n");
1775   JSONTEST_ASSERT_EQUAL("property", root);
1776   delete reader;
1777   }
1778   {
1779   b.settings_["failIfExtra"] = false;
1780   b.strictMode(&b.settings_);
1781   Json::CharReader* reader(b.newCharReader());
1782   std::string errs;
1783   bool ok = reader->parse(
1784       doc, doc + std::strlen(doc),
1785       &root, &errs);
1786   JSONTEST_ASSERT(!ok);
1787   JSONTEST_ASSERT_STRING_EQUAL(errs,
1788       "* Line 1, Column 13\n"
1789       "  Extra non-whitespace after JSON value.\n");
1790   JSONTEST_ASSERT_EQUAL("property", root);
1791   delete reader;
1792   }
1793 }
1794 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, issue107) {
1795   // This is interpretted as an int value followed by a colon.
1796   Json::CharReaderBuilder b;
1797   Json::Value root;
1798   char const doc[] =
1799       "1:2:3";
1800   b.settings_["failIfExtra"] = true;
1801   Json::CharReader* reader(b.newCharReader());
1802   std::string errs;
1803   bool ok = reader->parse(
1804       doc, doc + std::strlen(doc),
1805       &root, &errs);
1806   JSONTEST_ASSERT(!ok);
1807   JSONTEST_ASSERT_STRING_EQUAL(
1808       "* Line 1, Column 2\n"
1809       "  Extra non-whitespace after JSON value.\n",
1810       errs);
1811   JSONTEST_ASSERT_EQUAL(1, root.asInt());
1812   delete reader;
1813 }
1814 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterObject) {
1815   Json::CharReaderBuilder b;
1816   Json::Value root;
1817   {
1818   char const doc[] =
1819       "{ \"property\" : \"value\" } //trailing\n//comment\n";
1820   b.settings_["failIfExtra"] = true;
1821   Json::CharReader* reader(b.newCharReader());
1822   std::string errs;
1823   bool ok = reader->parse(
1824       doc, doc + std::strlen(doc),
1825       &root, &errs);
1826   JSONTEST_ASSERT(ok);
1827   JSONTEST_ASSERT_STRING_EQUAL("", errs);
1828   JSONTEST_ASSERT_EQUAL("value", root["property"]);
1829   delete reader;
1830   }
1831 }
1832 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterArray) {
1833   Json::CharReaderBuilder b;
1834   Json::Value root;
1835   char const doc[] =
1836       "[ \"property\" , \"value\" ] //trailing\n//comment\n";
1837   b.settings_["failIfExtra"] = true;
1838   Json::CharReader* reader(b.newCharReader());
1839   std::string errs;
1840   bool ok = reader->parse(
1841       doc, doc + std::strlen(doc),
1842       &root, &errs);
1843   JSONTEST_ASSERT(ok);
1844   JSONTEST_ASSERT_STRING_EQUAL("", errs);
1845   JSONTEST_ASSERT_EQUAL("value", root[1u]);
1846   delete reader;
1847 }
1848 JSONTEST_FIXTURE(CharReaderFailIfExtraTest, commentAfterBool) {
1849   Json::CharReaderBuilder b;
1850   Json::Value root;
1851   char const doc[] =
1852       " true /*trailing\ncomment*/";
1853   b.settings_["failIfExtra"] = true;
1854   Json::CharReader* reader(b.newCharReader());
1855   std::string errs;
1856   bool ok = reader->parse(
1857       doc, doc + std::strlen(doc),
1858       &root, &errs);
1859   JSONTEST_ASSERT(ok);
1860   JSONTEST_ASSERT_STRING_EQUAL("", errs);
1861   JSONTEST_ASSERT_EQUAL(true, root.asBool());
1862   delete reader;
1863 }
1864
1865 struct IteratorTest : JsonTest::TestCase {};
1866
1867 JSONTEST_FIXTURE(IteratorTest, distance) {
1868   Json::Value json;
1869   json["k1"] = "a";
1870   json["k2"] = "b";
1871   int dist;
1872   std::string str;
1873   for (Json::ValueIterator it = json.begin(); it != json.end(); ++it) {
1874     dist = it - json.begin();
1875     str = it->asString().c_str();
1876   }
1877   JSONTEST_ASSERT_EQUAL(1, dist);
1878   JSONTEST_ASSERT_STRING_EQUAL("b", str);
1879 }
1880
1881 int main(int argc, const char* argv[]) {
1882   JsonTest::Runner runner;
1883   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkNormalizeFloatingPointStr);
1884   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, memberCount);
1885   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, objects);
1886   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, arrays);
1887   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, null);
1888   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, strings);
1889   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, bools);
1890   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, integers);
1891   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, nonIntegers);
1892   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareNull);
1893   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareInt);
1894   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareUInt);
1895   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareDouble);
1896   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareString);
1897   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareBoolean);
1898   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareArray);
1899   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareObject);
1900   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareType);
1901   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, offsetAccessors);
1902   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, typeChecksThrowExceptions);
1903
1904   JSONTEST_REGISTER_FIXTURE(runner, WriterTest, dropNullPlaceholders);
1905   JSONTEST_REGISTER_FIXTURE(runner, StreamWriterTest, dropNullPlaceholders);
1906
1907   JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithNoErrors);
1908   JSONTEST_REGISTER_FIXTURE(
1909       runner, ReaderTest, parseWithNoErrorsTestingOffsets);
1910   JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithOneError);
1911   JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseChineseWithOneError);
1912   JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithDetailError);
1913
1914   JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithNoErrors);
1915   JSONTEST_REGISTER_FIXTURE(
1916       runner, CharReaderTest, parseWithNoErrorsTestingOffsets);
1917   JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithOneError);
1918   JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseChineseWithOneError);
1919   JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithDetailError);
1920   JSONTEST_REGISTER_FIXTURE(runner, CharReaderTest, parseWithStackLimit);
1921
1922   JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, issue164);
1923   JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, issue107);
1924   JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, commentAfterObject);
1925   JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, commentAfterArray);
1926   JSONTEST_REGISTER_FIXTURE(runner, CharReaderFailIfExtraTest, commentAfterBool);
1927
1928   JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, distance);
1929
1930   return runner.runCommandLine(argc, argv);
1931 }