mirror of
https://github.com/nlohmann/json.git
synced 2026-09-06 00:08:00 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Niels Lohmann
|
cc749ac699 | ||
|
Niels Lohmann
|
1c6ca81b8a |
@@ -177,24 +177,6 @@ json_test_add_test_for(src/unit-comparison.cpp
|
||||
MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
|
||||
)
|
||||
|
||||
# test the parser again with JSON_DIAGNOSTIC_POSITIONS enabled
|
||||
json_test_set_test_options(test-class_parser_diagnostic_positions
|
||||
COMPILE_DEFINITIONS JSON_DIAGNOSTIC_POSITIONS=1
|
||||
)
|
||||
json_test_add_test_for(src/unit-class_parser.cpp
|
||||
NAME test-class_parser_diagnostic_positions
|
||||
MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
|
||||
)
|
||||
|
||||
# test diagnostic positions again without regular diagnostics (JSON pointer paths)
|
||||
json_test_set_test_options(test-diagnostic-positions_only
|
||||
COMPILE_DEFINITIONS JSON_DIAGNOSTICS=0
|
||||
)
|
||||
json_test_add_test_for(src/unit-diagnostic-positions.cpp
|
||||
NAME test-diagnostic-positions_only
|
||||
MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
|
||||
)
|
||||
|
||||
# *DO NOT* use json_test_set_test_options() below this line
|
||||
|
||||
#############################################################################
|
||||
|
||||
@@ -344,50 +344,6 @@ void trailing_comma_helper(const std::string& s)
|
||||
}
|
||||
}
|
||||
|
||||
#if JSON_DIAGNOSTIC_POSITIONS
|
||||
/**
|
||||
* Validates that the generated JSON object is the same as expected
|
||||
* Validates that the start position and end position match the start and end of the string
|
||||
*
|
||||
* This check assumes that there is no whitespace around the json object in the original string.
|
||||
*/
|
||||
void validate_generated_json_and_start_end_pos_helper(const std::string& original_string, const json& j, const json& check)
|
||||
{
|
||||
CHECK(j == check);
|
||||
CHECK(j.start_pos() == 0);
|
||||
CHECK(j.end_pos() == original_string.size());
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses the root object from the given root string and validates that the start and end positions for the nested object are correct.
|
||||
*
|
||||
* This checks that whitespace around the nested object is included in the start and end positions of the root object.
|
||||
*/
|
||||
void validate_start_end_pos_for_nested_obj_helper(const std::string& nested_type_json_str, const std::string& root_type_json_str, const json& expected_json, const json::parser_callback_t& cb = nullptr)
|
||||
{
|
||||
json j;
|
||||
|
||||
// 1. If callback is provided, use callback version of parse()
|
||||
if (cb)
|
||||
{
|
||||
j = json::parse(root_type_json_str, cb);
|
||||
}
|
||||
else
|
||||
{
|
||||
j = json::parse(root_type_json_str);
|
||||
}
|
||||
|
||||
// 2. Check if the generated JSON is as expected
|
||||
// Assumptions: The root_type_json_str does not have any whitespace around the json object
|
||||
validate_generated_json_and_start_end_pos_helper(root_type_json_str, j, expected_json);
|
||||
|
||||
// 3. Get the nested object
|
||||
const auto& nested = j["nested"];
|
||||
// 4. Check if the start and end positions are generated correctly for nested objects and arrays
|
||||
CHECK(nested_type_json_str == root_type_json_str.substr(nested.start_pos(), nested.end_pos() - nested.start_pos()));
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("parser class")
|
||||
@@ -1823,228 +1779,6 @@ TEST_CASE("parser class")
|
||||
CHECK_THROWS_WITH_AS(_ = json::parse("/a", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid comment; expecting '/' or '*' after '/'; last read: '/a'", json::parse_error);
|
||||
CHECK_THROWS_WITH_AS(_ = json::parse("/*", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid comment; missing closing '*/'; last read: '/*<U+0000>'", json::parse_error);
|
||||
}
|
||||
|
||||
#if JSON_DIAGNOSTIC_POSITIONS
|
||||
// Macro for all test cases for start_pos and end_pos
|
||||
#define SETUP_TESTCASES() \
|
||||
SECTION("with callback") \
|
||||
{ \
|
||||
SECTION("filter nothing") \
|
||||
{ \
|
||||
json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t /*unused*/, json& /*unused*/) noexcept \
|
||||
{ \
|
||||
return true; \
|
||||
}; \
|
||||
validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, expected, cb); \
|
||||
} \
|
||||
SECTION("filter element") \
|
||||
{ \
|
||||
json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t event, json& j) noexcept \
|
||||
{ \
|
||||
return (event != json::parse_event_t::key && event != json::parse_event_t::value) || j != json("a"); \
|
||||
}; \
|
||||
validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, filteredExpected, cb); \
|
||||
} \
|
||||
} \
|
||||
SECTION("without callback") \
|
||||
{ \
|
||||
validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, expected); \
|
||||
}
|
||||
|
||||
SECTION("retrieve start position and end position")
|
||||
{
|
||||
SECTION("for object")
|
||||
{
|
||||
// Create an object with spaces to test the start and end positions. Spaces will not be included in the
|
||||
// JSON object, however, the start and end positions should include the spaces from the input JSON string.
|
||||
const std::string nested_type_json_str = R"({ "a": 1,"b" : "test1"})";
|
||||
const std::string root_type_json_str = R"({ "nested": )" + nested_type_json_str + R"(, "anotherValue": "test2"})";
|
||||
auto expected = json({{"nested", {{"a", 1}, {"b", "test1"}}}, {"anotherValue", "test2"}});
|
||||
auto filteredExpected = expected;
|
||||
filteredExpected["nested"].erase("a");
|
||||
|
||||
SETUP_TESTCASES()
|
||||
}
|
||||
|
||||
SECTION("for array")
|
||||
{
|
||||
const std::string nested_type_json_str = R"(["a", "test", 45])";
|
||||
const std::string root_type_json_str = R"({ "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
|
||||
auto expected = json({{"nested", {"a", "test", 45}}, {"anotherValue", "test"}});
|
||||
auto filteredExpected = expected;
|
||||
filteredExpected["nested"] = json({"test", 45});
|
||||
SETUP_TESTCASES()
|
||||
}
|
||||
|
||||
SECTION("for array with objects")
|
||||
{
|
||||
const std::string nested_type_json_str = R"([{"a": 1, "b": "test"}, {"c": 2, "d": "test2"}])";
|
||||
const std::string root_type_json_str = R"({ "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
|
||||
auto expected = json({{"nested", {{{"a", 1}, {"b", "test"}}, {{"c", 2}, {"d", "test2"}}}}, {"anotherValue", "test"}});
|
||||
auto filteredExpected = expected;
|
||||
filteredExpected["nested"][0].erase("a");
|
||||
SETUP_TESTCASES()
|
||||
|
||||
auto j = json::parse(root_type_json_str);
|
||||
auto nested_array = j["nested"];
|
||||
const auto& nested_obj = nested_array[0];
|
||||
CHECK(nested_type_json_str.substr(1, 21) == root_type_json_str.substr(nested_obj.start_pos(), nested_obj.end_pos() - nested_obj.start_pos()));
|
||||
CHECK(nested_type_json_str.substr(24, 22) == root_type_json_str.substr(nested_array[1].start_pos(), nested_array[1].end_pos() - nested_array[1].start_pos()));
|
||||
}
|
||||
|
||||
SECTION("for two levels of nesting objects")
|
||||
{
|
||||
const std::string nested_type_json_str = R"({"nested2": {"b": "test"}})";
|
||||
const std::string root_type_json_str = R"({ "a": 2, "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
|
||||
auto expected = json({{"a", 2}, {"nested", {{"nested2", {{"b", "test"}}}}}, {"anotherValue", "test"}});
|
||||
auto filteredExpected = expected;
|
||||
filteredExpected.erase("a");
|
||||
SETUP_TESTCASES()
|
||||
|
||||
auto j = json::parse(root_type_json_str);
|
||||
auto nested_obj = j["nested"]["nested2"];
|
||||
CHECK(nested_type_json_str.substr(12, 13) == root_type_json_str.substr(nested_obj.start_pos(), nested_obj.end_pos() - nested_obj.start_pos()));
|
||||
}
|
||||
|
||||
SECTION("for simple types")
|
||||
{
|
||||
SECTION("no nested")
|
||||
{
|
||||
SECTION("with callback")
|
||||
{
|
||||
json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t /*unused*/, json& /*unused*/) noexcept
|
||||
{
|
||||
return true;
|
||||
};
|
||||
|
||||
// 1. string type
|
||||
std::string json_str = R"("test")";
|
||||
auto j = json::parse(json_str, cb);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, "test");
|
||||
|
||||
// 2. number type
|
||||
json_str = R"(1)";
|
||||
j = json::parse(json_str, cb);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, 1);
|
||||
|
||||
// 3. boolean type
|
||||
json_str = R"(true)";
|
||||
j = json::parse(json_str, cb);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, true);
|
||||
|
||||
// 4. null type
|
||||
json_str = R"(null)";
|
||||
j = json::parse(json_str, cb);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, nullptr);
|
||||
}
|
||||
|
||||
SECTION("without callback")
|
||||
{
|
||||
// 1. string type
|
||||
std::string json_str = R"("test")";
|
||||
auto j = json::parse(json_str);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, "test");
|
||||
|
||||
// 2. number type
|
||||
json_str = R"(1)";
|
||||
j = json::parse(json_str);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, 1);
|
||||
|
||||
json_str = R"(1.001239923)";
|
||||
j = json::parse(json_str);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, 1.001239923);
|
||||
|
||||
json_str = R"(1.123812389000000)";
|
||||
j = json::parse(json_str);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, 1.123812389);
|
||||
|
||||
// 3. boolean type
|
||||
json_str = R"(true)";
|
||||
j = json::parse(json_str);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, true);
|
||||
|
||||
json_str = R"(false)";
|
||||
j = json::parse(json_str);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, false);
|
||||
|
||||
// 4. null type
|
||||
json_str = R"(null)";
|
||||
j = json::parse(json_str);
|
||||
validate_generated_json_and_start_end_pos_helper(json_str, j, nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("string type")
|
||||
{
|
||||
const std::string nested_type_json_str = R"("test")";
|
||||
const std::string root_type_json_str = R"({ "a": 1, "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
|
||||
auto expected = json({{"nested", "test"}, {"anotherValue", "test"}, {"a", 1}});
|
||||
auto filteredExpected = expected;
|
||||
filteredExpected.erase("a");
|
||||
SETUP_TESTCASES()
|
||||
}
|
||||
|
||||
SECTION("number type")
|
||||
{
|
||||
const std::string nested_type_json_str = R"(2)";
|
||||
const std::string root_type_json_str = R"({ "a": 1, "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
|
||||
auto expected = json({{"nested", 2}, {"anotherValue", "test"}, {"a", 1}});
|
||||
auto filteredExpected = expected;
|
||||
filteredExpected.erase("a");
|
||||
SETUP_TESTCASES()
|
||||
}
|
||||
|
||||
SECTION("boolean type")
|
||||
{
|
||||
const std::string nested_type_json_str = R"(true)";
|
||||
const std::string root_type_json_str = R"({ "a": 1, "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
|
||||
auto expected = json({{"nested", true}, {"anotherValue", "test"}, {"a", 1}});
|
||||
auto filteredExpected = expected;
|
||||
filteredExpected.erase("a");
|
||||
SETUP_TESTCASES()
|
||||
}
|
||||
|
||||
SECTION("null type")
|
||||
{
|
||||
const std::string nested_type_json_str = R"(null)";
|
||||
const std::string root_type_json_str = R"({ "a": 1, "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
|
||||
auto expected = json({{"nested", nullptr}, {"anotherValue", "test"}, {"a", 1}});
|
||||
auto filteredExpected = expected;
|
||||
filteredExpected.erase("a");
|
||||
SETUP_TESTCASES()
|
||||
}
|
||||
}
|
||||
SECTION("with leading whitespace and newlines around root JSON")
|
||||
{
|
||||
const std::string initial_whitespace = R"(
|
||||
|
||||
)";
|
||||
const std::string nested_type_json_str = R"({
|
||||
"a": 1,
|
||||
"nested": {
|
||||
"b": "test"
|
||||
},
|
||||
"anotherValue": "test"
|
||||
})";
|
||||
const std::string end_whitespace = R"(
|
||||
|
||||
)";
|
||||
const std::string root_type_json_str = initial_whitespace + nested_type_json_str + end_whitespace;
|
||||
|
||||
auto expected = json({{"a", 1}, {"nested", {{"b", "test"}}}, {"anotherValue", "test"}});
|
||||
|
||||
auto j = json::parse(root_type_json_str);
|
||||
|
||||
// 2. Check if the generated JSON is as expected
|
||||
CHECK(j == expected);
|
||||
|
||||
// 3. Check if the start and end positions do not include the surrounding whitespace
|
||||
CHECK(j.start_pos() == initial_whitespace.size());
|
||||
CHECK(j.end_pos() == root_type_json_str.size() - end_whitespace.size());
|
||||
}
|
||||
}
|
||||
#undef SETUP_TESTCASES
|
||||
#endif
|
||||
}
|
||||
|
||||
// this test relies on parse errors being thrown, so it is skipped when
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,44 @@
|
||||
// __ _____ _____ _____
|
||||
// __| | __| | | | JSON for Modern C++ (supporting code)
|
||||
// | | |__ | | | | | | version 3.12.0
|
||||
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
|
||||
//
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#ifdef JSON_DIAGNOSTICS
|
||||
#undef JSON_DIAGNOSTICS
|
||||
#endif
|
||||
|
||||
#define JSON_DIAGNOSTICS 0
|
||||
#define JSON_DIAGNOSTIC_POSITIONS 1
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
using json = nlohmann::json;
|
||||
|
||||
TEST_CASE("Better diagnostics with positions only")
|
||||
{
|
||||
SECTION("invalid type")
|
||||
{
|
||||
const std::string json_invalid_string = R"(
|
||||
{
|
||||
"address": {
|
||||
"street": "Fake Street",
|
||||
"housenumber": "1"
|
||||
}
|
||||
}
|
||||
)";
|
||||
json j = json::parse(json_invalid_string);
|
||||
CHECK_THROWS_WITH_AS(j.at("address").at("housenumber").get<int>(),
|
||||
"[json.exception.type_error.302] (bytes 108-111) type must be number, but is string", json::type_error);
|
||||
}
|
||||
|
||||
SECTION("invalid type without positions")
|
||||
{
|
||||
const json j = "foo";
|
||||
CHECK_THROWS_WITH_AS(j.get<int>(),
|
||||
"[json.exception.type_error.302] type must be number, but is string", json::type_error);
|
||||
}
|
||||
}
|
||||
@@ -8,9 +8,7 @@
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#ifndef JSON_DIAGNOSTICS
|
||||
#define JSON_DIAGNOSTICS 1
|
||||
#endif
|
||||
#define JSON_DIAGNOSTICS 1
|
||||
#define JSON_DIAGNOSTIC_POSITIONS 1
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
@@ -29,13 +27,8 @@ TEST_CASE("Better diagnostics with positions")
|
||||
}
|
||||
)";
|
||||
json j = json::parse(json_invalid_string);
|
||||
#if JSON_DIAGNOSTICS
|
||||
CHECK_THROWS_WITH_AS(j.at("address").at("housenumber").get<int>(),
|
||||
"[json.exception.type_error.302] (/address/housenumber) (bytes 108-111) type must be number, but is string", json::type_error);
|
||||
#else
|
||||
CHECK_THROWS_WITH_AS(j.at("address").at("housenumber").get<int>(),
|
||||
"[json.exception.type_error.302] (bytes 108-111) type must be number, but is string", json::type_error);
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("invalid type without positions")
|
||||
@@ -81,12 +74,7 @@ TEST_CASE("Better diagnostics with positions")
|
||||
// (/foo/bar); the position of that parent is reported in the message
|
||||
const json doc = json::parse(R"({"foo":{"bar":"a string"}})");
|
||||
const json patch = json::parse(R"([{"op":"add","path":"/foo/bar/baz","value":1}])");
|
||||
#if JSON_DIAGNOSTICS
|
||||
CHECK_THROWS_WITH_AS(doc.patch(patch),
|
||||
"[json.exception.out_of_range.411] (/foo/bar) (bytes 14-24) cannot add value: the JSON Patch 'add' target's parent is of type string, but must be an object or array", json::out_of_range);
|
||||
#else
|
||||
CHECK_THROWS_WITH_AS(doc.patch(patch),
|
||||
"[json.exception.out_of_range.411] (bytes 14-24) cannot add value: the JSON Patch 'add' target's parent is of type string, but must be an object or array", json::out_of_range);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@@ -304,8 +304,8 @@ TEST_CASE("Unicode (3/5)" * doctest::skip())
|
||||
{
|
||||
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
|
||||
{
|
||||
// skip fourth second byte
|
||||
if (0x80 <= byte3 && byte3 <= 0xBF)
|
||||
// skip correct fourth byte
|
||||
if (0x80 <= byte4 && byte4 <= 0xBF)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -305,7 +305,7 @@ TEST_CASE("Unicode (4/5)" * doctest::skip())
|
||||
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
|
||||
{
|
||||
// skip correct fourth byte
|
||||
if (0x80 <= byte3 && byte3 <= 0xBF)
|
||||
if (0x80 <= byte4 && byte4 <= 0xBF)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -305,7 +305,7 @@ TEST_CASE("Unicode (5/5)" * doctest::skip())
|
||||
for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
|
||||
{
|
||||
// skip correct fourth byte
|
||||
if (0x80 <= byte3 && byte3 <= 0xBF)
|
||||
if (0x80 <= byte4 && byte4 <= 0xBF)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user