// __ _____ _____ _____ // __| | __| | | | JSON for Modern C++ (supporting code) // | | |__ | | | | | | version 3.12.0 // |_____|_____|_____|_|___| https://github.com/nlohmann/json // // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann // SPDX-License-Identifier: MIT #include "doctest_compatibility.h" #include using nlohmann::json; #include #include #include 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]"); } } 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]"); } } SECTION("dump") { SECTION("invalid character") { const json j = "ä\xA9ü"; CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&); CHECK_THROWS_WITH_AS(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\""); } SECTION("ending with incomplete character") { const json j = "123\xC2"; CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0xC2", json::type_error&); CHECK_THROWS_AS(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\""); } SECTION("unexpected character") { const json j = "123\xF1\xB0\x34\x35\x36"; CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0x34", json::type_error&); CHECK_THROWS_AS(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\""); } 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::min)(); const json j = minimum; CHECK(j.dump() == std::to_string(minimum)); } SECTION("maximum") { constexpr auto maximum = (std::numeric_limits::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::basic_json; SECTION("round-trip dump/parse") { constexpr std::array 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::min)(), std::numeric_limits::lowest(), (std::numeric_limits::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() == 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::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::infinity(); if (!std::isfinite(inf_probe)) { CHECK(long_double_json(std::numeric_limits::infinity()).dump() == "null"); CHECK(long_double_json(-std::numeric_limits::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); } }