tests/src/unit-serialization.cpp - third_party/json - Git at Google

 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  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"

 #include <nlohmann/json.hpp>
 using nlohmann::json;

 #include <array>
 #include <sstream>
 #include <iomanip>

 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<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::basic_json<std::map, std::vector, std::string,
           bool, std::int64_t, std::uint64_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);
     }
 }
	// __ _____ _____ _____
	// __\| \| __\| \| \| \| 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"

	#include <nlohmann/json.hpp>
	using nlohmann::json;

	#include <array>
	#include <sstream>
	#include <iomanip>

	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<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::basic_json<std::map, std::vector, std::string,
	bool, std::int64_t, std::uint64_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);
	}
	}