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-06 16:27:59 +00:00 · 2026-09-06 11:20:08 +02:00 · 2026-09-05 20:53:09 +02:00
11 changed files with 567 additions and 536 deletions
@@ -241,7 +241,7 @@ update_hedley:
 	rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp
 	$(SED) -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
-	grep -oE "#[[:blank:]]*define[[:blank:]]+JSON_HEDLEY_[A-Za-z0-9_]+" include/nlohmann/thirdparty/hedley/hedley.hpp | awk '{print $$NF}' | grep -v "__" | sort -u | $(SED) 's/^/#undef /' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
+	grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | $(SED) 's/ //g' | $(SED) 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley.hpp
 	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(MAKE) amalgamate
@@ -1074,9 +1074,9 @@ char* to_chars(char* first, const char* last, FloatType value)
        *first++ = '-';
    }

-    JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
    if (value == 0) // +-0
    {
@@ -1086,7 +1086,9 @@ char* to_chars(char* first, const char* last, FloatType value)
        *first++ = '0';
        return first;
    }
-    JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif

    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);

@@ -32,9 +32,9 @@
 // functions to. As a result, we suppress this warning here to avoid client
 // code stumbling over this. See https://github.com/nlohmann/json/issues/4087
 // for a discussion.
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif

 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -286,4 +286,6 @@ class other_error : public exception
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
@@ -18,7 +18,6 @@
 #endif

 #include <nlohmann/detail/abi_macros.hpp>
-#include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
 #include <nlohmann/detail/string_utils.hpp>
 #include <nlohmann/detail/value_t.hpp>
