// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors

// Distributed under MIT license, or public domain if desired and

// recognized in your jurisdiction.

// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE

#if defined(__GNUC__)

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#elif defined(_MSC_VER)

#pragma warning(disable : 4996)

#endif

#include "fuzz.h"

#include "jsontest.h"

#include <cmath>

#include <cstring>

#include <iomanip>

#include <iostream>

#include <json/config.h>

#include <json/json.h>

#include <limits>

#include <sstream>

#include <string>

// Make numeric limits more convenient to talk about.

// Assumes int type in 32 bits.

#define kint32max Json::Value::maxInt

#define kint32min Json::Value::minInt

#define kuint32max Json::Value::maxUInt

#define kint64max Json::Value::maxInt64

#define kint64min Json::Value::minInt64

#define kuint64max Json::Value::maxUInt64

// static const double kdint64max = double(kint64max);

// static const float kfint64max = float(kint64max);

static const float kfint32max = float(kint32max);

static const float kfuint32max = float(kuint32max);

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// Json Library test cases

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

static inline double uint64ToDouble(Json::UInt64 value) {

return static_cast<double>(value);

}

#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

static inline double uint64ToDouble(Json::UInt64 value) {

return static_cast<double>(Json::Int64(value / 2)) * 2.0 +

static_cast<double>(Json::Int64(value & 1));

}

#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

struct ValueTest : JsonTest::TestCase {

Json::Value null_;

Json::Value emptyArray_;

Json::Value emptyObject_;

Json::Value integer_;

Json::Value unsignedInteger_;

Json::Value smallUnsignedInteger_;

Json::Value real_;

Json::Value float_;

Json::Value array1_;

Json::Value object1_;

Json::Value emptyString_;

Json::Value string1_;

Json::Value string_;

Json::Value true_;

Json::Value false_;

ValueTest()

: emptyArray_(Json::arrayValue), emptyObject_(Json::objectValue),

integer_(123456789), unsignedInteger_(34567890u),

smallUnsignedInteger_(Json::Value::UInt(Json::Value::maxInt)),

real_(1234.56789), float_(0.00390625f), emptyString_(""), string1_("a"),

string_("sometext with space"), true_(true), false_(false) {

array1_.append(1234);

object1_["id"] = 1234;

}

struct IsCheck {

/// Initialize all checks to \c false by default.

IsCheck();

bool isObject_{false};

bool isArray_{false};

bool isBool_{false};

bool isString_{false};

bool isNull_{false};

bool isInt_{false};

bool isInt64_{false};

bool isUInt_{false};

bool isUInt64_{false};

bool isIntegral_{false};

bool isDouble_{false};

bool isNumeric_{false};

};

void checkConstMemberCount(const Json::Value& value,

unsigned int expectedCount);

void checkMemberCount(Json::Value& value, unsigned int expectedCount);

void checkIs(const Json::Value& value, const IsCheck& check);

void checkIsLess(const Json::Value& x, const Json::Value& y);

void checkIsEqual(const Json::Value& x, const Json::Value& y);

/// Normalize the representation of floating-point number by stripped leading

/// 0 in exponent.

static Json::String normalizeFloatingPointStr(const Json::String& s);

};

