Return the parsed value by move from from_cbor() and friends

The binary entry points end with return res ? result : basic_json(value_t::discarded); The condition operator's second operand is an lvalue, so this is not a case where the return value can be elided or implicitly moved from: every successful from_cbor(), from_msgpack(), from_ubjson(), from_bjdata() and from_bson() call deep-copies the value it just parsed, and then destroys the original. The copy is not cheap, and it is not incidental: basic_json's copy constructor walks the whole value. Parsing a 2 MB CBOR document with 60,000 objects, median of 25 runs, clang 17 -O3: from_cbor 26.99 ms -> 14.65 ms from_msgpack 26.82 ms -> 14.82 ms Moving instead of copying is the entire change; the parsed value is not used again after the return expression is evaluated. There is a second reason to prefer the move. The copy constructor recurses once per nesting level, so the copy is also a stack-overflow path on the return side, on a value the reader has already accepted. That is currently masked because the readers themselves recurse and overflow first (#5104), but it has to be fixed for making them iterative to have any effect. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-09-07 00:37:58 +00:00 · 2026-09-06 16:41:35 +02:00
12 changed files with 30 additions and 406 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.
 ###############################################################################
@@ -4474,7 +4474,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in CBOR format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4491,7 +4491,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -4517,7 +4517,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in MessagePack format
@@ -4532,7 +4532,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in MessagePack format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4548,7 +4548,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -4572,7 +4572,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in UBJSON format
@@ -4587,7 +4587,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in UBJSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4603,7 +4603,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -4627,7 +4627,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BJData format
@@ -4642,7 +4642,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BJData format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4658,7 +4658,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BSON format
@@ -4673,7 +4673,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4689,7 +4689,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -4713,7 +4713,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }
    /// @}

@@ -25902,7 +25902,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in CBOR format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -25919,7 +25919,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -25945,7 +25945,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in MessagePack format
@@ -25960,7 +25960,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in MessagePack format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -25976,7 +25976,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -26000,7 +26000,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in UBJSON format
@@ -26015,7 +26015,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in UBJSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -26031,7 +26031,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -26055,7 +26055,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BJData format
@@ -26070,7 +26070,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BJData format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -26086,7 +26086,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BSON format
@@ -26101,7 +26101,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -26117,7 +26117,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -26141,7 +26141,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        return res ? std::move(result) : basic_json(value_t::discarded);
    }
    /// @}

@@ -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
@@ -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")
    {
@@ -52,23 +52,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)")