Pass alt_string's std::string constructor argument by value (clang-tidy modernize-pass-by-value)

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Add test coverage for ordered_json/alt_json across binary formats and patch/diff/flatten APIs
2026-09-07 16:57:59 +00:00 · 2026-09-06 11:20:08 +02:00 · 2026-09-05 20:53:09 +02:00
11 changed files with 504 additions and 378 deletions
@@ -100,7 +100,7 @@ jobs:
    container: ubuntu:focal
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_skiplibraryversioncheck]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git libssl-dev
@@ -242,40 +242,6 @@ add_custom_target(ci_test_noglobaludls
    COMMENT "Compile and test with global UDLs disabled"
 )
 ###############################################################################
 # Disable enum serialization.
 ###############################################################################
 add_custom_target(ci_test_disableenumserialization
    COMMAND ${CMAKE_COMMAND}
    -DCMAKE_BUILD_TYPE=Debug -GNinja
    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DisableEnumSerialization=ON
    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_disableenumserialization
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_disableenumserialization
    COMMAND cd ${PROJECT_BINARY_DIR}/build_disableenumserialization && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
    COMMENT "Compile and test with enum serialization disabled"
 )
 ###############################################################################
 # Skip the multiple-inclusion library version check.
 ###############################################################################
 # tests/src/skip_library_version_check.cpp deliberately simulates a scenario
 # (mixing two differently-versioned inclusions of the library in one
 # translation unit) that unavoidably triggers the compiler's own "macro
 # redefined" warning, so -- unlike the ci_test_* targets above -- it is
 # compiled directly here, with a modest warning set, instead of being folded
 # into the library's own -Weverything/-Werror unit test matrix.
 add_custom_target(ci_test_skiplibraryversioncheck
    COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/skip_library_version_check
    COMMAND ${CMAKE_CXX_COMPILER} -std=c++11 -Wall -Wextra
        -I${PROJECT_SOURCE_DIR}/include
        ${PROJECT_SOURCE_DIR}/tests/src/skip_library_version_check.cpp
        -o ${PROJECT_BINARY_DIR}/skip_library_version_check/skip_library_version_check
    COMMAND ${PROJECT_BINARY_DIR}/skip_library_version_check/skip_library_version_check
    COMMENT "Compile and run a translation unit simulating a mismatched library version, with JSON_SKIP_LIBRARY_VERSION_CHECK defined"
 )
 ###############################################################################
 # Coverage.
 ###############################################################################
@@ -1,61 +0,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
 // Standalone compile-and-run check for the JSON_SKIP_LIBRARY_VERSION_CHECK
 // configuration macro, which (per #5423) was never exercised anywhere in the
 // test matrix.
 //
 // include/nlohmann/detail/abi_macros.hpp normally emits a #warning if
 // NLOHMANN_JSON_VERSION_MAJOR/MINOR/PATCH are already defined (as they would
 // be by an earlier inclusion of a different version of the library) with
 // values that mismatch the version about to be defined -- unless
 // JSON_SKIP_LIBRARY_VERSION_CHECK is defined, in which case the check (and
 // that #warning) is skipped.
 //
 // This file deliberately is not named tests/src/unit-*.cpp: it is compiled
 // directly (with a modest, non-strict warning set) by the dedicated
 // ci_test_skiplibraryversioncheck target in cmake/ci.cmake, rather than being
 // folded into the library's own -Weverything/-Werror unit test matrix. That
 // is because the scenario simulated here -- mixing two different, already
 // differently-versioned inclusions of the library in one translation unit --
 // unavoidably also triggers the *compiler's own* "macro redefined" warning,
 // independent of (and unaffected by) JSON_SKIP_LIBRARY_VERSION_CHECK, which
 // only ever silences the library's own #warning. Building this file under
 // -Weverything -Werror would therefore fail for a reason unrelated to the
 // macro under test.
 #define NLOHMANN_JSON_VERSION_MAJOR 0
 #define NLOHMANN_JSON_VERSION_MINOR 0
 #define NLOHMANN_JSON_VERSION_PATCH 0
 #define JSON_SKIP_LIBRARY_VERSION_CHECK 1
 #include <nlohmann/json.hpp>
 int main()
 {
    // reaching this point at all already proves that the mismatched,
    // pre-defined version macros above did not stop compilation -- which is
    // exactly what JSON_SKIP_LIBRARY_VERSION_CHECK is for. The library must
    // also still be fully usable.
    const nlohmann::json j = {{"a", 1}, {"b", {1, 2, 3}}};
    if (j.dump() != "{\"a\":1,\"b\":[1,2,3]}")
    {
        return 1;
    }
    // include/nlohmann/detail/abi_macros.hpp unconditionally (re)defines the
    // version macros to the library's real, current version right after the
    // (here, skipped) mismatch check, regardless of the deliberately wrong
    // stand-in values defined above.
    if (NLOHMANN_JSON_VERSION_MAJOR == 0 && NLOHMANN_JSON_VERSION_MINOR == 0 && NLOHMANN_JSON_VERSION_PATCH == 0)
    {
        return 1;
    }
    return 0;
 }
