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