Json::String ValueTest::normalizeFloatingPointStr(const Json::String& s) {

Json::String::size_type index = s.find_last_of("eE");

if (index != Json::String::npos) {

Json::String::size_type hasSign =

(s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;

Json::String::size_type exponentStartIndex = index + 1 + hasSign;

Json::String normalized = s.substr(0, exponentStartIndex);

Json::String::size_type indexDigit =

s.find_first_not_of('0', exponentStartIndex);

Json::String exponent = "0";

if (indexDigit != Json::String::npos) // There is an exponent different

// from 0

{

exponent = s.substr(indexDigit);

}

return normalized + exponent;

}

return s;

}

JSONTEST_FIXTURE(ValueTest, checkNormalizeFloatingPointStr) {

JSONTEST_ASSERT_STRING_EQUAL("0.0", normalizeFloatingPointStr("0.0"));

JSONTEST_ASSERT_STRING_EQUAL("0e0", normalizeFloatingPointStr("0e0"));

JSONTEST_ASSERT_STRING_EQUAL("1234.0", normalizeFloatingPointStr("1234.0"));

JSONTEST_ASSERT_STRING_EQUAL("1234.0e0",

normalizeFloatingPointStr("1234.0e0"));

JSONTEST_ASSERT_STRING_EQUAL("1234.0e-1",

normalizeFloatingPointStr("1234.0e-1"));

JSONTEST_ASSERT_STRING_EQUAL("1234.0e+0",

normalizeFloatingPointStr("1234.0e+0"));

JSONTEST_ASSERT_STRING_EQUAL("1234.0e+1",

normalizeFloatingPointStr("1234.0e+001"));

JSONTEST_ASSERT_STRING_EQUAL("1234e-1", normalizeFloatingPointStr("1234e-1"));

JSONTEST_ASSERT_STRING_EQUAL("1234e+0",

normalizeFloatingPointStr("1234e+000"));

JSONTEST_ASSERT_STRING_EQUAL("1234e+1",

normalizeFloatingPointStr("1234e+001"));

JSONTEST_ASSERT_STRING_EQUAL("1234e10", normalizeFloatingPointStr("1234e10"));

JSONTEST_ASSERT_STRING_EQUAL("1234e10",

normalizeFloatingPointStr("1234e010"));

JSONTEST_ASSERT_STRING_EQUAL("1234e+10",

normalizeFloatingPointStr("1234e+010"));

JSONTEST_ASSERT_STRING_EQUAL("1234e-10",

normalizeFloatingPointStr("1234e-010"));

JSONTEST_ASSERT_STRING_EQUAL("1234e+100",

normalizeFloatingPointStr("1234e+100"));

JSONTEST_ASSERT_STRING_EQUAL("1234e-100",

normalizeFloatingPointStr("1234e-100"));

}

JSONTEST_FIXTURE(ValueTest, memberCount) {

JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));

JSONTEST_ASSERT_PRED(checkMemberCount(object1_, 1));

JSONTEST_ASSERT_PRED(checkMemberCount(null_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(integer_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(unsignedInteger_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(smallUnsignedInteger_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(real_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(false_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(string1_, 0));

JSONTEST_ASSERT_PRED(checkMemberCount(float_, 0));

}

JSONTEST_FIXTURE(ValueTest, objects) {

// Types

IsCheck checks;

checks.isObject_ = true;

JSONTEST_ASSERT_PRED(checkIs(emptyObject_, checks));

JSONTEST_ASSERT_PRED(checkIs(object1_, checks));

JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());

// Empty object okay

JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));

// Non-empty object not okay

JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));

// Always okay

JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));

// Never okay

JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));

JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));

JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));

JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));

// Access through const reference

const Json::Value& constObject = object1_;

JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);

JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);

// Access through find()

const char idKey[] = "id";

const Json::Value* foundId = object1_.find(idKey, idKey + strlen(idKey));

JSONTEST_ASSERT(foundId != nullptr);

JSONTEST_ASSERT_EQUAL(Json::Value(1234), *foundId);

const char unknownIdKey[] = "unknown id";

const Json::Value* foundUnknownId =

object1_.find(unknownIdKey, unknownIdKey + strlen(unknownIdKey));

JSONTEST_ASSERT_EQUAL(nullptr, foundUnknownId);

// Access through demand()

const char yetAnotherIdKey[] = "yet another id";

const Json::Value* foundYetAnotherId =

object1_.find(yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));

JSONTEST_ASSERT_EQUAL(nullptr, foundYetAnotherId);

Json::Value* demandedYetAnotherId = object1_.demand(

yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));

JSONTEST_ASSERT(demandedYetAnotherId != nullptr);

*demandedYetAnotherId = "baz";

JSONTEST_ASSERT_EQUAL(Json::Value("baz"), object1_["yet another id"]);

// Access through non-const reference

JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);

JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);

object1_["some other id"] = "foo";

JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);

JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);

// Remove.

Json::Value got;

