Grow the json_view dump's output in steps and compare raw-number dumps

- The output string reserves the size estimate (the source extent) and grows
  in steps of 64 KiB within it, instead of being resized to the estimate at
  once: resize() zero-fills, and for a pretty-printed source the estimate is
  far larger than the compact output. citm_catalog dump: 342 -> 283 us on
  x86-64, 144 -> 134 us on Apple M1.
- bench_corpus compares the dump with source numbers with yyjson writing
  numbers read as raw text (YYJSON_READ_NUMBER_AS_RAW); both write the same
  bytes.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

.github/external_ci/appveyor.yml

@@ -16,9 +16,6 @@ only_commits:
 
 environment:
   matrix:
-    # The Visual Studio 2017 jobs compile everything with /std:c++17, so they
-    # only build the C++17 variant of each test, split into two jobs each to
-    # stay below AppVeyor's 60-minute limit per job.
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       configuration: Debug
       platform: x86
@@ -37,13 +34,7 @@ environment:
       configuration: Release
       platform: x86
       CXX_FLAGS: "/permissive- /std:c++17 /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=0/2"
-      GENERATOR: Visual Studio 15 2017
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      configuration: Release
-      platform: x86
-      CXX_FLAGS: "/permissive- /std:c++17 /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=1/2"
+      CMAKE_OPTIONS: ""
       GENERATOR: Visual Studio 15 2017
 
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -64,13 +55,7 @@ environment:
       configuration: Release
       platform: x64
       CXX_FLAGS: "/permissive- /std:c++17 /Zc:__cplusplus /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=0/2"
-      GENERATOR: Visual Studio 15 2017
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      configuration: Release
-      platform: x64
-      CXX_FLAGS: "/permissive- /std:c++17 /Zc:__cplusplus /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=1/2"
+      CMAKE_OPTIONS: ""
       GENERATOR: Visual Studio 15 2017
 
 init:
@@ -81,7 +66,7 @@ install:
   - if "%platform%"=="x86"    set GENERATOR_PLATFORM=Win32
 
 before_build:
-  - cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On %CMAKE_OPTIONS%
+  - cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On "%CMAKE_OPTIONS%"
 
 build_script:
   - cmake --build . --config "%configuration%" --parallel 2

.github/workflows/macos.yml

@@ -17,11 +17,11 @@ permissions:
   contents: read
 
 jobs:
-  macos-15:
-    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
+  macos-14:
+    runs-on: macos-14 # https://github.com/actions/runner-images/blob/main/images/macos/macos-14-Readme.md
     strategy:
       matrix:
-        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1', '26.1.1', '26.2', '26.3']
+        xcode: ['15.0.1', '15.1', '15.2', '15.3', '15.4']
     env:
       DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
 
@@ -36,11 +36,11 @@ jobs:
       - name: Test
         run: cd build ; ctest -j 10 --output-on-failure
 
-  macos-26:
-    runs-on: macos-26 # https://github.com/actions/runner-images/blob/main/images/macos/macos-26-arm64-Readme.md
+  macos-15:
+    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
     strategy:
       matrix:
-        xcode: ['26.4.1', '26.5', '26.6']
+        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1']
     env:
       DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
 

.github/workflows/ubuntu.yml

@@ -107,7 +107,7 @@ jobs:
     container: ubuntu:24.04
     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_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_delete_deprecated_functions, ci_test_no_thread_local]
+        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_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_no_thread_local]
     steps:
       - name: Install build-essential
         run: apt-get update ; apt-get install -y build-essential unzip wget git
@@ -209,7 +209,7 @@ jobs:
     strategy:
       matrix:
         # older GCC docker images (4, 5, 6) fail to check out code
-        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', '16', 'latest']
+        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', 'latest']
     container: gcc:${{ matrix.compiler }}
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1

CMakeLists.txt

@@ -62,7 +62,6 @@ option(JSON_MultipleHeaders                "Use non-amalgamated version of the l
 option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)
 option(JSON_StrictNulHandling              "Build with strict NUL-byte handling enabled." OFF)
 option(JSON_StrictBinaryUTF8               "Build with UTF-8 checks in the CBOR, UBJSON, BJData, and BSON writers enabled." OFF)
-option(JSON_DeleteDeprecatedFunctions      "Delete the deprecated functions instead of only deprecating them." OFF)
 
 if (JSON_CI)
     include(ci)
@@ -124,10 +123,6 @@ if (JSON_StrictBinaryUTF8)
     message(STATUS "Strict UTF-8 checks in binary writers enabled (JSON_STRICT_BINARY_UTF8=1)")
 endif()
 
-if (JSON_DeleteDeprecatedFunctions)
-    message(STATUS "Deprecated functions are deleted (JSON_DELETE_DEPRECATED_FUNCTIONS=1)")
-endif()
-
 if (JSON_Diagnostic_Positions)
     message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)")
 endif()
