External/json
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

🚨 fix Clang-Tidy warnings

Browse Source
This commit is contained in:
Niels Lohmann 2022-09-10 23:10:56 +02:00
parent f844148560
commit 9a99e19bc7
No known key found for this signature in database
GPG Key ID: 7F3CEA63AE251B69
9 changed files with 139 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/nlohmann/json.hpp
View File

@ -4718,7 +4718,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
}
// make sure the top element of the pointer exists
json_pointer top_pointer = ptr.top();
json_pointer const top_pointer = ptr.top();
if (top_pointer != ptr)
{
result.at(top_pointer);
@ -4880,7 +4880,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
json_pointer from_ptr(from_path);
// the "from" location must exist - use at()
basic_json v = result.at(from_ptr);
basic_json const v = result.at(from_ptr);
// The move operation is functionally identical to a
// "remove" operation on the "from" location, followed
@ -4897,7 +4897,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
const json_pointer from_ptr(from_path);
// the "from" location must exist - use at()
basic_json v = result.at(from_ptr);
basic_json const v = result.at(from_ptr);
// The copy is functionally identical to an "add"
// operation at the target location using the value

6
tests/src/unit-bjdata.cpp
View File

@ -3109,9 +3109,9 @@ TEST_CASE("Universal Binary JSON Specification Examples 1")
'S', 'i', 3, 'b', 'a', 'z', ']'
};
std::vector<uint8_t> const v2 = {'[', 'S', 'i', 3, 'f', 'o', 'o', 'N',
'S', 'i', 3, 'b', 'a', 'r', 'N', 'N', 'N',
'S', 'i', 3, 'b', 'a', 'z', 'N', 'N', ']'
};
'S', 'i', 3, 'b', 'a', 'r', 'N', 'N', 'N',
'S', 'i', 3, 'b', 'a', 'z', 'N', 'N', ']'
};
CHECK(json::to_bjdata(j) == v);
CHECK(json::from_bjdata(v) == j);
CHECK(json::from_bjdata(v2) == j);

60
tests/src/unit-bson.cpp
View File

