Json::Value null_;

Json::Value emptyArray_{Json::arrayValue};

Json::Value emptyObject_{Json::objectValue};

Json::Value integer_{123456789};

Json::Value unsignedInteger_{34567890};

Json::Value smallUnsignedInteger_{Json::Value::UInt(Json::Value::maxInt)};

Json::Value real_{1234.56789};

Json::Value float_{0.00390625f};

Json::Value array1_;

Json::Value object1_;

Json::Value object2_;

Json::Value object3_;

Json::Value emptyString_{""};

Json::Value string1_{"a"};

Json::Value string_{"sometext with space"};

Json::Value true_{true};

Json::Value false_{false};

ValueTest() {

array1_.append(1234);

object1_["id"] = 1234;

// object2 with matching values

object2_["null"] = Json::nullValue;

object2_["bool"] = true;

object2_["int"] = Json::Int{Json::Value::maxInt};

object2_["int64"] = Json::Int64{Json::Value::maxInt64};

object2_["uint"] = Json::UInt{Json::Value::maxUInt};

object2_["uint64"] = Json::UInt64{Json::Value::maxUInt64};

object2_["integral"] = 1234;

object2_["double"] = 1234.56789;

object2_["numeric"] = 0.12345f;

object2_["string"] = "string";

object2_["array"] = Json::arrayValue;

object2_["object"] = Json::objectValue;

// object3 with not matching values

object3_["object"] = Json::nullValue;

object3_["null"] = true;

object3_["bool"] = Json::Int{Json::Value::maxInt};

object3_["int"] = "not_an_int";

object3_["int64"] = "not_an_int64";

object3_["uint"] = "not_an_uint";

object3_["uin64"] = "not_an_uint64";

object3_["integral"] = 1234.56789;

object3_["double"] = false;

object3_["numeric"] = "string";

object3_["string"] = Json::arrayValue;

object3_["array"] = Json::objectValue;

}

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);

void runCZStringTests();

auto index = s.find_last_of("eE");

if (index == s.npos)

return s;

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

auto exponentStartIndex = index + 1 + signWidth;

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

auto indexDigit = s.find_first_not_of('0', exponentStartIndex);

Json::String exponent = "0";

if (indexDigit != s.npos) { // nonzero exponent

exponent = s.substr(indexDigit);

}

return normalized + exponent;

// 1. Copy Constructor (Index)

Json::Value::CZString idx1(123);

Json::Value::CZString idx2(idx1);

JSONTEST_ASSERT_EQUAL(idx2.index(), 123);

// 2. Move Constructor (Index)

Json::Value::CZString idx3(std::move(idx1));

JSONTEST_ASSERT_EQUAL(idx3.index(), 123);

// 3. Move Assignment (Index)

Json::Value::CZString idx4(456);

idx4 = std::move(idx3);

JSONTEST_ASSERT_EQUAL(idx4.index(), 123);

// 4. Copy Constructor (String)

Json::Value::CZString str1("param", 5,

Json::Value::CZString::duplicateOnCopy);

Json::Value::CZString str2((str1)); // copy makes it duplicate (owning)

JSONTEST_ASSERT_STRING_EQUAL(str2.data(), "param");

// 5. Move Constructor (String)

// Move from Owning string (str2)

Json::Value::CZString str3(std::move(str2));

JSONTEST_ASSERT_STRING_EQUAL(str3.data(), "param");

// 6. Move Assignment (String)

Json::Value::CZString str4("other", 5,

Json::Value::CZString::duplicateOnCopy);

Json::Value::CZString str5((str4)); // owning "other"

// Move-assign owning "param" (str3) into owning "other" (str5)

// This verifies we don't leak "other" (if fixed) and correctly take "param"

str5 = std::move(str3);

JSONTEST_ASSERT_STRING_EQUAL(str5.data(), "param");

struct TestData {

std::string in;

std::string out;

} const testData[] = {

{"0.0", "0.0"},

{"0e0", "0e0"},

{"1234.0", "1234.0"},

{"1234.0e0", "1234.0e0"},

{"1234.0e-1", "1234.0e-1"},

{"1234.0e+0", "1234.0e+0"},

{"1234.0e+001", "1234.0e+1"},

{"1234e-1", "1234e-1"},

{"1234e+000", "1234e+0"},

{"1234e+001", "1234e+1"},

{"1234e10", "1234e10"},

{"1234e010", "1234e10"},

{"1234e+010", "1234e+10"},

{"1234e-010", "1234e-10"},

{"1234e+100", "1234e+100"},

{"1234e-100", "1234e-100"},

};

for (const auto& td : testData) {

JSONTEST_ASSERT_STRING_EQUAL(normalizeFloatingPointStr(td.in), td.out);

}

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));

// 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 std::string stringIdKey = "id";

const Json::Value* stringFoundId = object1_.find(stringIdKey);

JSONTEST_ASSERT(stringFoundId != nullptr);

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