@@ -164,7 +159,6 @@ target_compile_definitions(
     $<$<BOOL:${JSON_LegacyDiscardedValueComparison}>:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1>
     $<$<BOOL:${JSON_StrictNulHandling}>:JSON_STRICT_NUL_HANDLING=1>
     $<$<BOOL:${JSON_StrictBinaryUTF8}>:JSON_STRICT_BINARY_UTF8=1>
-    $<$<BOOL:${JSON_DeleteDeprecatedFunctions}>:JSON_DELETE_DEPRECATED_FUNCTIONS=1>
 )
 
 target_include_directories(

cmake/ci.cmake

@@ -249,20 +249,6 @@ add_custom_target(ci_test_strict_nul_handling
     COMMENT "Compile and test with strict NUL-byte handling enabled"
 )
 
-###############################################################################
-# Delete the deprecated functions.
-###############################################################################
-
-add_custom_target(ci_test_delete_deprecated_functions
-    COMMAND ${CMAKE_COMMAND}
-    -DCMAKE_BUILD_TYPE=Debug -GNinja
-    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DeleteDeprecatedFunctions=ON
-    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
-    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
-    COMMENT "Compile and test with the deprecated functions deleted"
-)
-
 ###############################################################################
 # Disable global UDLs.
 ###############################################################################
@@ -376,7 +362,7 @@ add_custom_target(ci_test_coverage
 # Sanitizers.
 ###############################################################################
 
-set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base -fsanitize-ignorelist=${PROJECT_SOURCE_DIR}/cmake/clang_sanitizer_ignorelist.txt")
+set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base")
 
 add_custom_target(ci_test_clang_sanitizer
     COMMAND CXX=${CLANG_TOOL} CXXFLAGS=${CLANG_CXX_FLAGS_SANITIZER} ${CMAKE_COMMAND}
@@ -722,7 +708,7 @@ ci_get_cmake(4.0.0  CMAKE_4_0_0_BINARY)
 # the tests require CMake 3.13 or later, so they are excluded for CMake 3.5.0
 set(JSON_CMAKE_FLAGS_3_5_0 JSON_Diagnostics JSON_Diagnostic_Positions JSON_GlobalUDLs JSON_ImplicitConversions JSON_DisableEnumSerialization
     JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind
-    JSON_StrictNulHandling JSON_StrictBinaryUTF8 JSON_DeleteDeprecatedFunctions)
+    JSON_StrictNulHandling JSON_StrictBinaryUTF8)
 set(JSON_CMAKE_FLAGS_3_31_6 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 set(JSON_CMAKE_FLAGS_4_0_0 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 

cmake/clang_sanitizer_ignorelist.txt

@@ -1,8 +0,0 @@
-# Sanitizer ignore list for ci_test_clang_sanitizer (-fsanitize-ignorelist).
-#
-# libstdc++ 14's <format> declares `_Scanner(basic_string_view<_CharT>, size_t __nargs = -1)`, so every std::format
-# call converts -1 to size_t, which -fsanitize=integer reports as implicit-integer-sign-change. This is
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119429, not a bug in this library. Only that check and only <format> are
-# excluded, so implicit sign changes in the library and the tests are still reported.
-[implicit-integer-sign-change]
-src:*/include/c++/*/format

docs/docset/docSet.sql

@@ -291,7 +291,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Supported Macros', 'Guide', '
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_ASSERT', 'Macro', 'api/macros/json_assert/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_BRACE_INIT_COPY_SEMANTICS', 'Macro', 'api/macros/json_brace_init_copy_semantics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_CATCH_USER', 'Macro', 'api/macros/json_throw_user/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DELETE_DEPRECATED_FUNCTIONS', 'Macro', 'api/macros/json_delete_deprecated_functions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTICS', 'Macro', 'api/macros/json_diagnostics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTIC_POSITIONS', 'Macro', 'api/macros/json_diagnostic_positions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DISABLE_ENUM_SERIALIZATION', 'Macro', 'api/macros/json_disable_enum_serialization/index.html');
@@ -322,7 +321,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_TRY_USER', 'Macro', 'api
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_GLOBAL_UDLS', 'Macro', 'api/macros/json_use_global_udls/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_IMPLICIT_CONVERSIONS', 'Macro', 'api/macros/json_use_implicit_conversions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON', 'Macro', 'api/macros/json_use_legacy_discarded_value_comparison/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS', 'Macro', 'api/macros/json_use_objects_for_enum_keyed_maps/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_SIMDUTF', 'Macro', 'api/macros/json_use_simdutf/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Macros', 'Macro', 'api/macros/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');

docs/mkdocs/docs/api/basic_json/diff.md

@@ -8,7 +8,7 @@ static basic_json diff(const basic_json& source,
 Creates a [JSON Patch](http://jsonpatch.com) so that value `source` can be changed into the value `target` by calling
 [`patch`](patch.md) function.
 
-For two JSON values `source` and `target`, the following code always yields `#!cpp true`:
+For two JSON values `source` and `target`, the following code yields always `#!cpp true`:
 ```cpp
 source.patch(diff(source, target)) == target;
 ```
@@ -27,7 +27,7 @@ a JSON patch to convert the `source` to `target`
 
 ## Exception safety
 
-Strong guarantee: `source` and `target` are never modified.
+Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
 
 ## Complexity
 

docs/mkdocs/docs/api/basic_json/from_bjdata.md

@@ -120,12 +120,3 @@ Linear in the size of the input.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - Added `error_handler` parameter in version 3.13.0.
-
-!!! warning "Deprecation"
-
-    - Overload (2) replaces calls to `from_bjdata` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
-      `#!cpp from_bjdata(ptr, len, ...);` with `#!cpp from_bjdata(ptr, ptr+len, ...);`.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.

docs/mkdocs/docs/api/basic_json/from_bon8.md

@@ -106,12 +106,3 @@ Linear in the size of the input.
 ## Version history
 
 - Added in version 3.13.0.
-
-!!! warning "Deprecation"
-
-    - Overload (2) replaces calls to `from_bon8` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
-      `#!cpp from_bon8(ptr, len, ...);` with `#!cpp from_bon8(ptr, ptr+len, ...);`.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.

docs/mkdocs/docs/api/basic_json/number_float_t.md

@@ -56,10 +56,6 @@ This implementation does exactly follow this approach, as it uses double precisi
 smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally
 and be serialized to `null`.
 
-During deserialization (from JSON text or any of the binary formats), a finite number that does not fit into
-`number_float_t` is rejected with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406), for
-example a double-precision number in a binary format when `number_float_t` is `#!cpp float`.
-
 ### Storage
 
 Floating-point number values are stored directly inside a `basic_json` type.

docs/mkdocs/docs/api/basic_json/number_integer_t.md

@@ -47,9 +47,8 @@ With the default values for `NumberIntegerType` (`std::int64_t`), the default va
 
 When the default type is used, the maximal integer number that can be stored is `9223372036854775807` (INT64_MAX) and
 the minimal integer number that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers that are out of
-range will yield over/underflow when used in a constructor. During deserialization (from JSON text or any of the binary
-formats), too large or small integer numbers will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md)
-or [`number_float_t`](number_float_t.md).
+range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers
+will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md) or [`number_float_t`](number_float_t.md).
 
 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are

docs/mkdocs/docs/api/basic_json/number_unsigned_t.md

@@ -48,9 +48,8 @@ With the default values for `NumberUnsignedType` (`std::uint64_t`), the default
 
 When the default type is used, the maximal integer number that can be stored is `18446744073709551615` (UINT64_MAX) and
 the minimal integer number that can be stored is `0`. Integer numbers that are out of range will yield over/underflow
-when used in a constructor. During deserialization (from JSON text or any of the binary formats), too large or small
-integer numbers will automatically be stored as [`number_integer_t`](number_integer_t.md) or
-[`number_float_t`](number_float_t.md).
+when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored
+as [`number_integer_t`](number_integer_t.md) or [`number_float_t`](number_float_t.md).
 
 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are

docs/mkdocs/docs/api/basic_json/to_bjdata.md

@@ -68,8 +68,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
-- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to BJData"`
 
 ## Complexity
 
@@ -121,6 +119,4 @@ Linear in the size of the JSON value `j`.
 - BJData version parameter (for draft3 binary encoding) added in version 3.12.0.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
-  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
-- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid BJData.
+  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.

docs/mkdocs/docs/api/basic_json/to_bson.md

@@ -58,9 +58,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
-- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if a value nested in `j` is discarded
-  (the top-level value itself is covered by `type_error.317` above, since it must be an object); example:
-  `"cannot serialize discarded value to BSON"`
 
 ## Complexity
 
@@ -113,8 +110,6 @@ pass before anything is written.
 - Throws `out_of_range.412` and `out_of_range.415` since version 3.13.0.
 - Linear in the size of `j`, and no longer limited by the call stack for deeply nested values, since version 3.13.0.
 - `out_of_range.415` is now detected before anything is written, like the other exceptions above, since version 3.13.0.
-- Throws `type_error.321` for a discarded value nested in `j` since version 3.13.0; previously, it was silently
-  skipped, producing a document whose declared size did not match what was actually written.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316` before anything

docs/mkdocs/docs/api/basic_json/to_cbor.md

@@ -49,8 +49,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
-- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to CBOR"`
 
 ## Complexity
 
@@ -88,5 +86,3 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
-- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid CBOR.

docs/mkdocs/docs/api/basic_json/to_msgpack.md

@@ -54,8 +54,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
   `"subtype 70000 is too large for the MessagePack ext type (max 255)"`
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict`
-- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to MessagePack"`
 
 ## Complexity
 
@@ -110,5 +108,3 @@ Linear in the size of the JSON value `j`.
 - Fixed in version 3.13.0 to serialize `number_integer_t`/`number_unsigned_t` pairs of different width correctly;
   before, integers could be serialized with the wrong value if `number_integer_t` was narrower than
   `number_unsigned_t`.
-- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid MessagePack.

docs/mkdocs/docs/api/basic_json/to_ubjson.md

@@ -61,8 +61,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
-- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to UBJSON"`
 
 ## Complexity
 
@@ -114,5 +112,3 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
-- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid UBJSON.

docs/mkdocs/docs/api/macros/index.md

@@ -60,13 +60,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_DISABLE_ENUM_SERIALIZATION**](json_disable_enum_serialization.md) - switch off default serialization/deserialization functions for enums
 - [**JSON_DISABLE_TUPLE_REFERENCE_CONVERSION**](json_disable_tuple_reference_conversion.md) - switch off conversion from a one-element tuple of a JSON reference
 - [**JSON_USE_IMPLICIT_CONVERSIONS**](json_use_implicit_conversions.md) - control implicit conversions
-- [**JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS**](json_use_objects_for_enum_keyed_maps.md) - opt in to storing maps with enum
-  keys as objects
-
-## Deprecated functions
-
-- [**JSON_DELETE_DEPRECATED_FUNCTIONS**](json_delete_deprecated_functions.md) - opt in to deleting the deprecated
-  functions ahead of their removal in version 4.0.0
 
 ## Comparison behavior
 

docs/mkdocs/docs/api/macros/json_delete_deprecated_functions.md

@@ -1,96 +0,0 @@
-# JSON_DELETE_DEPRECATED_FUNCTIONS
-
-```cpp
-#define JSON_DELETE_DEPRECATED_FUNCTIONS /* value */
-```
-
-When defined to `1`, all [deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) of the
-library are declared as deleted (`= delete`) instead of only being marked as deprecated. Code that still calls one of
-them no longer compiles. This way, you can find all calls that need to be replaced before version 4.0.0 removes these
-functions; the [migration guide](../../integration/migration_guide.md#replace-deprecated-functions) describes how.
-
-A deleted function, unlike a removed one, still takes part in overload resolution. A call that would select it
-therefore fails to compile instead of silently selecting another overload. This matters for the deprecated
-`from_*(ptr, len)` overloads of [`from_cbor`](../basic_json/from_cbor.md), [`from_msgpack`](../basic_json/from_msgpack.md),
-[`from_ubjson`](../basic_json/from_ubjson.md), [`from_bjdata`](../basic_json/from_bjdata.md),
-[`from_bon8`](../basic_json/from_bon8.md), and [`from_bson`](../basic_json/from_bson.md): without them, a call like
-`from_cbor(ptr, len)` would compile, read `ptr` as a NUL-terminated string, and convert `len` to the `strict` parameter.
-
-The macro does not affect the deprecated legacy comparison of discarded values, which is controlled by
-[`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](json_use_legacy_discarded_value_comparison.md).
-
-## Default definition
-
-The default value is `0` (disabled, the deprecated functions can still be called, and the compiler warns about it).
-
-```cpp
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-```
-
-## Notes
-
-!!! info "CMake option"
-
-    The macro can also be set with the CMake option
-    [`JSON_DeleteDeprecatedFunctions`](../../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default).
-
-!!! warning "Opt-in only"
-
-    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no
-    effect. Define it for the whole project to avoid different declarations of the same class in different
-    translation units.
-
-!!! note "ABI compatibility"
-
-    The macro only turns calls that compile into calls that do not; it does not change the layout or the behavior of
-    any type. Its value is therefore not encoded in the [namespace](../../features/namespace.md).
-
-## Examples
-
-??? example "Example: default behavior (macro not defined)"
-
-    Without the macro, the deprecated overload is called, and the compiler warns about it:
-
-    ```cpp
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        const std::vector<std::uint8_t> v = {0x82, 0x01, 0x02};
-        auto j = json::from_cbor(v.data(), v.size());
-        // warning: 'from_cbor' is deprecated: Since 3.8.0; use from_cbor(ptr, ptr + len)
-    }
-    ```
-
-??? example "Example: deleted deprecated functions (macro defined to 1)"
-
-    With the macro, the call does not compile:
-
-    ```cpp
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 1
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        const std::vector<std::uint8_t> v = {0x82, 0x01, 0x02};
-        auto j = json::from_cbor(v.data(), v.size());
-        // error: call to deleted function 'from_cbor'
-    }
-    ```
-
-## See also
-
-- [Roadmap: removal of deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) - the
-  deprecated functions and the version they were deprecated in
-- [Migration guide: replace deprecated functions](../../integration/migration_guide.md#replace-deprecated-functions) -
-  how to replace each deprecated function
-
-## Version history
-
-- Added in version 3.13.0.
-- Planned to be removed in version 4.0.0, which removes the deprecated functions. The deprecated `from_*(ptr, len)`
-  overloads stay deleted in version 4.0.0.

docs/mkdocs/docs/api/macros/json_disable_tuple_reference_conversion.md

@@ -112,4 +112,3 @@ The default value is `0` (disabled — existing behavior is preserved).
 ## Version history
 
 - Added in version 3.13.0.
-- Planned to become the default (with the macro removed) in version 4.0.0.

docs/mkdocs/docs/api/macros/json_use_implicit_conversions.md

@@ -44,7 +44,7 @@ By default, implicit conversions are enabled.
 
 ## Examples
 
-??? example "Example: implicit and explicit conversions"
+??? example "Example: implicit conversion"
 
     This is an example for an implicit conversion:
 

docs/mkdocs/docs/api/macros/json_use_objects_for_enum_keyed_maps.md

@@ -1,139 +0,0 @@
-# JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-
-```cpp
-#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS /* value */
-```
-
-When defined to `1`, maps whose keys are enums (such as `std::map<E, T>` or `std::unordered_map<E, T>`) are stored as
-JSON objects, using the enum's own conversion for the keys. By default, they are stored as arrays of `[key, value]`
-pairs.
-
-## Default definition
-
-The default value is `0` (disabled — existing behavior is preserved).
-
-```cpp
-#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-```
-
-## Notes
-
-!!! note "Background"
-
-    JSON object keys are strings, so a map is only stored as an object if its keys can be converted to a string type.
-    Enums are not, even if [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md) maps them to strings, so a
-    map with enum keys becomes an array of `[key, value]` pairs:
-
-    ```json
-    [["stopped", "aa"], ["completed", "bb"]]
-    ```
-
-    With this macro, the same map becomes an object
-    (see [#4378](https://github.com/nlohmann/json/issues/4378)):
-
-    ```json
-    {"completed": "bb", "stopped": "aa"}
-    ```
-
-!!! note "Maps with non-unique keys"
-
-    Maps that allow duplicate keys, such as `std::multimap<E, T>` or `std::unordered_multimap<E, T>`, are not affected
-    by the macro and are still stored as arrays of `[key, value]` pairs, as an object cannot hold duplicate keys.
-
-!!! note "Reading"
-
-    Reading is not affected by the macro: a map with enum keys can always be read from both an array of pairs and an
-    object. For the latter, each key is converted to the enum with its `from_json` function, e.g., the one defined by
-    [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md). Data written without the macro can therefore
-    still be read after enabling it.
-
-!!! warning "Keys must serialize to distinct strings"
-
-    Each key is converted with the enum's `to_json` function. If a key is not converted to a string (for instance, an
-    enum without [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md), which is stored as an integer, or an
-    enumerator mapped to `nullptr`), [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) is thrown.
-    If two keys are converted to the same string (for instance, because
-    [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md) maps an unlisted enumerator to the first entry),
-    [`type_error.318`](../../home/exceptions.md#jsonexceptiontype_error318) is thrown. In both cases, the target value
-    is not changed.
-
-!!! warning "Opt-in only"
-
-    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no effect.
-
-!!! note "ABI compatibility"
-
-    The value of this macro is encoded in the [namespace](../../features/namespace.md) (tag `_ekmo`), resulting in
-    distinct symbol names. Translation units compiled with and without it can therefore be linked into the same program
-    without One Definition Rule (ODR) violations, but they cannot exchange instances of library types.
-
-## Examples
-
-??? example "Example: default behavior (macro not defined)"
-
-    Without the macro, a map with enum keys is stored as an array of pairs:
-
-    ```cpp
-    #include <map>
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
-
-    NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
-        {TS_STOPPED, "stopped"},
-        {TS_RUNNING, "running"},
-        {TS_COMPLETED, "completed"},
-    })
-
-    int main()
-    {
-        std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-        json j = m;
-        // j is [["stopped","aa"],["completed","bb"]]
-    }
-    ```
-
-??? example "Example: objects for enum-keyed maps (macro defined to 1)"
-
-    With the macro, the same map is stored as an object:
-
-    ```cpp
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 1
-    #include <map>
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
-
-    NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
-        {TS_STOPPED, "stopped"},
-        {TS_RUNNING, "running"},
-        {TS_COMPLETED, "completed"},
-    })
-
-    int main()
-    {
-        std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-        json j = m;
-        // j is {"completed":"bb","stopped":"aa"}
-
-        auto m2 = j.get<std::map<TaskState, std::string>>();
-        // m2 == m
-    }
-    ```
-
-## See also
-
-- [Specializing enum conversion](../../features/enum_conversion.md)
-- [**NLOHMANN_JSON_SERIALIZE_ENUM**](nlohmann_json_serialize_enum.md) - serialize/deserialize an enum
-- [**NLOHMANN_JSON_SERIALIZE_ENUM_STRICT**](nlohmann_json_serialize_enum_strict.md) - serialize/deserialize an enum with
-  exceptions
-
-## Version history
-
-- Added in version 3.13.0.

docs/mkdocs/docs/api/macros/nlohmann_json_serialize_enum.md

@@ -41,9 +41,6 @@ inline void from_json(const BasicJsonType& j, type& e);
       conversion. Select this default pair carefully. See example 1 below.
     - If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the
       list will be returned when converting to or from JSON. See example 2 below.
-    - Maps with enum keys (e.g., `std::map<ENUM_TYPE, T>`) are stored as arrays of `[key, value]` pairs by default.
-      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
-      with the converted keys. Such maps can be read from both forms.
 
 ## Examples
 
@@ -83,7 +80,6 @@ inline void from_json(const BasicJsonType& j, type& e);
 - [Specializing enum conversion](../../features/enum_conversion.md)
 - [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](./nlohmann_json_serialize_enum_strict.md)
 - [`JSON_DISABLE_ENUM_SERIALIZATION`](json_disable_enum_serialization.md)
-- [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md)
 
 ## Version history
 

docs/mkdocs/docs/api/macros/nlohmann_json_serialize_enum_strict.md

@@ -44,9 +44,6 @@ inline void from_json(const BasicJsonType& j, type& e);
       `"enum value out of range for <type>"`.
     - If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the
       list will be returned when converting to or from JSON. See example 2 below.
-    - Maps with enum keys (e.g., `std::map<ENUM_TYPE, T>`) are stored as arrays of `[key, value]` pairs by default.
-      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
-      with the converted keys. Such maps can be read from both forms.
 
 ## Examples
 
@@ -102,7 +99,6 @@ inline void from_json(const BasicJsonType& j, type& e);
 - [Specializing enum conversion](../../features/enum_conversion.md)
 - [`NLOHMANN_JSON_SERIALIZE_ENUM`](./nlohmann_json_serialize_enum.md)
 - [`JSON_DISABLE_ENUM_SERIALIZATION`](json_disable_enum_serialization.md)
-- [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md)
 
 ## Version history
 

docs/mkdocs/docs/community/quality_assurance.md

@@ -21,18 +21,17 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
       
         | Compiler                                     | Architecture | Operating System                  | CI        |
         |----------------------------------------------|--------------|-----------------------------------|-----------|
+        | AppleClang 15.0.0.15000040; Xcode 15.0.1     | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000100; Xcode 15.1       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000100; Xcode 15.2       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000309; Xcode 15.3       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000309; Xcode 15.4       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
         | AppleClang 16.0.0.16000026; Xcode 16         | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
         | AppleClang 16.0.0.16000026; Xcode 16.1       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
         | AppleClang 16.0.0.16000026; Xcode 16.2       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
         | AppleClang 17.0.0.17000013; Xcode 16.3       | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
         | AppleClang 17.0.0.17000013; Xcode 16.4       | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
         | AppleClang 17.0.0.17000319; Xcode 26.0.1     | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
-        | AppleClang 17.0.0.17000404; Xcode 26.1.1     | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 17.0.0.17000603; Xcode 26.2       | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 17.0.0.17000604; Xcode 26.3       | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 21.0.0.21000099; Xcode 26.4.1     | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
-        | AppleClang 21.0.0.21000101; Xcode 26.5       | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
-        | AppleClang 21.0.0.21000101; Xcode 26.6       | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
         | Clang 3.4.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
         | Clang 3.5.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
         | Clang 3.6.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
@@ -90,7 +89,7 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
         | GNU 13.3.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
         | GNU 14.2.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
         | GNU 15.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
-        | GNU 16.2.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
+        | GNU 16.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
         | GNU 16.1.0                                   | arm64        | Ubuntu 24.04                      | GitHub    |
         | icpc (ICC) 2021.10.0 20230609                | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
         | icpx (Intel oneAPI DPC++/C++) 2025.3.2       | x86_64       | Ubuntu 24.04 LTS                  | GitHub    |

docs/mkdocs/docs/community/roadmap.md

@@ -64,8 +64,6 @@ The following macros guard changes that are planned to become the default in ver
 | [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md)                                  | `0`         | `1`: reading from a stream does not consume the character after a number                                                      | –                                                                                                                  | 3.13.0 |
 | [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md)                                          | `0`         | `1`: a NUL byte in the input is a parse error instead of the end of input                                                     | [`JSON_StrictNulHandling`](../integration/cmake.md#json_strictnulhandling)                                         | 3.13.0 |
 | [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md)                                            | `0`         | `1`: `to_cbor`, `to_ubjson`, `to_bjdata`, and `to_bson` throw for strings that are not valid UTF-8 by default                 | [`JSON_StrictBinaryUTF8`](../integration/cmake.md#json_strictbinaryutf8)                                           | 3.13.0 |
-| [`JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md)            | `0`         | `1`: a `basic_json` value can no longer be created from a one-element tuple of a reference to it, such as `std::forward_as_tuple(j)`| [`JSON_DisableTupleReferenceConversion`](../integration/cmake.md#json_disabletuplereferenceconversion)             | 3.13.0 |
-| [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md)                          | `0`         | removed: the deprecated functions are removed (see below); the `from_*(ptr, len)` overloads stay deleted                      | [`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions)                         | 3.13.0 |
 
 For example, the following makes a 3.x release behave like version 4.0 with respect to these changes:
 
@@ -77,8 +75,6 @@ For example, the following makes a 3.x release behave like version 4.0 with resp
 #define JSON_PRECISE_STREAM_POSITION 1
 #define JSON_STRICT_NUL_HANDLING 1
 #define JSON_STRICT_BINARY_UTF8 1
-#define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 1
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 1
 #include <nlohmann/json.hpp>
 ```
 
@@ -88,13 +84,8 @@ way to achieve this.
 ### Removal of deprecated functions
 
 Version 4.0 will remove all deprecated functions. Compiling with deprecation warnings enabled shows which of them your
-code still uses. Defining [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to
-`1` turns these warnings into errors, as the deprecated functions are then deleted. The
-[migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to replace each of them.
-
-The `from_*` overloads taking a pointer and a length are not removed in version 4.0, but stay deleted. Without them, a
-call like `from_cbor(ptr, len)` would still compile: it would read `ptr` as a NUL-terminated string and convert `len`
-to the `strict` parameter.
+code still uses. The [migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to
+replace each of them.
 
 | Deprecated                                                                                                                                                                                                                                         | Since  | Migration                                                                        |
 |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------|
@@ -106,7 +97,6 @@ to the `strict` parameter.
 | [`json_pointer::operator string_t`](../api/json_pointer/operator_string_t.md)                                                                                                                                                                      | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
 | [`json_pointer`](../api/json_pointer/index.md) with a `basic_json` type as template argument, and the overloads of `value`, `contains`, `operator[]`, and `at` accepting such a pointer                                                           | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
 | Comparing a [`json_pointer`](../api/json_pointer/index.md) with a string via [`operator==`](../api/json_pointer/operator_eq.md) or [`operator!=`](../api/json_pointer/operator_ne.md)                                                              | 3.11.2 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
-| [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) with `(ptr, len)`                                                                                                                              | 3.13.0 | [Parsing](../integration/migration_guide.md#parsing)                             |
 
 The deprecated legacy comparison of discarded values is controlled by a macro and therefore listed in the table above.
 

docs/mkdocs/docs/features/binary_formats/cbor.md

@@ -168,9 +168,9 @@ The library maps CBOR types to JSON value types as follows:
 !!! warning "Negative integer overflow"
 
     CBOR negative integers (major type 1) are decoded as `-1 - n`. If the encoded magnitude `n` is too large for the
-    result to fit into `number_integer_t` (`std::int64_t` by default), the result is stored as `number_float_t`, like
-    a too small integer in JSON text. For example, `-18446744073709551616` (`0x3B` followed by eight `0xFF` bytes) is
-    stored as `-1.8446744073709552e+19`.
+    result to fit into `number_integer_t` (`std::int64_t` by default), parsing fails with a
+    [`parse_error.112`](../../home/exceptions.md#jsonexceptionparse_error112) exception rather than overflowing
+    silently.
 
 !!! warning "Object keys"
 

docs/mkdocs/docs/features/enum_conversion.md

@@ -58,23 +58,6 @@ assert(jPi.get<TaskState>() == TS_INVALID );
     --8<-- "examples/nlohmann_json_serialize_enum.output"
     ```
 
-## Maps with enum keys
-
-By default, maps with enum keys, such as `std::map<TaskState, std::string>`, are stored as arrays of `[key, value]`
-pairs, because JSON object keys must be strings. Define
-[`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) before including the
-library to store them as objects, with the keys converted by the enum's `to_json()` function:
-
-```cpp
-std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-json j = m;
-// default:                                   [["stopped","aa"],["completed","bb"]]
-// with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS: {"completed":"bb","stopped":"aa"}
-```
-
-Either form can be read back, with or without the macro.
-
 ## Notes
 
 Just as in [Arbitrary Type Conversions](arbitrary_types.md) above,

docs/mkdocs/docs/features/macros.md

@@ -23,17 +23,6 @@ This macro overrides [`#!cpp catch`](https://en.cppreference.com/w/cpp/language/
 
 See [full documentation of `JSON_CATCH_USER(exception)`](../api/macros/json_throw_user.md).
 
-## `JSON_DELETE_DEPRECATED_FUNCTIONS`
-
-When defined to `1`, all deprecated functions are declared as deleted instead of only being marked as deprecated, so
-code that still calls them no longer compiles. This way, you can find all calls that need to be replaced before version
-4.0.0 removes these functions.
-
-The macro can also be set with the CMake option
-[`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default).
-
-See [full documentation of `JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md).
-
 ## `JSON_DIAGNOSTICS`
 
 This macro enables extended diagnostics for exception messages. Possible values are `1` to enable or `0` to disable
@@ -97,8 +86,7 @@ See [full documentation of `JSON_DISABLE_ENUM_SERIALIZATION`](../api/macros/json
 ## `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`
 
 When defined to `1`, a JSON value can no longer be created from a one-element `std::tuple` holding a reference to a JSON
-value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise. This
-is planned to become the default in version 4.0.0.
+value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise.
 
 See [full documentation of `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md).
 
@@ -210,13 +198,6 @@ default.
 
 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).
 
-## `JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`
-
-When defined to `1`, maps with enum keys (e.g., `std::map<E, T>`) are stored as objects, using the enum's conversion for
-the keys, instead of arrays of `[key, value]` pairs. It is switched off (`0`) by default.
-
-See [full documentation of `JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md).
-
 ## `JSON_USE_SIMDUTF`
 
 When defined, UTF-8 validation of JSON strings read from contiguous byte input is delegated to the

docs/mkdocs/docs/features/namespace.md

@@ -21,8 +21,6 @@ The complete default namespace name is derived as follows:
     - [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md) defined non-zero appends `_psp`.
     - [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md) defined non-zero appends `_snul`.
     - [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md) defined non-zero appends `_sbu8`.
-    - [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) defined non-zero
-      appends `_ekmo`.
 - The inline namespace ends with the suffix `_v` followed by the 3 components of the version number separated by
   underscores. To omit the version component, see [Disabling the version component](#disabling-the-version-component)
   below.

docs/mkdocs/docs/features/performance.md

@@ -55,7 +55,7 @@ always use the scalar path regardless of this macro.
 
 Parsing always produces SAX events internally; [`parse`](../api/basic_json/parse.md) simply feeds them to a consumer
 that builds a complete `basic_json` value tree (a DOM) in memory. For documents too large to comfortably hold as
-a DOM, three alternatives avoid building it:
+a DOM, two alternatives avoid building it:
 
 - Implement the [SAX interface](parsing/sax_interface.md) directly and pass it to
   [`sax_parse`](../api/basic_json/sax_parse.md); only the parts of the input you choose to keep ever become
@@ -64,12 +64,6 @@ a DOM, three alternatives avoid building it:
   discard finished elements as soon as they are handled, so memory usage stays bounded by one element (plus the
   unparsed remainder of the input) instead of the whole document -- see the [recipe for streaming a large homogeneous
   array](parsing/parser_callbacks.md#recipe-streaming-a-large-homogeneous-array).
-- Parse into a [`json_document`](json_view.md) (`#!cpp <nlohmann/json_view.hpp>`) instead of a `basic_json`. It keeps
-  the input text and builds a flat index of 16 bytes per value; strings and numbers are not copied, but read from the
-  text when needed. Read-only [views](../api/basic_json_view/index.md) give the familiar element access, and only the
-  parts you [`materialize()`](../api/basic_json_view/materialize.md) become `basic_json` values. A document that
-  borrows the text instead of owning a copy needs the text to outlive it; see
-  [choosing between `json`, the SAX interface, and `json_view`](json_view.md#choosing-between-json-ordered_json-the-sax-interface-and-json_view).
 
 If the data is naturally record-oriented, consider [JSON Lines](parsing/json_lines.md) instead of one large JSON
 document: reading and parsing it line by line with `#!cpp std::getline` means only one line's value is ever in memory
@@ -215,7 +209,6 @@ those headers are then never processed by the compiler at all.
 - [Architecture](../home/architecture.md) - how input adapters, the lexer, and the serializer fit together
 - [Parsing](parsing/index.md) - the available parsing functions and inputs
 - [SAX interface](parsing/sax_interface.md) - parse without building a DOM
-- [Zero-copy JSON views](json_view.md) - parse into a flat index of the text and read it without building a DOM
 - [Binary formats](binary_formats/index.md) - compact alternatives to JSON text
 - [Object Order](object_order.md) - `json` vs. `ordered_json` and other `ObjectType` choices
 - [Template Parameter Requirements](types/template_parameters.md) - custom container and allocator types

docs/mkdocs/docs/home/exceptions.md

@@ -331,6 +331,9 @@ An unexpected byte was read in a [binary format](../features/binary_formats/inde
     [json.exception.parse_error.112] parse error at byte 15: syntax error while parsing BSON binary: byte array length cannot be negative, is -1
     ```
     ```
+    [json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow
+    ```
+    ```
     [json.exception.parse_error.112] parse error at byte 5: syntax error while parsing BSON document: document size 6 does not match the number of bytes read (5)
     ```
 
@@ -613,9 +616,6 @@ During implicit or explicit value conversion, the JSON type must be compatible w
     [json.exception.type_error.302] type must be string, but is object
     ```
 
-This exception is also thrown with [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md)
-if a key of a map with enum keys is not converted to a string, for instance, because the enum is stored as an integer.
-
 ### json.exception.type_error.303
 
 To retrieve a reference to a value stored in a `basic_json` object with `get_ref`, the type of the reference must match the value type. For instance, for a JSON array, the `ReferenceType` must be `array_t &`.
@@ -808,19 +808,6 @@ The dynamic type of the object cannot be represented in the requested serializat
 
     Encapsulate the JSON value in an object. That is, instead of serializing `#!json true`, serialize `#!json {"value": true}`
 
-### json.exception.type_error.318
-
-With [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md), a map with enum
-keys is stored as an object. This exception is thrown if two of its keys are converted to the same string, so one of the
-entries would be lost. This happens, for instance, if [`NLOHMANN_JSON_SERIALIZE_ENUM`](../api/macros/nlohmann_json_serialize_enum.md)
-does not list an enumerator and it is therefore converted like the first listed one.
-
-!!! failure "Example message"
-
-    ```
-    [json.exception.type_error.318] duplicate object key 'red'
-    ```
-
 ### json.exception.type_error.319
 
 [`basic_json_document::set`](../api/basic_json_document/set.md) and
@@ -859,20 +846,6 @@ exception on a big-endian target, since the image format is little-endian only.
 
     This exception was added in version 3.13.0, together with [images](../features/json_view.md#images).
 
-### json.exception.type_error.321
-
-A discarded value (one created by [`parse()`](../api/basic_json/parse.md) with a callback that returns `false` for the
-value, or by default-constructing a [`basic_json`](../api/basic_json/index.md) with
-[`value_t::discarded`](../api/basic_json/value_t.md)) was passed to a binary serialization function, either directly or
-nested in an array or object. There is no way to represent a discarded value in CBOR, MessagePack, UBJSON, BJData, or BSON.
-
-!!! failure "Example message"
-
-    Serializing `#!json [1, 2]` to CBOR, where the second element was discarded by a parser callback:
-    ```
-    [json.exception.type_error.321] cannot serialize discarded value to CBOR
-    ```
-
 ## Out of range
 
 This exception is thrown in case a library function is called on an input parameter that exceeds the expected range, for instance, in the case of array indices or nonexisting object keys.
@@ -945,18 +918,13 @@ The JSON Patch operations 'remove' and 'add' cannot be applied to the root eleme
 
 ### json.exception.out_of_range.406
 
-A parsed number could not be stored without changing it to NaN or INF. For the binary formats, this happens when a
-finite floating-point number does not fit into [`number_float_t`](../api/basic_json/number_float_t.md), for example a
-double-precision number when `number_float_t` is `#!cpp float`.
+A parsed number could not be stored as without changing it to NaN or INF.
 
-!!! failure "Example messages"
+!!! failure "Example message"
 
     ```
     number overflow parsing '10E1000'
     ```
-    ```
-    [json.exception.out_of_range.406] syntax error while parsing CBOR value: number overflow
-    ```
 
 ### json.exception.out_of_range.407
 

docs/mkdocs/docs/integration/cmake.md

@@ -132,12 +132,6 @@ Build the unit tests when [`BUILD_TESTING`](https://cmake.org/cmake/help/latest/
 
 Enable CI build targets. The exact targets are used during the several CI steps and are subject to change without notice. This option is `OFF` by default.
 
-### `JSON_DeleteDeprecatedFunctions`
-
-Delete the deprecated functions instead of only deprecating them by defining the macro
-[`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md). This option is `OFF` by
-default.
-
 ### `JSON_Diagnostics`
 
 Enable [extended diagnostic messages](../home/exceptions.md#extended-diagnostic-messages) by defining macro [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md). This option is `OFF` by default.

docs/mkdocs/docs/integration/migration_guide.md

@@ -14,13 +14,6 @@ deprecations are annotated with
 [`HEDLEY_DEPRECATED_FOR`](https://nemequ.github.io/hedley/api-reference.html#HEDLEY_DEPRECATED_FOR) to report which
 function to use instead.
 
-!!! tip "Find all calls of deprecated functions"
-
-    Define [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to `1` (or set the
-    CMake option [`JSON_DeleteDeprecatedFunctions`](cmake.md#json_deletedeprecatedfunctions)) to delete all deprecated
-    functions. Every remaining call then fails to compile, even if deprecation warnings are disabled, so your code is
-    ready for version 4.0.0 once it compiles with the macro.
-
 ### Parsing
 
 - Function `friend std::istream& operator<<(basic_json&, std::istream&)` is deprecated since 3.0.0. Please use
@@ -48,10 +41,8 @@ function to use instead.
   [`from_ubjson`](../api/basic_json/from_ubjson.md), and [`from_bson`](../api/basic_json/from_bson.md)) via initializer
   lists is deprecated since 3.8.0. Instead, pass two iterators; for instance, call `from_cbor(ptr, ptr+len)` instead of
   `from_cbor({ptr, len})`. Likewise, passing a pointer and a length as two separate arguments to `from_cbor`,
-  `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0, and to
-  [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) since 3.13.0; call
-  `from_cbor(ptr, ptr+len)` instead of `from_cbor(ptr, len)`. These overloads will not be removed in version 4.0.0, but
-  deleted, so a call like `from_cbor(ptr, len)` cannot compile and convert `len` to the `strict` parameter.
+  `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0; call `from_cbor(ptr, ptr+len)` instead of
+  `from_cbor(ptr, len)`.
 
     === "Deprecated"
   

docs/mkdocs/mkdocs.yml

@@ -366,7 +366,6 @@ nav:
           - 'JSON_BRACE_INIT_COPY_SEMANTICS': api/macros/json_brace_init_copy_semantics.md
           - 'JSON_CATCH_USER, JSON_THROW_USER, JSON_TRY_USER': api/macros/json_throw_user.md
           - 'JSON_DIAGNOSTICS': api/macros/json_diagnostics.md
-          - 'JSON_DELETE_DEPRECATED_FUNCTIONS': api/macros/json_delete_deprecated_functions.md
           - 'JSON_DIAGNOSTIC_POSITIONS': api/macros/json_diagnostic_positions.md
           - 'JSON_DISABLE_ENUM_SERIALIZATION': api/macros/json_disable_enum_serialization.md
           - 'JSON_DISABLE_TUPLE_REFERENCE_CONVERSION': api/macros/json_disable_tuple_reference_conversion.md
@@ -388,7 +387,6 @@ nav:
           - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
           - 'JSON_USE_IMPLICIT_CONVERSIONS': api/macros/json_use_implicit_conversions.md
           - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
-          - 'JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS': api/macros/json_use_objects_for_enum_keyed_maps.md
           - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
           - 'JSON_VIEW_NO_SIMD': api/macros/json_view_no_simd.md
           - 'JSON_VIEW_USE_SSSE3': api/macros/json_view_use_ssse3.md

include/nlohmann/detail/abi_macros.hpp

@@ -50,10 +50,6 @@
     #define JSON_STRICT_BINARY_UTF8 0
 #endif
 
-#ifndef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-#endif
-
 #if JSON_DIAGNOSTICS
     #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -96,20 +92,14 @@
     #define NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8
 #endif
 
-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS _ekmo
-#else
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
-#endif
-
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
     #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif
 
 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g) json_abi ## a ## b ## c ## d ## e ## f ## g
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -119,8 +109,7 @@
             NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
             NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
             NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
-            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

include/nlohmann/detail/conversions/from_json.hpp

@@ -172,7 +172,7 @@ inline void from_json(const BasicJsonType& j, EnumType& e)
           typename BasicJsonType::number_unsigned_t, underlying_type>::type;
     value_type val;
     get_arithmetic_value(j, val);
-    e = static_cast<EnumType>(bool_aware_static_cast<underlying_type>(val));
+    e = static_cast<EnumType>(static_cast<underlying_type>(val));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION
 
@@ -530,40 +530,11 @@ void from_json_pair_array_to_map(const BasicJsonType& j, MapType& m)
     }
 }
 
-// read a map with enum keys from an object, using the enum's own from_json for
-// the keys (e.g., from NLOHMANN_JSON_SERIALIZE_ENUM); this is the form written
-// with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-template<typename BasicJsonType, typename Map>
-inline bool from_json_enum_keyed_object(const BasicJsonType& j, Map& m, std::true_type /*key is enum*/)
-{
-    if (!j.is_object())
-    {
-        return false;
-    }
-    m.clear();
-    for (const auto& p : *j.template get_ptr<const typename BasicJsonType::object_t*>())
-    {
-        m.emplace(BasicJsonType(p.first).template get<typename Map::key_type>(), p.second.template get<typename Map::mapped_type>());
-    }
-    return true;
-}
-
-template<typename BasicJsonType, typename Map>
-inline bool from_json_enum_keyed_object(const BasicJsonType& /*j*/, Map& /*m*/, std::false_type /*key is enum*/)
-{
-    return false;
-}
-
 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
            typename = enable_if_t < !std::is_constructible <
                                         typename BasicJsonType::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
 {
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    if (from_json_enum_keyed_object(j, m, std::is_enum<Key> {}))
-    {
-        return;
-    }
     from_json_pair_array_to_map(j, m);
 }
 
@@ -572,11 +543,6 @@ template < typename BasicJsonType, typename Key, typename Value, typename Hash,
                                         typename BasicJsonType::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
 {
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    if (from_json_enum_keyed_object(j, m, std::is_enum<Key> {}))
-    {
-        return;
-    }
     from_json_pair_array_to_map(j, m);
 }
 

include/nlohmann/detail/conversions/to_json.hpp

@@ -23,7 +23,6 @@
 #include <valarray> // valarray
 #include <vector> // vector
 
-#include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/iterators/iteration_proxy.hpp>
 #include <nlohmann/detail/meta/cpp_future.hpp>
 #include <nlohmann/detail/meta/std_fs.hpp>
@@ -287,20 +286,9 @@ struct external_constructor<value_t::object>
 /////////////
 
 #ifdef JSON_HAS_CPP_17
-// whether storing the value of a std::optional<T> cannot throw; MSVC 2017
-// evaluates std::is_nothrow_assignable as true even if T's to_json throws, so
-// the exception would call std::terminate (#5642)
-#if defined(_MSC_VER) && !defined(__clang__) && _MSC_VER < 1920
-    template<typename BasicJsonType, typename T>
-    using is_nothrow_optional_to_json = std::false_type;
-#else
-    template<typename BasicJsonType, typename T>
-    using is_nothrow_optional_to_json = std::is_nothrow_assignable<BasicJsonType&, const T&>;
-#endif
-
 template<typename BasicJsonType, typename T,
          enable_if_t<std::is_constructible<BasicJsonType, T>::value, int> = 0>
-void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept(is_nothrow_optional_to_json<BasicJsonType, T>::value)
+void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept(std::is_nothrow_assignable<BasicJsonType&, const T&>::value)
 {
     if (opt.has_value())
     {
@@ -376,7 +364,7 @@ inline void to_json(BasicJsonType& j, EnumType e) noexcept
 {
     using underlying_type = typename std::underlying_type<EnumType>::type;
     static constexpr value_t integral_value_t = std::is_unsigned<underlying_type>::value ? value_t::number_unsigned : value_t::number_integer;
-    external_constructor<integral_value_t>::construct(j, bool_aware_static_cast<underlying_type>(e));
+    external_constructor<integral_value_t>::construct(j, static_cast<underlying_type>(e));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION
 
@@ -396,9 +384,6 @@ template < typename BasicJsonType, typename CompatibleArrayType,
                          !is_basic_json<CompatibleArrayType>::value
 #if JSON_HAS_RANGE_VIEW_CONVERSION
     && !is_compatible_range_view<CompatibleArrayType>::value
-#endif
-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    && !is_enum_keyed_map<CompatibleArrayType>::value
 #endif
                          ,
                          int > = 0 >
@@ -453,33 +438,6 @@ inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
     external_constructor<value_t::object>::construct(j, obj);
 }
 
-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-// store a map with enum keys as an object, using the enum's own to_json for the
-// keys (e.g., from NLOHMANN_JSON_SERIALIZE_ENUM); without the macro, such maps
-// are stored as arrays of [key, value] pairs
-template < typename BasicJsonType, typename EnumKeyedMap,
-           enable_if_t < is_enum_keyed_map<EnumKeyedMap>::value&& !is_basic_json<EnumKeyedMap>::value, int > = 0 >
-inline void to_json(BasicJsonType& j, const EnumKeyedMap& map)
-{
-    typename BasicJsonType::object_t obj;
-    for (const auto& p : map)
-    {
-        BasicJsonType key = p.first;
-        if (JSON_HEDLEY_UNLIKELY(!key.is_string()))
-        {
-            JSON_THROW(type_error::create(302, concat("type must be string, but is ", key.type_name()), &key));
-        }
-
-        auto& key_string = *key.template get_ptr<typename BasicJsonType::string_t*>();
-        if (JSON_HEDLEY_UNLIKELY(!obj.emplace(key_string, BasicJsonType(p.second)).second))
-        {
-            JSON_THROW(type_error::create(318, concat("duplicate object key '", key_string, "'"), &key));
-        }
-    }
-    external_constructor<value_t::object>::construct(j, std::move(obj));
-}
-#endif
-
 template<typename BasicJsonType>
 inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
 {

include/nlohmann/detail/input/lexer.hpp

@@ -221,7 +221,7 @@ class lexer : public lexer_base<BasicJsonType>
     // scan functions
     /////////////////////
 
-    /// contiguous input: try to decode the 4 hex digits following `\\u`
+    /// contiguous input: try to decode the 4 hex digits following `\u`
     /// directly from the input buffer via hex_codepoint(), instead of 4 calls
     /// to get(). On success, advances the adapter and the position counters
     /// exactly as those 4 get() calls would (a hex digit is never '\n', so
@@ -2070,39 +2070,6 @@ scan_number_done:
         // read the next character and ignore whitespace
         skip_whitespace();
 
-        return scan_after_whitespace();
-    }
-
-    /*!
-    @brief scan the next token when the caller expects a separator (':' or
-           ',') most of the time
-
-    After an object key the next token is almost always ':', after a value
-    inside an object or array almost always ','. Testing for that character
-    first is a compare and a well-predicted branch, where the switch in
-    scan_after_whitespace() is an indirect jump through a table. Anything else
-    goes through the switch, so the result is the same as scan()'s.
-
-    May only be called after scan() has run once (the BOM check is skipped).
-    */
-    token_type scan_expecting(token_type expected_type)
-    {
-        JSON_ASSERT(expected_type == token_type::name_separator || expected_type == token_type::value_separator);
-        JSON_ASSERT(position.chars_read_total > 0);
-        const char_int_type expected_char = static_cast<unsigned char>((expected_type == token_type::name_separator) ? ':' : ',');
-        skip_whitespace();
-        if (JSON_HEDLEY_LIKELY(current == expected_char))
-        {
-            return expected_type;
-        }
-        return scan_after_whitespace();
-    }
-
-  private:
-    /// the part of scan() after the leading whitespace: skip comments and
-    /// scan the token that starts with current
-    token_type scan_after_whitespace()
-    {
         // ignore comments
         while (ignore_comments && current == '/')
         {
@@ -2182,6 +2149,7 @@ scan_number_done:
         }
     }
 
+  private:
     /// input adapter
     InputAdapterType ia;
 

include/nlohmann/detail/input/parser.hpp

@@ -260,7 +260,7 @@ class parser
                         }
 
                         // parse separator (:)
-                        if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                         {
                             return sax->parse_error(m_lexer.get_position(),
                                                     m_lexer.get_token_string(),
@@ -423,7 +423,7 @@ class parser
             {
                 // comma -> next value
                 // or end of array (ignore_trailing_commas = true)
-                if (get_token_expecting(token_type::value_separator))
+                if (get_token() == token_type::value_separator)
                 {
                     // parse a new value
                     get_token();
@@ -463,7 +463,7 @@ class parser
 
             // comma -> next value
             // or end of object (ignore_trailing_commas = true)
-            if (get_token_expecting(token_type::value_separator))
+            if (get_token() == token_type::value_separator)
             {
                 get_token();
 
@@ -484,7 +484,7 @@ class parser
                     }
 
                     // parse separator (:)
-                    if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                     {
                         return sax->parse_error(m_lexer.get_position(),
                                                 m_lexer.get_token_string(),
@@ -528,13 +528,6 @@ class parser
         return last_token = m_lexer.scan();
     }
 
-    /// get next token from lexer; true if it is the separator @a expected_type
-    /// (name_separator or value_separator), which it usually is
-    bool get_token_expecting(token_type expected_type)
-    {
-        return (last_token = m_lexer.scan_expecting(expected_type)) == expected_type;
-    }
-
     std::string exception_message(const token_type expected, const std::string& context)
     {
         std::string error_msg = "syntax error ";

include/nlohmann/detail/json_pointer.hpp

@@ -88,13 +88,9 @@ class json_pointer
     /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
     operator string_t() const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return to_string();
     }
-#endif
 
 #ifndef JSON_NO_IO
     /// @brief write string representation of the JSON pointer to stream
@@ -1033,13 +1029,9 @@ class json_pointer
     /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
     JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
     bool operator==(const string_t& rhs) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return *this == json_pointer(rhs);
     }
-#endif
 
     /// @brief 3-way compares two JSON pointers
     template<typename RefStringTypeRhs>
@@ -1117,26 +1109,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                        const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
     return lhs == json_pointer<RefStringTypeLhs>(rhs);
 }
-#endif
 
 template<typename RefStringTypeRhs,
          typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const StringType& lhs,
                        const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
     return json_pointer<RefStringTypeRhs>(lhs) == rhs;
 }
-#endif
 
 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
@@ -1150,26 +1134,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                        const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
     return !(lhs == rhs);
 }
-#endif
 
 template<typename RefStringTypeRhs,
          typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const StringType& lhs,
                        const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
     return !(lhs == rhs);
 }
-#endif
 
 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,

include/nlohmann/detail/macro_scope.hpp

@@ -888,10 +888,6 @@
     #define JSON_DISABLE_ENUM_SERIALIZATION 0
 #endif
 
-#ifndef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-#endif
-
 #ifndef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
     #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 0
 #endif

include/nlohmann/detail/macro_unscope.hpp

@@ -45,8 +45,6 @@
     #undef JSON_PRECISE_STREAM_POSITION
     #undef JSON_STRICT_NUL_HANDLING
     #undef JSON_STRICT_BINARY_UTF8
-    #undef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 #endif
 
 #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>

include/nlohmann/detail/meta/type_traits.hpp

@@ -438,30 +438,6 @@ template<typename BasicJsonType, typename CompatibleObjectType>
 struct is_compatible_object_type
     : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
 
-template<typename T>
-using insert_result_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()));
-
-template<typename T>
-using insert_result_second_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()).second);
-
-// a map-like type (std::map, std::unordered_map, ...) whose keys are enums; see
-// JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-template<typename T, typename = void>
-struct is_enum_keyed_map : std::false_type {};
-
-template<typename T>
-struct is_enum_keyed_map <
-    T, enable_if_t < is_detected<mapped_type_t, T>::value&&
-    is_detected<key_type_t, T>::value >>
-{
-    // maps with non-unique keys (std::multimap, std::unordered_multimap, ...)
-    // are excluded, because an object cannot hold duplicate keys; they are
-    // detected by insert() returning an iterator instead of a pair<iterator, bool>
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    static constexpr bool value = std::is_enum<typename T::key_type>::value &&
-                                  !(is_detected<insert_result_t, T>::value && !is_detected<insert_result_second_t, T>::value);
-};
-
 template<typename BasicJsonType, typename ConstructibleObjectType,
          typename = void>
 struct is_constructible_object_type_impl : std::false_type {};
@@ -906,21 +882,6 @@ T conditional_static_cast(U value)
     return value;
 }
 
-// like conditional_static_cast, but converts to bool by comparing with zero,
-// because MSVC 2015 warns about any conversion to bool (C4800), even with an
-// explicit cast; used for enums whose underlying type is bool
-template < typename T, typename U, enable_if_t < !std::is_same<T, bool>::value, int > = 0 >
-T bool_aware_static_cast(U value)
-{
-    return conditional_static_cast<T>(value);
-}
-
-template<typename T, typename U, enable_if_t<std::is_same<T, bool>::value, int> = 0>
-bool bool_aware_static_cast(U value)
-{
-    return value != U();
-}
-
 template<typename... Types>
 using all_integral = conjunction<std::is_integral<Types>...>;
 

include/nlohmann/detail/output/binary_writer.hpp

@@ -127,7 +127,6 @@ class binary_writer
     @throw type_error.316 if a string value or an object key is not valid
            UTF-8
     @throw type_error.317 if @a j is not an object
-    @throw type_error.321 if a value nested in @a j is discarded
     */
     void write_bson(const BasicJsonType& j)
     {
@@ -159,7 +158,6 @@ class binary_writer
     @param[in] j  JSON value to serialize
     @throw type_error.316 if a string value or an object key is not valid
            UTF-8
-    @throw type_error.321 if @a j or a value nested in it is discarded
     */
     void write_cbor(const BasicJsonType& j)
     {
@@ -324,7 +322,7 @@ class binary_writer
 
             case value_t::discarded:
             default:
-                throw_on_discarded(j, "CBOR");
+                break;
         }
     }
 
@@ -384,7 +382,6 @@ class binary_writer
 
     /*!
     @param[in] j  JSON value to serialize
-    @throw type_error.321 if @a j or a value nested in it is discarded
     */
     void write_msgpack(const BasicJsonType& j)
     {
@@ -658,7 +655,7 @@ class binary_writer
 
             case value_t::discarded:
             default:
-                throw_on_discarded(j, "MessagePack");
+                break;
         }
     }
 
@@ -671,7 +668,6 @@ class binary_writer
     @param[in] bjdata_version  which BJData version to use, default is draft2
     @throw type_error.316 if a string value or an object key is not valid
            UTF-8
-    @throw type_error.321 if @a j or a value nested in it is discarded
     */
     void write_ubjson(const BasicJsonType& j, const bool use_count,
                       const bool use_type, const bool add_prefix = true,
@@ -905,7 +901,7 @@ class binary_writer
 
             case value_t::discarded:
             default:
-                throw_on_discarded(j, use_bjdata ? "BJData" : "UBJSON");
+                break;
         }
     }
 
@@ -925,15 +921,6 @@ class binary_writer
     }
 
   private:
-    /*!
-    @brief throws because @a j is discarded and cannot be serialized
-    @throw type_error.321 always
-    */
-    JSON_HEDLEY_NO_RETURN static void throw_on_discarded(const BasicJsonType& j, const char* format_name)
-    {
-        JSON_THROW(type_error::create(321, concat("cannot serialize discarded value to ", format_name), &j));
-    }
-
     //////////
     // BSON //
     //////////
@@ -1185,7 +1172,6 @@ class binary_writer
            into a byte, before anything is written
     @throw type_error.316 if @a j is a string that is not valid UTF-8, before
            anything is written
-    @throw type_error.321 if @a j is discarded
     */
     std::size_t calc_bson_value_size(const BasicJsonType& j)
     {
@@ -1212,12 +1198,10 @@ class binary_writer
             case value_t::null:
                 return 0ul;
 
-            case value_t::discarded:
-                throw_on_discarded(j, "BSON");
-
             // LCOV_EXCL_START
             case value_t::object:
             case value_t::array:
+            case value_t::discarded:
             default:
                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
                 return 0ul;
@@ -1254,12 +1238,10 @@ class binary_writer
             case value_t::null:
                 return write_bson_null(name);
 
-            case value_t::discarded:
-                throw_on_discarded(j, "BSON");
-
             // LCOV_EXCL_START
             case value_t::object:
             case value_t::array:
+            case value_t::discarded:
             default:
                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
                 return;
@@ -1326,8 +1308,6 @@ class binary_writer
            byte, before anything is written
     @throw type_error.316 if a string value or a key is not valid UTF-8,
            before anything is written
-    @throw type_error.321 if a value nested in @a document is discarded,
-           before anything is written
     */
     std::size_t calc_bson_sizes(const BasicJsonType& document, std::vector<std::size_t>& nested_sizes)
     {

include/nlohmann/detail/view/builder.hpp

@@ -164,12 +164,14 @@ class builder
         if (p[1] == '/')
         {
             p += 2;
-            // (as in parse(), a null byte is the end of the input, so it is
-            // left for the caller to see)
             while (p != e && *p != '\n' && *p != '\r' && !(NulIsEnd && *p == 0))
             {
                 ++p;
             }
+            if (NulIsEnd && p != e && *p == 0)
+            {
+                ++p; // as in parse(), a null byte ends the comment like a line break
+            }
             return p;
         }
         if (p[1] == '*')

include/nlohmann/detail/view/serializer.hpp

@@ -426,11 +426,11 @@ class view_serializer
         // copy n bytes of the source (after room(n))
         const auto copy = [&](const char* from, std::size_t n)
         {
-            if (n <= 32 && static_cast<std::size_t>(src_end - from) >= 32)
+            if (n <= 32 && src_end - from >= 32)
             {
                 std::memcpy(w, from, 32);
             }
-            else if (n <= 256 && static_cast<std::size_t>(src_end - from) >= n + 32)
+            else if (n <= 256 && src_end - from >= static_cast<std::ptrdiff_t>(n) + 32)
             {
                 for (std::size_t i = 0; i < n; i += 32)
                 {

include/nlohmann/json.hpp

@@ -613,210 +613,100 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         /// constructor for rvalue binary arrays (internal type)
         json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
 
-private:
-        // raw, allocation-free transfer of m_data from src to dst: no
-        // set_parents()/assert_invariant() (the former is O(#children) per
-        // call under JSON_DIAGNOSTICS, which would make the walk below
-        // quadratic); dst takes ownership, src is left as value_t::null.
-        static void take(basic_json& dst, basic_json& src) noexcept
-        {
-            dst.m_data.m_type = src.m_data.m_type;
-            dst.m_data.m_value = src.m_data.m_value;
-            src.m_data.m_type = value_t::null;
-        }
-
-        // true if v is not an array/object, or is an already-empty one
-        static bool has_no_children(const basic_json& v) noexcept
-        {
-            switch (v.m_data.m_type)
-            {
-                case value_t::array:
-                    return v.m_data.m_value.array->empty();
-                case value_t::object:
-                    return v.m_data.m_value.object->empty();
-                default:
-                    return true;
-            }
-        }
-
-        static basic_json& last_child(basic_json& v)
-        {
-            if (v.m_data.m_type == value_t::array)
-            {
-                return v.m_data.m_value.array->back();
-            }
-            JSON_ASSERT(v.m_data.m_type == value_t::object);
-            return v.m_data.m_value.object->rbegin()->second;
-        }
-
-        // removes the last child of a non-empty array/object v; this never
-        // allocates, and since it is only ever called when that child is a
-        // scalar or an already-empty array/object, destroying it never
-        // recurses more than one level deep (see destroy() below)
-        static void pop_last_child(basic_json& v)
-        {
-            if (v.m_data.m_type == value_t::array)
-            {
-                v.m_data.m_value.array->pop_back();
-            }
-            else
-            {
-                JSON_ASSERT(v.m_data.m_type == value_t::object);
-                // erase() needs a forward iterator, so std::prev(end()) is
-                // used here rather than rbegin() (see last_child() above)
-                v.m_data.m_value.object->erase(std::prev(v.m_data.m_value.object->end()));
-            }
-        }
-
-        // deallocates the (already empty) array/object held by v; this is
-        // the same allocator-based free the old recursive implementation
-        // used, just factored out so every level of the walk in destroy()
-        // can share it
-        static void free_container(basic_json& v) noexcept
-        {
-            if (v.m_data.m_type == value_t::array)
-            {
-                JSON_ASSERT(v.m_data.m_value.array->empty());
-                AllocatorType<array_t> alloc;
-                std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.array);
-                std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.array, 1);
-            }
-            else
-            {
-                JSON_ASSERT(v.m_data.m_type == value_t::object);
-                JSON_ASSERT(v.m_data.m_value.object->empty());
-                AllocatorType<object_t> alloc;
-                std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.object);
-                std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.object, 1);
-            }
-            v.m_data.m_type = value_t::null; // avoid a double free if v is later destructed
-        }
-
-public:
-        void destroy_string() noexcept
-        {
-            if (string == nullptr)
-            {
-                // not initialized (e.g., due to exception in the ctor)
-                return;
-            }
-            AllocatorType<string_t> alloc;
-            std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
-            std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
-        }
-
-        void destroy_binary() noexcept
-        {
-            if (binary == nullptr)
-            {
-                // not initialized (e.g., due to exception in the ctor)
-                return;
-            }
-            AllocatorType<binary_t> alloc;
-            std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
-            std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
-        }
-
-        // t must be value_t::array or value_t::object
-        void destroy_container(value_t t) noexcept
+        void destroy(value_t t)
         {
             if (
                 (t == value_t::object && object == nullptr) ||
-                (t == value_t::array && array == nullptr)
+                (t == value_t::array && array == nullptr) ||
+                (t == value_t::string && string == nullptr) ||
+                (t == value_t::binary && binary == nullptr)
             )
             {
                 // not initialized (e.g., due to exception in the ctor)
                 return;
             }
-
-            // Destroy the tree without recursing per nesting level and
-            // without any heap allocation: a heap-allocated flattening
-            // stack (the previous implementation) can itself throw
-            // bad_alloc, which would escape this noexcept destructor and
-            // terminate the program (#5135).
-            //
-            // Instead, walk down the "last child" chain, reversing links
-            // as we go: cur is the container currently being emptied,
-            // and prev is its parent (value_t::null when there is none).
-            // Each parent's last child slot doubles as storage for that
-            // parent's own parent link while we are below it, so no
-            // extra memory is needed. We only ever remove a child once
-            // it is a scalar or an empty array/object, which neither
-            // allocates nor recurses more than one level deep.
-            //
-            // This json_value is not itself a basic_json, so the
-            // top-level container is first moved into a local stand-in
-            // ("cur"); a default-constructed basic_json has a null
-            // pointer in its m_value (see data::m_value's initializer),
-            // so swapping it with *this leaves this union's own pointer
-            // null, and it is never looked at or freed a second time.
-            basic_json cur;
-            cur.m_data.m_type = t;
-            using std::swap;
-            swap(cur.m_data.m_value, *this);
-
-            basic_json prev; // value_t::null: no parent
-
-            while (true)
+            if (t == value_t::array || t == value_t::object)
             {
-                if (has_no_children(cur))
+                // flatten the current json_value to a heap-allocated stack
+                std::vector<basic_json> stack;
+
+                // move the top-level items to stack
+                if (t == value_t::array)
                 {
-                    if (prev.m_data.m_type == value_t::null)
+                    stack.reserve(array->size());
+                    std::move(array->begin(), array->end(), std::back_inserter(stack));
+                }
+                else
+                {
+                    stack.reserve(object->size());
+                    for (auto&& it : *object)
                     {
-                        free_container(cur);
-                        return; // back at the top with nothing left to do
+                        stack.push_back(std::move(it.second));
+                    }
+                }
+
+                while (!stack.empty())
+                {
+                    // move the last item to a local variable to be processed
+                    basic_json current_item(std::move(stack.back()));
+                    stack.pop_back();
+
+                    // if current_item is array/object, move
+                    // its children to the stack to be processed later
+                    if (current_item.is_array())
+                    {
+                        std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
+
+                        current_item.m_data.m_value.array->clear();
+                    }
+                    else if (current_item.is_object())
+                    {
+                        for (auto&& it : *current_item.m_data.m_value.object)
+                        {
+                            stack.push_back(std::move(it.second));
+                        }
+
+                        current_item.m_data.m_value.object->clear();
                     }
 
-                    // ascend: detach the grandparent link from prev's
-                    // last slot, drop that (now null) slot, free cur
-                    // (it is empty), then move up one level
-                    basic_json gp;
-                    take(gp, last_child(prev));
-                    pop_last_child(prev);
-
-                    free_container(cur);
-
-                    take(cur, prev);
-                    take(prev, gp);
-                    continue;
+                    // it's now safe that current_item gets destructed
+                    // since it doesn't have any children
                 }
-
-                basic_json& cur_last_ref = last_child(cur);
-
-                if (has_no_children(cur_last_ref))
-                {
-                    // scalar, or already-empty array/object
-                    pop_last_child(cur);
-                    continue;
-                }
-
-                // descend into the non-empty last child, reversing the
-                // link: its slot takes over prev, and the child becomes
-                // the new cur
-                basic_json tmp;
-                take(tmp, cur_last_ref);
-                take(cur_last_ref, prev);
-                take(prev, cur);
-                take(cur, tmp);
             }
-        }
 
-        void destroy(value_t t)
-        {
             switch (t)
             {
-                case value_t::string:
-                    destroy_string();
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
                     break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
 
                 case value_t::binary:
-                    destroy_binary();
-                    break;
-
-                case value_t::object:
-                case value_t::array:
-                    destroy_container(t);
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
                     break;
+                }
 
                 case value_t::null:
                 case value_t::boolean:
@@ -825,7 +715,9 @@ public:
                 case value_t::number_float:
                 case value_t::discarded:
                 default:
+                {
                     break;
+                }
             }
         }
     };
@@ -3601,13 +3493,9 @@ public:
                    && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return value(ptr.convert(), default_value);
     }
-#endif
 
     template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
                detail::enable_if_t <
@@ -3616,13 +3504,9 @@ public:
                    && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return value(ptr.convert(), std::forward<ValueType>(default_value));
     }
-#endif
 
     /// @brief access the first element
     /// @sa https://json.nlohmann.me/api/basic_json/front/
@@ -3980,13 +3864,9 @@ public:
     JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return ptr.contains(this);
     }
-#endif
 
     /// @}
 
@@ -4097,13 +3977,9 @@ public:
     ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
     JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
     static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return ref.items();
     }
-#endif
 
     /// @brief wrapper to access iterator member functions in range-based for
     /// @sa https://json.nlohmann.me/api/basic_json/items/
@@ -4112,13 +3988,9 @@ public:
     ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
     JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
     static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return ref.items();
     }
-#endif
 
     /// @brief helper to access iterator member functions in range-based for
     /// @sa https://json.nlohmann.me/api/basic_json/items/
@@ -5207,7 +5079,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
     template<typename ScalarType>
     requires std::is_scalar_v<ScalarType>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) <= rhs;
     }
@@ -5216,7 +5088,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
     template<typename ScalarType>
     requires std::is_scalar_v<ScalarType>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) >= rhs;
     }
@@ -5237,16 +5109,11 @@ public:
 #endif
     }
 
-    // The friend comparisons with a scalar name the JSON type via decltype of
-    // their parameter in noexcept, because older MSVC versions do not see the
-    // class scope there: MSVC 2015 and 2017 take basic_json as the template,
-    // and MSVC 2019 16.0 rejects member types and template parameters.
-
     /// @brief comparison: equal
     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return lhs == basic_json(rhs);
     }
@@ -5255,7 +5122,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) == rhs;
     }
@@ -5271,7 +5138,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return lhs != basic_json(rhs);
     }
@@ -5280,7 +5147,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) != rhs;
     }
@@ -5300,7 +5167,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return lhs < basic_json(rhs);
     }
@@ -5309,7 +5176,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) < rhs;
     }
@@ -5329,7 +5196,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return lhs <= basic_json(rhs);
     }
@@ -5338,7 +5205,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) <= rhs;
     }
@@ -5359,7 +5226,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return lhs > basic_json(rhs);
     }
@@ -5368,7 +5235,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) > rhs;
     }
@@ -5388,7 +5255,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return lhs >= basic_json(rhs);
     }
@@ -5397,7 +5264,7 @@ public:
     /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
     template<typename ScalarType, typename std::enable_if<
                  std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) >= rhs;
     }
@@ -5433,9 +5300,6 @@ public:
         return o;
     }
 
-#if !JSON_DELETE_DEPRECATED_FUNCTIONS
-    // the deleted version is a function template after the class, because
-    // GCC < 5 and Clang < 10 reject deleted friend functions in class templates
     /// @brief serialize to stream
     /// @sa https://json.nlohmann.me/api/operator_ltlt/
     /// @deprecated This function is deprecated since 3.0.0 and will be removed in
@@ -5447,7 +5311,6 @@ public:
     {
         return o << j;
     }
-#endif
 #endif  // JSON_NO_IO
     /// @}
 
@@ -5499,16 +5362,12 @@ public:
                             const bool allow_exceptions = true,
                             const bool ignore_comments = false,
                             const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         basic_json result;
         auto p = parser(i.get(), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas);
         p.parse(true, result);
         return result;
     }
-#endif
 
     /// @brief check if the input is valid JSON
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
@@ -5538,13 +5397,9 @@ public:
     static bool accept(detail::span_input_adapter&& i,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
     }
-#endif
 
     /// @brief generate SAX events
     /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
@@ -5605,9 +5460,6 @@ public:
                           const bool strict = true,
                           const bool ignore_comments = false,
                           const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         auto ia = i.get();
         return format == input_format_t::json
@@ -5616,14 +5468,10 @@ public:
                // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
                : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict);
     }
-#endif
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif
 #ifndef JSON_NO_IO
-#if !JSON_DELETE_DEPRECATED_FUNCTIONS
-    // the deleted version is a function template after the class, because
-    // GCC < 5 and Clang < 10 reject deleted friend functions in class templates
     /// @brief deserialize from stream
     /// @sa https://json.nlohmann.me/api/operator_gtgt/
     /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
@@ -5635,7 +5483,6 @@ public:
     {
         return operator>>(i, j);
     }
-#endif
 
     /// @brief deserialize from stream
     /// @sa https://json.nlohmann.me/api/operator_gtgt/
@@ -5961,13 +5808,9 @@ public:
                                 const bool strict = true,
                                 const bool allow_exceptions = true,
                                 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
     }
-#endif
 
     JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
@@ -5975,13 +5818,9 @@ public:
                                 const bool strict = true,
                                 const bool allow_exceptions = true,
                                 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return from_binary_impl(i.get(), input_format_t::cbor, strict, allow_exceptions, error_handler_t::keep, tag_handler);
     }
-#endif
 
     /// @brief create a JSON value from an input in MessagePack format
     /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
@@ -6014,26 +5853,18 @@ public:
     static basic_json from_msgpack(const T* ptr, std::size_t len,
                                    const bool strict = true,
                                    const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
     }
-#endif
 
     JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
     static basic_json from_msgpack(detail::span_input_adapter&& i,
                                    const bool strict = true,
                                    const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return from_binary_impl(i.get(), input_format_t::msgpack, strict, allow_exceptions);
     }
-#endif
 
     /// @brief create a JSON value from an input in UBJSON format
     /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
@@ -6066,26 +5897,18 @@ public:
     static basic_json from_ubjson(const T* ptr, std::size_t len,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
     }
-#endif
 
     JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
     static basic_json from_ubjson(detail::span_input_adapter&& i,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return from_binary_impl(i.get(), input_format_t::ubjson, strict, allow_exceptions);
     }
-#endif
 
     /// @brief create a JSON value from an input in BJData format
     /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
@@ -6112,20 +5935,6 @@ public:
         return from_binary_impl(detail::input_adapter(std::move(first), std::move(last)), input_format_t::bjdata, strict, allow_exceptions, error_handler);
     }
 
-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bjdata(ptr, ptr + len))
-    static basic_json from_bjdata(const T* ptr, std::size_t len,
-                                  const bool strict = true,
-                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
-    {
-        return from_bjdata(ptr, ptr + len, strict, allow_exceptions);
-    }
-#endif
-
     /// @brief create a JSON value from an input in BON8 format
     /// @sa https://json.nlohmann.me/api/basic_json/from_bon8/
     template<typename InputType>
@@ -6149,20 +5958,6 @@ public:
         return from_binary_impl(detail::input_adapter(std::move(first), std::move(last)), input_format_t::bon8, strict, allow_exceptions);
     }
 
-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bon8(ptr, ptr + len))
-    static basic_json from_bon8(const T* ptr, std::size_t len,
-                                const bool strict = true,
-                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
-    {
-        return from_bon8(ptr, ptr + len, strict, allow_exceptions);
-    }
-#endif
-
     /// @brief create a JSON value from an input in BSON format
     /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
     template<typename InputType>
@@ -6194,26 +5989,18 @@ public:
     static basic_json from_bson(const T* ptr, std::size_t len,
                                 const bool strict = true,
                                 const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return from_bson(ptr, ptr + len, strict, allow_exceptions);
     }
-#endif
 
     JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
     static basic_json from_bson(detail::span_input_adapter&& i,
                                 const bool strict = true,
                                 const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
     {
         return from_binary_impl(i.get(), input_format_t::bson, strict, allow_exceptions);
     }
-#endif
     /// @}
 
     //////////////////////////
@@ -6233,13 +6020,9 @@ public:
     template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return ptr.get_unchecked(this);
     }
-#endif
 
     /// @brief access specified element via JSON Pointer
     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
@@ -6251,13 +6034,9 @@ public:
     template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return ptr.get_unchecked(this);
     }
-#endif
 
     /// @brief access specified element via JSON Pointer
     /// @sa https://json.nlohmann.me/api/basic_json/at/
@@ -6269,13 +6048,9 @@ public:
     template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return ptr.get_checked(this);
     }
-#endif
 
     /// @brief access specified element via JSON Pointer
     /// @sa https://json.nlohmann.me/api/basic_json/at/
@@ -6287,13 +6062,9 @@ public:
     template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
     {
         return ptr.get_checked(this);
     }
-#endif
 
     /// @brief return flattened JSON value
     /// @sa https://json.nlohmann.me/api/basic_json/flatten/
@@ -7270,18 +7041,6 @@ std::string format_as(const NLOHMANN_BASIC_JSON_TPL& j)
     return j.dump();
 }
 
-#if JSON_DELETE_DEPRECATED_FUNCTIONS && !defined(JSON_NO_IO)
-    /// @brief serialize to stream (deleted; use operator<<(std::ostream&, const basic_json&))
-    /// @sa https://json.nlohmann.me/api/operator_ltlt/
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    std::ostream& operator>>(const NLOHMANN_BASIC_JSON_TPL& j, std::ostream& o) = delete;
-
-    /// @brief deserialize from stream (deleted; use operator>>(std::istream&, basic_json&))
-    /// @sa https://json.nlohmann.me/api/operator_gtgt/
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    std::istream& operator<<(NLOHMANN_BASIC_JSON_TPL& j, std::istream& i) = delete;
-#endif
-
 NLOHMANN_JSON_NAMESPACE_END
 
 ///////////////////////

single_include/nlohmann/json_fwd.hpp

@@ -67,10 +67,6 @@
     #define JSON_STRICT_BINARY_UTF8 0
 #endif
 
-#ifndef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-#endif
-
 #if JSON_DIAGNOSTICS
     #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -113,20 +109,14 @@
     #define NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8
 #endif
 
-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS _ekmo
-#else
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
-#endif
-
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
     #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif
 
 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g) json_abi ## a ## b ## c ## d ## e ## f ## g
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -136,8 +126,7 @@
             NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
             NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
             NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
-            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

single_include/nlohmann/json_view.hpp

@@ -1218,12 +1218,14 @@ class builder
         if (p[1] == '/')
         {
             p += 2;
-            // (as in parse(), a null byte is the end of the input, so it is
-            // left for the caller to see)
             while (p != e && *p != '\n' && *p != '\r' && !(NulIsEnd && *p == 0))
             {
                 ++p;
             }
+            if (NulIsEnd && p != e && *p == 0)
+            {
+                ++p; // as in parse(), a null byte ends the comment like a line break
+            }
             return p;
         }
         if (p[1] == '*')
@@ -5802,11 +5804,11 @@ class view_serializer
         // copy n bytes of the source (after room(n))
         const auto copy = [&](const char* from, std::size_t n)
         {
-            if (n <= 32 && static_cast<std::size_t>(src_end - from) >= 32)
+            if (n <= 32 && src_end - from >= 32)
             {
                 std::memcpy(w, from, 32);
             }
-            else if (n <= 256 && static_cast<std::size_t>(src_end - from) >= n + 32)
+            else if (n <= 256 && src_end - from >= static_cast<std::ptrdiff_t>(n) + 32)
             {
                 for (std::size_t i = 0; i < n; i += 32)
                 {

tests/CMakeLists.txt

@@ -8,7 +8,6 @@ set(JSON_SIMDUTF_VERSION 9.1.0 CACHE STRING "The simdutf version used by JSON_Te
 
 set(JSON_32bitTest     AUTO CACHE STRING "Enable the 32bit unit test (ON/OFF/AUTO/ONLY).")
 set(JSON_TestStandards "" CACHE STRING "The list of standards to test explicitly.")
-set(JSON_TestShard     "" CACHE STRING "Build only a part of the unit tests, given as <index>/<count> (e.g. 0/2), to split them across CI jobs with a time limit.")
 
 # using an env var, since this will also affect targets executing cmake (such as "ci_test_compiler_default")
 if (NOT "" STREQUAL "$ENV{JSON_FORCED_GLOBAL_COMPILE_OPTIONS}")
@@ -289,33 +288,6 @@ elseif(NOT json_32bit_test)
     list(FILTER files EXCLUDE REGEX src/unit-32bit.cpp)
 endif()
 
-# with JSON_TestShard=<index>/<count>, keep every <count>-th unit test file,
-# starting at <index> (the glob is sorted, so the split is stable)
-set(test_shard_index 0)
-if(NOT "${JSON_TestShard}" STREQUAL "")
-    if(NOT JSON_TestShard MATCHES "^([0-9]+)/([1-9][0-9]*)$")
-        message(FATAL_ERROR "JSON_TestShard must be <index>/<count>, e.g. 0/2, not '${JSON_TestShard}'.")
-    endif()
-    set(test_shard_index ${CMAKE_MATCH_1})
-    set(test_shard_count ${CMAKE_MATCH_2})
-    if(NOT test_shard_index LESS test_shard_count)
-        message(FATAL_ERROR "JSON_TestShard: the index must be less than the count, not '${JSON_TestShard}'.")
-    endif()
-    list(LENGTH files test_file_count)
-    set(shard_files "")
-    set(file_position 0)
-    foreach(file ${files})
-        math(EXPR file_shard "${file_position} % ${test_shard_count}")
-        if(file_shard EQUAL test_shard_index)
-            list(APPEND shard_files ${file})
-        endif()
-        math(EXPR file_position "${file_position} + 1")
-    endforeach()
-    set(files ${shard_files})
-    list(LENGTH files shard_file_count)
-    message(STATUS "Test shard ${JSON_TestShard}: ${shard_file_count} of ${test_file_count} unit test files")
-endif()
-
 foreach(file ${files})
     json_test_add_test_for(${file} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force})
 endforeach()
@@ -333,9 +305,6 @@ if(json_32bit_test_only)
     return()
 endif()
 
-# the following variants of single test files are only built in the first shard
-if(test_shard_index EQUAL 0)
-
 # test legacy comparison of discarded values
 json_test_set_test_options(test-comparison_legacy
     COMPILE_DEFINITIONS JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1
@@ -382,7 +351,6 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|amd64)$" AND NOT MSVC)
         MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
     )
 endif()
-endif()
 
 # *DO NOT* use json_test_set_test_options() below this line
 

tests/abi/config/default.cpp

@@ -48,10 +48,6 @@ TEST_CASE("default namespace")
         expected += "_sbu8";
 #endif
 
-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-        expected += "_ekmo";
-#endif
-
         expected += "_v" STRINGIZE(NLOHMANN_JSON_VERSION_MAJOR);
         expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_MINOR);
         expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_PATCH) "::basic_json";

tests/abi/config/noversion.cpp

@@ -49,10 +49,6 @@ TEST_CASE("default namespace without version component")
         expected += "_sbu8";
 #endif
 
-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-        expected += "_ekmo";
-#endif
-
         expected += "::basic_json";
 
         // fallback for Clang

tests/src/unit-allocator.cpp

@@ -521,10 +521,6 @@ struct countdown_allocator : std::allocator<T>
 
 TEST_CASE("converting a deeply nested value from another specialization fails cleanly (#5650)")
 {
-    // MSVC 2015's debug STL constructs the containers' debug proxies through
-    // the allocator in noexcept constructors, so a failing construction crashes
-    // the program there instead of throwing std::bad_alloc. Nothing to check.
-#if !(defined(_MSC_VER) && _MSC_VER < 1910 && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0)
     using countdown_json = nlohmann::basic_json<std::map,
           std::vector,
           std::string,
@@ -562,7 +558,6 @@ TEST_CASE("converting a deeply nested value from another specialization fails cl
         }
     }
     CHECK(failures > 0);
-#endif
 }
 
 namespace
@@ -607,88 +602,3 @@ TEST_CASE("bad my_allocator::construct")
         j["test"].push_back("should not leak");
     }
 }
-
-namespace
-{
-std::size_t counting_allocator_allocations = 0;
-std::size_t counting_allocator_deallocations = 0;
-
-template<class T>
-struct counting_allocator : std::allocator<T>
-{
-    using std::allocator<T>::allocator;
-
-    T* allocate(std::size_t n)
-    {
-        ++counting_allocator_allocations;
-        return std::allocator<T>::allocate(n);
-    }
-
-    void deallocate(T* p, std::size_t n)
-    {
-        ++counting_allocator_deallocations;
-        std::allocator<T>::deallocate(p, n);
-    }
-
-    template <class U>
-    struct rebind
-    {
-        using other = counting_allocator<U>;
-    };
-};
-} // namespace
-
-TEST_CASE("destructor performs no allocation, only deallocation")
-{
-    // see https://github.com/nlohmann/json/issues/4842 and
-    // https://github.com/nlohmann/json/issues/5135: destroying nested
-    // arrays/objects used to allocate a temporary stack (first with
-    // std::allocator, later - after #4842 - with the provided allocator).
-    // Since that stack could itself throw bad_alloc from inside the
-    // noexcept destructor (#5135), destroy() no longer allocates anything:
-    // it only ever frees what is already there.
-    using counting_json = nlohmann::basic_json<std::map,
-          std::vector,
-          std::string,
-          bool,
-          std::int64_t,
-          std::uint64_t,
-          double,
-          counting_allocator>;
-
-    SECTION("array")
-    {
-        auto* j = new counting_json({1, {2, {3, 4}}, 5}); // NOLINT(cppcoreguidelines-owning-memory)
-        const auto allocations_before = counting_allocator_allocations;
-        const auto deallocations_before = counting_allocator_deallocations;
-        delete j; // NOLINT(cppcoreguidelines-owning-memory)
-        CHECK(counting_allocator_allocations == allocations_before);
-        CHECK(counting_allocator_deallocations > deallocations_before);
-    }
-
-    SECTION("object")
-    {
-        auto* j = new counting_json({{"a", {{"b", {1, 2}}}}, {"c", 3}}); // NOLINT(cppcoreguidelines-owning-memory)
-        const auto allocations_before = counting_allocator_allocations;
-        const auto deallocations_before = counting_allocator_deallocations;
-        delete j; // NOLINT(cppcoreguidelines-owning-memory)
-        CHECK(counting_allocator_allocations == allocations_before);
-        CHECK(counting_allocator_deallocations > deallocations_before);
-    }
-
-    SECTION("mixed tree of empty/non-empty arrays and objects")
-    {
-        auto* j = new counting_json( // NOLINT(cppcoreguidelines-owning-memory)
-        {
-            {"empty_obj", counting_json::object()},
-            {"empty_arr", counting_json::array()},
-            {"nested", {{"a", counting_json::array({1, 2, counting_json::object()})}, {"b", 3}}},
-            {"tail", counting_json::array({counting_json::array({1}), 2, counting_json::array({3})})}
-        });
-        const auto allocations_before = counting_allocator_allocations;
-        const auto deallocations_before = counting_allocator_deallocations;
-        delete j; // NOLINT(cppcoreguidelines-owning-memory)
-        CHECK(counting_allocator_allocations == allocations_before);
-        CHECK(counting_allocator_deallocations > deallocations_before);
-    }
-}

tests/src/unit-binary_formats.cpp

@@ -11,12 +11,7 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
-#include <cmath>
 #include <fstream>
-#include <limits>
-#include <map>
-#include <string>
-#include <vector>
 #include "make_test_data_available.hpp"
 
 TEST_CASE("Binary Formats" * doctest::skip())
@@ -229,139 +224,3 @@ TEST_CASE("Binary Formats" * doctest::skip())
         CHECK((100.0 * double(ubjson_3_size) / double(json_size)) == Approx(89.450));
     }
 }
-
-namespace
-{
-// the binary formats as function pointers for "Binary formats with narrow number types";
-// named functions rather than lambdas, because clang 3.5 cannot convert a lambda
-// to a function pointer in the braced initializer of the format table
-using narrow_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int32_t, std::uint32_t, float>;
-using bytes = std::vector<std::uint8_t>;
-
-bytes encode_cbor(const json& j)
-{
-    return json::to_cbor(j);
-}
-narrow_json decode_cbor(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_cbor(v, true, allow_exceptions);
-}
-
-bytes encode_msgpack(const json& j)
-{
-    return json::to_msgpack(j);
-}
-narrow_json decode_msgpack(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_msgpack(v, true, allow_exceptions);
-}
-
-bytes encode_ubjson(const json& j)
-{
-    return json::to_ubjson(j);
-}
-narrow_json decode_ubjson(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_ubjson(v, true, allow_exceptions);
-}
-
-bytes encode_bjdata(const json& j)
-{
-    return json::to_bjdata(j);
-}
-narrow_json decode_bjdata(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_bjdata(v, true, allow_exceptions);
-}
-
-// BSON can only store numbers as object members
-bytes encode_bson(const json& j)
-{
-    return json::to_bson(json{{"a", j}});
-}
-narrow_json decode_bson(const bytes& v, bool allow_exceptions)
-{
-    const auto result = narrow_json::from_bson(v, true, allow_exceptions);
-    return result.is_discarded() ? result : result.at("a");
-}
-
-bytes encode_bon8(const json& j)
-{
-    return json::to_bon8(j);
-}
-narrow_json decode_bon8(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_bon8(v, true, allow_exceptions);
-}
-
-} // namespace
-
-TEST_CASE("Binary formats with narrow number types")
-{
-    // Numbers that do not fit the number types are handled like the lexer
-    // handles them in JSON text: an integer that fits neither integer type is
-    // stored as a floating-point number, and a finite floating-point number
-    // that overflows number_float_t is rejected with out_of_range.406.
-    struct binary_format
-    {
-        const char* name;
-        bytes (*encode)(const json&);
-        narrow_json (*decode)(const bytes&, bool);
-    };
-
-    const std::vector<binary_format> formats =
-    {
-        {"CBOR", encode_cbor, decode_cbor},
-        {"MessagePack", encode_msgpack, decode_msgpack},
-        {"UBJSON", encode_ubjson, decode_ubjson},
-        {"BJData", encode_bjdata, decode_bjdata},
-        {"BSON", encode_bson, decode_bson},
-        {"BON8", encode_bon8, decode_bon8},
-    };
-
-    for (const auto& format : formats)
-    {
-        const std::string name = format.name;
-        INFO("format := ", name);
-        const auto roundtrip = [&format](const json & j)
-        {
-            return format.decode(format.encode(j), true);
-        };
-
-        // integers that fit keep their type
-        CHECK(roundtrip(json(-5)).is_number_integer());
-        CHECK(roundtrip(json(-5)).get<std::int32_t>() == -5);
-        CHECK(roundtrip(json(3000000000u)).is_number_unsigned());
-        CHECK(roundtrip(json(3000000000u)).get<std::uint32_t>() == 3000000000u);
-
-        // integers that fit neither integer type are stored as float
-        CHECK(roundtrip(json(5000000000u)).is_number_float());
-        CHECK(roundtrip(json(5000000000u)).get<float>() == 5000000000.0f);
-        if (name != "BON8") // BON8 cannot encode integers above INT64_MAX
-        {
-            CHECK(roundtrip(json(10000000000000000000u)).is_number_float());
-            CHECK(roundtrip(json(10000000000000000000u)).get<float>() == 10000000000000000000.0f);
-        }
-        CHECK(roundtrip(json(-3000000000LL)).is_number_float());
-        CHECK(roundtrip(json(-3000000000LL)).get<float>() == -3000000000.0f);
-        CHECK(roundtrip(json(-5000000000LL)).is_number_float());
-        CHECK(roundtrip(json(-5000000000LL)).get<float>() == -5000000000.0f);
-
-        // floating-point numbers that fit
-        CHECK(roundtrip(json(1.5)).get<float>() == 1.5f);
-        const auto just_above_max = std::nextafter(static_cast<double>((std::numeric_limits<float>::max)()),
-                                    std::numeric_limits<double>::infinity());
-        CHECK(roundtrip(json(just_above_max)).get<float>() == (std::numeric_limits<float>::max)());
-
-        // infinity and NaN are passed on
-        CHECK(std::isinf(roundtrip(json(std::numeric_limits<double>::infinity())).get<float>()));
-        CHECK(std::isnan(roundtrip(json(std::numeric_limits<double>::quiet_NaN())).get<float>()));
-
-        // finite floating-point numbers that overflow number_float_t are rejected
-        const std::string message = "[json.exception.out_of_range.406] syntax error while parsing " + name
-                                    + " value: number overflow";
-        CHECK_THROWS_WITH_AS(roundtrip(json(1e300)), message.c_str(), narrow_json::out_of_range&);
-        CHECK_THROWS_WITH_AS(roundtrip(json(-1e300)), message.c_str(), narrow_json::out_of_range&);
-        CHECK(format.decode(format.encode(json(1e300)), false).is_discarded());
-    }
-}

tests/src/unit-bjdata.cpp

@@ -9,14 +9,6 @@
 #include "doctest_compatibility.h"
 
 #define JSON_TESTS_PRIVATE
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
@@ -114,59 +106,10 @@ TEST_CASE("BJData")
     {
         SECTION("discarded")
         {
-            // a discarded value cannot be serialized to BJData
+            // discarded values are not serialized
             json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-        }
-
-        SECTION("discarded values nested in a container")
-        {
-            json const discarded = json::value_t::discarded;
-
-            SECTION("in an array")
-            {
-                json const j = {1, discarded, 2};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] (/1) cannot serialize discarded value to BJData", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-#endif
-            }
-
-            SECTION("as an object value")
-            {
-                json j;
-                j["a"] = 1;
-                j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to BJData", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-#endif
-            }
-
-            SECTION("nested deeper (array in object in array)")
-            {
-                json inner_array = {1, discarded};
-                json middle_object;
-                middle_object["x"] = inner_array;
-                json const j = {middle_object};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] (/0/x/1) cannot serialize discarded value to BJData", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-#endif
-            }
-
-            SECTION("optimized array of all-discarded elements")
-            {
-                json const j = {discarded, discarded};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j, true, true), "[json.exception.type_error.321] (/0) cannot serialize discarded value to BJData", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j, true, true), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-#endif
-            }
+            const auto result = json::to_bjdata(j);
+            CHECK(result.empty());
         }
 
         SECTION("null")
@@ -4547,33 +4490,3 @@ TEST_CASE("BJData roundtrips" * doctest::skip())
         }
     }
 }
-
-TEST_CASE("issue #5648 - from_bjdata(ptr, len) must read len bytes, not treat ptr as a C string")
-{
-    // to_bjdata() encodes the integer 0 as the two bytes 'i' 0x00 (a BJData
-    // type marker followed by the value byte 0x00), so the packed data
-    // below contains a 0x00 byte before its end.
-    const json j = {{"a", 0}};
-    const std::vector<std::uint8_t> packed = json::to_bjdata(j);
-    bool contains_nul = false;
-    for (const auto byte : packed)
-    {
-        contains_nul |= (byte == 0x00);
-    }
-    REQUIRE(contains_nul);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-    // before the fix, from_bjdata had no (ptr, len) overload, so this call
-    // bound to from_bjdata(InputType&&, bool strict) instead: ptr was read
-    // as a NUL-terminated C string (stopping at the embedded 0x00 byte), and
-    // len was silently converted to the strict flag. The deprecated
-    // overload added for this issue forwards to from_bjdata(ptr, ptr + len,
-    // ...) instead, like from_ubjson's deprecated (ptr, len) overload does.
-    json result;
-    CHECK_NOTHROW(result = json::from_bjdata(packed.data(), packed.size()));
-    CHECK(result == j);
-
-    // len must not collapse into the strict flag either
-    CHECK(json::from_bjdata(packed.data(), packed.size(), false) == j);
-#endif
-}

tests/src/unit-bon8.cpp

@@ -8,14 +8,6 @@
 
 #include "doctest_compatibility.h"
 
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -1022,36 +1014,6 @@ TEST_CASE("BON8 roundtrips" * doctest::skip())
     }
 }
 
-TEST_CASE("issue #5648 - from_bon8(ptr, len) must read len bytes, not treat ptr as a C string")
-{
-    // to_bon8() encodes the integer 40 as the two bytes 0xC2 0x00 (a BON8
-    // lead byte followed by a continuation byte of 0x00), so the packed data
-    // below contains a 0x00 byte before its end.
-    const json j = {{"a", 40}, {"b", "x"}};
-    const std::vector<std::uint8_t> packed = json::to_bon8(j);
-    bool contains_nul = false;
-    for (const auto byte : packed)
-    {
-        contains_nul |= (byte == 0x00);
-    }
-    REQUIRE(contains_nul);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-    // before the fix, from_bon8 had no (ptr, len) overload, so this call
-    // bound to from_bon8(InputType&&, bool strict) instead: ptr was read as
-    // a NUL-terminated C string (stopping at the embedded 0x00 byte), and
-    // len was silently converted to the strict flag. The deprecated
-    // overload added for this issue forwards to from_bon8(ptr, ptr + len,
-    // ...) instead, like from_cbor's deprecated (ptr, len) overload does.
-    json result;
-    CHECK_NOTHROW(result = json::from_bon8(packed.data(), packed.size()));
-    CHECK(result == j);
-
-    // len must not collapse into the strict flag either
-    CHECK(json::from_bon8(packed.data(), packed.size(), false) == j);
-#endif
-}
-
 #ifdef JSON_HAS_CPP_17
 TEST_CASE("BON8 with std::byte")
 {

tests/src/unit-bson.cpp

@@ -8,14 +8,6 @@
 
 #include "doctest_compatibility.h"
 
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
@@ -149,54 +141,6 @@ TEST_CASE("BSON")
             json const j = std::vector<int> {1, 2, 3, 4, 5, 6, 7};
             CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is array", json::type_error&);
         }
-
-        SECTION("discarded")
-        {
-            json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is discarded", json::type_error&);
-        }
-    }
-
-    SECTION("discarded values nested in a container cannot be serialized to BSON")
-    {
-        json const discarded = json::value_t::discarded;
-
-        SECTION("as an object value")
-        {
-            json j;
-            j["a"] = 1;
-            j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to BSON", json::type_error&);
-#else
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] cannot serialize discarded value to BSON", json::type_error&);
-#endif
-        }
-
-        SECTION("in an array that is an object value")
-        {
-            json j;
-            j["a"] = json::array({1, discarded, 2});
-#if JSON_DIAGNOSTICS
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] (/a/1) cannot serialize discarded value to BSON", json::type_error&);
-#else
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] cannot serialize discarded value to BSON", json::type_error&);
-#endif
-        }
-
-        SECTION("nested deeper (array in object in object)")
-        {
-            json inner_array = {1, discarded};
-            json middle_object;
-            middle_object["x"] = inner_array;
-            json j;
-            j["outer"] = middle_object;
-#if JSON_DIAGNOSTICS
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] (/outer/x/1) cannot serialize discarded value to BSON", json::type_error&);
-#else
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] cannot serialize discarded value to BSON", json::type_error&);
-#endif
-        }
     }
 
     SECTION("keys containing code-point U+0000 cannot be serialized to BSON")
@@ -1317,10 +1261,8 @@ TEST_CASE("BSON input that cannot be read is discarded by every overload")
     CHECK_THROWS_AS(_ = json::from_bson(input.begin(), input.end()), json::parse_error&);
     CHECK(json::from_bson(input, true, false).is_discarded());
     CHECK(json::from_bson(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
     CHECK(json::from_bson(input.data(), input.size(), true, false).is_discarded());
     CHECK(json::from_bson({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }
 
 TEST_CASE("BSON SAX parsing stops at every event")
@@ -1798,7 +1740,6 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                 CHECK(j1 == j2);
             }
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
             {
                 INFO_WITH_TEMP(filename + ": uint8_t* and size");
                 // parse JSON file
@@ -1813,7 +1754,6 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                 // compare parsed JSON values
                 CHECK(j1 == j2);
             }
-#endif
 
             {
                 INFO_WITH_TEMP(filename + ": output to output adapters");

tests/src/unit-cbor.cpp

@@ -8,14 +8,6 @@
 
 #include "doctest_compatibility.h"
 
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
@@ -38,49 +30,10 @@ TEST_CASE("CBOR")
     {
         SECTION("discarded")
         {
-            // a discarded value cannot be serialized to CBOR
+            // discarded values are not serialized
             json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error&);
-        }
-
-        SECTION("discarded values nested in a container")
-        {
-            json const discarded = json::value_t::discarded;
-
-            SECTION("in an array")
-            {
-                json const j = {1, discarded, 2};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] (/1) cannot serialize discarded value to CBOR", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error&);
-#endif
-            }
-
-            SECTION("as an object value")
-            {
-                json j;
-                j["a"] = 1;
-                j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to CBOR", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error&);
-#endif
-            }
-
-            SECTION("nested deeper (array in object in array)")
-            {
-                json inner_array = {1, discarded};
-                json middle_object;
-                middle_object["x"] = inner_array;
-                json const j = {middle_object};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] (/0/x/1) cannot serialize discarded value to CBOR", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error&);
-#endif
-            }
+            const auto result = json::to_cbor(j);
+            CHECK(result.empty());
         }
 
         SECTION("NaN")
@@ -2262,10 +2215,8 @@ TEST_CASE("CBOR input that cannot be read is discarded by every overload")
     CHECK_THROWS_AS(_ = json::from_cbor(input.begin(), input.end()), json::parse_error&);
     CHECK(json::from_cbor(input, true, false).is_discarded());
     CHECK(json::from_cbor(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
     CHECK(json::from_cbor(input.data(), input.size(), true, false).is_discarded());
     CHECK(json::from_cbor({input.data(), input.size()}, true, false).is_discarded());
-#endif
 
     // a string that ends early, read through iterators that are not
     // contiguous and have to be copied from one element at a time
@@ -2662,14 +2613,12 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                 CHECK(j1 == j2);
             }
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
             {
                 INFO_WITH_TEMP(filename + ": uint8_t* and size");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_cbor({packed.data(), packed.size()}));
                 CHECK(j1 == j2);
             }
-#endif
 
             {
                 INFO_WITH_TEMP(filename + ": output to output adapters");
@@ -3236,8 +3185,7 @@ TEST_CASE("Tagged values")
         // CBOR encodes negative integers as: result = -1 - n
         // For type 0x3B, n is an 8-byte uint64_t. Valid range for n with
         // the default int64_t is [0, INT64_MAX], producing results in [INT64_MIN, -1].
-        // When n > INT64_MAX, the result exceeds int64_t range and is stored
-        // as a floating-point number, as the lexer does for JSON text.
+        // When n > INT64_MAX, the result exceeds int64_t range and is rejected.
 
         SECTION("n = 0 is valid (result = -1)")
         {
@@ -3258,34 +3206,33 @@ TEST_CASE("Tagged values")
             CHECK(result.get<int64_t>() == (std::numeric_limits<int64_t>::min)());
         }
 
-        SECTION("n = INT64_MAX + 1 is stored as float")
+        SECTION("n = INT64_MAX + 1 is rejected (overflow)")
         {
             // n = INT64_MAX + 1 (0x8000000000000000)
-            // result = -1 - n = -9223372036854775809, which exceeds int64_t range;
-            // the nearest double is -9223372036854775808.0
+            // result = -1 - n = -9223372036854775809, which exceeds int64_t range
             const std::vector<uint8_t> input = {0x3B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-            const auto result = json::from_cbor(input);
-            CHECK(result.is_number_float());
-            CHECK(result.get<double>() == -9223372036854775808.0);
-            CHECK(result == json::parse("-9223372036854775809"));
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_cbor(input),
+                                 "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow",
+                                 json::parse_error);
         }
 
-        SECTION("n = UINT64_MAX is stored as float")
+        SECTION("n = UINT64_MAX is rejected (overflow)")
         {
             // n = UINT64_MAX (0xFFFFFFFFFFFFFFFF)
             // result = -1 - n = -18446744073709551616, which exceeds int64_t range
             const std::vector<uint8_t> input = {0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
-            const auto result = json::from_cbor(input);
-            CHECK(result.is_number_float());
-            CHECK(result.get<double>() == -18446744073709551616.0);
-            CHECK(result == json::parse("-18446744073709551616"));
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_cbor(input),
+                                 "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow",
+                                 json::parse_error);
         }
 
-        SECTION("overflow with allow_exceptions=false is not an error")
+        SECTION("overflow with allow_exceptions=false returns discarded")
         {
             const std::vector<uint8_t> input = {0x3B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
             const auto result = json::from_cbor(input, true, false);
-            CHECK(result.is_number_float());
+            CHECK(result.is_discarded());
         }
     }
 

tests/src/unit-class_lexer.cpp

@@ -689,7 +689,7 @@ TEST_CASE("lexer escape fast path")
                     })
             {
                 const std::string doc = "[\"" + std::string(offset, 'a') + c.first + "\"]";
-                CAPTURE(doc)
+                CAPTURE(doc);
                 CHECK(json::accept(doc) == c.second);
                 std::stringstream ss(doc);
                 CHECK(json::accept(ss) == c.second);
@@ -748,14 +748,14 @@ TEST_CASE("lexer escape fast path")
                     })
             {
                 const std::string doc = "[\"" + std::string(offset, 'a') + escape + "\"]";
-                CAPTURE(doc)
+                CAPTURE(doc);
                 CHECK(outcome(doc, false) == outcome(doc, true));
             }
 
             // the escape is the last thing before end of input: no closing
             // quote at all
             const std::string truncated_doc = "[\"" + escape;
-            CAPTURE(truncated_doc)
+            CAPTURE(truncated_doc);
             CHECK(outcome(truncated_doc, false) == outcome(truncated_doc, true));
         }
     }
@@ -773,7 +773,7 @@ TEST_CASE("lexer escape fast path")
                 })
         {
             const std::string doc = "[\"\\u" + tail;
-            CAPTURE(doc)
+            CAPTURE(doc);
             CHECK(outcome(doc, false) == outcome(doc, true));
             CHECK(outcome(doc, false).find("must be followed by 4 hex digits") != std::string::npos);
         }
@@ -789,7 +789,7 @@ TEST_CASE("lexer escape fast path")
             std::string digits = "1234";
             digits[bad_pos] = 'g'; // not a hex digit
             const std::string doc = "[\"\\u" + digits + "\"]";
-            CAPTURE(doc)
+            CAPTURE(doc);
             CHECK(outcome(doc, false) == outcome(doc, true));
             CHECK(outcome(doc, false).find("must be followed by 4 hex digits") != std::string::npos);
         }
@@ -837,7 +837,7 @@ TEST_CASE("lexer escape fast path")
                 mismatches.push_back(doc);
             }
         }
-        CAPTURE(mismatches)
+        CAPTURE(mismatches);
         CHECK(mismatches.empty());
     }
 #endif
@@ -970,7 +970,7 @@ TEST_CASE("parse_float_native rounds correctly")
         using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
         for (const auto& t : tokens)
         {
-            CAPTURE(t)
+            CAPTURE(t);
             const auto layout = float_token_layout(t);
             const char* const first = t.data();
             const char* const last = first + t.size();
@@ -1572,7 +1572,7 @@ TEST_CASE("Eisel-Lemire float conversion")
             std::array<char, 64> buffer{};
             const char* end = nlohmann::detail::to_chars(buffer.data(), buffer.data() + buffer.size(), f);
             const std::string token(buffer.data(), static_cast<std::size_t>(end - buffer.data()));
-            CAPTURE(token)
+            CAPTURE(token);
             CHECK(native_bits32(token) == b);
         }
     }
@@ -1626,7 +1626,7 @@ TEST_CASE("float conversion of hard cases")
     for (const auto& c : float_hard_cases::cases())
     {
         const std::string token = c.token;
-        CAPTURE(token)
+        CAPTURE(token);
         CHECK(native_bits64(token) == c.bits64);
         CHECK(native_bits32(token) == c.bits32);
         check_parse<json>(token, c.bits64, std::uint64_t{0x7FF0000000000000u});
@@ -1746,8 +1746,8 @@ TEST_CASE("string scanning kernels")
         for (std::size_t offset = 0; offset < 3 && offset <= text.size(); ++offset)
         {
             const std::size_t n = text.size() - offset;
-            CAPTURE(text)
-            CAPTURE(offset)
+            CAPTURE(text);
+            CAPTURE(offset);
             CHECK(nlohmann::detail::find_string_special(data + offset, n) == reference_special(data + offset, n));
             CHECK(nlohmann::detail::find_ascii_copyable_run(data + offset, n) == reference_copyable(data + offset, n));
             CHECK(nlohmann::detail::scalar_string_bulk_run(data + offset, n) == reference_bulk_run(data + offset, n));

tests/src/unit-class_parser.cpp

@@ -2317,58 +2317,6 @@ TEST_CASE("parser class")
 #endif
     }
 
-    SECTION("comments before separators")
-    {
-        // The parser first checks for the expected ':' or ',' and only then
-        // falls back to the full token switch, which skips comments. A comment
-        // directly before a separator takes that fallback.
-        json _;
-
-        SECTION("ignored")
-        {
-            const std::vector<std::pair<std::string, json>> inputs =
-            {
-                {"{\"a\" /* c */ : 1}", {{"a", 1}}},
-                {"{\"a\" // c\n: 1}", {{"a", 1}}},
-                {R"({"a": 1, "b" /* c */ : 2})", {{"a", 1}, {"b", 2}}},
-                {R"({"a": 1 /* c */ , "b": 2})", {{"a", 1}, {"b", 2}}},
-                {"{\"a\": 1 // c\n, \"b\": 2}", {{"a", 1}, {"b", 2}}},
-                {"[1 /* c */ , 2]", {1, 2}},
-                {"[1 // c\n, 2]", {1, 2}},
-                {"{\"a\" /* c */ /* d */ : [1 // c\n , 2 /**/ ] /**/ , \"b\" : 3}", {{"a", {1, 2}}, {"b", 3}}}
-            };
-            for (const auto& input : inputs)
-            {
-                CAPTURE(input.first)
-                CHECK(json::parse(input.first, nullptr, true, true) == input.second);
-                CHECK(json::accept(input.first, true));
-            }
-        }
-
-        SECTION("ignored, with trailing commas")
-        {
-            CHECK(json::parse(std::string("[1 /* c */ , ]"), nullptr, true, true, true) == json({1}));
-            CHECK(json::parse(std::string("{\"a\": 1 /* c */ , }"), nullptr, true, true, true) == json({{"a", 1}}));
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("[1 /* c */ , ]"), nullptr, true, true),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 14: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal", json::parse_error);
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("{\"a\": 1 /* c */ , }"), nullptr, true, true),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 19: syntax error while parsing object key - unexpected '}'; expected string literal", json::parse_error);
-        }
-
-        SECTION("not ignored")
-        {
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("{\"a\" /* c */ : 1}")),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 6: syntax error while parsing object separator - invalid literal; last read: '\"a\" /'; expected ':'", json::parse_error);
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("{\"a\": 1, \"b\" /* c */ : 2}")),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 14: syntax error while parsing object separator - invalid literal; last read: '\"b\" /'; expected ':'", json::parse_error);
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("{\"a\": 1 /* c */ , \"b\": 2}")),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 9: syntax error while parsing object - invalid literal; last read: '1 /'; expected '}'", json::parse_error);
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("[1 /* c */ , 2]")),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing array - invalid literal; last read: '1 /'; expected ']'", json::parse_error);
-            CHECK(!json::accept(std::string("[1 /* c */ , 2]")));
-        }
-    }
-
 #if JSON_DIAGNOSTIC_POSITIONS
     // Macro for all test cases for start_pos and end_pos
 #define SETUP_TESTCASES() \

tests/src/unit-conversions2.cpp

@@ -191,10 +191,8 @@ TEST_CASE("value conversion")
     {
         enum class bool_enum : bool { off, on };
 
-        // the extra parentheses keep doctest from printing the enum via its
-        // underlying type, which MSVC 2015 reports as C4800
-        CHECK((json(bool_enum::off).get<bool_enum>() == bool_enum::off));
-        CHECK((json(bool_enum::on).get<bool_enum>() == bool_enum::on));
+        CHECK(json(bool_enum::off).get<bool_enum>() == bool_enum::off);
+        CHECK(json(bool_enum::on).get<bool_enum>() == bool_enum::on);
     }
 #endif
 
@@ -853,11 +851,8 @@ TEST_CASE("std::optional")
         CHECK_THROWS_WITH_AS(json(opt), "cannot serialize throwing_to_json_type", std::runtime_error&);
 
         // the conversion is noexcept exactly when converting the contained value is
-        // (except with MSVC 2017, where it is never noexcept, see to_json.hpp)
-#if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1920
         static_assert(!std::is_nothrow_constructible<json, const std::optional<throwing_to_json_type>&>::value);
         static_assert(std::is_nothrow_constructible<json, const std::optional<int>&>::value);
-#endif
     }
 #endif
 }

tests/src/unit-delete_deprecated_functions.cpp

@@ -1,229 +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
-
-#include "doctest_compatibility.h"
-
-// This file tests the opt-in JSON_DELETE_DEPRECATED_FUNCTIONS, so it defines the
-// macro itself instead of relying on the build configuration.
-#ifdef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #undef JSON_DELETE_DEPRECATED_FUNCTIONS
-#endif
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 1
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstddef>
-#include <cstdint>
-#include <istream>
-#include <ostream>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-namespace
-{
-template<typename...>
-struct make_void
-{
-    using type = void;
-};
-
-template<typename... Ts>
-using void_t = typename make_void<Ts...>::type;
-
-// A deleted function is still found by overload resolution, but naming it in an
-// unevaluated operand is ill-formed, so each of the following traits is false
-// exactly if the expression selects a deleted (or no) function.
-#define JSON_TEST_DETECT(name, expr)                                 \
-    template<typename J, typename = void>                            \
-    struct name : std::false_type {};                                \
-    template<typename J>                                             \
-    struct name<J, void_t<decltype(expr)>> : std::true_type {}
-
-using ptr_t = const std::uint8_t*;
-
-JSON_TEST_DETECT(from_cbor_ptr_len, J::from_cbor(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_msgpack_ptr_len, J::from_msgpack(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_ubjson_ptr_len, J::from_ubjson(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bjdata_ptr_len, J::from_bjdata(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bon8_ptr_len, J::from_bon8(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bson_ptr_len, J::from_bson(std::declval<ptr_t>(), std::declval<std::size_t>()));
-
-JSON_TEST_DETECT(from_cbor_ptr_ptr, J::from_cbor(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_msgpack_ptr_ptr, J::from_msgpack(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_ubjson_ptr_ptr, J::from_ubjson(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bjdata_ptr_ptr, J::from_bjdata(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bon8_ptr_ptr, J::from_bon8(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bson_ptr_ptr, J::from_bson(std::declval<ptr_t>(), std::declval<ptr_t>()));
-
-JSON_TEST_DETECT(from_cbor_init_list, J::from_cbor({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_msgpack_init_list, J::from_msgpack({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_ubjson_init_list, J::from_ubjson({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_bson_init_list, J::from_bson({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-
-JSON_TEST_DETECT(parse_init_list, J::parse({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(accept_init_list, J::accept({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(sax_parse_init_list, J::sax_parse({std::declval<ptr_t>(), std::declval<std::size_t>()}, std::declval<nlohmann::json_sax<J>*>()));
-JSON_TEST_DETECT(parse_ptr_ptr, J::parse(std::declval<ptr_t>(), std::declval<ptr_t>()));
-
-JSON_TEST_DETECT(iterator_wrapper, J::iterator_wrapper(std::declval<J&>()));
-JSON_TEST_DETECT(iterator_wrapper_const, J::iterator_wrapper(std::declval<const J&>()));
-JSON_TEST_DETECT(items, std::declval<J&>().items());
-
-JSON_TEST_DETECT(json_ltlt_istream, std::declval<J&>() << std::declval<std::istream&>());
-JSON_TEST_DETECT(istream_gtgt_json, std::declval<std::istream&>() >> std::declval<J&>());
-JSON_TEST_DETECT(json_gtgt_ostream, std::declval<const J&>() >> std::declval<std::ostream&>());
-JSON_TEST_DETECT(ostream_ltlt_json, std::declval<std::ostream&>() << std::declval<const J&>());
-
-JSON_TEST_DETECT(ptr_eq_ptr, std::declval<const typename J::json_pointer&>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_ne_ptr, std::declval<const typename J::json_pointer&>() != std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_eq_string, std::declval<const typename J::json_pointer&>() == std::declval<const std::string&>());
-JSON_TEST_DETECT(string_eq_ptr, std::declval<const std::string&>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_eq_c_string, std::declval<const typename J::json_pointer&>() == std::declval<const char*>());
-JSON_TEST_DETECT(c_string_eq_ptr, std::declval<const char*>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_ne_string, std::declval<const typename J::json_pointer&>() != std::declval<const std::string&>());
-JSON_TEST_DETECT(string_ne_ptr, std::declval<const std::string&>() != std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_to_string, std::declval<const typename J::json_pointer&>().to_string());
-
-// json_pointer with a basic_json type as template argument
-template<typename J>
-using legacy_ptr_t = const nlohmann::json_pointer<J>& ;
-JSON_TEST_DETECT(legacy_ptr_value, std::declval<const J&>().value(std::declval<legacy_ptr_t<J>>(), 0));
-JSON_TEST_DETECT(legacy_ptr_value_rvalue, std::declval<const J&>().value(std::declval<legacy_ptr_t<J>>(), std::string()));
-JSON_TEST_DETECT(legacy_ptr_contains, std::declval<const J&>().contains(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(legacy_ptr_subscript, std::declval<J&>()[std::declval<legacy_ptr_t<J>>()]);
-JSON_TEST_DETECT(legacy_ptr_subscript_const, std::declval<const J&>()[std::declval<legacy_ptr_t<J>>()]);
-JSON_TEST_DETECT(legacy_ptr_at, std::declval<J&>().at(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(legacy_ptr_at_const, std::declval<const J&>().at(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(ptr_value, std::declval<const J&>().value(std::declval<const typename J::json_pointer&>(), 0));
-JSON_TEST_DETECT(ptr_at, std::declval<J&>().at(std::declval<const typename J::json_pointer&>()));
-
-#undef JSON_TEST_DETECT
-} // namespace
-
-TEST_CASE("JSON_DELETE_DEPRECATED_FUNCTIONS")
-{
-    // MSVC 2015 does not treat selecting a deleted function in decltype as a
-    // substitution failure, so the traits cannot tell deleted functions apart
-    // there; calling them still fails to compile
-#if !(defined(_MSC_VER) && _MSC_VER < 1910)
-    SECTION("from_* with a pointer and a length")
-    {
-        // the overloads are deleted rather than removed, so the length cannot
-        // silently bind to the strict parameter of from_*(InputType&&, bool)
-        CHECK_FALSE(from_cbor_ptr_len<json>::value);
-        CHECK_FALSE(from_msgpack_ptr_len<json>::value);
-        CHECK_FALSE(from_ubjson_ptr_len<json>::value);
-        CHECK_FALSE(from_bjdata_ptr_len<json>::value);
-        CHECK_FALSE(from_bon8_ptr_len<json>::value);
-        CHECK_FALSE(from_bson_ptr_len<json>::value);
-
-        // the replacement
-        CHECK(from_cbor_ptr_ptr<json>::value);
-        CHECK(from_msgpack_ptr_ptr<json>::value);
-        CHECK(from_ubjson_ptr_ptr<json>::value);
-        CHECK(from_bjdata_ptr_ptr<json>::value);
-        CHECK(from_bon8_ptr_ptr<json>::value);
-        CHECK(from_bson_ptr_ptr<json>::value);
-    }
-
-    SECTION("initializer lists of a pointer and a length")
-    {
-        CHECK_FALSE(from_cbor_init_list<json>::value);
-        CHECK_FALSE(from_msgpack_init_list<json>::value);
-        CHECK_FALSE(from_ubjson_init_list<json>::value);
-        CHECK_FALSE(from_bson_init_list<json>::value);
-        CHECK_FALSE(parse_init_list<json>::value);
-        CHECK_FALSE(accept_init_list<json>::value);
-        CHECK_FALSE(sax_parse_init_list<json>::value);
-
-        // the replacement
-        CHECK(parse_ptr_ptr<json>::value);
-    }
-
-    SECTION("iterator_wrapper")
-    {
-        CHECK_FALSE(iterator_wrapper<json>::value);
-        CHECK_FALSE(iterator_wrapper_const<json>::value);
-
-        // the replacement
-        CHECK(items<json>::value);
-    }
-
-    SECTION("stream operators with reversed operands")
-    {
-        CHECK_FALSE(json_ltlt_istream<json>::value);
-        CHECK_FALSE(json_gtgt_ostream<json>::value);
-
-        // the replacement
-        CHECK(istream_gtgt_json<json>::value);
-        CHECK(ostream_ltlt_json<json>::value);
-    }
-
-    SECTION("json_pointer")
-    {
-        // conversion to a string
-        CHECK_FALSE(std::is_constructible<std::string, json::json_pointer>::value);
-        CHECK_FALSE(std::is_convertible<json::json_pointer, std::string>::value);
-
-        // comparison with a string
-        CHECK_FALSE(ptr_eq_string<json>::value);
-        CHECK_FALSE(string_eq_ptr<json>::value);
-        CHECK_FALSE(ptr_eq_c_string<json>::value);
-        CHECK_FALSE(c_string_eq_ptr<json>::value);
-        CHECK_FALSE(ptr_ne_string<json>::value);
-        CHECK_FALSE(string_ne_ptr<json>::value);
-
-        // the replacement
-        CHECK(ptr_to_string<json>::value);
-        CHECK(ptr_eq_ptr<json>::value);
-        CHECK(ptr_ne_ptr<json>::value);
-    }
-
-    SECTION("json_pointer with a basic_json type as template argument")
-    {
-        CHECK_FALSE(legacy_ptr_value<json>::value);
-        CHECK_FALSE(legacy_ptr_value_rvalue<json>::value);
-        CHECK_FALSE(legacy_ptr_contains<json>::value);
-        CHECK_FALSE(legacy_ptr_subscript<json>::value);
-        CHECK_FALSE(legacy_ptr_subscript_const<json>::value);
-        CHECK_FALSE(legacy_ptr_at<json>::value);
-        CHECK_FALSE(legacy_ptr_at_const<json>::value);
-
-        // the replacement
-        CHECK(ptr_value<json>::value);
-        CHECK(ptr_at<json>::value);
-    }
-
-#endif
-
-    SECTION("the non-deprecated functions still work")
-    {
-        const json j = {{"a", {1, 2}}};
-        const auto cbor = json::to_cbor(j);
-        CHECK(json::from_cbor(cbor.data(), cbor.data() + cbor.size()) == j);
-
-        const json::json_pointer ptr("/a/1");
-        CHECK(ptr == json::json_pointer("/a/1"));
-        CHECK(ptr.to_string() == "/a/1");
-        CHECK(j[ptr] == 2);
-        CHECK(j.at(ptr) == 2);
-        CHECK(j.value(ptr, 0) == 2);
-        CHECK(j.contains(ptr));
-
-        std::ostringstream os;
-        os << j;
-        CHECK(os.str() == R"({"a":[1,2]})");
-        std::istringstream is(os.str());
-        json parsed;
-        is >> parsed;
-        CHECK(parsed == j);
-    }
-}

tests/src/unit-deserialization.cpp

@@ -16,14 +16,6 @@
     #define JSON_TEST_STRICT_NUL_HANDLING_ENABLED 1
 #endif
 
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -299,7 +291,6 @@ TEST_CASE("deserialization")
             }));
         }
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
         SECTION("operator<<")
         {
             std::stringstream ss;
@@ -308,7 +299,6 @@ TEST_CASE("deserialization")
             j << ss;
             CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
         }
-#endif
 
         SECTION("operator>>")
         {
@@ -433,7 +423,6 @@ TEST_CASE("deserialization")
             CHECK_THROWS_WITH_AS(_ = json::parse(nullptr), "[json.exception.parse_error.101] parse error: attempting to parse an empty input; check that your input string or stream contains the expected JSON", json::parse_error&);
         }
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
         SECTION("operator<<")
         {
             std::stringstream ss;
@@ -441,7 +430,6 @@ TEST_CASE("deserialization")
             json j;
             CHECK_THROWS_WITH_AS(j << ss, "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'", json::parse_error&);
         }
-#endif
 
         SECTION("operator>>")
         {
@@ -1160,9 +1148,9 @@ TEST_CASE("deserialization")
         {
             std::istringstream s(bom + "123 456");
             json j;
-            s >> j;
+            j << s;
             CHECK(j == 123);
-            s >> j;
+            j << s;
             CHECK(j == 456);
         }
     }

tests/src/unit-element_access2.cpp

@@ -1551,10 +1551,6 @@ TEST_CASE_TEMPLATE("element access 2", Json, nlohmann::json, nlohmann::ordered_j
         // count(0) used to compile and then crash instead of failing to compile
         using nlohmann::detail::is_detected;
 
-        // MSVC 2015 does not treat selecting a deleted function in decltype as
-        // a substitution failure, so it detects the deleted overloads as
-        // callable; calling them still fails to compile
-#if !(defined(_MSC_VER) && _MSC_VER < 1910)
         CHECK_FALSE(is_detected<can_call_find_with_0, Json&>::value);
         CHECK_FALSE(is_detected<can_call_find_with_0, const Json&>::value);
         CHECK_FALSE(is_detected<can_call_count_with_0, Json&>::value);
@@ -1566,7 +1562,6 @@ TEST_CASE_TEMPLATE("element access 2", Json, nlohmann::json, nlohmann::ordered_j
 
         // another integral literal type must be rejected as well, not just int
         CHECK_FALSE(is_detected<can_call_contains_with_0L, Json&>::value);
-#endif
 
         // the valid overloads must remain callable
         CHECK(is_detected<can_call_find, Json&, const char*>::value);

tests/src/unit-enum_keyed_maps.cpp

@@ -1,246 +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
-
-#include "doctest_compatibility.h"
-
-// skip tests if JSON_DisableEnumSerialization=ON (#4384)
-#if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
-    #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
-#endif
-
-// This file tests the opt-in JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS, so it defines
-// the macro itself rather than relying on a -D flag, and runs in every build.
-// The default behavior is tested in unit-enum_keyed_maps_default.cpp.
-#ifdef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-#endif
-
-#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 1
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-using nlohmann::ordered_json;
-
-#include <cstddef>
-#include <functional>
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#define STRINGIZE_EX(x) #x
-#define STRINGIZE(x) STRINGIZE_EX(x)
-
-// NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
-DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
-
-namespace
-{
-// std::hash is only required for enums since C++14
-struct enum_hash
-{
-    template<typename T>
-    std::size_t operator()(T t) const noexcept
-    {
-        return static_cast<std::size_t>(t);
-    }
-};
-} // namespace
-
-// the example from #4378
-enum TaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
-{
-    TS_STOPPED,
-    TS_RUNNING,
-    TS_COMPLETED,
-    TS_INVALID = -1,
-};
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(TaskState,
-{
-    {TS_INVALID, nullptr},
-    {TS_STOPPED, "stopped"},
-    {TS_RUNNING, "running"},
-    {TS_COMPLETED, "completed"},
-})
-
-enum class color {red, green, blue}; // blue is not mapped and falls back to "red"
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(color,
-{
-    {color::red, "red"},
-    {color::green, "green"},
-})
-
-enum class strict_color {red, green, blue}; // blue is not mapped
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_color,
-{
-    {strict_color::red, "red"},
-    {strict_color::green, "green"},
-})
-
-enum class digit {zero, one};
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(digit,
-{
-    {digit::zero, 0},
-    {digit::one, 1},
-})
-
-#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
-enum class plain {zero, one}; // serialized as integer
-#endif
-
-TEST_CASE("JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS")
-{
-    SECTION("the macro is part of the ABI tag")
-    {
-        const std::string ns = STRINGIZE(NLOHMANN_JSON_NAMESPACE);
-        CHECK(ns.find("_ekmo") != std::string::npos);
-    }
-
-    SECTION("std::map (#4378)")
-    {
-        using task_map = std::map<TaskState, std::string>;
-        const task_map m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"stopped":"aa","completed":"bb"})"));
-        CHECK(j.get<task_map>() == m);
-
-        json j2;
-        j2["x"] = m;
-        CHECK(j2.dump() == R"({"x":{"completed":"bb","stopped":"aa"}})");
-    }
-
-    SECTION("std::map with custom comparator")
-    {
-        using task_map = std::map<TaskState, int, std::greater<TaskState>>;
-        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"stopped":1,"running":2})"));
-        CHECK(j.get<task_map>() == m);
-    }
-
-    SECTION("std::unordered_map")
-    {
-        using task_map = std::unordered_map<TaskState, int, enum_hash>;
-        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"stopped":1,"running":2})"));
-        CHECK(j.get<task_map>() == m);
-    }
-
-    SECTION("nested maps")
-    {
-        using nested_map = std::map<color, std::map<TaskState, int>>;
-        const nested_map m = {{color::green, {{TS_RUNNING, 1}}}, {color::red, {}}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"green":{"running":1},"red":{}})"));
-        CHECK(j.get<nested_map>() == m);
-    }
-
-    SECTION("ordered_json keeps the order of the map")
-    {
-        using task_map = std::map<TaskState, int>;
-        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}, {TS_COMPLETED, 3}};
-        const ordered_json j = m;
-        CHECK(j.dump() == R"({"stopped":1,"running":2,"completed":3})");
-        CHECK(j.get<task_map>() == m);
-    }
-
-    SECTION("empty map")
-    {
-        const json j = std::map<TaskState, int>();
-        CHECK(j.is_object());
-        CHECK(j.empty());
-    }
-
-    SECTION("NLOHMANN_JSON_SERIALIZE_ENUM_STRICT")
-    {
-        using color_map = std::map<strict_color, int>;
-        const color_map m = {{strict_color::red, 1}, {strict_color::green, 2}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"red":1,"green":2})"));
-        CHECK(j.get<color_map>() == m);
-
-        const color_map unmapped = {{strict_color::blue, 1}};
-        json _;
-        CHECK_THROWS_WITH_AS(_ = unmapped,
-                             "[json.exception.out_of_range.410] enum value out of range for strict_color", json::out_of_range&);
-    }
-
-    SECTION("arrays of [key, value] pairs are still read")
-    {
-        using task_map = std::map<TaskState, int>;
-        const task_map m = {{TS_STOPPED, 1}};
-        CHECK(json::parse(R"([["stopped",1]])").get<task_map>() == m);
-    }
-
-    SECTION("other containers are not affected")
-    {
-        const std::vector<std::pair<TaskState, int>> pairs = {{TS_STOPPED, 1}};
-        const std::map<std::string, TaskState> string_keys = {{"a", TS_STOPPED}};
-        const std::map<int, int> int_keys = {{1, 2}};
-        CHECK(json(pairs) == json::parse(R"([["stopped",1]])"));
-        CHECK(json(string_keys) == json::parse(R"({"a":"stopped"})"));
-        CHECK(json(int_keys) == json::parse("[[1,2]]"));
-    }
-
-    SECTION("maps with non-unique keys are still stored as arrays of pairs")
-    {
-        const std::multimap<TaskState, int> mm = {{TS_STOPPED, 1}, {TS_STOPPED, 2}};
-        const std::unordered_multimap<TaskState, int, enum_hash> umm = {{TS_RUNNING, 3}, {TS_RUNNING, 3}};
-        CHECK(json(mm) == json::parse(R"([["stopped",1],["stopped",2]])"));
-        CHECK(json(umm) == json::parse(R"([["running",3],["running",3]])"));
-    }
-
-    SECTION("keys that do not serialize to strings")
-    {
-        const std::map<TaskState, int> null_key = {{TS_INVALID, 1}};
-        const std::map<digit, int> number_key = {{digit::zero, 1}};
-        json j = "unchanged";
-
-        // mapped to null
-        CHECK_THROWS_WITH_AS(j = null_key,
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-
-        // mapped to a number
-        CHECK_THROWS_WITH_AS(j = number_key,
-                             "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
-
-#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
-        // enum without NLOHMANN_JSON_SERIALIZE_ENUM
-        const std::map<plain, int> plain_key = {{plain::zero, 1}};
-        CHECK_THROWS_WITH_AS(j = plain_key,
-                             "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
-#endif
-
-        CHECK(j == "unchanged");
-    }
-
-    SECTION("keys that serialize to the same string")
-    {
-        const std::map<color, int> m = {{color::red, 1}, {color::blue, 2}};
-        json j = "unchanged";
-
-        // color::blue is not mapped and falls back to "red"
-        CHECK_THROWS_WITH_AS(j = m,
-                             "[json.exception.type_error.318] duplicate object key 'red'", json::type_error&);
-
-        CHECK(j == "unchanged");
-    }
-}
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP

tests/src/unit-enum_keyed_maps_default.cpp

@@ -1,144 +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
-
-#include "doctest_compatibility.h"
-
-// This file tests maps with enum keys with the default setting of
-// JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS (or whatever a -D flag sets it to).
-// unit-enum_keyed_maps.cpp tests JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS=1.
-// These tests are not part of unit-conversions.cpp, because that object file
-// is already too big for the MinGW linker of some compilers.
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstddef>
-#include <functional>
-#include <map>
-#include <string>
-#include <unordered_map>
-
-// NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
-DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
-
-enum class cards {kreuz, pik, herz, karo};
-
-// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(cards,
-{
-    {cards::kreuz, "kreuz"},
-    {cards::pik, "pik"},
-    {cards::herz, "herz"},
-    {cards::karo, "karo"}
-})
-
-enum TaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
-{
-    TS_STOPPED,
-    TS_RUNNING,
-    TS_COMPLETED,
-    TS_INVALID = -1,
-};
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(TaskState,
-{
-    {TS_INVALID, nullptr},
-    {TS_STOPPED, "stopped"},
-    {TS_RUNNING, "running"},
-    {TS_COMPLETED, "completed"},
-})
-
-enum class strict_cards {kreuz, pik, herz, karo, andere}; // andere not included in mapping
-
-// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_cards,
-{
-    {strict_cards::kreuz, "kreuz"},
-    {strict_cards::pik, "pik"},
-    {strict_cards::herz, "herz"},
-    {strict_cards::karo, "karo"}
-})
-
-namespace
-{
-// std::hash is only required for enums since C++14
-struct enum_hash
-{
-    template<typename T>
-    std::size_t operator()(T t) const noexcept
-    {
-        return static_cast<std::size_t>(t);
-    }
-};
-} // namespace
-
-// see unit-enum_keyed_maps.cpp for JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS=1
-TEST_CASE("maps with enum keys")
-{
-    using task_map = std::map<TaskState, std::string>;
-    using task_umap = std::unordered_map<TaskState, std::string, enum_hash>;
-    using task_gmap = std::map<TaskState, std::string, std::greater<TaskState>>;
-    using nested_map = std::map<cards, std::map<TaskState, int>>;
-    using strict_map = std::map<strict_cards, int>;
-    using int_map = std::map<int, int>;
-    using int_umap = std::unordered_map<int, int>;
-
-    const task_map m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-#if !JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    SECTION("stored as array of pairs")
-    {
-        CHECK(json(m) == json::parse(R"([["stopped","aa"],["completed","bb"]])"));
-        CHECK(json(task_umap {{TS_RUNNING, "cc"}}) == json::parse(R"([["running","cc"]])"));
-    }
-#endif
-
-    SECTION("read from array of pairs")
-    {
-        CHECK(json::parse(R"([["stopped","aa"],["completed","bb"]])").get<task_map>() == m);
-    }
-
-    SECTION("read from object (#4378)")
-    {
-        const json j = json::parse(R"({"stopped":"aa","completed":"bb"})");
-        CHECK(j.get<task_map>() == m);
-        CHECK(j.get<task_umap>() == task_umap(m.begin(), m.end()));
-        CHECK(j.get<task_gmap>() == task_gmap(m.begin(), m.end()));
-        CHECK(json::parse(R"({"kreuz":{"stopped":1}})").get<nested_map>() == nested_map {{cards::kreuz, {{TS_STOPPED, 1}}}});
-        CHECK(nlohmann::ordered_json::parse(R"({"stopped":"aa","completed":"bb"})").get<task_map>() == m);
-
-        // object keys go through the enum's from_json
-        strict_map sm;
-        CHECK_THROWS_WITH_AS(json::parse(R"({"what?":1})").get_to(sm),
-                             "[json.exception.out_of_range.410] enum value out of range for strict_cards: \"what?\"", json::out_of_range&);
-    }
-
-    SECTION("objects are only read for enum keys")
-    {
-        // built rather than parsed, so that the messages do not gain a byte
-        // range with JSON_DIAGNOSTIC_POSITIONS
-        const json j = {{"1", 2}};
-        int_map im;
-        int_umap ium;
-        CHECK_THROWS_WITH_AS(j.get_to(im),
-                             "[json.exception.type_error.302] type must be array, but is object", json::type_error&);
-        CHECK_THROWS_WITH_AS(j.get_to(ium),
-                             "[json.exception.type_error.302] type must be array, but is object", json::type_error&);
-    }
-
-    SECTION("other types are rejected")
-    {
-        task_map tm;
-        CHECK_THROWS_WITH_AS(json("stopped").get_to(tm),
-                             "[json.exception.type_error.302] type must be array, but is string", json::type_error&);
-    }
-}
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP

tests/src/unit-items.cpp

@@ -8,14 +8,6 @@
 
 #include "doctest_compatibility.h"
 
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
@@ -27,7 +19,6 @@ DOCTEST_GCC_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING("-Wrange-loop-construct")
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
 TEST_CASE("iterator_wrapper")
 {
     SECTION("object")
@@ -724,7 +715,6 @@ TEST_CASE("iterator_wrapper")
         }
     }
 }
-#endif
 
 TEST_CASE("items()")
 {

tests/src/unit-json_pointer.cpp

@@ -9,14 +9,6 @@
 #include "doctest_compatibility.h"
 
 #define JSON_TESTS_PRIVATE
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -572,9 +564,7 @@ TEST_CASE("JSON pointers")
             std::stringstream ss;
             ss << ptr;
             CHECK(ptr.to_string() == ptr_str);
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
             CHECK(std::string(ptr) == ptr_str);
-#endif
             CHECK(ss.str() == ptr_str);
         }
     }
@@ -754,6 +744,8 @@ TEST_CASE("JSON pointers")
 
     SECTION("equality comparison")
     {
+        const char* ptr_cpstring = "/foo/bar";
+        const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
         std::string ptr_string{"/foo/bar"};
         auto ptr1 = json::json_pointer(ptr_string);
         auto ptr2 = json::json_pointer(ptr_string);
@@ -763,12 +755,6 @@ TEST_CASE("JSON pointers")
 
         CHECK(ptr1 == ptr2);
 
-        CHECK_FALSE(ptr1 != ptr2);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-        const char* ptr_cpstring = "/foo/bar";
-        const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
-
         CHECK(ptr1 == "/foo/bar");
         CHECK(ptr1 == ptr_cpstring);
         CHECK(ptr1 == ptr_castring);
@@ -779,6 +765,8 @@ TEST_CASE("JSON pointers")
         CHECK(ptr_castring == ptr1);
         CHECK(ptr_string == ptr1);
 
+        CHECK_FALSE(ptr1 != ptr2);
+
         CHECK_FALSE(ptr1 != "/foo/bar");
         CHECK_FALSE(ptr1 != ptr_cpstring);
         CHECK_FALSE(ptr1 != ptr_castring);
@@ -800,7 +788,6 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_WITH_AS("/~~" == ptr1,
                                  "[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'", json::parse_error&);
         }
-#endif
     }
 
     SECTION("less-than comparison")
@@ -852,7 +839,6 @@ TEST_CASE("JSON pointers")
         json_ptr_j ptr_j{ptr_string};
         json_ptr_oj ptr_oj{ptr_string};
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
         CHECK(j.contains(ptr));
         CHECK(j.contains(ptr_j));
         CHECK(j.contains(ptr_oj));
@@ -865,7 +851,6 @@ TEST_CASE("JSON pointers")
 
         CHECK(j.value(ptr, "x") == j.value(ptr_j, "x"));
         CHECK(j.value(ptr, "x") == j.value(ptr_oj, "x"));
-#endif
 
         CHECK(ptr == ptr_j);
         CHECK(ptr == ptr_oj);

tests/src/unit-json_view.cpp

@@ -134,7 +134,7 @@ TEST_CASE("json_view")
                  "\"\"", "\"text\"", "[]", "[1,2,3]", "{}", "{\"a\":1,\"b\":2}" // NOLINT(modernize-raw-string-literal)
                 })
         {
-            CAPTURE(text)
+            CAPTURE(text);
             const json j = json::parse(text);
             const json_document d = json_document::parse(text);
             const json_view v = d.root();
@@ -175,7 +175,7 @@ TEST_CASE("json_view")
         {
             std::string text;
             g.value(text, 0);
-            CAPTURE(text)
+            CAPTURE(text);
             CHECK(json_document::parse(text).root().materialize() == json::parse(text));
             // member order as ordered_json::parse keeps it
             CHECK(ordered_json_document::parse(text).root().materialize().dump() == ordered_json::parse(text).dump());
@@ -202,7 +202,7 @@ TEST_CASE("json_view")
                     "1e400", "-1e400", "[1.7976931348623159e308]", "{\"a\":\n{\"b\": [1, 2,\n 3 x]}}"
                 })
         {
-            CAPTURE(text)
+            CAPTURE(text);
 #if !defined(JSON_NOEXCEPTION)
             const std::string expected = parse_exception(text);
             REQUIRE(!expected.empty());
@@ -226,7 +226,7 @@ TEST_CASE("json_view")
                 {"// c\n[1]", "[1, /* c */ 2]", "[1,]", "{\"a\":1,}", "[1,/* c */]", "/", "/* ", "[1,,]"
                 })
         {
-            CAPTURE(text)
+            CAPTURE(text);
             for (int options = 0; options < 4; ++options)
             {
                 const bool comments = (options & 1) != 0;
@@ -254,7 +254,7 @@ TEST_CASE("json_view")
                     "1e39", "-1e39", "[3.4028235e38]", "[3.4028236e38]", "{\"a\": [1e38, -3.4028235e38]}", "{\"a\": [1e-50, 1e39]}"
                 })
         {
-            CAPTURE(text)
+            CAPTURE(text);
             const bool accepted = json_float::accept(text);
             CHECK(float_document::accept(text) == accepted);
             CHECK(float_document::parse(text, false).is_discarded() == !accepted);
@@ -540,7 +540,7 @@ TEST_CASE("json_view element access and iteration")
         {
             std::string text;
             g.value(text, 0);
-            CAPTURE(text)
+            CAPTURE(text);
             const ordered_json_document d = ordered_json_document::parse(text);
             check_access(d.root(), ordered_json::parse(text));
         }
@@ -566,7 +566,7 @@ TEST_CASE("json_view element access and iteration")
         const json_view root = d.root();
         for (std::size_t i = 0; i < keys.size(); ++i)
         {
-            CAPTURE(keys[i])
+            CAPTURE(keys[i]);
             CHECK(root[keys[i]].materialize() == i);
             CHECK(root.at(keys[i]).materialize() == i);
             CHECK(root.find(keys[i]).key() == keys[i]);
@@ -604,7 +604,7 @@ TEST_CASE("json_view element access and iteration")
                 {"null", "true", "42", "-1", "1.5", "\"s\"", "[]", "[1,2]", "{}", "{\"a\":1}"
                 })
         {
-            CAPTURE(text)
+            CAPTURE(text);
             const json_document d = json_document::parse(text);
             const json_view v = d.root();
             const json j = v.materialize();
@@ -862,7 +862,7 @@ TEST_CASE("json_view values")
         {
             std::string text;
             g.value(text, 0);
-            CAPTURE(text)
+            CAPTURE(text);
             const ordered_json_document d = ordered_json_document::parse(text);
             check_values(d.root(), ordered_json::parse(text), text);
         }
@@ -916,7 +916,7 @@ TEST_CASE("json_view values")
         using json_float = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
         for (const auto& token : tokens)
         {
-            CAPTURE(token)
+            CAPTURE(token);
             const std::string text = "[" + token + "]";
             const double b = json::parse(text)[0].get<double>();
             CHECK(bits(json_document::parse(text).root()[0].get<double>()) == bits(b));
@@ -1025,7 +1025,7 @@ TEST_CASE("json_view JSON pointers")
             {
                 continue;
             }
-            CAPTURE(text)
+            CAPTURE(text);
             const ordered_json j = ordered_json::parse(text);
             const ordered_json flat = j.flatten();
             for (const auto& leaf : flat.items())
@@ -1033,7 +1033,7 @@ TEST_CASE("json_view JSON pointers")
                 // the leaf and each of its parents
                 for (ordered_json::json_pointer p(leaf.key());; p = p.parent_pointer())
                 {
-                    CAPTURE(p.to_string())
+                    CAPTURE(p.to_string());
                     CHECK(d.root()[p].materialize() == j[p]);
                     CHECK(d.root().at(p).materialize() == j.at(p));
                     CHECK(d.root().contains(p));
@@ -1058,7 +1058,7 @@ TEST_CASE("json_view JSON pointers")
                  "/a/18446744073709551615", "/a/-1", "/a/+1", "/a/ 1", "/x", "/c/x", "/a/0/x", "/a/1/b/c", "/a~0b", "/c~1d", "/c~1d/x", "/a/1/-"
                 })
         {
-            CAPTURE(pointer)
+            CAPTURE(pointer);
             const json::json_pointer p(pointer);
             const std::string at_error = without_path(exception_of([&] { static_cast<void>(j.at(p)); }));
             CHECK(exception_of([&] { static_cast<void>(v.at(p)); }) == at_error);
@@ -1105,7 +1105,7 @@ TEST_CASE("json_view dump")
             {
                 continue;
             }
-            CAPTURE(text)
+            CAPTURE(text);
             const ordered_json j = ordered_json::parse(text);
             for (const int indent :
                     {
@@ -1263,8 +1263,8 @@ TEST_CASE("json_view comparison")
         {
             for (std::size_t k = i; k < i + 3; ++k)
             {
-                CAPTURE(texts[i])
-                CAPTURE(texts[k])
+                CAPTURE(texts[i]);
+                CAPTURE(texts[k]);
                 const json_document a = json_document::parse(texts[i]);
                 const json_document b = json_document::parse(texts[k]);
                 const json ja = json::parse(texts[i]);
@@ -1337,7 +1337,7 @@ TEST_CASE("json_view large objects")
                 127u, 128u, 129u, 10000u
             })
     {
-        CAPTURE(members)
+        CAPTURE(members);
         std::string text = "{";
         for (std::size_t i = 0; i < members; ++i)
         {

tests/src/unit-json_view_builder.cpp

@@ -122,7 +122,7 @@ json value_of(const built& b)
 // with and without a NUL after the text
 void check_same(const std::string& text)
 {
-    CAPTURE(text)
+    CAPTURE(text);
     for (int options = 0; options < 4; ++options)
     {
         const bool comments = (options & 1) != 0;
@@ -161,7 +161,7 @@ void check_string(const std::string& content)
             const built b = build(text, false, false, sentinel);
             if (b.ok != accepted || (accepted && value_of(b) != json::parse(text)))
             {
-                CAPTURE(text)
+                CAPTURE(text);
                 CHECK(b.ok == accepted);
                 CHECK((b.ok && accepted ? value_of(b) == json::parse(text) : true));
             }
@@ -303,7 +303,7 @@ TEST_CASE("json_view builder")
                     "[1.5e38, 3.5e38]", "{\"a\": 1e-50, \"b\": 1e39}"
                 })
         {
-            CAPTURE(text)
+            CAPTURE(text);
             const bool float_accepted = float_json::accept(text);
             for (const bool sentinel :
                     {
@@ -416,7 +416,7 @@ TEST_CASE("json_view builder")
                     "/nativejson-benchmark/twitter.json", "/json_tests/pass1.json", "/json_tests/pass2.json", "/json_tests/pass3.json"
                 })
         {
-            CAPTURE(name)
+            CAPTURE(name);
             std::ifstream f(std::string(TEST_DATA_DIRECTORY) + name, std::ios::binary);
             std::stringstream ss;
             ss << f.rdbuf();

tests/src/unit-json_view_edit.cpp

@@ -212,7 +212,7 @@ TEST_CASE("json_view edits: differential")
             j = ordered_json::object({{"a", random_value(1)}, {"b", random_value(1)}});
         }
         const std::string text = j.dump(r(2) == 0 ? -1 : 2);
-        CAPTURE(text)
+        CAPTURE(text);
         ordered_json_editable_document d = ordered_json_editable_document::parse(text);
         j = ordered_json::parse(text);
         const ordered_json_document other = ordered_json_document::parse(random_value(0).dump());
@@ -338,8 +338,8 @@ TEST_CASE("json_view edits: differential")
                     continue;
                 }
             }
-            CAPTURE(p.to_string())
-            CAPTURE(op)
+            CAPTURE(p.to_string());
+            CAPTURE(op);
             check_all(d, j, e % 8 == 7 || e == edits - 1);
         }
     }
@@ -402,7 +402,7 @@ TEST_CASE("json_view edits: errors")
             {"\xC3\x28", "a\xE2\x28\xA1", "\xF0\x28\x8C\xBC", "\xE2\x82", "x\xF0\x9F\x98", "\xFF", "\xED\xA0\x80", "\xC0\xAF"
             })
     {
-        CAPTURE(bad)
+        CAPTURE(bad);
         const std::string expected = exception_of_call([&]
         {
             const std::string text = json(bad).dump();

tests/src/unit-json_view_image.cpp

@@ -168,7 +168,7 @@ TEST_CASE("json_view images: round trips")
                     "  [1 ,  2 ]  "
                 })
         {
-            CAPTURE(text)
+            CAPTURE(text);
             // false positive: parse() returns a document with a root
             // @infer-ignore NULLPTR_DEREFERENCE
             check_round_trip(json_document::parse(text));
@@ -186,7 +186,7 @@ TEST_CASE("json_view images: round trips")
                     "/nativejson-benchmark/twitter.json", "/json_tests/pass1.json", "/json_tests/pass2.json", "/json_tests/pass3.json"
                 })
         {
-            CAPTURE(name)
+            CAPTURE(name);
             const std::string text = read_file(name);
             const json_document d = json_document::parse(text);
             check_round_trip(d);
@@ -698,7 +698,7 @@ TEST_CASE("json_view images: check")
                     "x.5e300", "01.5e30", "1.xe300", "1.5ex00", "1.5e+x0", "1.5e30x", "-.5e300", "1.5E300"
                 })
         {
-            CAPTURE(token)
+            CAPTURE(token);
             std::vector<std::uint8_t> b = img;
             node n = node_at(b, 1);
             n.extra = 0xFFFFu;

tests/src/unit-msgpack.cpp

@@ -8,14 +8,6 @@
 
 #include "doctest_compatibility.h"
 
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -41,49 +33,10 @@ TEST_CASE("MessagePack")
     {
         SECTION("discarded")
         {
-            // a discarded value cannot be serialized to MessagePack
+            // discarded values are not serialized
             json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error&);
-        }
-
-        SECTION("discarded values nested in a container")
-        {
-            json const discarded = json::value_t::discarded;
-
-            SECTION("in an array")
-            {
-                json const j = {1, discarded, 2};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] (/1) cannot serialize discarded value to MessagePack", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error&);
-#endif
-            }
-
-            SECTION("as an object value")
-            {
-                json j;
-                j["a"] = 1;
-                j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to MessagePack", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error&);
-#endif
-            }
-
-            SECTION("nested deeper (array in object in array)")
-            {
-                json inner_array = {1, discarded};
-                json middle_object;
-                middle_object["x"] = inner_array;
-                json const j = {middle_object};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] (/0/x/1) cannot serialize discarded value to MessagePack", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error&);
-#endif
-            }
+            const auto result = json::to_msgpack(j);
+            CHECK(result.empty());
         }
 
         SECTION("null")
@@ -1842,10 +1795,8 @@ TEST_CASE("MessagePack input that cannot be read is discarded by every overload"
     CHECK_THROWS_AS(_ = json::from_msgpack(input.begin(), input.end()), json::parse_error&);
     CHECK(json::from_msgpack(input, true, false).is_discarded());
     CHECK(json::from_msgpack(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
     CHECK(json::from_msgpack(input.data(), input.size(), true, false).is_discarded());
     CHECK(json::from_msgpack({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }
 
 TEST_CASE("MessagePack SAX parsing stops at every event")
@@ -2148,14 +2099,12 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
                 CHECK(j1 == j2);
             }
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
             {
                 INFO_WITH_TEMP(filename + ": uint8_t* and size");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_msgpack({packed.data(), packed.size()}));
                 CHECK(j1 == j2);
             }
-#endif
 
             {
                 INFO_WITH_TEMP(filename + ": output to output adapters");

tests/src/unit-regression2.cpp

@@ -40,9 +40,7 @@ using ordered_json = nlohmann::ordered_json;
 #endif
 
 #include <cstdio>
-#include <cstdlib>
 #include <list>
-#include <new>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -109,84 +107,6 @@ DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
 
 using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
 
-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
-namespace
-{
-// An allocator whose allocate() can be told to fail on demand, so tests can
-// check that ~basic_json() tolerates - in fact, after #5135, never even
-// triggers - an allocation failure. This replaces an earlier version of
-// this test that overrode the process-wide ::operator new/::operator
-// delete, which affected every allocation in the whole unit-regression2
-// binary rather than just the values under test.
-std::size_t failing_allocator_allocations = 0;
-std::size_t failing_allocator_deallocations = 0;
-bool fail_next_allocation = false;
-
-template<class T>
-struct failing_allocator : std::allocator<T>
-{
-    using std::allocator<T>::allocator;
-
-    failing_allocator() noexcept = default;
-    template<class U>
-    failing_allocator(const failing_allocator<U>& /*unused*/) noexcept {} // NOLINT(google-explicit-constructor)
-
-    T* allocate(std::size_t n)
-    {
-        if (fail_next_allocation)
-        {
-            fail_next_allocation = false;
-            throw std::bad_alloc();
-        }
-        ++failing_allocator_allocations;
-        return std::allocator<T>::allocate(n);
-    }
-
-    void deallocate(T* p, std::size_t n)
-    {
-        ++failing_allocator_deallocations;
-        std::allocator<T>::deallocate(p, n);
-    }
-
-    template<class U>
-    struct rebind
-    {
-        using other = failing_allocator<U>;
-    };
-};
-
-using failing_json = nlohmann::basic_json<std::map, std::vector, std::string, bool,
-      std::int64_t, std::uint64_t, double, failing_allocator>;
-using failing_ordered_json = nlohmann::basic_json<nlohmann::ordered_map, std::vector, std::string, bool,
-      std::int64_t, std::uint64_t, double, failing_allocator>;
-
-// builds `depth` levels of nesting around a scalar, iteratively (never
-// recursing: each wrap only moves the previous, already-built value, which
-// is O(1)), each level an array or an object depending on `nest_objects`
-template<class BasicJsonType>
-BasicJsonType make_deep_nest(std::size_t depth, bool nest_objects)
-{
-    BasicJsonType v = 0;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        if (nest_objects)
-        {
-            BasicJsonType wrapper = BasicJsonType::object();
-            wrapper["x"] = std::move(v);
-            v = std::move(wrapper);
-        }
-        else
-        {
-            BasicJsonType wrapper = BasicJsonType::array();
-            wrapper.push_back(std::move(v));
-            v = std::move(wrapper);
-        }
-    }
-    return v;
-}
-} // namespace
-#endif
-
 /////////////////////////////////////////////////////////////////////
 // for #1647
 /////////////////////////////////////////////////////////////////////
@@ -649,7 +569,7 @@ TEST_CASE("regression tests 2")
     SECTION("issue #2067 - cannot serialize binary data to text JSON")
     {
         const std::array<unsigned char, 23> data = {{0x81, 0xA4, 0x64, 0x61, 0x74, 0x61, 0xC4, 0x0F, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x31, 0x30, 0x37, 0x30, 0x35, 0x30, 0x31, 0x30}};
-        const json j = json::from_msgpack(data.begin(), data.end());
+        const json j = json::from_msgpack(data.data(), data.size());
         // dump() is nodiscard; this only checks that dumping does not throw
         CHECK_NOTHROW(
             utils::ignore_return_value(
@@ -1020,211 +940,4 @@ TEST_CASE("regression test - excessive binary container size honors allow_except
     CHECK(json::from_cbor(std::vector<std::uint8_t> {0x9b, 0, 0, 0, 0, 0, 0, 0, 0x02}, true, false).is_discarded());
 }
 
-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
-TEST_CASE("regression test #5135 - destructor never allocates, even under memory pressure")
-{
-    // Before the fix, ~basic_json() flattened a nested array/object into a
-    // heap-allocated std::vector to avoid recursing; that allocation could
-    // itself throw bad_alloc, which escapes a noexcept destructor and
-    // terminates the program. destroy() no longer allocates anything, so
-    // none of the sections below ever observe fail_next_allocation being
-    // consumed: CHECK(fail_next_allocation) confirms it was never touched.
-
-    SECTION("the original report: a small, mixed array/object nest")
-    {
-        failing_allocator_allocations = 0;
-        failing_allocator_deallocations = 0;
-        {
-            failing_json j = failing_json::array(
-            {
-                failing_json::array({1, 2}),
-                failing_json::object({{"key", failing_json::array({3})}})
-            });
-            fail_next_allocation = true;
-        } // j is destroyed here, with every further allocation set to fail
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_deallocations > 0);
-    }
-
-    SECTION("100000-deep nested array")
-    {
-        std::size_t allocations_before = 0;
-        {
-            failing_json j = make_deep_nest<failing_json>(100000, false);
-            allocations_before = failing_allocator_allocations;
-            fail_next_allocation = true;
-        }
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_allocations == allocations_before);
-    }
-
-    SECTION("100000-deep nested object")
-    {
-        std::size_t allocations_before = 0;
-        {
-            failing_json j = make_deep_nest<failing_json>(100000, true);
-            allocations_before = failing_allocator_allocations;
-            fail_next_allocation = true;
-        }
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_allocations == allocations_before);
-    }
-
-    SECTION("100000-deep nested ordered_json")
-    {
-        std::size_t allocations_before = 0;
-        {
-            failing_ordered_json j = make_deep_nest<failing_ordered_json>(100000, true);
-            allocations_before = failing_allocator_allocations;
-            fail_next_allocation = true;
-        }
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_allocations == allocations_before);
-    }
-
-    SECTION("wide and deep: 1000 arrays of 1000 elements, each a small nested object")
-    {
-        std::size_t allocations_before = 0;
-        {
-            failing_json wide = failing_json::array();
-            for (std::size_t i = 0; i < 1000; ++i)
-            {
-                failing_json inner = failing_json::array();
-                for (std::size_t k = 0; k < 1000; ++k)
-                {
-                    inner.push_back(failing_json::object({{"a", 1}, {"b", failing_json::array({1, 2, 3})}}));
-                }
-                wide.push_back(std::move(inner));
-            }
-
-            allocations_before = failing_allocator_allocations;
-            fail_next_allocation = true;
-        }
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_allocations == allocations_before);
-    }
-}
-#endif
-
-namespace
-{
-// a single-element chain of `depth` arrays, built iteratively (never
-// recursing: each wrap only moves the previous, already-built value)
-template<class BasicJsonType>
-BasicJsonType make_single_chain(std::size_t depth)
-{
-    BasicJsonType v = 1;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        BasicJsonType wrapper = BasicJsonType::array();
-        wrapper.push_back(std::move(v));
-        v = std::move(wrapper);
-    }
-    return v;
-}
-
-// copies value first, to make sure nothing was corrupted by building it,
-// then lets both the copy and the original destruct via normal scope exit
-template<class BasicJsonType>
-void check_destroy_edge_case(const BasicJsonType& value)
-{
-    const BasicJsonType copy = value;
-    CHECK(copy == value);
-}
-} // namespace
-
-TEST_CASE_TEMPLATE("regression test #5135 - destroy() edge cases", BasicJsonType, json, ordered_json)
-{
-    using binary_t = typename BasicJsonType::binary_t;
-
-    SECTION("mix of empty objects, empty arrays, non-empty containers, and scalars")
-    {
-        BasicJsonType root = BasicJsonType::array();
-        root.push_back(BasicJsonType::object());
-        root.push_back(BasicJsonType::array());
-        root.push_back(BasicJsonType::object({{"k", 1}}));
-        root.push_back(BasicJsonType::array({1, 2, 3}));
-        root.push_back(nullptr);
-        root.push_back(true);
-        root.push_back(42);
-        root.push_back(3.14);
-        root.push_back("a string");
-        root.push_back(BasicJsonType(binary_t({1, 2, 3})));
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("container child in first position only")
-    {
-        BasicJsonType root = BasicJsonType::array({BasicJsonType::array({1, 2}), 3, 4, 5});
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("container child in last position only")
-    {
-        BasicJsonType root = BasicJsonType::array({1, 2, 3, BasicJsonType::array({4, 5})});
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("container children in first and last position")
-    {
-        BasicJsonType root = BasicJsonType::array({BasicJsonType::array({1}), 2, 3, BasicJsonType::array({4})});
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("single-element chain, 1000 levels deep")
-    {
-        BasicJsonType root = make_single_chain<BasicJsonType>(1000);
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("top-level empty array")
-    {
-        BasicJsonType root = BasicJsonType::array();
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("top-level empty object")
-    {
-        BasicJsonType root = BasicJsonType::object();
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("object whose last child is a non-empty array whose last child is an empty object")
-    {
-        BasicJsonType inner_array = BasicJsonType::array({1, 2, BasicJsonType::object()});
-        BasicJsonType root = BasicJsonType::object({{"a", 1}, {"b", inner_array}});
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("destruction via erase() on a deeply nested child")
-    {
-        BasicJsonType root = BasicJsonType::array();
-        root.push_back(make_single_chain<BasicJsonType>(500));
-        root.push_back(BasicJsonType::object({{"k", BasicJsonType::array({1, 2, 3})}}));
-        // erase() must destroy the removed subtree without recursing or
-        // allocating beyond what erase() itself needs
-        root.erase(0);
-        CAPTURE(root.size())
-        CHECK(root.size() == 1);
-    }
-
-    SECTION("destruction via assignment on a deep tree")
-    {
-        BasicJsonType root = make_single_chain<BasicJsonType>(2000);
-        // assigning a new value destroys the old one in place
-        root = nullptr;
-        CHECK(root.is_null());
-    }
-}
-
 DOCTEST_CLANG_SUPPRESS_WARNING_POP

tests/src/unit-serialization.cpp

@@ -8,14 +8,6 @@
 
 #include "doctest_compatibility.h"
 
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
@@ -56,7 +48,6 @@ TEST_CASE("serialization")
         }
     }
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
     SECTION("operator>>")
     {
         SECTION("no given width")
@@ -88,7 +79,6 @@ TEST_CASE("serialization")
                   "[\n\t\"foo\",\n\t1,\n\t2,\n\t3,\n\tfalse,\n\t{\n\t\t\"one\": 1\n\t}\n]");
         }
     }
-#endif
 
     SECTION("dump")
     {

tests/src/unit-to_chars.cpp

@@ -643,8 +643,7 @@ std::pair<std::string, int> digits_and_exponent(const std::string& s)
 bool reads_back(const std::string& digits, int e, double v)
 {
     const std::string text = digits + "e" + std::to_string(e);
-    // (compared bit for bit: v is positive and finite, and -Wfloat-equal)
-    return reinterpret_bits<std::uint64_t>(std::strtod(text.c_str(), nullptr)) == reinterpret_bits<std::uint64_t>(v);
+    return std::strtod(text.c_str(), nullptr) == v;
 }
 
 /// Check the representation of a positive finite double: it reads back as
@@ -654,7 +653,7 @@ void check_shortest(double v)
     std::array<char, 33> buf{};
     char* end = nlohmann::detail::to_chars(buf.data(), buf.data() + 32, v);
     const std::string text(buf.data(), end);
-    CAPTURE(text)
+    CAPTURE(text);
     CHECK(std::strtod(text.c_str(), nullptr) == v);
     // the layout is that of format_buffer() for the same digits
     std::array<char, 64> reference{};
@@ -687,7 +686,7 @@ void check_shortest(double v)
                     mid - 1, mid, mid + 1
                 })
         {
-            CAPTURE(candidate)
+            CAPTURE(candidate);
             CHECK(!reads_back(std::to_string(candidate), e, v));
         }
     }
@@ -707,7 +706,7 @@ TEST_CASE("shortest digits of doubles")
         // the 128-bit significands of 10^k, rounded down, recomputed
         for (int k = -342; k <= 341; ++k)
         {
-            CAPTURE(k)
+            CAPTURE(k);
             big x{1};
             if (k >= 0)
             {
@@ -767,7 +766,7 @@ TEST_CASE("shortest digits of doubles")
         {
             const std::uint64_t bits = rng() & 0x7FFFFFFFFFFFFFFFu;
             const auto v = reinterpret_bits<double>(bits);
-            if (std::isfinite(v) && bits != 0)
+            if (std::isfinite(v) && v != 0)
             {
                 check_shortest(v);
             }

tests/src/unit-ubjson.cpp

@@ -8,14 +8,6 @@
 
 #include "doctest_compatibility.h"
 
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
@@ -35,59 +27,10 @@ TEST_CASE("UBJSON")
     {
         SECTION("discarded")
         {
-            // a discarded value cannot be serialized to UBJSON
+            // discarded values are not serialized
             json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-        }
-
-        SECTION("discarded values nested in a container")
-        {
-            json const discarded = json::value_t::discarded;
-
-            SECTION("in an array")
-            {
-                json const j = {1, discarded, 2};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] (/1) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
-            }
-
-            SECTION("as an object value")
-            {
-                json j;
-                j["a"] = 1;
-                j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
-            }
-
-            SECTION("nested deeper (array in object in array)")
-            {
-                json inner_array = {1, discarded};
-                json middle_object;
-                middle_object["x"] = inner_array;
-                json const j = {middle_object};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] (/0/x/1) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
-            }
-
-            SECTION("optimized array of all-discarded elements")
-            {
-                json const j = {discarded, discarded};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j, true, true), "[json.exception.type_error.321] (/0) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j, true, true), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
-            }
+            const auto result = json::to_ubjson(j);
+            CHECK(result.empty());
         }
 
         SECTION("null")
@@ -2148,14 +2091,9 @@ TEST_CASE("UBJSON")
 
         SECTION("discarded")
         {
-            // a discarded value cannot be serialized to UBJSON, even as part
-            // of an optimized array of a single (here: valueless) type
             json const j = {json::value_t::discarded, json::value_t::discarded};
-#if JSON_DIAGNOSTICS
-            CHECK_THROWS_WITH_AS(json::to_ubjson(j, true, true), "[json.exception.type_error.321] (/0) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-            CHECK_THROWS_WITH_AS(json::to_ubjson(j, true, true), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
+            std::vector<uint8_t> expected = {'[', '$', 'N', '#', 'i', 2};
+            CHECK(json::to_ubjson(j, true, true) == expected);
         }
     }
 }
@@ -2274,10 +2212,8 @@ TEST_CASE("UBJSON input that cannot be read is discarded by every overload")
     CHECK_THROWS_AS(_ = json::from_ubjson(input.begin(), input.end()), json::parse_error&);
     CHECK(json::from_ubjson(input, true, false).is_discarded());
     CHECK(json::from_ubjson(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
     CHECK(json::from_ubjson(input.data(), input.size(), true, false).is_discarded());
     CHECK(json::from_ubjson({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }
 
 TEST_CASE("UBJSON SAX parsing stops at every event")
@@ -3025,14 +2961,12 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
                 CHECK(j1 == j2);
             }
 
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
             {
                 INFO_WITH_TEMP(filename + ": uint8_t* and size");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_ubjson({packed.data(), packed.size()}));
                 CHECK(j1 == j2);
             }
-#endif
 
             {
                 INFO_WITH_TEMP(filename + ": output to output adapters");