bool did;

did = object1_.removeMember("some other id", &got);

JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);

JSONTEST_ASSERT_EQUAL(true, did);

got = Json::Value("bar");

did = object1_.removeMember("some other id", &got);

JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);

JSONTEST_ASSERT_EQUAL(false, did);

object1_["some other id"] = "foo";

Json::Value* gotPtr = nullptr;

did = object1_.removeMember("some other id", gotPtr);

JSONTEST_ASSERT_EQUAL(nullptr, gotPtr);

JSONTEST_ASSERT_EQUAL(true, did);

}

JSONTEST_FIXTURE(ValueTest, arrays) {

const unsigned int index0 = 0;

// Types

IsCheck checks;

checks.isArray_ = true;

JSONTEST_ASSERT_PRED(checkIs(emptyArray_, checks));

JSONTEST_ASSERT_PRED(checkIs(array1_, checks));

JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());

// Empty array okay

JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));

// Non-empty array not okay

JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));

// Always okay

JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));

// Never okay

JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));

JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));

JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));

JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));

// Access through const reference

const Json::Value& constArray = array1_;

JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);

JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);

// Access through non-const reference

JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);

JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);

array1_[2] = Json::Value(17);

JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);

JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);

Json::Value got;

JSONTEST_ASSERT_EQUAL(true, array1_.removeIndex(2, &got));

JSONTEST_ASSERT_EQUAL(Json::Value(17), got);

JSONTEST_ASSERT_EQUAL(false, array1_.removeIndex(2, &got)); // gone now

}

JSONTEST_FIXTURE(ValueTest, arrayIssue252) {

int count = 5;

Json::Value root;

Json::Value item;

root["array"] = Json::Value::nullSingleton();

for (int i = 0; i < count; i++) {

item["a"] = i;

item["b"] = i;

root["array"][i] = item;

}

// JSONTEST_ASSERT_EQUAL(5, root["array"].size());

}

JSONTEST_FIXTURE(ValueTest, null) {

JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());

IsCheck checks;

checks.isNull_ = true;

JSONTEST_ASSERT_PRED(checkIs(null_, checks));

JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));

JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));

JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));

JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));

JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));

JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());

JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());

JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());

JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());

JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());

JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());

JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());

JSONTEST_ASSERT_EQUAL(Json::Value::nullSingleton(), null_);

// Test using a Value in a boolean context (false iff null)

JSONTEST_ASSERT_EQUAL(null_, false);

JSONTEST_ASSERT_EQUAL(object1_, true);

JSONTEST_ASSERT_EQUAL(!null_, true);

JSONTEST_ASSERT_EQUAL(!object1_, false);

}

JSONTEST_FIXTURE(ValueTest, strings) {

JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());

IsCheck checks;

checks.isString_ = true;

JSONTEST_ASSERT_PRED(checkIs(emptyString_, checks));

JSONTEST_ASSERT_PRED(checkIs(string_, checks));

JSONTEST_ASSERT_PRED(checkIs(string1_, checks));

// Empty string okay

JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));

// Non-empty string not okay

JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));

// Always okay

JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));

// Never okay

JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));

JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));

JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));

JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());

JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());

}

JSONTEST_FIXTURE(ValueTest, bools) {

JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());

IsCheck checks;

checks.isBool_ = true;

JSONTEST_ASSERT_PRED(checkIs(false_, checks));

JSONTEST_ASSERT_PRED(checkIs(true_, checks));

// False okay

JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));

// True not okay

JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));

// Always okay

JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));

JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));

JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));

// Never okay

JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));

JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));

JSONTEST_ASSERT_EQUAL(true, true_.asBool());

JSONTEST_ASSERT_EQUAL(1, true_.asInt());

JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());

JSONTEST_ASSERT_EQUAL(1, true_.asUInt());

JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());

JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());

JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());

JSONTEST_ASSERT_EQUAL(false, false_.asBool());

JSONTEST_ASSERT_EQUAL(0, false_.asInt());

JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());

JSONTEST_ASSERT_EQUAL(0, false_.asUInt());

JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());

JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());

JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());

}

JSONTEST_FIXTURE(ValueTest, integers) {

IsCheck checks;

Json::Value val;

// Conversions that don't depend on the value.

JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));

JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));

JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));

JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));

JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));

JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));

JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));

JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));

JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));

JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));

JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));

JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));

JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));

JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));

JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));

// Default int

val = Json::Value(Json::intValue);

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(0, val.asInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(0, val.asUInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());

JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());

JSONTEST_ASSERT_EQUAL(false, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());

// Default uint

val = Json::Value(Json::uintValue);

JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(0, val.asInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(0, val.asUInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());

JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());

JSONTEST_ASSERT_EQUAL(false, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());

// Default real

val = Json::Value(Json::realValue);

JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());

JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT_EQUAL(0, val.asInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(0, val.asUInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());

JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());

JSONTEST_ASSERT_EQUAL(false, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());

// Zero (signed constructor arg)

val = Json::Value(0);

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(0, val.asInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(0, val.asUInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());

JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());

JSONTEST_ASSERT_EQUAL(false, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());

// Zero (unsigned constructor arg)

val = Json::Value(0u);

JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(0, val.asInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(0, val.asUInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());

JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());

JSONTEST_ASSERT_EQUAL(false, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());

// Zero (floating-point constructor arg)

val = Json::Value(0.0);

JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(0, val.asInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(0, val.asUInt());

JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());

JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());

JSONTEST_ASSERT_EQUAL(false, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());

// 2^20 (signed constructor arg)

val = Json::Value(1 << 20);

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());

// 2^20 (unsigned constructor arg)

val = Json::Value(Json::UInt(1 << 20));

JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());

// 2^20 (floating-point constructor arg)

val = Json::Value((1 << 20) / 1.0);

JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());

JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL(

"1048576.0",

normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));

// -2^20

val = Json::Value(-(1 << 20));

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());

JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());

JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());

JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());

// int32 max

val = Json::Value(kint32max);

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());

JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());

JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());

JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());

// int32 min

val = Json::Value(kint32min);

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt_ = true;

checks.isInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());

JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());

JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());

// uint32 max

val = Json::Value(kuint32max);

JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());

checks = IsCheck();

checks.isInt64_ = true;

checks.isUInt_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));

#ifndef JSON_NO_INT64

JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());

#endif

JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());

JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());

JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());

#ifdef JSON_NO_INT64

// int64 max

val = Json::Value(double(kint64max));

JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());

checks = IsCheck();

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());

JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());

// int64 min

val = Json::Value(double(kint64min));

JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());

checks = IsCheck();

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());

JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());

// uint64 max

val = Json::Value(double(kuint64max));

JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());

checks = IsCheck();

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());

JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());

#else // ifdef JSON_NO_INT64

// 2^40 (signed constructor arg)

val = Json::Value(Json::Int64(1) << 40);

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt64_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());

// 2^40 (unsigned constructor arg)

val = Json::Value(Json::UInt64(1) << 40);

JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());

checks = IsCheck();

checks.isInt64_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());

// 2^40 (floating-point constructor arg)

val = Json::Value((Json::Int64(1) << 40) / 1.0);

JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());

checks = IsCheck();

checks.isInt64_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());

JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL(

"1099511627776.0",

normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));

// -2^40

val = Json::Value(-(Json::Int64(1) << 40));

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());

JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());

JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());

JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());

// int64 max

val = Json::Value(Json::Int64(kint64max));

JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());

checks = IsCheck();

checks.isInt64_ = true;

checks.isUInt64_ = true;

checks.isIntegral_ = true;

checks.isDouble_ = true;

checks.isNumeric_ = true;

JSONTEST_ASSERT_PRED(checkIs(val, checks));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));

JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));

JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());

JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());

JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());

JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());

JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());

JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());

JSONTEST_ASSERT_EQUAL(true, val.asBool());

JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());

// int64 max (floating point constructor). Note that kint64max is not exactly

// representable as a double, and will be rounded up to be higher.

val = Json::Value(double(kint64max));

JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());