Add test coverage for ordered_json/alt_json across binary formats and patch/diff/flatten APIs

Closes a test-coverage gap from #5421: ordered_json (and the alt_string-based basic_json specialization from unit-alt-string.cpp) were never round-tripped through the binary formats (CBOR/MessagePack/UBJSON/BSON/BJData), nor through flatten()/unflatten(), diff()/patch()/patch_inplace(), or merge_patch(). Also adds a std::formatter<ordered_json> spot-check, mirroring the precedent set by the format_as() ADL-deduction test. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-09-06 08:17:59 +00:00 · 2026-09-05 20:53:09 +02:00
7 changed files with 2504 additions and 297 deletions
@@ -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
@@ -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
    #define JSON_DIAGNOSTICS 1
 #endif
 #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
    }
 }
@@ -0,0 +1,489 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  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-FileCopyrightText: 2018 Vitaliy Manushkin <agri@akamo.info>
 // SPDX-License-Identifier: MIT
 // This file closes a test-coverage gap described in GitHub issue #5421:
 // nlohmann::ordered_json (and other non-default basic_json specializations,
 // such as the alt_string-based one from unit-alt-string.cpp) were never
 // exercised through the binary formats (CBOR/MessagePack/UBJSON/BSON/BJData)
 // or through flatten()/unflatten()/diff()/patch()/merge_patch().
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 #include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>
 using nlohmann::json;
 using nlohmann::ordered_json;
 /////////////////////////////////////////////////////////////////////////////
 // alt_json: a second, independent copy of the custom-string_t basic_json
 // specialization defined in unit-alt-string.cpp.
 //
 // It is duplicated here (rather than shared via a header) because every
 // unit-*.cpp file in this test suite is compiled into its own standalone
 // executable (see tests/CMakeLists.txt), so there is no ODR concern in
 // having the same class name defined in multiple translation units.
 //
 // Two members had to be added relative to the original alt_string
 // (a constructor from std::string, and a find(char, pos) overload) because
 // the original type was never used with the binary writers/readers before
 // this file: BSON's array/document writer converts std::to_string() results
 // and checks for embedded NUL characters via find(char), and the UBJSON/BSON
 // high-precision-number path constructs the SAX string_t argument from a
 // std::string. Neither path is exercised anywhere else in the test suite for
 // this type, which is presumably why the gap was never noticed.
 /////////////////////////////////////////////////////////////////////////////
 class alt_string;
 bool operator<(const char* op1, const alt_string& op2) noexcept; // NOLINT(misc-use-internal-linkage)
 void int_to_string(alt_string& target, std::size_t value); // NOLINT(misc-use-internal-linkage)
 class alt_string
 {
  public:
    using value_type = std::string::value_type;
    static constexpr auto npos = (std::numeric_limits<std::size_t>::max)();
    alt_string(const char* str): str_impl(str) {}
    alt_string(const char* str, std::size_t count): str_impl(str, count) {}
    alt_string(const std::string& str): str_impl(str) {}
    alt_string(size_t count, char chr): str_impl(count, chr) {}
    alt_string() = default;
    alt_string& append(char ch)
    {
        str_impl.push_back(ch);
        return *this;
    }
    alt_string& append(const alt_string& str)
    {
        str_impl.append(str.str_impl);
        return *this;
    }
    alt_string& append(const char* s, std::size_t length)
    {
        str_impl.append(s, length);
        return *this;
    }
    void push_back(char c)
    {
        str_impl.push_back(c);
    }
    template <typename op_type>
    bool operator==(const op_type& op) const
    {
        return str_impl == op;
    }
    bool operator==(const alt_string& op) const
    {
        return str_impl == op.str_impl;
    }
    template <typename op_type>
    bool operator!=(const op_type& op) const
    {
        return str_impl != op;
    }
    bool operator!=(const alt_string& op) const
    {
        return str_impl != op.str_impl;
    }
    std::size_t size() const noexcept
    {
        return str_impl.size();
    }
    void resize(std::size_t n)
    {
        str_impl.resize(n);
    }
    void resize(std::size_t n, char c)
    {
        str_impl.resize(n, c);
    }
    template <typename op_type>
    bool operator<(const op_type& op) const noexcept
    {
        return str_impl < op;
    }
    bool operator<(const alt_string& op) const noexcept
    {
        return str_impl < op.str_impl;
    }
    const char* c_str() const
    {
        return str_impl.c_str();
    }
    char& operator[](std::size_t index)
    {
        return str_impl[index];
    }
    const char& operator[](std::size_t index) const
    {
        return str_impl[index];
    }
    char& back()
    {
        return str_impl.back();
    }
    const char& back() const
    {
        return str_impl.back();
    }
    void clear()
    {
        str_impl.clear();
    }
    const value_type* data() const
    {
        return str_impl.data();
    }
    bool empty() const
    {
        return str_impl.empty();
    }
    std::size_t find(const alt_string& str, std::size_t pos = 0) const
    {
        return str_impl.find(str.str_impl, pos);
    }
    // needed by binary_writer's BSON support, which probes string keys for
    // embedded NUL characters via find(char)
    std::size_t find(char c, std::size_t pos = 0) const
    {
        return str_impl.find(c, pos);
    }
    std::size_t find_first_of(char c, std::size_t pos = 0) const
    {
        return str_impl.find_first_of(c, pos);
    }
    alt_string substr(std::size_t pos = 0, std::size_t count = npos) const
    {
        const std::string s = str_impl.substr(pos, count);
        return {s.data(), s.size()};
    }
    alt_string& replace(std::size_t pos, std::size_t count, const alt_string& str)
    {
        str_impl.replace(pos, count, str.str_impl);
        return *this;
    }
    void reserve(std::size_t new_cap = 0)
    {
        str_impl.reserve(new_cap);
    }
  private:
    std::string str_impl {}; // NOLINT(readability-redundant-member-init)
    friend bool operator<(const char* /*op1*/, const alt_string& /*op2*/) noexcept;
 };
 void int_to_string(alt_string& target, std::size_t value)
 {
    target = std::to_string(value).c_str();
 }
 using alt_json = nlohmann::basic_json <
                 std::map,
                 std::vector,
                 alt_string,
                 bool,
                 std::int64_t,
                 std::uint64_t,
                 double,
                 std::allocator,
                 nlohmann::adl_serializer >;
 bool operator<(const char* op1, const alt_string& op2) noexcept
 {
    return op1 < op2.str_impl;
 }
 namespace
 {
 // collects the object keys of j, in iteration order
 std::vector<std::string> collect_keys(const ordered_json& j)
 {
    std::vector<std::string> result;
    for (auto it = j.cbegin(); it != j.cend(); ++it)
    {
        result.push_back(it.key());
    }
    return result;
 }
 // a nested object/array value with keys inserted in non-alphabetical order,
 // used to check both round-trip equality and (for ordered_json) that
 // insertion order survives a trip through a binary format
 ordered_json make_rich_ordered_json()
 {
    ordered_json j;
    j["zebra"] = 1;
    j["apple"] = ordered_json::array({1, 2, 3});
    j["mango"]["z_nested"] = true;
    j["mango"]["a_nested"] = nullptr;
    j["banana"] = "some text";
    j["cherry"] = 3.14;
    return j;
 }
 alt_json make_rich_alt_json()
 {
    alt_json j;
    j["zebra"] = 1;
    j["apple"] = alt_json::array({1, 2, 3});
    j["mango"]["z_nested"] = true;
    j["mango"]["a_nested"] = nullptr;
    j["banana"] = "some text";
    j["cherry"] = 3.14;
    return j;
 }
 } // namespace
 TEST_CASE("ordered_json across binary formats")
 {
    const ordered_json original = make_rich_ordered_json();
    const std::vector<std::string> original_keys = collect_keys(original);
    const std::vector<std::string> original_mango_keys = collect_keys(original["mango"]);
    SECTION("CBOR")
    {
        const auto bytes = ordered_json::to_cbor(original);
        const auto restored = ordered_json::from_cbor(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
    SECTION("MessagePack")
    {
        const auto bytes = ordered_json::to_msgpack(original);
        const auto restored = ordered_json::from_msgpack(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
    SECTION("UBJSON")
    {
        const auto bytes = ordered_json::to_ubjson(original);
        const auto restored = ordered_json::from_ubjson(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
    SECTION("BSON")
    {
        const auto bytes = ordered_json::to_bson(original);
        const auto restored = ordered_json::from_bson(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
    SECTION("BJData")
    {
        const auto bytes = ordered_json::to_bjdata(original);
        const auto restored = ordered_json::from_bjdata(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
 }
 TEST_CASE("alt_json (custom string_t) across binary formats")
 {
    const alt_json original = make_rich_alt_json();
    SECTION("CBOR")
    {
        const auto bytes = alt_json::to_cbor(original);
        const auto restored = alt_json::from_cbor(bytes);
        CHECK(restored == original);
    }
    SECTION("MessagePack")
    {
        const auto bytes = alt_json::to_msgpack(original);
        const auto restored = alt_json::from_msgpack(bytes);
        CHECK(restored == original);
    }
    SECTION("UBJSON")
    {
        const auto bytes = alt_json::to_ubjson(original);
        const auto restored = alt_json::from_ubjson(bytes);
        CHECK(restored == original);
    }
    SECTION("BSON")
    {
        const auto bytes = alt_json::to_bson(original);
        const auto restored = alt_json::from_bson(bytes);
        CHECK(restored == original);
    }
    SECTION("BJData")
    {
        const auto bytes = alt_json::to_bjdata(original);
        const auto restored = alt_json::from_bjdata(bytes);
        CHECK(restored == original);
    }
 }
 TEST_CASE("ordered_json operator== is sensitive to key order")
 {
    // Unlike nlohmann::json (whose object_t is a std::map, so equality never
    // depends on insertion order), ordered_json's object_t (ordered_map) is a
    // std::vector<std::pair<Key, T>> under the hood, and does not define its
    // own operator==: it inherits std::vector's element-wise comparison. As a
    // result, two ordered_json objects holding the very same key/value pairs
    // in different insertion order compare *unequal*. This is the property
    // that makes the round-trip `CHECK(restored == original)` checks above a
    // meaningful order-preservation check by themselves (the explicit
    // collect_keys() comparisons make that check explicit/readable, and
    // guard against this operator== behavior ever changing).
    ordered_json a;
    a["x"] = 1;
    a["y"] = 2;
    ordered_json b;
    b["y"] = 2;
    b["x"] = 1;
    CHECK(a.size() == b.size());
    CHECK(a["x"] == b["x"]);
    CHECK(a["y"] == b["y"]);
    CHECK_FALSE(a == b);
 }
 TEST_CASE("duplicate keys in a binary-encoded object")
 {
    // CBOR encoding of a map with two entries under the same key "a": {"a": 1, "a": 2}
    const std::vector<std::uint8_t> cbor_bytes
    {
        0xA2, 0x61, 'a', 0x01, 0x61, 'a', 0x02
    };
    // Both json (std::map, via operator[]) and ordered_json (ordered_map, via
    // operator[]) build binary-decoded objects by looking up/creating the
    // entry for each incoming key and then assigning the value into it. This
    // means a repeated key does *not* produce two entries in either case;
    // instead, the *first* occurrence's position is kept (relevant only for
    // ordered_json) while the *last* occurrence's value wins (for both) --
    // this matches operator[]'s "assign the referenced slot" semantics, and
    // is worth noting because it differs from the initializer-list
    // construction path (`ordered_json{{"a",1},{"a",2}}`), which builds
    // through insert()/emplace() and therefore keeps the *first* value, not
    // the last (see the "There are no dup keys..." case in
    // unit-ordered_json.cpp).
    const auto j = json::from_cbor(cbor_bytes);
    const auto oj = ordered_json::from_cbor(cbor_bytes);
    CHECK(j.size() == 1);
    CHECK(oj.size() == 1);
    CHECK(j["a"] == 2);
    CHECK(oj["a"] == 2);
    CHECK(j == json(oj));
 }
 TEST_CASE("ordered_json through flatten/unflatten")
 {
    const ordered_json original = make_rich_ordered_json();
    const std::vector<std::string> original_keys = collect_keys(original);
    const std::vector<std::string> original_mango_keys = collect_keys(original["mango"]);
    const ordered_json flat = original.flatten();
    const ordered_json unflattened = flat.unflatten();
    CHECK(unflattened == original);
    // flatten() walks the value depth-first in iteration order and
    // unflatten() re-inserts each flattened key via operator[] in the flat
    // object's iteration order, so for ordered_json the original key order
    // (both top-level and nested) is preserved end-to-end.
    CHECK(collect_keys(unflattened) == original_keys);
    CHECK(collect_keys(unflattened["mango"]) == original_mango_keys);
 }
 TEST_CASE("ordered_json through diff/patch/patch_inplace")
 {
    ordered_json original;
    original["one"] = 1;
    original["two"] = 2;
    original["three"] = 3;
    ordered_json target = original;
    target["one"] = 100;      // replace
    target.erase("two");      // remove
    target["four"] = 4;       // add
    const ordered_json patch = ordered_json::diff(original, target);
    SECTION("patch")
    {
        const ordered_json patched = original.patch(patch);
        CHECK(patched == target);
    }
    SECTION("patch_inplace")
    {
        ordered_json copy = original;
        copy.patch_inplace(patch);
        CHECK(copy == target);
    }
 }
 TEST_CASE("ordered_json through merge_patch")
 {
    ordered_json original;
    original["a"] = 1;
    original["b"] = 2;
    const ordered_json patch = {{"b", nullptr}, {"c", 3}};
    original.merge_patch(patch);
    ordered_json expected;
    expected["a"] = 1;
    expected["c"] = 3;
    CHECK(original == expected);
    CHECK(collect_keys(original) == collect_keys(expected));
 }
@@ -17,6 +17,7 @@
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 using ordered_json = nlohmann::ordered_json;
 // JSON_HAS_CPP_20 (do not remove; see note at top of file)
 #if JSON_HAS_STD_FORMAT
@@ -93,4 +94,16 @@ TEST_CASE("std::formatter<nlohmann::json>")
    }
 }
 TEST_CASE("std::formatter<nlohmann::ordered_json>")
 {
    // spot-check a non-default basic_json instantiation, since the formatter
    // is written against the generic NLOHMANN_BASIC_JSON_TPL_DECLARATION
    // template and must actually instantiate (and behave correctly) for
    // template arguments other than nlohmann::json
    const ordered_json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
    CHECK(std::format("{}", j) == j.dump());
    CHECK(std::format("{:#}", j) == j.dump(4));
    CHECK(std::format("{:2}", j) == j.dump(2));
 }
 #endif