@ -22,7 +22,7 @@ TEST_CASE("BSON")
{
SECTION("null")
{
json j = nullptr;
json const j = nullptr;
CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is null", json::type_error&);
}
@ -30,45 +30,45 @@ TEST_CASE("BSON")
{
SECTION("true")
{
json j = true;
json const j = true;
CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is boolean", json::type_error&);
}
SECTION("false")
{
json j = false;
json const j = false;
CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is boolean", json::type_error&);
}
}
SECTION("number")
{
json j = 42;
json const j = 42;
CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is number", json::type_error&);
}
SECTION("float")
{
json j = 4.2;
json const j = 4.2;
CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is number", json::type_error&);
}
SECTION("string")
{
json j = "not supported";
json const j = "not supported";
CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is string", json::type_error&);
}
SECTION("array")
{
json j = std::vector<int> {1, 2, 3, 4, 5, 6, 7};
json const j = std::vector<int> {1, 2, 3, 4, 5, 6, 7};
CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is array", json::type_error&);
}
}
SECTION("keys containing code-point U+0000 cannot be serialized to BSON")
{
json j =
json const j =
{
{ std::string("en\0try", 6), true }
};
@ -82,7 +82,7 @@ TEST_CASE("BSON")
SECTION("string length must be at least 1")
{
// from https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=11175
std::vector<std::uint8_t> v =
std::vector<std::uint8_t> const v =
{
0x20, 0x20, 0x20, 0x20,
0x02,
@ -597,7 +597,7 @@ TEST_CASE("BSON input/output_adapters")
{"object", {{ "string", "value" }}}
};
std::vector<std::uint8_t> bson_representation =
std::vector<std::uint8_t> const bson_representation =
{
/*size */ 0x4f, 0x00, 0x00, 0x00,
/*entry*/ 0x01, 'd', 'o', 'u', 'b', 'l', 'e', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x45, 0x40,
@ -726,7 +726,7 @@ TEST_CASE("Incomplete BSON Input")
{
SECTION("Incomplete BSON Input 1")
{
std::vector<std::uint8_t> incomplete_bson =
std::vector<std::uint8_t> const incomplete_bson =
{
0x0D, 0x00, 0x00, 0x00, // size (little endian)
0x08, // entry: boolean
@ -744,7 +744,7 @@ TEST_CASE("Incomplete BSON Input")
SECTION("Incomplete BSON Input 2")
{
std::vector<std::uint8_t> incomplete_bson =
std::vector<std::uint8_t> const incomplete_bson =
{
0x0D, 0x00, 0x00, 0x00, // size (little endian)
0x08, // entry: boolean, unexpected EOF
@ -760,7 +760,7 @@ TEST_CASE("Incomplete BSON Input")
SECTION("Incomplete BSON Input 3")
{
std::vector<std::uint8_t> incomplete_bson =
std::vector<std::uint8_t> const incomplete_bson =
{
0x41, 0x00, 0x00, 0x00, // size (little endian)
0x04, /// entry: embedded document
@ -782,7 +782,7 @@ TEST_CASE("Incomplete BSON Input")
SECTION("Incomplete BSON Input 4")
{
std::vector<std::uint8_t> incomplete_bson =
std::vector<std::uint8_t> const incomplete_bson =
{
0x0D, 0x00, // size (incomplete), unexpected EOF
};
@ -799,7 +799,7 @@ TEST_CASE("Incomplete BSON Input")
{
SECTION("key")
{
json j = {{"key", "value"}};
json const j = {{"key", "value"}};
auto bson_vec = json::to_bson(j);
SaxCountdown scp(2);
CHECK(!json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
@ -807,7 +807,7 @@ TEST_CASE("Incomplete BSON Input")
SECTION("array")
{
json j =
json const j =
{
{ "entry", json::array() }
};
@ -821,7 +821,7 @@ TEST_CASE("Incomplete BSON Input")
TEST_CASE("Negative size of binary value")
{
// invalid BSON: the size of the binary value is -1
std::vector<std::uint8_t> input =
std::vector<std::uint8_t> const input =
{
0x21, 0x00, 0x00, 0x00, // size (little endian)
0x05, // entry: binary
@ -839,7 +839,7 @@ TEST_CASE("Negative size of binary value")
TEST_CASE("Unsupported BSON input")
{
std::vector<std::uint8_t> bson =
std::vector<std::uint8_t> const bson =
{
0x0C, 0x00, 0x00, 0x00, // size (little endian)
0xFF, // entry type: Min key (not supported yet)
@ -863,7 +863,7 @@ TEST_CASE("BSON numerical data")
{
SECTION("std::int64_t: INT64_MIN .. INT32_MIN-1")
{
std::vector<int64_t> numbers
std::vector<int64_t> const numbers
{
INT64_MIN,
-1000000000000000000LL,
@ -889,7 +889,7 @@ TEST_CASE("BSON numerical data")
};
CHECK(j.at("entry").is_number_integer());
std::uint64_t iu = *reinterpret_cast<std::uint64_t*>(&i);
std::uint64_t const iu = *reinterpret_cast<std::uint64_t*>(&i);
std::vector<std::uint8_t> expected_bson =
{
0x14u, 0x00u, 0x00u, 0x00u, // size (little endian)
@ -921,7 +921,7 @@ TEST_CASE("BSON numerical data")
SECTION("signed std::int32_t: INT32_MIN .. INT32_MAX")
{
std::vector<int32_t> numbers
std::vector<int32_t> const numbers
{
INT32_MIN,
-2147483647L,
@ -961,7 +961,7 @@ TEST_CASE("BSON numerical data")
};
CHECK(j.at("entry").is_number_integer());
std::uint32_t iu = *reinterpret_cast<std::uint32_t*>(&i);
std::uint32_t const iu = *reinterpret_cast<std::uint32_t*>(&i);
std::vector<std::uint8_t> expected_bson =
{
0x10u, 0x00u, 0x00u, 0x00u, // size (little endian)
@ -988,7 +988,7 @@ TEST_CASE("BSON numerical data")
SECTION("signed std::int64_t: INT32_MAX+1 .. INT64_MAX")
{
std::vector<int64_t> numbers
std::vector<int64_t> const numbers
{
INT64_MAX,
1000000000000000000LL,
@ -1014,7 +1014,7 @@ TEST_CASE("BSON numerical data")
};
CHECK(j.at("entry").is_number_integer());
std::uint64_t iu = *reinterpret_cast<std::uint64_t*>(&i);
std::uint64_t const iu = *reinterpret_cast<std::uint64_t*>(&i);
std::vector<std::uint8_t> expected_bson =
{
0x14u, 0x00u, 0x00u, 0x00u, // size (little endian)
@ -1048,7 +1048,7 @@ TEST_CASE("BSON numerical data")
{
SECTION("unsigned std::uint64_t: 0 .. INT32_MAX")
{
std::vector<std::uint64_t> numbers
std::vector<std::uint64_t> const numbers
{
0ULL,
1ULL,
@ -1103,7 +1103,7 @@ TEST_CASE("BSON numerical data")
SECTION("unsigned std::uint64_t: INT32_MAX+1 .. INT64_MAX")
{
std::vector<std::uint64_t> numbers
std::vector<std::uint64_t> const numbers
{
static_cast<std::uint64_t>(INT32_MAX) + 1,
4000000000ULL,
@ -1161,7 +1161,7 @@ TEST_CASE("BSON numerical data")
SECTION("unsigned std::uint64_t: INT64_MAX+1 .. UINT64_MAX")
{
std::vector<std::uint64_t> numbers
std::vector<std::uint64_t> const numbers
{
static_cast<std::uint64_t>(INT64_MAX) + 1ULL,
10000000000000000000ULL,
@ -1175,13 +1175,13 @@ TEST_CASE("BSON numerical data")
CAPTURE(i)
json j =
json const j =
{
{ "entry", i }
};
auto iu = i;
std::vector<std::uint8_t> expected_bson =
std::vector<std::uint8_t> const expected_bson =
{
0x14u, 0x00u, 0x00u, 0x00u, // size (little endian)
0x12u, /// entry: int64
@ -1274,7 +1274,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
INFO_WITH_TEMP(filename + ": output to output adapters");
// parse JSON file
std::ifstream f_json(filename);
json j1 = json::parse(f_json);
json const j1 = json::parse(f_json);
// parse BSON file
auto packed = utils::read_binary_file(filename + ".bson");

16
tests/src/unit-cbor.cpp
View File

@ -1607,8 +1607,8 @@ TEST_CASE("CBOR")
SECTION("0x5b (byte array)")
{
std::vector<uint8_t> const given = {0x5b, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x61
};
0x00, 0x00, 0x00, 0x01, 0x61
};
json j = json::from_cbor(given);
CHECK(j == json::binary(std::vector<uint8_t> {'a'}));
}
@ -1616,8 +1616,8 @@ TEST_CASE("CBOR")
SECTION("0x7b (string)")
{
std::vector<uint8_t> const given = {0x7b, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x61
};
0x00, 0x00, 0x00, 0x01, 0x61
};
json j = json::from_cbor(given);
CHECK(j == "a");
}
@ -1625,8 +1625,8 @@ TEST_CASE("CBOR")
SECTION("0x9b (array)")
{
std::vector<uint8_t> const given = {0x9b, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0xf4
};
0x00, 0x00, 0x00, 0x01, 0xf4
};
json j = json::from_cbor(given);
CHECK(j == json::parse("[false]"));
}
@ -1634,8 +1634,8 @@ TEST_CASE("CBOR")
SECTION("0xbb (map)")
{
std::vector<uint8_t> const given = {0xbb, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x60, 0xf4
};
0x00, 0x00, 0x00, 0x01, 0x60, 0xf4
};
json j = json::from_cbor(given);
CHECK(j == json::parse("{\"\": false}"));
}

24
tests/src/unit-class_iterator.cpp
View File

@ -27,26 +27,26 @@ TEST_CASE("iterator class")
SECTION("null")
{
json j(json::value_t::null);
json::iterator it(&j);
json::iterator const it(&j);
}
SECTION("object")
{
json j(json::value_t::object);
json::iterator it(&j);
json::iterator const it(&j);
}
SECTION("array")
{
json j(json::value_t::array);
json::iterator it(&j);
json::iterator const it(&j);
}
}
SECTION("copy assignment")
{
json j(json::value_t::null);
json::iterator it(&j);
json::iterator const it(&j);
json::iterator it2(&j);
it2 = it;
}
@ -116,7 +116,7 @@ TEST_CASE("iterator class")
SECTION("null")
{
json j(json::value_t::null);
json::iterator it = j.begin();
json::iterator const it = j.begin();
CHECK_THROWS_WITH_AS(*it, "[json.exception.invalid_iterator.214] cannot get value", json::invalid_iterator&);
}
@ -132,14 +132,14 @@ TEST_CASE("iterator class")
SECTION("object")
{
json j({{"foo", "bar"}});
json::iterator it = j.begin();
json::iterator const it = j.begin();
CHECK(*it == json("bar"));
}
SECTION("array")
{
json j({1, 2, 3, 4});
json::iterator it = j.begin();
json::iterator const it = j.begin();
CHECK(*it == json(1));
}
}
@ -149,7 +149,7 @@ TEST_CASE("iterator class")
SECTION("null")
{
json j(json::value_t::null);
json::iterator it = j.begin();
json::iterator const it = j.begin();
CHECK_THROWS_WITH_AS(std::string(it->type_name()), "[json.exception.invalid_iterator.214] cannot get value", json::invalid_iterator&);
}
@ -165,14 +165,14 @@ TEST_CASE("iterator class")
SECTION("object")
{
json j({{"foo", "bar"}});
json::iterator it = j.begin();
json::iterator const it = j.begin();
CHECK(std::string(it->type_name()) == "string");
}
SECTION("array")
{
json j({1, 2, 3, 4});
json::iterator it = j.begin();
json::iterator const it = j.begin();
CHECK(std::string(it->type_name()) == "number");
}
}
@ -287,7 +287,7 @@ TEST_CASE("iterator class")
SECTION("null")
{
json j(json::value_t::null);
json::iterator it = j.end();
json::iterator const it = j.end();
CHECK((it.m_it.primitive_iterator.m_it == 1));
}
@ -336,7 +336,7 @@ TEST_CASE("iterator class")
SECTION("null")
{
json j(json::value_t::null);
json::iterator it = j.end();
json::iterator const it = j.end();
CHECK((it.m_it.primitive_iterator.m_it == 1));
}

2
tests/src/unit-conversions.cpp
View File

@ -47,7 +47,7 @@ TEST_CASE("value conversion")
SECTION("json::object_t")
{
json::object_t const const o = j.get<json::object_t>();
json::object_t const o = j.get<json::object_t>();
CHECK(json(o) == j);
}

4
tests/src/unit-diagnostics.cpp
View File

@ -22,7 +22,7 @@ TEST_CASE("Better diagnostics")
{
SECTION("empty JSON Pointer")
{
json j = 1;
json const j = 1;
std::string s;
CHECK_THROWS_WITH_AS(s = j.get<std::string>(), "[json.exception.type_error.302] type must be string, but is number", json::type_error);
}
@ -240,7 +240,7 @@ TEST_CASE("Regression tests for extended diagnostics")
j_arr[5] = 5;
j_arr[6] = 6;
j_arr[7] = 7;
json j_arr_copy = j_arr;
json const j_arr_copy = j_arr;
}
}
}

142
tests/src/unit-regression1.cpp
View File

@ -143,27 +143,27 @@ TEST_CASE("regression tests 1")
// to null), but are serialized as null.
SECTION("NAN value")
{
json j1 = NAN;
json const j1 = NAN;
CHECK(j1.is_number_float());
json::number_float_t f1{j1};
json::number_float_t const f1{j1};
CHECK(std::isnan(f1));
json j2 = static_cast<json::number_float_t>(NAN);
json const j2 = static_cast<json::number_float_t>(NAN);
CHECK(j2.is_number_float());
json::number_float_t f2{j2};
json::number_float_t const f2{j2};
CHECK(std::isnan(f2));
}
SECTION("infinity")
{
json j1 = INFINITY;
json const j1 = INFINITY;
CHECK(j1.is_number_float());
json::number_float_t f1{j1};
json::number_float_t const f1{j1};
CHECK(!std::isfinite(f1));
json j2 = static_cast<json::number_float_t>(INFINITY);
json const j2 = static_cast<json::number_float_t>(INFINITY);
CHECK(j2.is_number_float());
json::number_float_t f2{j2};
json::number_float_t const f2{j2};
CHECK(!std::isfinite(f2));
}
}
@ -200,7 +200,7 @@ TEST_CASE("regression tests 1")
fields["three"] = std::string("three \"four\"");
// create another JSON object by deserializing the serialization
std::string payload = fields.dump();
std::string const payload = fields.dump();
json parsed_fields = json::parse(payload);
// check individual fields to match both objects
@ -288,7 +288,7 @@ TEST_CASE("regression tests 1")
}
{
json a = {1, 2, 3};
json::reverse_iterator rit = ++a.rbegin();
json::reverse_iterator const rit = ++a.rbegin();
CHECK(*rit == json(2));
CHECK(rit.value() == json(2));
}
@ -340,8 +340,8 @@ TEST_CASE("regression tests 1")
SECTION("issue #101 - binary string causes numbers to be dumped as hex")
{
int64_t number = 10;
std::string bytes{"\x00" "asdf\n", 6};
int64_t const number = 10;
std::string const bytes{"\x00" "asdf\n", 6};
json j;
j["int64"] = number;
j["binary string"] = bytes;
@ -352,7 +352,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #111 - subsequent unicode chars")
{
std::string bytes{0x7, 0x7};
std::string const bytes{0x7, 0x7};
json j;
j["string"] = bytes;
CHECK(j["string"] == "\u0007\u0007");
@ -465,33 +465,33 @@ TEST_CASE("regression tests 1")
// create JSON class with nonstandard float number type
// float
nlohmann::basic_json<std::map, std::vector, std::string, bool, int32_t, uint32_t, float> j_float =
nlohmann::basic_json<std::map, std::vector, std::string, bool, int32_t, uint32_t, float> const j_float =
1.23e25f;
CHECK(j_float.get<float>() == 1.23e25f);
// double
nlohmann::basic_json<std::map, std::vector, std::string, bool, int64_t, uint64_t, double> j_double =
nlohmann::basic_json<std::map, std::vector, std::string, bool, int64_t, uint64_t, double> const j_double =
1.23e35;
CHECK(j_double.get<double>() == 1.23e35);
// long double
nlohmann::basic_json<std::map, std::vector, std::string, bool, int64_t, uint64_t, long double>
j_long_double = 1.23e45L;
const j_long_double = 1.23e45L;
CHECK(j_long_double.get<long double>() == 1.23e45L);
}
SECTION("issue #228 - double values are serialized with commas as decimal points")
{
json j1a = 2312.42;
json j1b = json::parse("2312.42");
json const j1a = 2312.42;
json const j1b = json::parse("2312.42");
json j2a = 2342e-2;
json const j2a = 2342e-2;
//issue #230
//json j2b = json::parse("2342e-2");
json j3a = 10E3;
json j3b = json::parse("10E3");
json j3c = json::parse("10e3");
json const j3a = 10E3;
json const j3b = json::parse("10E3");
json const j3c = json::parse("10e3");
// class to create a locale that would use a comma for decimals
class CommaDecimalSeparator : public std::numpunct<char>
@ -585,7 +585,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #269 - diff generates incorrect patch when removing multiple array elements")
{
json doc = R"( { "arr1": [1, 2, 3, 4] } )"_json;
json const doc = R"( { "arr1": [1, 2, 3, 4] } )"_json;
json expected = R"( { "arr1": [1, 2] } )"_json;
// check roundtrip
@ -610,7 +610,7 @@ TEST_CASE("regression tests 1")
// code triggered a "warning: unused variable" warning and is left
// here to avoid the warning in the future
json object;
json patch = json::array();
json const patch = json::array();
object = object.patch(patch);
}
@ -837,7 +837,7 @@ TEST_CASE("regression tests 1")
SECTION("second example from #529")
{
std::string str = "{\n\"one\" : 1,\n\"two\" : 2\n}\n{\n\"three\" : 3\n}";
std::string const str = "{\n\"one\" : 1,\n\"two\" : 2\n}\n{\n\"three\" : 3\n}";
{
std::ofstream file("test.json");
@ -875,23 +875,23 @@ TEST_CASE("regression tests 1")
SECTION("issue #389 - Integer-overflow (OSS-Fuzz issue 267)")
{
// original test case
json j1 = json::parse("-9223372036854775808");
json const j1 = json::parse("-9223372036854775808");
CHECK(j1.is_number_integer());
CHECK(j1.get<json::number_integer_t>() == INT64_MIN);
// edge case (+1; still an integer)
json j2 = json::parse("-9223372036854775807");
json const j2 = json::parse("-9223372036854775807");
CHECK(j2.is_number_integer());
CHECK(j2.get<json::number_integer_t>() == INT64_MIN + 1);
// edge case (-1; overflow -> floats)
json j3 = json::parse("-9223372036854775809");
json const j3 = json::parse("-9223372036854775809");
CHECK(j3.is_number_float());
}
SECTION("issue #380 - bug in overflow detection when parsing integers")
{
json j = json::parse("166020696663385964490");
json const j = json::parse("166020696663385964490");
CHECK(j.is_number_float());
CHECK(j.get<json::number_float_t>() == 166020696663385964490.0);
}
@ -899,7 +899,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #405 - Heap-buffer-overflow (OSS-Fuzz issue 342)")
{
// original test case
std::vector<uint8_t> vec {0x65, 0xf5, 0x0a, 0x48, 0x21};
std::vector<uint8_t> const vec {0x65, 0xf5, 0x0a, 0x48, 0x21};
json _;
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec), "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
}
@ -909,23 +909,23 @@ TEST_CASE("regression tests 1")
json _;
// original test case: incomplete float64
std::vector<uint8_t> vec1 {0xcb, 0x8f, 0x0a};
std::vector<uint8_t> const vec1 {0xcb, 0x8f, 0x0a};
CHECK_THROWS_WITH_AS(_ = json::from_msgpack(vec1), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing MessagePack number: unexpected end of input", json::parse_error&);
// related test case: incomplete float32
std::vector<uint8_t> vec2 {0xca, 0x8f, 0x0a};
std::vector<uint8_t> const vec2 {0xca, 0x8f, 0x0a};
CHECK_THROWS_WITH_AS(_ = json::from_msgpack(vec2), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing MessagePack number: unexpected end of input", json::parse_error&);
// related test case: incomplete Half-Precision Float (CBOR)
std::vector<uint8_t> vec3 {0xf9, 0x8f};
std::vector<uint8_t> const vec3 {0xf9, 0x8f};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec3), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR number: unexpected end of input", json::parse_error&);
// related test case: incomplete Single-Precision Float (CBOR)
std::vector<uint8_t> vec4 {0xfa, 0x8f, 0x0a};
std::vector<uint8_t> const vec4 {0xfa, 0x8f, 0x0a};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec4), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR number: unexpected end of input", json::parse_error&);
// related test case: incomplete Double-Precision Float (CBOR)
std::vector<uint8_t> vec5 {0xfb, 0x8f, 0x0a};
std::vector<uint8_t> const vec5 {0xfb, 0x8f, 0x0a};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec5), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR number: unexpected end of input", json::parse_error&);
}
@ -934,7 +934,7 @@ TEST_CASE("regression tests 1")
json _;
// original test case
std::vector<uint8_t> vec1 {0x87};
std::vector<uint8_t> const vec1 {0x87};
CHECK_THROWS_WITH_AS(_ = json::from_msgpack(vec1), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing MessagePack string: unexpected end of input", json::parse_error&);
// more test cases for MessagePack
@ -946,7 +946,7 @@ TEST_CASE("regression tests 1")
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf
})
{
std::vector<uint8_t> vec(1, static_cast<uint8_t>(b));
std::vector<uint8_t> const vec(1, static_cast<uint8_t>(b));
CHECK_THROWS_AS(_ = json::from_msgpack(vec), json::parse_error&);
}
@ -961,12 +961,12 @@ TEST_CASE("regression tests 1")
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7 // map
})
{
std::vector<uint8_t> vec(1, static_cast<uint8_t>(b));
std::vector<uint8_t> const vec(1, static_cast<uint8_t>(b));
CHECK_THROWS_AS(_ = json::from_cbor(vec), json::parse_error&);
}
// special case: empty input
std::vector<uint8_t> vec2;
std::vector<uint8_t> const vec2;
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec2), "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
CHECK_THROWS_WITH_AS(_ = json::from_msgpack(vec2), "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing MessagePack value: unexpected end of input", json::parse_error&);
}
@ -976,22 +976,22 @@ TEST_CASE("regression tests 1")
json _;
// original test case: empty UTF-8 string (indefinite length)
std::vector<uint8_t> vec1 {0x7f};
std::vector<uint8_t> const vec1 {0x7f};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec1), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
// related test case: empty array (indefinite length)
std::vector<uint8_t> vec2 {0x9f};
std::vector<uint8_t> const vec2 {0x9f};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec2), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
// related test case: empty map (indefinite length)
std::vector<uint8_t> vec3 {0xbf};
std::vector<uint8_t> const vec3 {0xbf};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec3), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
}
SECTION("issue #412 - Heap-buffer-overflow (OSS-Fuzz issue 367)")
{
// original test case
std::vector<uint8_t> vec
std::vector<uint8_t> const vec
{
0xab, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
0x98, 0x98, 0x98, 0x98, 0x98, 0x00, 0x00, 0x00,
@ -1016,15 +1016,15 @@ TEST_CASE("regression tests 1")
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x98", json::parse_error&);
// related test case: nonempty UTF-8 string (indefinite length)
std::vector<uint8_t> vec1 {0x7f, 0x61, 0x61};
std::vector<uint8_t> const vec1 {0x7f, 0x61, 0x61};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec1), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
// related test case: nonempty array (indefinite length)
std::vector<uint8_t> vec2 {0x9f, 0x01};
std::vector<uint8_t> const vec2 {0x9f, 0x01};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec2), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
// related test case: nonempty map (indefinite length)
std::vector<uint8_t> vec3 {0xbf, 0x61, 0x61, 0x01};
std::vector<uint8_t> const vec3 {0xbf, 0x61, 0x61, 0x01};
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec3), "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
}
@ -1049,7 +1049,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #416 - Use-of-uninitialized-value (OSS-Fuzz issue 377)")
{
// original test case
std::vector<uint8_t> vec1
std::vector<uint8_t> const vec1
{
0x94, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa,
0x3a, 0x96, 0x96, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
@ -1063,7 +1063,7 @@ TEST_CASE("regression tests 1")
CHECK_THROWS_WITH_AS(_ = json::from_cbor(vec1), "[json.exception.parse_error.113] parse error at byte 13: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0xB4", json::parse_error&);
// related test case: double-precision
std::vector<uint8_t> vec2
std::vector<uint8_t> const vec2
{
0x94, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa,
0x3a, 0x96, 0x96, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
@ -1077,7 +1077,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #452 - Heap-buffer-overflow (OSS-Fuzz issue 585)")
{
std::vector<uint8_t> vec = {'-', '0', '1', '2', '2', '7', '4'};
std::vector<uint8_t> const vec = {'-', '0', '1', '2', '2', '7', '4'};
json _;
CHECK_THROWS_AS(_ = json::parse(vec), json::parse_error&);
}
@ -1100,9 +1100,9 @@ TEST_CASE("regression tests 1")
SECTION("issue #465 - roundtrip error while parsing 1000000000000000010E5")
{
json j1 = json::parse("1000000000000000010E5");
json const j1 = json::parse("1000000000000000010E5");
std::string s1 = j1.dump();
json j2 = json::parse(s1);
json const j2 = json::parse(s1);
std::string s2 = j2.dump();
CHECK(s1 == s2);
}
@ -1110,15 +1110,15 @@ TEST_CASE("regression tests 1")
#if JSON_USE_IMPLICIT_CONVERSIONS
SECTION("issue #473 - inconsistent behavior in conversion to array type")
{
json j_array = {1, 2, 3, 4};
json j_number = 42;
json j_null = nullptr;
json const j_array = {1, 2, 3, 4};
json const j_number = 42;
json const j_null = nullptr;
SECTION("std::vector")
{
auto create = [](const json & j)
{
std::vector<int> v = j;
std::vector<int> const v = j;
};
CHECK_NOTHROW(create(j_array));
@ -1130,7 +1130,7 @@ TEST_CASE("regression tests 1")
{
auto create = [](const json & j)
{
std::list<int> v = j;
std::list<int> const v = j;
};
CHECK_NOTHROW(create(j_array));
@ -1142,7 +1142,7 @@ TEST_CASE("regression tests 1")
{
auto create = [](const json & j)
{
std::forward_list<int> v = j;
std::forward_list<int> const v = j;
};
CHECK_NOTHROW(create(j_array));
@ -1161,7 +1161,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #494 - conversion from vector<bool> to json fails to build")
{
std::vector<bool> boolVector = {false, true, false, false};
std::vector<bool> const boolVector = {false, true, false, false};
json j;
j["bool_vector"] = boolVector;
@ -1170,14 +1170,14 @@ TEST_CASE("regression tests 1")
SECTION("issue #504 - assertion error (OSS-Fuzz 856)")
{
std::vector<uint8_t> vec1 = {0xf9, 0xff, 0xff, 0x4a, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x37, 0x02, 0x38};
json j1 = json::from_cbor(vec1, false);
std::vector<uint8_t> const vec1 = {0xf9, 0xff, 0xff, 0x4a, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x37, 0x02, 0x38};
json const j1 = json::from_cbor(vec1, false);
// step 2: round trip
std::vector<uint8_t> vec2 = json::to_cbor(j1);
// parse serialization
json j2 = json::from_cbor(vec2);
json const j2 = json::from_cbor(vec2);
// NaN is dumped to "null"
CHECK(j2.is_number_float());
@ -1226,7 +1226,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #575 - heap-buffer-overflow (OSS-Fuzz 1400)")
{
json _;
std::vector<uint8_t> vec = {'"', '\\', '"', 'X', '"', '"'};
std::vector<uint8_t> const vec = {'"', '\\', '"', 'X', '"', '"'};
CHECK_THROWS_AS(_ = json::parse(vec), json::parse_error&);
}
@ -1239,7 +1239,7 @@ TEST_CASE("regression tests 1")
std::map<std::string, int> m1 {{"key", 1}};
// create and print a JSON from the map
json j = m1;
json const j = m1;
// get the map out of JSON
std::map<std::string, int> m2 = j;
@ -1254,7 +1254,7 @@ TEST_CASE("regression tests 1")
std::map<std::string, std::string> m1 {{"key", "val"}};
// create and print a JSON from the map
json j = m1;
json const j = m1;
// get the map out of JSON
std::map<std::string, std::string> m2 = j;
@ -1277,7 +1277,7 @@ TEST_CASE("regression tests 1")
{
SECTION("original example")
{
std::valarray<double> v;
std::valarray<double> const v;
nlohmann::json j;
j["test"] = v;
}
@ -1364,8 +1364,8 @@ TEST_CASE("regression tests 1")
SECTION("issue #838 - incorrect parse error with binary data in keys")
{
std::array<uint8_t, 28> key1 = {{ 103, 92, 117, 48, 48, 48, 55, 92, 114, 215, 126, 214, 95, 92, 34, 174, 40, 71, 38, 174, 40, 71, 38, 223, 134, 247, 127, 0 }};
std::string key1_str(reinterpret_cast<char*>(key1.data()));
json j = key1_str;
std::string const key1_str(reinterpret_cast<char*>(key1.data()));
json const j = key1_str;
CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 10: 0x7E", json::type_error&);
}
@ -1405,7 +1405,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #961 - incorrect parsing of indefinite length CBOR strings")
{
std::vector<uint8_t> v_cbor =
std::vector<uint8_t> const v_cbor =
{
0x7F,
0x64,
@ -1453,7 +1453,7 @@ TEST_CASE("regression tests 1")
)";
// define parser callback
json::parser_callback_t cb = [](int /*depth*/, json::parse_event_t event, json & parsed)
json::parser_callback_t const cb = [](int /*depth*/, json::parse_event_t event, json & parsed)
{
// skip object elements with key "Thumbnail"
return !(event == json::parse_event_t::key && parsed == json("Thumbnail"));
@ -1467,7 +1467,7 @@ TEST_CASE("regression tests 1")
SECTION("issue #972 - Segmentation fault on G++ when trying to assign json string literal to custom json type")
{
my_json foo = R"([1, 2, 3])"_json;
my_json const foo = R"([1, 2, 3])"_json;
}
SECTION("issue #977 - Assigning between different json types")
@ -1478,7 +1478,7 @@ TEST_CASE("regression tests 1")
CHECK(lj.size() == 1);
CHECK(lj["x"] == 3);
CHECK(ff.x == 3);
nlohmann::json nj = lj; // This line works as expected
nlohmann::json const nj = lj; // This line works as expected
}
}

18
tests/src/unit-wstring.cpp
View File

@ -40,8 +40,8 @@ TEST_CASE("wide strings")
{
if (wstring_is_utf16())
{
std::wstring w = L"[12.2,\"Ⴥaäö💤🧢\"]";
json j = json::parse(w);
std::wstring const w = L"[12.2,\"Ⴥaäö💤🧢\"]";
json const j = json::parse(w);
CHECK(j.dump() == "[12.2,\"Ⴥaäö💤🧢\"]");
}
}
@ -50,7 +50,7 @@ TEST_CASE("wide strings")
{
if (wstring_is_utf16())
{
std::wstring w = L"\"\xDBFF";
std::wstring const w = L"\"\xDBFF";
json _;
CHECK_THROWS_AS(_ = json::parse(w), json::parse_error&);
}
@ -60,8 +60,8 @@ TEST_CASE("wide strings")
{
if (u16string_is_utf16())
{
std::u16string w = u"[12.2,\"Ⴥaäö💤🧢\"]";
json j = json::parse(w);
std::u16string const w = u"[12.2,\"Ⴥaäö💤🧢\"]";
json const j = json::parse(w);
CHECK(j.dump() == "[12.2,\"Ⴥaäö💤🧢\"]");
}
}
@ -70,7 +70,7 @@ TEST_CASE("wide strings")
{
if (wstring_is_utf16())
{
std::u16string w = u"\"\xDBFF";
std::u16string const w = u"\"\xDBFF";
json _;
CHECK_THROWS_AS(_ = json::parse(w), json::parse_error&);
}
@ -80,8 +80,8 @@ TEST_CASE("wide strings")
{
if (u32string_is_utf32())
{
std::u32string w = U"[12.2,\"Ⴥaäö💤🧢\"]";
json j = json::parse(w);
std::u32string const w = U"[12.2,\"Ⴥaäö💤🧢\"]";
json const j = json::parse(w);
CHECK(j.dump() == "[12.2,\"Ⴥaäö💤🧢\"]");
}
}
@ -90,7 +90,7 @@ TEST_CASE("wide strings")
{
if (u32string_is_utf32())
{
std::u32string w = U"\"\x110000";
std::u32string const w = U"\"\x110000";
json _;
CHECK_THROWS_AS(_ = json::parse(w), json::parse_error&);
}