src/test_lib_json/main.cpp

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