@@ -42,39 +42,6 @@ TEST_CASE("byte_container_with_subtype")
        CHECK(container.subtype() == static_cast<subtype_type>(-1));
    }
    SECTION("move semantics")
    {
        // the rvalue-reference constructor (without a subtype) must actually move
        // the passed-in container rather than copy it; comparing the buffer address
        // before and after is a stronger check than just observing the source is
        // empty afterward, since a copy-then-clear could also leave it empty
        {
            std::vector<std::uint8_t> bytes = {{0xCA, 0xFE, 0xBA, 0xBE}};
            const auto* const data_ptr = bytes.data();
            nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>> container(std::move(bytes));
            CHECK(container.size() == 4);
            CHECK(container.data() == data_ptr);
            CHECK(!container.has_subtype());
            CHECK(bytes.empty()); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move,hicpp-invalid-access-moved)
        }
        // same check for the rvalue-reference constructor that also takes a subtype
        {
            std::vector<std::uint8_t> bytes = {{0xCA, 0xFE, 0xBA, 0xBE}};
            const auto* const data_ptr = bytes.data();
            nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>> container(std::move(bytes), 42);
            CHECK(container.size() == 4);
            CHECK(container.data() == data_ptr);
            CHECK(container.has_subtype());
            CHECK(container.subtype() == 42);
            CHECK(bytes.empty()); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move,hicpp-invalid-access-moved)
        }
    }
    SECTION("comparisons")
    {
        std::vector<std::uint8_t> const bytes = {{0xCA, 0xFE, 0xBA, 0xBE}};
@@ -1761,40 +1761,6 @@ TEST_CASE("std::filesystem::path")
 }
 #endif
 // the ADL to_json overload for std::u8string only exists under the same guard
 // as std::filesystem::path support (it is otherwise only reached indirectly,
 // via std::filesystem::path::u8string()) -- mirror both #if conditions from
 // include/nlohmann/detail/conversions/to_json.hpp exactly
 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
 #if defined(__cpp_lib_char8_t)
 TEST_CASE("std::u8string")
 {
    SECTION("ascii")
    {
        const std::u8string s = u8"Path";
        json const j = s;
        CHECK(j.template get<std::string>() == "Path");
    }
    SECTION("utf-8")
    {
        // use \u universal-character-names (rather than raw \x byte escapes
        // or literal non-ASCII source bytes) to compose the multi-byte UTF-8
        // encoding -- MSVC treats \x escapes used that way inside a u8
        // literal as a nonstandard extension (warning C5321), which some of
        // our CI configs promote to an error; \u is portable and produces
        // the exact same encoded bytes without depending on the source
        // file's encoding
        const std::u8string s = u8"P\u011B\u0161ina";
        json const j = s;
        CHECK(j.template get<std::string>() == "P\xc4\x9b\xc5\xa1ina");
    }
 }
 #endif
 #endif
 TEST_CASE("std::optional")
 {
    SECTION("null")
@@ -672,102 +672,6 @@ TEST_CASE("JSON patch")
        }
    }
    SECTION("patch_inplace")
    {
        SECTION("happy path: patch_inplace mirrors patch() on success")
        {
            // mirrors "A.5. Replacing a Value" above, but applies the patch with
            // patch_inplace() to a mutable copy instead of using patch()'s
            // returned copy
            json doc = R"(
                    {
                        "baz": "qux",
                        "foo": "bar"
                    }
                )"_json;
            json const patch = R"(
                    [
                        { "op": "replace", "path": "/baz", "value": "boo" }
                    ]
                )"_json;
            json const expected = R"(
                    {
                        "baz": "boo",
                        "foo": "bar"
                    }
                )"_json;
            doc.patch_inplace(patch);
            CHECK(doc == expected);
        }
        // this test relies on the "test" operation actually throwing so the
        // partial-application state can be observed right after the throw
        // point; under JSON_NOEXCEPTION, JSON_THROW() calls std::abort()
        // instead (there is no C++ exception to throw), and doctest's
        // CHECK_THROWS_AS() is compiled out to a no-op that never even
        // invokes the given expression (see doctest's "--no-throw" test
        // filter, which ci_test_noexceptions passes) -- so patch()/
        // patch_inplace() would never be called at all and the follow-up
        // state assertions below would fail against the untouched original
 #if !defined(JSON_NOEXCEPTION)
        SECTION("distinguishing contract vs patch(): partial application on failure")
        {
            // Unlike patch(), which is all-or-nothing because it applies the
            // patch to an internal copy that is simply discarded when an
            // exception is thrown (leaving the original untouched no matter
            // what), patch_inplace() mutates the document it is called on
            // directly and immediately, operation by operation. So if a JSON
            // Patch fails partway through, whatever operations already
            // succeeded remain applied -- the document is left in a partially
            // patched state. This is empirically verified current behavior,
            // not just documented intent, and is pinned here as such.
            json const original = R"(
                    {
                        "baz": "qux",
                        "foo": "bar"
                    }
                )"_json;
            // the first operation ("replace") succeeds; the second ("test")
            // fails because the value at "/baz" no longer (and never did)
            // equal "not boo"
            json const patch = R"(
                    [
                        { "op": "replace", "path": "/baz", "value": "boo" },
                        { "op": "test", "path": "/baz", "value": "not boo" }
                    ]
                )"_json;
            // patch() never modifies the object it is called on -- it always
            // operates on (and returns) a separate copy, so the original is
            // left completely untouched, regardless of success or failure.
            // copy_for_patch is intentionally a real copy, not a reference
            // to `original`: the whole point of this check is to catch a
            // hypothetical future regression where patch() *does* mutate its
            // receiver. Using a reference here would make the assertion
            // below compare `original` to itself -- trivially true even if
            // such a bug existed -- which is exactly what a static analyzer
            // can't see when it suggests "this copy is never modified, use
            // a reference instead".
            json copy_for_patch = original; // NOLINT(performance-unnecessary-copy-initialization)
            CHECK_THROWS_AS(copy_for_patch.patch(patch), json::other_error&);
            CHECK(copy_for_patch == original);
            // patch_inplace(), in contrast, already applied the successful
            // "replace" operation to the document before the "test" operation
            // threw -- that change is not rolled back
            json doc = original;
            CHECK_THROWS_AS(doc.patch_inplace(patch), json::other_error&);
            CHECK(doc != original);
            CHECK(doc.at("baz") == "boo");
            CHECK(doc.at("foo") == "bar");
        }
 #endif // !defined(JSON_NOEXCEPTION)
    }
    SECTION("errors")
    {
        SECTION("unknown operation")
@@ -70,7 +70,7 @@ TEST_CASE("check_for_mem_leak_on_adl_to_json-2")
    }
 }
