| // __ _____ _____ _____ |
| // __| | __| | | | 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" |
| |
| // capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command |
| // line *before* including json.hpp, since the library #undefs it once the header |
| // has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the |
| // tests of deprecated functions are skipped if these functions are deleted |
| #if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) |
| #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED |
| #endif |
| |
| #include <nlohmann/json.hpp> |
| using nlohmann::json; |
| |
| #include <array> |
| #include <sstream> |
| #include <iomanip> |
| |
| #include "test_utils.hpp" |
| |
| TEST_CASE("serialization") |
| { |
| SECTION("operator<<") |
| { |
| SECTION("no given width") |
| { |
| std::stringstream ss; |
| const json j = {"foo", 1, 2, 3, false, {{"one", 1}}}; |
| ss << j; |
| CHECK(ss.str() == "[\"foo\",1,2,3,false,{\"one\":1}]"); |
| } |
| |
| SECTION("given width") |
| { |
| std::stringstream ss; |
| const json j = {"foo", 1, 2, 3, false, {{"one", 1}}}; |
| ss << std::setw(4) << j; |
| CHECK(ss.str() == |
| "[\n \"foo\",\n 1,\n 2,\n 3,\n false,\n {\n \"one\": 1\n }\n]"); |
| } |
| |
| SECTION("given fill") |
| { |
| std::stringstream ss; |
| const json j = {"foo", 1, 2, 3, false, {{"one", 1}}}; |
| ss << std::setw(1) << std::setfill('\t') << j; |
| CHECK(ss.str() == |
| "[\n\t\"foo\",\n\t1,\n\t2,\n\t3,\n\tfalse,\n\t{\n\t\t\"one\": 1\n\t}\n]"); |
| } |
| } |
| |
| #ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED |
| SECTION("operator>>") |
| { |
| SECTION("no given width") |
| { |
| std::stringstream ss; |
| const json j = {"foo", 1, 2, 3, false, {{"one", 1}}}; |
| j >> ss; |
| CHECK(ss.str() == "[\"foo\",1,2,3,false,{\"one\":1}]"); |
| } |
| |
| SECTION("given width") |
| { |
| std::stringstream ss; |
| const json j = {"foo", 1, 2, 3, false, {{"one", 1}}}; |
| ss.width(4); |
| j >> ss; |
| CHECK(ss.str() == |
| "[\n \"foo\",\n 1,\n 2,\n 3,\n false,\n {\n \"one\": 1\n }\n]"); |
| } |
| |
| SECTION("given fill") |
| { |
| std::stringstream ss; |
| const json j = {"foo", 1, 2, 3, false, {{"one", 1}}}; |
| ss.width(1); |
| ss.fill('\t'); |
| j >> ss; |
| CHECK(ss.str() == |
| "[\n\t\"foo\",\n\t1,\n\t2,\n\t3,\n\tfalse,\n\t{\n\t\t\"one\": 1\n\t}\n]"); |
| } |
| } |
| #endif |
| |
| SECTION("dump") |
| { |
| SECTION("invalid character") |
| { |
| const json j = "ä\xA9ü"; |
| |
| // dump() is nodiscard; the exception is thrown by dump() itself before it would return |
| CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&); |
| CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"äü\""); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"ä\xEF\xBF\xBDü\""); |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"\\u00e4\\ufffd\\u00fc\""); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::keep) == "\"ä\xA9ü\""); |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::keep) == "\"\\u00e4\xA9\\u00fc\""); |
| } |
| |
| SECTION("invalid character (regression guard for shared UTF-8 decoder, see #5529)") |
| { |
| // dump_escaped_impl() now calls the UTF-8 decoder shared with the |
| // binary readers (detail::decode() in string_utils.hpp) instead |
| // of a private copy; the exact type_error.316 message/behavior |
| // must stay byte-for-byte the same as before that extraction |
| const json j = "ä\xA9ü"; |
| CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&); |
| } |
| |
| SECTION("ending with incomplete character") |
| { |
| const json j = "123\xC2"; |
| |
| // dump() is nodiscard; the exception is thrown by dump() itself before it would return |
| CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0xC2", json::type_error&); |
| CHECK_THROWS_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), json::type_error&); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"123\""); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"123\xEF\xBF\xBD\""); |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"123\\ufffd\""); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::keep) == "\"123\xC2\""); |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::keep) == "\"123\xC2\""); |
| } |
| |
| SECTION("unexpected character") |
| { |
| const json j = "123\xF1\xB0\x34\x35\x36"; |
| |
| // dump() is nodiscard; the exception is thrown by dump() itself before it would return |
| CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0x34", json::type_error&); |
| CHECK_THROWS_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), json::type_error&); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"123456\""); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"123\xEF\xBF\xBD\x34\x35\x36\""); |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"123\\ufffd456\""); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::keep) == "\"123\xF1\xB0\x34\x35\x36\""); |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::keep) == "\"123\xF1\xB0\x34\x35\x36\""); |
| } |
| |
| SECTION("keep: valid characters are still escaped") |
| { |
| // an invalid byte followed by characters that must be escaped |
| const json j = "\xC2\"\\\n\xFF\x05"; |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::keep) == "\"\xC2\\\"\\\\\\n\xFF\\u0005\""); |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::keep) == "\"\xC2\\\"\\\\\\n\xFF\\u0005\""); |
| } |
| |
| SECTION("keep: truncated multibyte sequences") |
| { |
| CHECK(json("\xF0\x9F\x98").dump(-1, ' ', false, json::error_handler_t::keep) == "\"\xF0\x9F\x98\""); |
| CHECK(json("\xF0\x9F\x98").dump(-1, ' ', true, json::error_handler_t::keep) == "\"\xF0\x9F\x98\""); |
| CHECK(json("\xF0\x9F\x98" "a").dump(-1, ' ', false, json::error_handler_t::keep) == "\"\xF0\x9F\x98" "a\""); |
| CHECK(json("\xF0\x9F\x98" "a").dump(-1, ' ', true, json::error_handler_t::keep) == "\"\xF0\x9F\x98" "a\""); |
| } |
| |
| SECTION("keep: long string with many invalid bytes") |
| { |
| // exceeds the internal string buffer several times |
| std::string input; |
| std::string expected = "\""; |
| for (int i = 0; i < 2000; ++i) |
| { |
| input += "\xFF\xE2\x82\n\xC3\xA4"; |
| expected += "\xFF\xE2\x82\\n\xC3\xA4"; |
| } |
| expected += "\""; |
| const json j = input; |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::keep) == expected); |
| } |
| |
| SECTION("U+FFFD Substitution of Maximal Subparts") |
| { |
| // Some tests (mostly) from |
| // https://www.unicode.org/versions/Unicode11.0.0/ch03.pdf |
| // Section 3.9 -- U+FFFD Substitution of Maximal Subparts |
| |
| auto test = [&](std::string const & input, std::string const & expected) |
| { |
| const json j = input; |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"" + expected + "\""); |
| }; |
| |
| test("\xC2", "\\ufffd"); |
| test("\xC2\x41\x42", "\\ufffd" "\x41" "\x42"); |
| test("\xC2\xF4", "\\ufffd" "\\ufffd"); |
| |
| test("\xF0\x80\x80\x41", "\\ufffd" "\\ufffd" "\\ufffd" "\x41"); |
| test("\xF1\x80\x80\x41", "\\ufffd" "\x41"); |
| test("\xF2\x80\x80\x41", "\\ufffd" "\x41"); |
| test("\xF3\x80\x80\x41", "\\ufffd" "\x41"); |
| test("\xF4\x80\x80\x41", "\\ufffd" "\x41"); |
| test("\xF5\x80\x80\x41", "\\ufffd" "\\ufffd" "\\ufffd" "\x41"); |
| |
| test("\xF0\x90\x80\x41", "\\ufffd" "\x41"); |
| test("\xF1\x90\x80\x41", "\\ufffd" "\x41"); |
| test("\xF2\x90\x80\x41", "\\ufffd" "\x41"); |
| test("\xF3\x90\x80\x41", "\\ufffd" "\x41"); |
| test("\xF4\x90\x80\x41", "\\ufffd" "\\ufffd" "\\ufffd" "\x41"); |
| test("\xF5\x90\x80\x41", "\\ufffd" "\\ufffd" "\\ufffd" "\x41"); |
| |
| test("\xC0\xAF\xE0\x80\xBF\xF0\x81\x82\x41", "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\x41"); |
| test("\xED\xA0\x80\xED\xBF\xBF\xED\xAF\x41", "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\x41"); |
| test("\xF4\x91\x92\x93\xFF\x41\x80\xBF\x42", "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\x41" "\\ufffd""\\ufffd" "\x42"); |
| test("\xE1\x80\xE2\xF0\x91\x92\xF1\xBF\x41", "\\ufffd" "\\ufffd" "\\ufffd" "\\ufffd" "\x41"); |
| } |
| } |
| |
| SECTION("to_string") |
| { |
| auto test = [&](std::string const & input, std::string const & expected) |
| { |
| using std::to_string; |
| const json j = input; |
| CHECK(to_string(j) == "\"" + expected + "\""); |
| }; |
| |
| test(R"({"x":5,"y":6})", R"({\"x\":5,\"y\":6})"); |
| test("{\"x\":[10,null,null,null]}", R"({\"x\":[10,null,null,null]})"); |
| test("test", "test"); |
| test("[3,\"false\",false]", R"([3,\"false\",false])"); |
| } |
| } |
| |
| TEST_CASE_TEMPLATE("serialization for extreme integer values", T, int32_t, uint32_t, int64_t, uint64_t) // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization) |
| { |
| SECTION("minimum") |
| { |
| constexpr auto minimum = (std::numeric_limits<T>::min)(); |
| const json j = minimum; |
| CHECK(j.dump() == std::to_string(minimum)); |
| } |
| |
| SECTION("maximum") |
| { |
| constexpr auto maximum = (std::numeric_limits<T>::max)(); |
| const json j = maximum; |
| CHECK(j.dump() == std::to_string(maximum)); |
| } |
| } |
| |
| TEST_CASE("dump with binary values") |
| { |
| auto binary = json::binary({1, 2, 3, 4}); |
| auto binary_empty = json::binary({}); |
| auto binary_with_subtype = json::binary({1, 2, 3, 4}, 128); |
| auto binary_empty_with_subtype = json::binary({}, 128); |
| |
| const json object = {{"key", binary}}; |
| const json object_empty = {{"key", binary_empty}}; |
| const json object_with_subtype = {{"key", binary_with_subtype}}; |
| const json object_empty_with_subtype = {{"key", binary_empty_with_subtype}}; |
| |
| const json array = {"value", 1, binary}; |
| const json array_empty = {"value", 1, binary_empty}; |
| const json array_with_subtype = {"value", 1, binary_with_subtype}; |
| const json array_empty_with_subtype = {"value", 1, binary_empty_with_subtype}; |
| |
| SECTION("normal") |
| { |
| CHECK(binary.dump() == "{\"bytes\":[1,2,3,4],\"subtype\":null}"); |
| CHECK(binary_empty.dump() == "{\"bytes\":[],\"subtype\":null}"); |
| CHECK(binary_with_subtype.dump() == "{\"bytes\":[1,2,3,4],\"subtype\":128}"); |
| CHECK(binary_empty_with_subtype.dump() == "{\"bytes\":[],\"subtype\":128}"); |
| |
| CHECK(object.dump() == "{\"key\":{\"bytes\":[1,2,3,4],\"subtype\":null}}"); |
| CHECK(object_empty.dump() == "{\"key\":{\"bytes\":[],\"subtype\":null}}"); |
| CHECK(object_with_subtype.dump() == "{\"key\":{\"bytes\":[1,2,3,4],\"subtype\":128}}"); |
| CHECK(object_empty_with_subtype.dump() == "{\"key\":{\"bytes\":[],\"subtype\":128}}"); |
| |
| CHECK(array.dump() == "[\"value\",1,{\"bytes\":[1,2,3,4],\"subtype\":null}]"); |
| CHECK(array_empty.dump() == "[\"value\",1,{\"bytes\":[],\"subtype\":null}]"); |
| CHECK(array_with_subtype.dump() == "[\"value\",1,{\"bytes\":[1,2,3,4],\"subtype\":128}]"); |
| CHECK(array_empty_with_subtype.dump() == "[\"value\",1,{\"bytes\":[],\"subtype\":128}]"); |
| } |
| |
| SECTION("pretty-printed") |
| { |
| CHECK(binary.dump(4) == "{\n" |
| " \"bytes\": [1, 2, 3, 4],\n" |
| " \"subtype\": null\n" |
| "}"); |
| CHECK(binary_empty.dump(4) == "{\n" |
| " \"bytes\": [],\n" |
| " \"subtype\": null\n" |
| "}"); |
| CHECK(binary_with_subtype.dump(4) == "{\n" |
| " \"bytes\": [1, 2, 3, 4],\n" |
| " \"subtype\": 128\n" |
| "}"); |
| CHECK(binary_empty_with_subtype.dump(4) == "{\n" |
| " \"bytes\": [],\n" |
| " \"subtype\": 128\n" |
| "}"); |
| |
| CHECK(object.dump(4) == "{\n" |
| " \"key\": {\n" |
| " \"bytes\": [1, 2, 3, 4],\n" |
| " \"subtype\": null\n" |
| " }\n" |
| "}"); |
| CHECK(object_empty.dump(4) == "{\n" |
| " \"key\": {\n" |
| " \"bytes\": [],\n" |
| " \"subtype\": null\n" |
| " }\n" |
| "}"); |
| CHECK(object_with_subtype.dump(4) == "{\n" |
| " \"key\": {\n" |
| " \"bytes\": [1, 2, 3, 4],\n" |
| " \"subtype\": 128\n" |
| " }\n" |
| "}"); |
| CHECK(object_empty_with_subtype.dump(4) == "{\n" |
| " \"key\": {\n" |
| " \"bytes\": [],\n" |
| " \"subtype\": 128\n" |
| " }\n" |
| "}"); |
| |
| CHECK(array.dump(4) == "[\n" |
| " \"value\",\n" |
| " 1,\n" |
| " {\n" |
| " \"bytes\": [1, 2, 3, 4],\n" |
| " \"subtype\": null\n" |
| " }\n" |
| "]"); |
| CHECK(array_empty.dump(4) == "[\n" |
| " \"value\",\n" |
| " 1,\n" |
| " {\n" |
| " \"bytes\": [],\n" |
| " \"subtype\": null\n" |
| " }\n" |
| "]"); |
| CHECK(array_with_subtype.dump(4) == "[\n" |
| " \"value\",\n" |
| " 1,\n" |
| " {\n" |
| " \"bytes\": [1, 2, 3, 4],\n" |
| " \"subtype\": 128\n" |
| " }\n" |
| "]"); |
| CHECK(array_empty_with_subtype.dump(4) == "[\n" |
| " \"value\",\n" |
| " 1,\n" |
| " {\n" |
| " \"bytes\": [],\n" |
| " \"subtype\": 128\n" |
| " }\n" |
| "]"); |
| } |
| } |
| |
| TEST_CASE("dump for basic_json with long double number_float_t") |
| { |
| // Custom basic_json instantiation with long double as NumberFloatType. |
| // On platforms where long double is wider than double (e.g. GCC/Clang on |
| // Linux/macOS x86_64), dump() goes through the snprintf path in |
| // serializer::dump_float(x, std::false_type). That branch must use the |
| // "%.*Lg" format specifier; using "%.*g" with a long double argument is |
| // undefined behavior and corrupts the output. |
| using long_double_json = nlohmann::json::with_float_t<long double>; |
| |
| SECTION("round-trip dump/parse") |
| { |
| constexpr std::array<long double, 13> values = |
| { |
| { |
| 0.0L, -0.0L, 1.0L, -1.0L, |
| 0.5L, -0.5L, 1.5L, -2.25L, |
| 1.23e45L, 1.23e-45L, |
| (std::numeric_limits<long double>::min)(), |
| std::numeric_limits<long double>::lowest(), |
| (std::numeric_limits<long double>::max)() |
| } |
| }; |
| |
| for (long double v : values) |
| { |
| const long_double_json j = v; |
| const auto s = j.dump(); |
| const auto j2 = long_double_json::parse(s); |
| CHECK(j2.template get<long double>() == v); |
| } |
| } |
| |
| SECTION("exact dump string for simple values") |
| { |
| CHECK(long_double_json(0.5L).dump() == "0.5"); |
| CHECK(long_double_json(-0.5L).dump() == "-0.5"); |
| CHECK(long_double_json(1.5L).dump() == "1.5"); |
| CHECK(long_double_json(-2.25L).dump() == "-2.25"); |
| CHECK(long_double_json(0.0L).dump() == "0.0"); |
| CHECK(long_double_json(1.0L).dump() == "1.0"); |
| CHECK(long_double_json(-1.0L).dump() == "-1.0"); |
| CHECK(long_double_json(100.0L).dump() == "100.0"); |
| } |
| |
| SECTION("NaN and infinity dump as null") |
| { |
| CHECK(long_double_json(std::numeric_limits<long double>::quiet_NaN()).dump() == "null"); |
| |
| // Probe the platform's runtime behavior — `volatile` forces a runtime |
| // call rather than constexpr-folding to a known answer at compile time. |
| // Skip the infinity assertions if std::isfinite() doesn't actually |
| // recognize long double infinity on this platform (notably, Valgrind |
| // 3.22's x87 80-bit emulation reports +/-inf as a large finite value). |
| // TODO(rusloker): remove this guard once Valgrind's 80-bit long double |
| // support ships (Valgrind bug https://bugs.kde.org/show_bug.cgi?id=197915, |
| // ASSIGNED since 2009 — the Valgrind project tracks its bugs on |
| // bugs.kde.org) and the minimum supported Valgrind version contains it. |
| const volatile long double inf_probe = std::numeric_limits<long double>::infinity(); |
| if (!std::isfinite(inf_probe)) |
| { |
| CHECK(long_double_json(std::numeric_limits<long double>::infinity()).dump() == "null"); |
| CHECK(long_double_json(-std::numeric_limits<long double>::infinity()).dump() == "null"); |
| } |
| } |
| |
| SECTION("dump output matches double for exactly-representable values") |
| { |
| auto check_same = [](long double v_ld, double v_d) |
| { |
| const long_double_json j_ld = v_ld; |
| const json j_d = v_d; |
| CHECK(j_ld.dump() == j_d.dump()); |
| }; |
| |
| check_same(0.0L, 0.0); |
| check_same(0.5L, 0.5); |
| check_same(-0.5L, -0.5); |
| check_same(1.5L, 1.5); |
| check_same(-2.25L, -2.25); |
| check_same(1.0L, 1.0); |
| check_same(100.0L, 100.0); |
| } |
| } |
| |
| TEST_CASE("serialization of strings (bulk fast path)") |
| { |
| // These cases exercise the SWAR bulk-copy fast path in dump_escaped and the |
| // internal write buffer: long runs, escapes interrupting runs, 0x7F/DEL, |
| // multibyte UTF-8 under both ensure_ascii settings, and payloads larger than |
| // the write buffer. |
| |
| SECTION("long unescaped ASCII exceeds the write buffer") |
| { |
| const std::string big(3000, 'a'); |
| const json j = big; |
| CHECK(j.dump() == '"' + big + '"'); |
| CHECK(j.dump(-1, ' ', true) == '"' + big + '"'); |
| // round-trips |
| CHECK(json::parse(j.dump()) == j); |
| } |
| |
| SECTION("runs interrupted by escapes") |
| { |
| const json j = std::string(500, 'x') + "\n\"\\" + std::string(500, 'y'); |
| const std::string out = j.dump(); |
| CHECK(out == '"' + std::string(500, 'x') + "\\n\\\"\\\\" + std::string(500, 'y') + '"'); |
| CHECK(json::parse(out) == j); |
| } |
| |
| SECTION("DEL (0x7F) depends on ensure_ascii") |
| { |
| const json j = std::string("a\x7f" "b"); |
| CHECK(j.dump(-1, ' ', false) == "\"a\x7f" "b\""); // copied verbatim |
| CHECK(j.dump(-1, ' ', true) == "\"a\\u007fb\""); // escaped |
| } |
| |
| SECTION("multibyte UTF-8 under both ensure_ascii settings") |
| { |
| const json j = std::string("A\xc3\xa9\xe4\xbd\xa0\xf0\x9f\x98\x80Z"); // A é 你 😀 Z |
| // not escaping non-ASCII: bytes are copied through the bulk validator |
| CHECK(j.dump(-1, ' ', false) == "\"A\xc3\xa9\xe4\xbd\xa0\xf0\x9f\x98\x80Z\""); |
| // ensure_ascii: escaped (with a surrogate pair for the emoji) |
| CHECK(j.dump(-1, ' ', true) == "\"A\\u00e9\\u4f60\\ud83d\\ude00Z\""); |
| CHECK(json::parse(j.dump(-1, ' ', true)) == j); |
| } |
| |
| SECTION("many small structural writes exceed the write buffer") |
| { |
| json arr = json::array(); |
| for (int i = 0; i < 2000; ++i) |
| { |
| arr.push_back(i); |
| } |
| const std::string out = arr.dump(); |
| CHECK(out.front() == '['); |
| CHECK(out.back() == ']'); |
| CHECK(json::parse(out) == arr); |
| |
| json obj = json::object(); |
| for (int i = 0; i < 500; ++i) |
| { |
| obj["key" + std::to_string(i)] = i; |
| } |
| CHECK(json::parse(obj.dump()) == obj); |
| CHECK(json::parse(obj.dump(2)) == obj); |
| |
| // an array of many empty strings emits a long run of single-character |
| // writes ('"', '"', ',') at shallow nesting depth, so the write buffer |
| // fills and flushes mid-run without the deep recursion that would |
| // overflow the stack on some debug builds |
| json many_empty = json::array(); |
| for (int i = 0; i < 500; ++i) |
| { |
| many_empty.push_back(""); |
| } |
| const std::string out2 = many_empty.dump(); |
| CHECK(out2.size() > 1024); // spans multiple write-buffer flushes |
| CHECK(out2.front() == '['); |
| CHECK(out2.back() == ']'); |
| CHECK(json::parse(out2) == many_empty); |
| } |
| |
| SECTION("invalid UTF-8 handling is unaffected by the fast path") |
| { |
| const json j = std::string("valid\xff" "more"); |
| CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0xFF", json::type_error&); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"valid\xef\xbf\xbd" "more\""); |
| CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"valid\\ufffdmore\""); |
| CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"validmore\""); |
| } |
| } |
| |
| TEST_CASE("indentation is written straight into the write buffer") |
| { |
| // put_indent() memsets the indentation into the write buffer instead of |
| // copying it out of a pre-grown indentation string. These cases cover an |
| // indentation wider than the buffer, a non-space indentation character, and |
| // nesting deep enough that the accumulated indentation spans several |
| // buffer-fulls - the situations the old grow-a-string approach got wrong. |
| |
| SECTION("indent_step wider than the write buffer") |
| { |
| const json j = {{"a", 1}}; |
| // 2000 > the 1024-byte write buffer, and > the 512 the indentation |
| // string used to start at |
| CHECK(j.dump(2000) == "{\n" + std::string(2000, ' ') + "\"a\": 1\n}"); |
| // several whole buffer-fulls, so the buffer is refilled once and then |
| // flushed repeatedly |
| CHECK(j.dump(5000) == "{\n" + std::string(5000, ' ') + "\"a\": 1\n}"); |
| CHECK(j.dump(5000, '\t') == "{\n" + std::string(5000, '\t') + "\"a\": 1\n}"); |
| // an exact multiple of the buffer size |
| CHECK(j.dump(4096) == "{\n" + std::string(4096, ' ') + "\"a\": 1\n}"); |
| } |
| |
| SECTION("a non-space indentation character is used throughout") |
| { |
| const json j = {{"a", 1}}; |
| // 600 is past the point where the indentation used to be grown, which |
| // is where a hard-coded space would have shown up |
| CHECK(j.dump(600, '\t') == "{\n" + std::string(600, '\t') + "\"a\": 1\n}"); |
| CHECK(j.dump(3, '.') == "{\n...\"a\": 1\n}"); |
| } |
| |
| SECTION("accumulated indentation spans several buffer-fulls") |
| { |
| // five levels deep at 400 per level: the innermost value is indented by |
| // 2000 characters, reached in steps that each straddle the buffer end |
| json j = json::array({1}); |
| for (int i = 0; i < 4; ++i) |
| { |
| j = json::array({j}); |
| } |
| |
| const std::string out = j.dump(400); |
| CHECK(out.find(std::string("\n") + std::string(2000, ' ') + "1\n") != std::string::npos); |
| CHECK(json::parse(out) == j); |
| } |
| |
| SECTION("binary values are indented the same way") |
| { |
| // a binary value is serialized as an object with "bytes" and |
| // "subtype" keys; the byte array itself is always written compactly |
| // (see dump_byte()), so only the surrounding object's indentation |
| // goes through put_indent() |
| const json j = json::binary({1, 2, 3}, 128); |
| CHECK(j.dump(2000) == "{\n" + std::string(2000, ' ') + "\"bytes\": [1, 2, 3],\n" |
| + std::string(2000, ' ') + "\"subtype\": 128\n}"); |
| CHECK(j.dump(2000, '\t') == "{\n" + std::string(2000, '\t') + "\"bytes\": [1, 2, 3],\n" |
| + std::string(2000, '\t') + "\"subtype\": 128\n}"); |
| } |
| |
| SECTION("indentation is unchanged for ordinary widths") |
| { |
| const json j = {{"a", {1, 2}}, {"b", nullptr}}; |
| CHECK(j.dump(2) == "{\n \"a\": [\n 1,\n 2\n ],\n \"b\": null\n}"); |
| CHECK(j.dump(0) == "{\n\"a\": [\n1,\n2\n],\n\"b\": null\n}"); |
| } |
| } |
| |
| TEST_CASE("serialization of deeply nested values") |
| { |
| // dump() descends into a bounded number of levels and writes out whatever |
| // is nested deeper than that without the call stack; see |
| // https://github.com/nlohmann/json/issues/5387 |
| |
| SECTION("nested deeper than the call stack could follow") |
| { |
| // parsing is iterative, so building these costs little |
| const std::size_t depth = 100000; |
| |
| const std::string array_text = std::string(depth, '[') + '0' + std::string(depth, ']'); |
| CHECK(json::parse(array_text).dump() == array_text); |
| |
| std::string object_text; |
| object_text.reserve((6 * depth) + 1); |
| for (std::size_t i = 0; i < depth; ++i) |
| { |
| object_text += "{\"a\":"; |
| } |
| object_text += '1'; |
| object_text.append(depth, '}'); |
| CHECK(json::parse(object_text).dump() == object_text); |
| } |
| |
| SECTION("depths around the bound of the descent") |
| { |
| // Cover every depth around the bound, so that the two ways of writing a |
| // value are known to meet cleanly - wherever the bound is set. |
| for (std::size_t d = 1; d <= 300; ++d) |
| { |
| CAPTURE(d) |
| |
| const std::string array_text = std::string(d, '[') + '7' + std::string(d, ']'); |
| CHECK(json::parse(array_text).dump() == array_text); |
| |
| std::string object_text; |
| for (std::size_t i = 0; i < d; ++i) |
| { |
| object_text += "{\"k\":"; |
| } |
| object_text += '7'; |
| object_text.append(d, '}'); |
| CHECK(json::parse(object_text).dump() == object_text); |
| } |
| } |
| |
| SECTION("pretty-printing across the bound") |
| { |
| for (std::size_t d = 120; d <= 140; ++d) |
| { |
| CAPTURE(d) |
| |
| const json j = json::parse(std::string(d, '[') + '7' + std::string(d, ']')); |
| |
| std::string expected; |
| for (std::size_t i = 0; i < d; ++i) |
| { |
| expected += std::string(2 * i, ' ') + "[\n"; |
| } |
| expected += std::string(2 * d, ' ') + '7'; |
| for (std::size_t i = d; i > 0; --i) |
| { |
| expected += '\n' + std::string(2 * (i - 1), ' ') + ']'; |
| } |
| |
| CHECK(j.dump(2) == expected); |
| } |
| } |
| |
| SECTION("an empty container below the bound") |
| { |
| // an empty container is written out in full and never descended into, |
| // so it must not gain a newline when it is reached iteratively |
| for (std::size_t d = 125; d <= 135; ++d) |
| { |
| CAPTURE(d) |
| |
| const std::string compact = std::string(d, '[') + "[]" + std::string(d, ']'); |
| CHECK(json::parse(compact).dump() == compact); |
| |
| const std::string with_object = std::string(d, '[') + "{}" + std::string(d, ']'); |
| CHECK(json::parse(with_object).dump() == with_object); |
| } |
| } |
| } |
| |
| namespace |
| { |
| // wraps @a inner into @a depth single-element arrays |
| json wrap_in_arrays(const json& inner, const std::size_t depth) |
| { |
| json j = inner; |
| for (std::size_t i = 0; i < depth; ++i) |
| { |
| j = json::array({std::move(j)}); |
| } |
| return j; |
| } |
| |
| // what wrap_in_arrays(inner, depth).dump(2) is expected to be: the arrays |
| // around inner.dump(2), with inner's own lines indented by the depth |
| std::string expected_pretty_in_arrays(const json& inner, const std::size_t depth) |
| { |
| std::string expected; |
| for (std::size_t i = 0; i < depth; ++i) |
| { |
| expected += std::string(2 * i, ' ') + "[\n"; |
| } |
| |
| const std::string indent(2 * depth, ' '); |
| expected += indent; |
| for (const char c : inner.dump(2)) |
| { |
| expected += c; |
| if (c == '\n') |
| { |
| expected += indent; |
| } |
| } |
| |
| for (std::size_t i = depth; i > 0; --i) |
| { |
| expected += '\n' + std::string(2 * (i - 1), ' ') + ']'; |
| } |
| return expected; |
| } |
| } // namespace |
| |
| TEST_CASE("serialization of every kind of value below the bound of the descent") |
| { |
| // Values nested deeper than the bound are written without the call stack, |
| // by code of their own; each kind of value must come out the same there as |
| // it does at the top level, compact and pretty-printed. |
| std::vector<json> values = |
| { |
| json::parse(R"({"a": 1, "b": [1, 2, {"c": "x"}], "d": {}, "e": []})"), |
| json::parse(R"([1, [2, 3], {"k": null}, "s"])"), |
| json::object(), |
| json::array(), |
| json::binary({1, 2, 3}, 42), |
| json::binary({1, 2, 3}), |
| json::binary({}, 7), |
| json::binary({}), |
| "a string with \"escapes\"\n", |
| true, |
| false, |
| -42, |
| 42u, |
| 1.5, |
| nullptr, |
| json(json::value_t::discarded), |
| }; |
| // a pretty-printed object whose members are themselves deep |
| values.push_back({{"x", wrap_in_arrays(1, 5)}, {"y", {{"z", 2}}}}); |
| |
| for (const std::size_t depth : std::vector<std::size_t> {1, 200}) |
| { |
| CAPTURE(depth) |
| for (const auto& inner : values) |
| { |
| CAPTURE(inner.dump()) |
| const json j = wrap_in_arrays(inner, depth); |
| CHECK(j.dump() == std::string(depth, '[') + inner.dump() + std::string(depth, ']')); |
| CHECK(j.dump(2) == expected_pretty_in_arrays(inner, depth)); |
| } |
| } |
| |
| SECTION("pretty-printed objects across the bound") |
| { |
| for (std::size_t d = 120; d <= 140; ++d) |
| { |
| CAPTURE(d) |
| |
| // built from the inside out: {"k": <level below>, "n": <level>} |
| json j = 7; |
| std::string expected = "7"; |
| for (std::size_t i = d; i > 0; --i) |
| { |
| j = json({{"k", std::move(j)}, {"n", i}}); |
| |
| const std::string indent(2 * i, ' '); |
| const std::string outer_indent(2 * (i - 1), ' '); |
| std::string next = "{\n"; |
| next += indent; |
| next += "\"k\": "; |
| next += expected; |
| next += ",\n"; |
| next += indent; |
| next += "\"n\": "; |
| next += std::to_string(i); |
| next += '\n'; |
| next += outer_indent; |
| next += '}'; |
| expected = std::move(next); |
| } |
| |
| CHECK(j.dump(2) == expected); |
| CHECK(json::parse(j.dump(2)) == j); |
| CHECK(json::parse(j.dump()) == j); |
| } |
| } |
| } |
| |
| TEST_CASE("serializer buffers are flushed mid-string and mid-binary") |
| { |
| SECTION("a long run of escaped characters") |
| { |
| // each character is escaped on its own, so the escape buffer fills up |
| const json newlines = std::string(600, '\n'); |
| std::string expected = "\""; |
| for (int i = 0; i < 600; ++i) |
| { |
| expected += "\\n"; |
| } |
| expected += '"'; |
| CHECK(newlines.dump() == expected); |
| |
| // every character is \u-escaped under ensure_ascii |
| std::string umlauts; |
| std::string escaped_umlauts = "\""; |
| for (int i = 0; i < 300; ++i) |
| { |
| umlauts += "\xC3\xA4"; |
| escaped_umlauts += "\\u00e4"; |
| } |
| escaped_umlauts += '"'; |
| CHECK(json(umlauts).dump(-1, ' ', true) == escaped_umlauts); |
| } |
| |
| SECTION("a large binary value") |
| { |
| std::vector<std::uint8_t> bytes(3000); |
| std::string expected_bytes; |
| std::string expected_pretty_bytes; |
| for (std::size_t i = 0; i < bytes.size(); ++i) |
| { |
| bytes[i] = static_cast<std::uint8_t>(i % 256); |
| expected_bytes += (i == 0 ? "" : ",") + std::to_string(i % 256); |
| expected_pretty_bytes += (i == 0 ? "" : ", ") + std::to_string(i % 256); |
| } |
| const json j = json::binary(bytes); |
| CHECK(j.dump() == "{\"bytes\":[" + expected_bytes + "],\"subtype\":null}"); |
| CHECK(j.dump(2) == "{\n \"bytes\": [" + expected_pretty_bytes + "],\n \"subtype\": null\n}"); |
| } |
| } |
| |
| TEST_CASE("serialization boundary values for the write buffer") |
| { |
| // write_buffer is a std::array<char, 1024> (write_buffer_size). put_string() |
| // guards it with two checks, and each must be exercised exactly on and one |
| // past its own boundary: a heap overflow in a different manual buffer path |
| // (the dump(1100) indent buffer) once survived 100% line coverage because |
| // every test that touched it only ever grew the buffer by a single step, |
| // never landing on the exact edge of the comparison that protects it. |
| // |
| // - straight-through: put_string() bypasses write_buffer entirely and |
| // writes directly to the output adapter once `length >= write_buffer.size()`. |
| // - flush-then-copy: otherwise, if `write_buffer_pos + length > write_buffer.size()`, |
| // put_string() flushes what is pending and then memcpy's the new run into |
| // the freshly emptied buffer. |
| |
| SECTION("top-level string exercises the straight-through guard (length >= 1024)") |
| { |
| // dump() of a bare string writes the opening quote with put_char() |
| // (write_buffer_pos: 0 -> 1), then the body with put_string(). With |
| // write_buffer_pos == 1, `1 + length > 1024` and `length >= 1024` flip |
| // together at length 1024, so 1023/1024/1025 cover "just under", |
| // "exactly at" and "just over" the guard in one move: 1023 is copied |
| // into the buffer (filling it exactly), 1024 and 1025 bypass it. |
| for (const std::size_t len : |
| { |
| std::size_t{1023}, std::size_t{1024}, std::size_t{1025} |
| }) |
| { |
| CAPTURE(len) |
| const std::string body(len, 'a'); |
| const json j = body; |
| const std::string expected = '"' + body + '"'; |
| |
| CHECK(j.dump() == expected); |
| |
| std::ostringstream o; |
| o << j; |
| CHECK(o.str() == expected); |
| } |
| } |
| |
| SECTION("string nested in an array exercises the flush-then-copy guard") |
| { |
| // json::array({body}) writes '[' then '"' before the body, so |
| // write_buffer_pos == 2 when put_string() is entered for it. The |
| // body's last byte then lands at logical offset 2 + len: len == 1022 |
| // lands exactly on offset 1024 (2 + 1022 == write_buffer.size(), so the |
| // strict "> " guard does not fire and the body fits snugly), while |
| // len == 1023 lands one past it at offset 1025 (2 + 1023 > 1024), |
| // which must flush what's pending before copying the body in. |
| for (const std::size_t len : |
| { |
| std::size_t{1022}, std::size_t{1023} |
| }) |
| { |
| CAPTURE(len) |
| const std::string body(len, 'a'); |
| const json j = json::array({body}); |
| const std::string expected = "[\"" + body + "\"]"; |
| |
| CHECK(j.dump() == expected); |
| |
| std::ostringstream o; |
| o << j; |
| CHECK(o.str() == expected); |
| |
| CHECK(json::parse(j.dump()) == j); |
| } |
| } |
| } |
| |
| TEST_CASE("serialization boundary values for the string buffer") |
| { |
| // string_buffer is a std::array<char, 512>. dump_escaped_impl() flushes it |
| // mid-string once fewer than 13 bytes remain (`string_buffer.size() - bytes |
| // < 13`), 13 being one more than the most a single code point can ever |
| // write at once (a surrogate pair: two back-to-back "\uXXXX" escapes, 12 |
| // bytes). Every write into string_buffer that this check protects happens |
| // in steps of 2 (a simple "\\x" escape) or 6 (one "\uXXXX" unit), so |
| // `bytes` only ever takes even values at the point the check runs - the |
| // tightest values actually reachable are therefore 498 (512 - 498 == 14, |
| // one simple escape away from the threshold) and 500 (512 - 500 == 12, |
| // where the flush fires immediately and resets bytes to 0). |
| |
| SECTION("a run of 2-byte escapes lands bytes on, and one step past, the flush threshold") |
| { |
| for (const int count : |
| { |
| 249, 250, 251 |
| }) |
| { |
| CAPTURE(count) |
| const json j = std::string(static_cast<std::size_t>(count), '\n'); |
| std::string expected = "\""; |
| for (int i = 0; i < count; ++i) |
| { |
| expected += "\\n"; |
| } |
| expected += '"'; |
| CHECK(j.dump() == expected); |
| } |
| } |
| |
| SECTION("an ASCII prefix leaves the tightest reachable margin before a 12-byte surrogate pair") |
| { |
| // U+1F600 (the "\xF0\x9F\x98\x80" UTF-8 bytes) is dumped under |
| // ensure_ascii as the 12-byte surrogate pair "\ud83d\ude00"; that |
| // write happens in a single step with no intermediate flush check, so |
| // it is the write most exposed by an off-by-one in the "< 13" guard. |
| // A prefix of 249 newlines leaves exactly 14 bytes of headroom |
| // (512 - 498), the smallest margin the guard ever actually allows |
| // into a new code point; 250 newlines instead trigger the guard's own |
| // flush first, so the emoji starts from a freshly emptied (512-byte) |
| // buffer, and 251 repeats that with one more escape already past the |
| // reset. Together they cover the margin the guard allows landing on, |
| // one step before, and one step after - all must still produce the |
| // identical, correct escapes. |
| for (const int prefix_count : |
| { |
| 249, 250, 251 |
| }) |
| { |
| CAPTURE(prefix_count) |
| const std::string prefix(static_cast<std::size_t>(prefix_count), '\n'); |
| const std::string emoji = "\xF0\x9F\x98\x80"; |
| const json j = prefix + emoji; |
| |
| std::string expected_prefix; |
| for (int i = 0; i < prefix_count; ++i) |
| { |
| expected_prefix += "\\n"; |
| } |
| |
| // newline escaping does not depend on ensure_ascii: only the |
| // emoji differs (raw UTF-8 bytes vs. a \u-escaped surrogate pair) |
| std::string expected_raw = "\""; |
| expected_raw += expected_prefix; |
| expected_raw += emoji; |
| expected_raw += '"'; |
| std::string expected_ascii = "\""; |
| expected_ascii += expected_prefix; |
| expected_ascii += R"(\ud83d\ude00")"; |
| CHECK(j.dump(-1, ' ', false) == expected_raw); |
| CHECK(j.dump(-1, ' ', true) == expected_ascii); |
| CHECK(json::parse(j.dump(-1, ' ', true)) == j); |
| CHECK(json::parse(j.dump(-1, ' ', false)) == j); |
| } |
| } |
| |
| SECTION("SWAR bulk-copy stride: k plain bytes followed by a byte handled individually") |
| { |
| // string_bulk_run()/find_ascii_copyable_run() (string_scan.hpp) scan 8 |
| // bytes at a time and fall back to a byte-at-a-time tail scan for |
| // what is left over. k from 0 to 17 spans zero, one and two full |
| // 8-byte strides plus a 1-byte tail, so every possible stopping point |
| // within and right after the SIMD stride is covered. |
| for (std::size_t k = 0; k <= 17; ++k) |
| { |
| CAPTURE(k) |
| const std::string prefix(k, 'a'); |
| |
| // (a) the run is stopped by a quote that must itself be escaped |
| { |
| const json j = prefix + "\""; |
| CHECK(j.dump() == '"' + prefix + "\\\"" + '"'); |
| } |
| |
| // (b) the run is stopped by a control character |
| { |
| const json j = prefix + "\x01"; |
| CHECK(j.dump() == '"' + prefix + "\\u0001" + '"'); |
| } |
| |
| // (c) the run is stopped by a non-ASCII byte under ensure_ascii |
| { |
| const json j = prefix + "\xC3\xA9"; // prefix + 'é' |
| CHECK(j.dump(-1, ' ', true) == '"' + prefix + "\\u00e9" + '"'); |
| } |
| } |
| } |
| } |