@@ -207,10 +206,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {

-// Fix: https://github.com/nlohmann/json/issues/1401
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
@@ -224,7 +223,9 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                     get<N>(std::declval <
                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif

 }  // namespace std

@@ -1849,9 +1849,9 @@ class binary_writer

    void write_compact_float(const number_float_t n, detail::input_format_t format)
    {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        if (!std::isfinite(n) || ((static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
                                   static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
@@ -1869,7 +1869,9 @@ class binary_writer
                                : get_msgpack_float_prefix(n));
            write_number(n);
        }
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
    }

  public:
@@ -3769,13 +3769,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    bool operator==(const_reference rhs) const noexcept
    {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        const_reference lhs = *this;
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
    }

    /// @brief comparison: equal
@@ -3860,12 +3862,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
    {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
    }

    /// @brief comparison: equal
@@ -17,7 +17,7 @@
 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -108,10 +108,7 @@
 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 #undef JSON_HEDLEY_PGI_VERSION
 #undef JSON_HEDLEY_PGI_VERSION_CHECK
-#undef JSON_HEDLEY_PRAGMA
 #undef JSON_HEDLEY_PREDICT
-#undef JSON_HEDLEY_PREDICT_FALSE
-#undef JSON_HEDLEY_PREDICT_TRUE
 #undef JSON_HEDLEY_PRINTF_FORMAT
 #undef JSON_HEDLEY_PRIVATE
 #undef JSON_HEDLEY_PUBLIC
@@ -4944,9 +4944,9 @@ NLOHMANN_JSON_NAMESPACE_END
 // functions to. As a result, we suppress this warning here to avoid client
 // code stumbling over this. See https://github.com/nlohmann/json/issues/4087
 // for a discussion.
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif

 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -5198,7 +5198,9 @@ class other_error : public exception
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif

 // #include <nlohmann/detail/macro_scope.hpp>

@@ -5973,8 +5975,6 @@ NLOHMANN_JSON_NAMESPACE_END

 // #include <nlohmann/detail/abi_macros.hpp>

-// #include <nlohmann/detail/macro_scope.hpp>
-
 // #include <nlohmann/detail/meta/type_traits.hpp>

 // #include <nlohmann/detail/string_utils.hpp>
@@ -6204,10 +6204,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {

-// Fix: https://github.com/nlohmann/json/issues/1401
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
@@ -6221,7 +6221,9 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                     get<N>(std::declval <
                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif

 }  // namespace std

@@ -18855,9 +18857,9 @@ class binary_writer

    void write_compact_float(const number_float_t n, detail::input_format_t format)
    {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        if (!std::isfinite(n) || ((static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
                                   static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
@@ -18875,7 +18877,9 @@ class binary_writer
                                : get_msgpack_float_prefix(n));
            write_number(n);
        }
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
    }

  public:
@@ -20048,9 +20052,9 @@ char* to_chars(char* first, const char* last, FloatType value)
        *first++ = '-';
    }

-    JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
    if (value == 0) // +-0
    {
@@ -20060,7 +20064,9 @@ char* to_chars(char* first, const char* last, FloatType value)
        *first++ = '0';
        return first;
    }
-    JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif

    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);

@@ -25191,13 +25197,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    bool operator==(const_reference rhs) const noexcept
    {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        const_reference lhs = *this;
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
    }

    /// @brief comparison: equal
@@ -25282,12 +25290,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
    {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
    }

    /// @brief comparison: equal
@@ -26955,7 +26965,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -27046,10 +27056,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 #undef JSON_HEDLEY_PGI_VERSION
 #undef JSON_HEDLEY_PGI_VERSION_CHECK
-#undef JSON_HEDLEY_PRAGMA
 #undef JSON_HEDLEY_PREDICT
-#undef JSON_HEDLEY_PREDICT_FALSE
-#undef JSON_HEDLEY_PREDICT_TRUE
 #undef JSON_HEDLEY_PRINTF_FORMAT
 #undef JSON_HEDLEY_PRIVATE
 #undef JSON_HEDLEY_PUBLIC
@@ -1,486 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file makes sure that none of the internal JSON_HEDLEY_* macros (vendored
-// from https://nemequ.github.io/hedley/, see
-// include/nlohmann/thirdparty/hedley/hedley.hpp) leak into the including
-// translation unit. include/nlohmann/detail/macro_unscope.hpp is supposed to
-// #undef every JSON_HEDLEY_* macro (via hedley_undef.hpp) once json.hpp has
-// been fully processed. See https://github.com/nlohmann/json/issues/5408,
-// where JSON_HEDLEY_PRAGMA, JSON_HEDLEY_PREDICT_TRUE, JSON_HEDLEY_PREDICT_FALSE,
-// and JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE escaped this cleanup because
-// hedley_undef.hpp had no matching #undef for them.
-//
-// The #ifdef/#error checks below are mechanically derived from the full list
-// of macro names in hedley_undef.hpp, so every JSON_HEDLEY_* macro is covered
-// -- not just the four that leaked historically.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#ifdef JSON_HEDLEY_ALWAYS_INLINE
-    #error "JSON_HEDLEY_ALWAYS_INLINE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_ARM_VERSION
-    #error "JSON_HEDLEY_ARM_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_ARM_VERSION_CHECK
-    #error "JSON_HEDLEY_ARM_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_ARRAY_PARAM
-    #error "JSON_HEDLEY_ARRAY_PARAM must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_ASSUME
-    #error "JSON_HEDLEY_ASSUME must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_BEGIN_C_DECLS
-    #error "JSON_HEDLEY_BEGIN_C_DECLS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
-    #error "JSON_HEDLEY_CLANG_HAS_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_BUILTIN
-    #error "JSON_HEDLEY_CLANG_HAS_BUILTIN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-    #error "JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
-    #error "JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_EXTENSION
-    #error "JSON_HEDLEY_CLANG_HAS_EXTENSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_FEATURE
-    #error "JSON_HEDLEY_CLANG_HAS_FEATURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_WARNING
-    #error "JSON_HEDLEY_CLANG_HAS_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_COMPCERT_VERSION
-    #error "JSON_HEDLEY_COMPCERT_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_COMPCERT_VERSION_CHECK
-    #error "JSON_HEDLEY_COMPCERT_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONCAT
-    #error "JSON_HEDLEY_CONCAT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONCAT3
-    #error "JSON_HEDLEY_CONCAT3 must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONCAT3_EX
-    #error "JSON_HEDLEY_CONCAT3_EX must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONCAT_EX
-    #error "JSON_HEDLEY_CONCAT_EX must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONST
-    #error "JSON_HEDLEY_CONST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONSTEXPR
-    #error "JSON_HEDLEY_CONSTEXPR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONST_CAST
-    #error "JSON_HEDLEY_CONST_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CPP_CAST
-    #error "JSON_HEDLEY_CPP_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CRAY_VERSION
-    #error "JSON_HEDLEY_CRAY_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CRAY_VERSION_CHECK
-    #error "JSON_HEDLEY_CRAY_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_C_DECL
-    #error "JSON_HEDLEY_C_DECL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DEPRECATED
-    #error "JSON_HEDLEY_DEPRECATED must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DEPRECATED_FOR
-    #error "JSON_HEDLEY_DEPRECATED_FOR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_POP
-    #error "JSON_HEDLEY_DIAGNOSTIC_POP must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_PUSH
-    #error "JSON_HEDLEY_DIAGNOSTIC_PUSH must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DMC_VERSION
-    #error "JSON_HEDLEY_DMC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DMC_VERSION_CHECK
-    #error "JSON_HEDLEY_DMC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_EMPTY_BASES
-    #error "JSON_HEDLEY_EMPTY_BASES must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_EMSCRIPTEN_VERSION
-    #error "JSON_HEDLEY_EMSCRIPTEN_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
-    #error "JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_END_C_DECLS
-    #error "JSON_HEDLEY_END_C_DECLS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_FALL_THROUGH
-    #error "JSON_HEDLEY_FALL_THROUGH must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_FLAGS
-    #error "JSON_HEDLEY_FLAGS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_FLAGS_CAST
-    #error "JSON_HEDLEY_FLAGS_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
-    #error "JSON_HEDLEY_GCC_HAS_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_BUILTIN
-    #error "JSON_HEDLEY_GCC_HAS_BUILTIN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-    #error "JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-    #error "JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_EXTENSION
-    #error "JSON_HEDLEY_GCC_HAS_EXTENSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_FEATURE
-    #error "JSON_HEDLEY_GCC_HAS_FEATURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_WARNING
-    #error "JSON_HEDLEY_GCC_HAS_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-    #error "JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_VERSION
-    #error "JSON_HEDLEY_GCC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_VERSION_CHECK
-    #error "JSON_HEDLEY_GCC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
-    #error "JSON_HEDLEY_GNUC_HAS_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_BUILTIN
-    #error "JSON_HEDLEY_GNUC_HAS_BUILTIN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-    #error "JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-    #error "JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_EXTENSION
-    #error "JSON_HEDLEY_GNUC_HAS_EXTENSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_FEATURE
-    #error "JSON_HEDLEY_GNUC_HAS_FEATURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_WARNING
-    #error "JSON_HEDLEY_GNUC_HAS_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_VERSION
-    #error "JSON_HEDLEY_GNUC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_VERSION_CHECK
-    #error "JSON_HEDLEY_GNUC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_ATTRIBUTE
-    #error "JSON_HEDLEY_HAS_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_BUILTIN
-    #error "JSON_HEDLEY_HAS_BUILTIN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
-    #error "JSON_HEDLEY_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
-    #error "JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-    #error "JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_EXTENSION
-    #error "JSON_HEDLEY_HAS_EXTENSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_FEATURE
-    #error "JSON_HEDLEY_HAS_FEATURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_WARNING
-    #error "JSON_HEDLEY_HAS_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IAR_VERSION
-    #error "JSON_HEDLEY_IAR_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IAR_VERSION_CHECK
-    #error "JSON_HEDLEY_IAR_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IBM_VERSION
-    #error "JSON_HEDLEY_IBM_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IBM_VERSION_CHECK
-    #error "JSON_HEDLEY_IBM_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IMPORT
-    #error "JSON_HEDLEY_IMPORT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INLINE
-    #error "JSON_HEDLEY_INLINE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INTEL_CL_VERSION
-    #error "JSON_HEDLEY_INTEL_CL_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
-    #error "JSON_HEDLEY_INTEL_CL_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INTEL_VERSION
-    #error "JSON_HEDLEY_INTEL_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INTEL_VERSION_CHECK
-    #error "JSON_HEDLEY_INTEL_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IS_CONSTANT
-    #error "JSON_HEDLEY_IS_CONSTANT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IS_CONSTEXPR_
-    #error "JSON_HEDLEY_IS_CONSTEXPR_ must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_LIKELY
-    #error "JSON_HEDLEY_LIKELY must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MALLOC
-    #error "JSON_HEDLEY_MALLOC must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MCST_LCC_VERSION
-    #error "JSON_HEDLEY_MCST_LCC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
-    #error "JSON_HEDLEY_MCST_LCC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MESSAGE
-    #error "JSON_HEDLEY_MESSAGE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MSVC_VERSION
-    #error "JSON_HEDLEY_MSVC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MSVC_VERSION_CHECK
-    #error "JSON_HEDLEY_MSVC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NEVER_INLINE
-    #error "JSON_HEDLEY_NEVER_INLINE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NON_NULL
-    #error "JSON_HEDLEY_NON_NULL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NO_ESCAPE
-    #error "JSON_HEDLEY_NO_ESCAPE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NO_RETURN
-    #error "JSON_HEDLEY_NO_RETURN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NO_THROW
-    #error "JSON_HEDLEY_NO_THROW must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NULL
-    #error "JSON_HEDLEY_NULL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PELLES_VERSION
-    #error "JSON_HEDLEY_PELLES_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PELLES_VERSION_CHECK
-    #error "JSON_HEDLEY_PELLES_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PGI_VERSION
-    #error "JSON_HEDLEY_PGI_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PGI_VERSION_CHECK
-    #error "JSON_HEDLEY_PGI_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PRAGMA
-    #error "JSON_HEDLEY_PRAGMA must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PREDICT
-    #error "JSON_HEDLEY_PREDICT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PREDICT_FALSE
-    #error "JSON_HEDLEY_PREDICT_FALSE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PREDICT_TRUE
-    #error "JSON_HEDLEY_PREDICT_TRUE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PRINTF_FORMAT
-    #error "JSON_HEDLEY_PRINTF_FORMAT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PRIVATE
-    #error "JSON_HEDLEY_PRIVATE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PUBLIC
-    #error "JSON_HEDLEY_PUBLIC must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PURE
-    #error "JSON_HEDLEY_PURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_REINTERPRET_CAST
-    #error "JSON_HEDLEY_REINTERPRET_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_REQUIRE
-    #error "JSON_HEDLEY_REQUIRE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_REQUIRE_CONSTEXPR
-    #error "JSON_HEDLEY_REQUIRE_CONSTEXPR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_REQUIRE_MSG
-    #error "JSON_HEDLEY_REQUIRE_MSG must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_RESTRICT
-    #error "JSON_HEDLEY_RESTRICT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_RETURNS_NON_NULL
-    #error "JSON_HEDLEY_RETURNS_NON_NULL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_SENTINEL
-    #error "JSON_HEDLEY_SENTINEL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_STATIC_ASSERT
-    #error "JSON_HEDLEY_STATIC_ASSERT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_STATIC_CAST
-    #error "JSON_HEDLEY_STATIC_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_STRINGIFY
-    #error "JSON_HEDLEY_STRINGIFY must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_STRINGIFY_EX
-    #error "JSON_HEDLEY_STRINGIFY_EX must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_SUNPRO_VERSION
-    #error "JSON_HEDLEY_SUNPRO_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_SUNPRO_VERSION_CHECK
-    #error "JSON_HEDLEY_SUNPRO_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TINYC_VERSION
-    #error "JSON_HEDLEY_TINYC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TINYC_VERSION_CHECK
-    #error "JSON_HEDLEY_TINYC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_ARMCL_VERSION
-    #error "JSON_HEDLEY_TI_ARMCL_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_ARMCL_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL2000_VERSION
-    #error "JSON_HEDLEY_TI_CL2000_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CL2000_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL430_VERSION
-    #error "JSON_HEDLEY_TI_CL430_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL430_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CL430_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL6X_VERSION
-    #error "JSON_HEDLEY_TI_CL6X_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CL6X_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL7X_VERSION
-    #error "JSON_HEDLEY_TI_CL7X_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CL7X_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CLPRU_VERSION
-    #error "JSON_HEDLEY_TI_CLPRU_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CLPRU_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_VERSION
-    #error "JSON_HEDLEY_TI_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNAVAILABLE
-    #error "JSON_HEDLEY_UNAVAILABLE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNLIKELY
-    #error "JSON_HEDLEY_UNLIKELY must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNPREDICTABLE
-    #error "JSON_HEDLEY_UNPREDICTABLE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNREACHABLE
-    #error "JSON_HEDLEY_UNREACHABLE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNREACHABLE_RETURN
-    #error "JSON_HEDLEY_UNREACHABLE_RETURN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION
-    #error "JSON_HEDLEY_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION_DECODE_MAJOR
-    #error "JSON_HEDLEY_VERSION_DECODE_MAJOR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION_DECODE_MINOR
-    #error "JSON_HEDLEY_VERSION_DECODE_MINOR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION_DECODE_REVISION
-    #error "JSON_HEDLEY_VERSION_DECODE_REVISION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION_ENCODE
-    #error "JSON_HEDLEY_VERSION_ENCODE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_WARNING
-    #error "JSON_HEDLEY_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_WARN_UNUSED_RESULT
-    #error "JSON_HEDLEY_WARN_UNUSED_RESULT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
-    #error "JSON_HEDLEY_WARN_UNUSED_RESULT_MSG must not remain defined after including json.hpp"
-#endif
-
-TEST_CASE("no JSON_HEDLEY_* macro leaks after including json.hpp")
-{
-    // if this test compiles at all, none of the JSON_HEDLEY_* macros checked
-    // above remained defined after including <nlohmann/json.hpp>
-    CHECK(true);
-}
@@ -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));
+}
@@ -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