-TEST_CASE("check_for_mem_leak_on_adl_to_json-3")
+TEST_CASE("check_for_mem_leak_on_adl_to_json-2")
 {
    try
    {
@@ -1,91 +0,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
 // This translation unit is a dedicated, small compile-and-run check for two
 // configuration macros that (per #5423) were never exercised anywhere in the
 // test matrix:
 // - JSON_NO_IO, which removes the library's <istream>/<ostream> support
 //   (operator<<, operator>>, and the stream-based overloads of dump()/parse())
 // - the JSON_THROW_USER / JSON_TRY_USER / JSON_CATCH_USER trio, which lets a
 //   user replace the library's internal exception handling
 //
 // Both macros are about excluding/replacing a facility the library would
 // otherwise pull in on its own, and defining one has no bearing on the other,
 // so -- to keep the test matrix small -- they are exercised together in a
 // single dedicated file instead of two.
 //
 // JSON_NO_IO requires this file itself to never rely on <iostream>/<sstream>;
 // only string-based parsing/dumping is used below.
 #define JSON_NO_IO 1
 // The user-supplied exception macros below are a *conforming* replacement:
 // they simply forward to the real throw/try/catch keywords (via a counter so
 // the test can assert each macro was actually invoked, not just defined), so
 // every exception-related behavior the library relies on internally --
 // including rethrowing std::out_of_range as json::out_of_range in at() --
 // keeps working exactly as it would with the library's own default macros.
 static int json_throw_user_call_count = 0; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 #define JSON_THROW_USER(exception) do { ++json_throw_user_call_count; throw exception; } while (false) // NOLINT(cppcoreguidelines-macro-usage)
 #define JSON_TRY_USER try // NOLINT(cppcoreguidelines-macro-usage)
 #define JSON_CATCH_USER(exception) catch (exception) // NOLINT(cppcoreguidelines-macro-usage)
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 TEST_CASE("JSON_NO_IO")
 {
    // everything that does not touch <istream>/<ostream> must keep working:
    // parsing from and dumping to std::string
    const json j = json::parse("{\"a\":[1,2,3],\"b\":true}");
    CHECK(j.dump() == "{\"a\":[1,2,3],\"b\":true}");
    CHECK(j.at("a").size() == 3);
    CHECK(j.at("b").get<bool>() == true);
 }
 // this test relies on CHECK_THROWS_AS() actually invoking the guarded
 // expression so json_throw_user_call_count gets bumped and can be observed
 // afterwards; doctest's "--no-throw" test filter (which ci_test_noexceptions
 // passes, together with a global -DJSON_NOEXCEPTION added to CMAKE_CXX_FLAGS
 // for every translation unit in that build, this file included) compiles
 // CHECK_THROWS_AS() out to a no-op that never even invokes the given
 // expression -- so json::parse()/at() below would never be called at all and
 // the call-count assertions would fail even though our JSON_THROW_USER
 // override (which always really throws, regardless of JSON_NOEXCEPTION) would
 // have worked fine on its own
 #if !defined(JSON_NOEXCEPTION)
 TEST_CASE("JSON_THROW_USER, JSON_TRY_USER, JSON_CATCH_USER")
 {
    json_throw_user_call_count = 0;
    // json::parse() is [[nodiscard]] (JSON_HEDLEY_WARN_UNUSED_RESULT); under
    // GCC in C++11 mode that expands to __attribute__((warn_unused_result)),
    // which -- unlike a [[nodiscard]] attribute proper -- GCC does not
    // consider satisfied by doctest's CHECK_THROWS_AS() wrapping the
    // expression in a (void) cast, so the discarded return value would still
    // be flagged under -Werror=unused-result; assign it to discard it instead,
    // matching the established `json _ = json::parse(...)` pattern used
    // elsewhere in the test suite (see unit-class_parser.cpp)
    json _; // NOLINT(readability-identifier-naming)
    // a parse error goes through JSON_THROW directly, i.e., through our
    // JSON_THROW_USER override
    CHECK_THROWS_AS(_ = json::parse("this is not JSON"), json::parse_error&);
    CHECK(json_throw_user_call_count > 0);
    // at() on an out-of-range array index internally catches std::out_of_range
    // (JSON_TRY_USER/JSON_CATCH_USER) and rethrows it as json::out_of_range
    // (JSON_THROW_USER again), so this exercises all three macros together
    const int count_before = json_throw_user_call_count;
    const json arr = json::array({1, 2, 3});
    CHECK_THROWS_AS(arr.at(10), json::out_of_range&);
    CHECK(json_throw_user_call_count > count_before);
 }
 #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(std::string str): str_impl(std::move(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));
 }
@@ -18,14 +18,6 @@
 // for some reason including this after the json header leads to linker errors with VS 2017...
 #include <locale>
 // skip tests if JSON_DisableEnumSerialization=ON (#4384): std::byte is a
 // scoped enum, so get<std::byte>() (needed below to get<std::vector<std::byte>>()
 // from a plain JSON array, not just from an already-binary value) relies on
 // enum serialization being enabled
 #if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
    #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
 #endif
 #define JSON_TESTS_PRIVATE
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
@@ -1144,7 +1136,6 @@ TEST_CASE("regression tests 2")
        CHECK((decoded == json_4804::array()));
    }
 #ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
    SECTION("discussion #4209 - custom BinaryType direct assignment and round-tripping")
    {
        // Test that assigning a custom BinaryType directly creates a binary value, not an array
@@ -1178,7 +1169,6 @@ TEST_CASE("regression tests 2")
        CHECK(extracted[1] == std::byte{2});
        CHECK(extracted[2] == std::byte{3});
    }
 #endif
    SECTION("issue #5046 - implicit conversion of return json to std::optional no longer implicit")
    {
@@ -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
@@ -52,23 +53,6 @@ TEST_CASE("std::formatter<nlohmann::json>")
        CHECK(std::format("{:2}", j) == j.dump(2));
        CHECK(std::format("{:#2}", j) == j.dump(2));
        CHECK(std::format("{:8}", j) == j.dump(8));
        // multi-digit widths must accumulate every digit, not just the first
        CHECK(std::format("{:12}", j) == j.dump(12));
        CHECK(std::format("{:#12}", j) == j.dump(12));
        CHECK(std::format("{:10}", j) == j.dump(10));
    }
    SECTION("bare alignment with no fill character defaults to a space indent character")
    {
        const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
        // without a preceding fill character, the alignment character itself must not
        // be mistaken for the indent character -- the default space is kept
        CHECK(std::format("{:<}", j) == j.dump());
        CHECK(std::format("{:>}", j) == j.dump());
        CHECK(std::format("{:^}", j) == j.dump());
        CHECK(std::format("{:<3}", j) == j.dump(3, ' '));
        CHECK(std::format("{:>3}", j) == j.dump(3, ' '));
        CHECK(std::format("{:^3}", j) == j.dump(3, ' '));
    }
    SECTION("fill-and-align sets the indent character, like dump(indent, indent_char)")
@@ -110,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