const char unknownIdKey[] = "unknown id";

const Json::Value* foundUnknownId =

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

JSONTEST_ASSERT_EQUAL(nullptr, foundUnknownId);

const std::string stringUnknownIdKey = "unknown id";

const Json::Value* stringFoundUnknownId = object1_.find(stringUnknownIdKey);

JSONTEST_ASSERT_EQUAL(nullptr, stringFoundUnknownId);

// Access through find<Type>()

const Json::Value* nullFound = object2_.findNull("null");

JSONTEST_ASSERT(nullFound != nullptr);

JSONTEST_ASSERT_EQUAL(Json::nullValue, *nullFound);

JSONTEST_ASSERT(object3_.findNull("null") == nullptr);

const Json::Value* boolFound = object2_.findBool("bool");

JSONTEST_ASSERT(boolFound != nullptr);

JSONTEST_ASSERT_EQUAL(true, *boolFound);

JSONTEST_ASSERT(object3_.findBool("bool") == nullptr);

const Json::Value* intFound = object2_.findInt("int");

JSONTEST_ASSERT(intFound != nullptr);

JSONTEST_ASSERT_EQUAL(Json::Int{Json::Value::maxInt}, *intFound);

JSONTEST_ASSERT(object3_.findInt("int") == nullptr);

const Json::Value* int64Found = object2_.findInt64("int64");

JSONTEST_ASSERT(int64Found != nullptr);

JSONTEST_ASSERT_EQUAL(Json::Int64{Json::Value::maxInt64}, *int64Found);

JSONTEST_ASSERT(object3_.findInt64("int64") == nullptr);

const Json::Value* uintFound = object2_.findUInt("uint");

JSONTEST_ASSERT(uintFound != nullptr);

JSONTEST_ASSERT_EQUAL(Json::UInt{Json::Value::maxUInt}, *uintFound);

JSONTEST_ASSERT(object3_.findUInt("uint") == nullptr);

const Json::Value* uint64Found = object2_.findUInt64("uint64");

JSONTEST_ASSERT(uint64Found != nullptr);

JSONTEST_ASSERT_EQUAL(Json::UInt64{Json::Value::maxUInt64}, *uint64Found);

JSONTEST_ASSERT(object3_.findUInt64("uint64") == nullptr);

const Json::Value* integralFound = object2_.findIntegral("integral");

JSONTEST_ASSERT(integralFound != nullptr);

JSONTEST_ASSERT_EQUAL(1234, *integralFound);

JSONTEST_ASSERT(object3_.findIntegral("integral") == nullptr);

const Json::Value* doubleFound = object2_.findDouble("double");

JSONTEST_ASSERT(doubleFound != nullptr);

JSONTEST_ASSERT_EQUAL(1234.56789, *doubleFound);

JSONTEST_ASSERT(object3_.findDouble("double") == nullptr);

const Json::Value* numericFound = object2_.findNumeric("numeric");

JSONTEST_ASSERT(numericFound != nullptr);

JSONTEST_ASSERT_EQUAL(0.12345f, numericFound->asFloat());

JSONTEST_ASSERT(object3_.findNumeric("numeric") == nullptr);

const Json::Value* stringFound = object2_.findString("string");

JSONTEST_ASSERT(stringFound != nullptr);

JSONTEST_ASSERT_EQUAL(std::string{"string"}, *stringFound);

JSONTEST_ASSERT(object3_.findString("string") == nullptr);

const Json::Value* arrayFound = object2_.findArray("array");

JSONTEST_ASSERT(arrayFound != nullptr);

JSONTEST_ASSERT_EQUAL(Json::arrayValue, *arrayFound);

JSONTEST_ASSERT(object3_.findArray("array") == nullptr);

// 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);

// Using other removeMember interfaces, the test idea is the same as above.

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

const Json::String key("some other id");

did = object1_.removeMember(key, &got);

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

JSONTEST_ASSERT_EQUAL(true, did);

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

did = object1_.removeMember(key, &got);

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

JSONTEST_ASSERT_EQUAL(false, did);

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

object1_.removeMember(key);

JSONTEST_ASSERT_EQUAL(Json::nullValue, object1_[key]);

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]);

JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray.front());

JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray.back());

// Access through non-const reference

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

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

JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_.front());

JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_.back());

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

Json::Value array;

{

for (Json::ArrayIndex i = 0; i < 10; i++)

array[i] = i;

JSONTEST_ASSERT_EQUAL(array.size(), 10);

// The length set is greater than the length of the array.

array.resize(15);

JSONTEST_ASSERT_EQUAL(array.size(), 15);

// The length set is less than the length of the array.

array.resize(5);

JSONTEST_ASSERT_EQUAL(array.size(), 5);

// The length of the array is set to 0.

array.resize(0);

JSONTEST_ASSERT_EQUAL(array.size(), 0);

}

{

for (Json::ArrayIndex i = 0; i < 10; i++)

array[i] = i;

JSONTEST_ASSERT_EQUAL(array.size(), 10);

array.clear();

JSONTEST_ASSERT_EQUAL(array.size(), 0);

}

Json::Value array;

array.append("item1");

array.append("item2");

// Test Copy Constructor (covers CZString(const CZString&) with index)

Json::Value copy(array);

JSONTEST_ASSERT_EQUAL(copy.size(), 2);

JSONTEST_ASSERT_EQUAL(Json::Value("item1"), copy[0]);

JSONTEST_ASSERT_EQUAL(Json::Value("item2"), copy[1]);

// Test Move Constructor (covers CZString(CZString&&) with index)

Json::Value moved(std::move(copy));

JSONTEST_ASSERT_EQUAL(moved.size(), 2);

JSONTEST_ASSERT_EQUAL(Json::Value("item1"), moved[0]);

JSONTEST_ASSERT_EQUAL(Json::Value("item2"), moved[1]);

Json::ArrayIndex n = 10;

Json::Value v;

v.resize(n);

JSONTEST_ASSERT_EQUAL(n, v.size());

JSONTEST_ASSERT_EQUAL(n, std::distance(v.begin(), v.end()));

JSONTEST_ASSERT_EQUAL(v.front(), Json::Value{});

JSONTEST_ASSERT_EQUAL(v.back(), Json::Value{});

for (const Json::Value& e : v)

JSONTEST_ASSERT_EQUAL(e, Json::Value{});

// Regression test for #1611: assigning past the end of an array via

// operator[] must fill the intervening indices with null, so that size(),

// iteration, and serialization all agree (JSON arrays are dense). Before the

// fix, `arr[5] = x` stored a single element while size() reported 6 and

// serialization emitted six, and range-for visited only the one element.

Json::Value arr(Json::arrayValue);

arr[5] = "Hello, World!";

JSONTEST_ASSERT_EQUAL(6u, arr.size());

JSONTEST_ASSERT_EQUAL(6, std::distance(arr.begin(), arr.end()));

for (Json::ArrayIndex i = 0; i < 5; ++i)

JSONTEST_ASSERT_EQUAL(Json::Value{}, arr[i]);

JSONTEST_ASSERT_EQUAL("Hello, World!", arr[5].asString());

// Iteration count matches size() and the dense serialization.

Json::ArrayIndex iterated = 0;

for (const Json::Value& e : arr) {

(void)e;

++iterated;

}

JSONTEST_ASSERT_EQUAL(6u, iterated);

Json::StreamWriterBuilder b;

b.settings_["indentation"] = "";

JSONTEST_ASSERT_EQUAL("[null,null,null,null,null,\"Hello, World!\"]",

Json::writeString(b, arr));

Json::Value array;

for (Json::ArrayIndex i = 0; i < 5; i++)

array[i] = i;

JSONTEST_ASSERT_EQUAL(array.size(), 5);

const Json::Value defaultValue(10);

Json::ArrayIndex index = 0;

for (; index <= 4; index++)

JSONTEST_ASSERT_EQUAL(index, array.get(index, defaultValue).asInt());

index = 4;

JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), true);

index = 5;

JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), false);

JSONTEST_ASSERT_EQUAL(defaultValue, array.get(index, defaultValue));

JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), false);

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());

Json::Value array;

const Json::Value str0("index2");

const Json::Value str1("index3");

array.append("index0"); // append rvalue

array.append("index1");

array.append(str0); // append lvalue

std::vector<Json::Value*> vec; // storage value address for checking

for (Json::ArrayIndex i = 0; i < 3; i++) {

vec.push_back(&array[i]);

}

JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[0]); // check append

JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[1]);

JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[2]);

JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array.front());

JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array.back());

// insert lvalue at the head

JSONTEST_ASSERT(array.insert(0, str1));

JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);

JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);

JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[2]);

JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[3]);

JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array.front());

JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array.back());

// checking address

for (Json::ArrayIndex i = 0; i < 3; i++) {

JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);

}

vec.push_back(&array[3]);

// insert rvalue at middle

JSONTEST_ASSERT(array.insert(2, "index4"));

JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);

JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);

JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);

JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);

JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);

JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array.front());

JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array.back());

// checking address

for (Json::ArrayIndex i = 0; i < 4; i++) {

JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);

}

vec.push_back(&array[4]);

// insert rvalue at the tail

JSONTEST_ASSERT(array.insert(5, "index5"));

JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);

JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);

JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);

JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);

JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);

JSONTEST_ASSERT_EQUAL(Json::Value("index5"), array[5]);

JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array.front());

JSONTEST_ASSERT_EQUAL(Json::Value("index5"), array.back());

// checking address

for (Json::ArrayIndex i = 0; i < 5; i++) {

JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);

}

vec.push_back(&array[5]);

// beyond max array size, it should not be allowed to insert into its tail

JSONTEST_ASSERT(!array.insert(10, "index10"));

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_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_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());

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());