Build the update()/merge_patch() diagnostics test values instead of parsing them

Parsed values carry byte positions under JSON_DIAGNOSTIC_POSITIONS, which
the expected messages do not include.

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -2,7 +2,6 @@
 
 - [ ] The changes are described in detail, both the what and why.
 - [ ] If applicable, an [existing issue](https://github.com/nlohmann/json/issues) is referenced.
-- [ ] If applicable, a fixed [OSS-Fuzz](https://issues.oss-fuzz.com) issue is referenced as `OSS-Fuzz: <id>` (see [fuzz testing](https://github.com/nlohmann/json/blob/develop/tests/fuzzing.md#handling-oss-fuzz-reports)).
 - [ ] The [Code coverage](https://coveralls.io/github/nlohmann/json) remained at 100%. A test case for every new line of code.
 - [ ] If applicable, the [documentation](https://json.nlohmann.me) is updated.
 - [ ] The source code is amalgamated by running `make amalgamate`.

.github/workflows/windows.yml

@@ -124,11 +124,11 @@ jobs:
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Run CMake (Release)
-        run: cmake -S . -B build -G "Visual Studio 18 2026" -A ARM64 -DJSON_BuildTests=On -DCMAKE_CXX_FLAGS="/W4 /WX"
+        run: cmake -S . -B build -G "Visual Studio 17 2022" -A ARM64 -DJSON_BuildTests=On -DCMAKE_CXX_FLAGS="/W4 /WX"
         if: matrix.build_type == 'Release'
         shell: pwsh
       - name: Run CMake (Debug)
-        run: cmake -S . -B build -G "Visual Studio 18 2026" -A ARM64 -DJSON_BuildTests=On -DJSON_FastTests=ON -DCMAKE_CXX_FLAGS="/W4 /WX"
+        run: cmake -S . -B build -G "Visual Studio 17 2022" -A ARM64 -DJSON_BuildTests=On -DJSON_FastTests=ON -DCMAKE_CXX_FLAGS="/W4 /WX"
         if: matrix.build_type == 'Debug'
         shell: pwsh
       - name: Build

BUILD.bazel

@@ -71,6 +71,7 @@ cc_library(
     ],
     includes = ["include"],
     visibility = ["//visibility:public"],
+    alwayslink = True,
 )
 
 cc_library(

cmake/ci.cmake

@@ -300,10 +300,10 @@ add_custom_target(ci_test_skiplibraryversioncheck
 # Disable thread-local storage.
 ###############################################################################
 
-# Without thread-local storage, copying and comparing cannot bound their
-# descent and handle every object and array without the call stack. Those paths
-# are otherwise only reached by values nested deeper than the bound, so this
-# target is what runs the whole test suite through them.
+# Without thread-local storage, the copy constructor cannot bound its descent
+# and copies every object and array without the call stack. That path is
+# otherwise only reached by values nested deeper than the bound, so this target
+# is what runs the whole test suite through it.
 add_custom_target(ci_test_no_thread_local
     COMMAND ${CMAKE_COMMAND}
     -DCMAKE_BUILD_TYPE=Debug -GNinja

cmake/scripts/gen_bazel_build_file.cmake

@@ -42,6 +42,7 @@ string(APPEND CONTENT [=[
     ],
     includes = ["include"],
     visibility = ["//visibility:public"],
+    alwayslink = True,
 )
 
 cc_library(

docs/mkdocs/docs/api/basic_json/get_to.md

@@ -21,10 +21,6 @@ This overload is chosen if:
 - `ValueType` is not `basic_json`,
 - `json_serializer<ValueType>` has a `from_json()` method of the form `void from_json(const basic_json&, ValueType&)`
 
-`v` must not be `const`. Passing a `const` object is a compile-time error. For types such as arithmetic types, enums,
-and C arrays, the error is a `static_assert` that names the problem. For other types, the overload is not viable, and
-the compiler reports that no matching `get_to` was found.
-
 ## Template parameters
 
 `ValueType`
@@ -71,4 +67,3 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
 ## Version history
 
 - Since version 3.3.0.
-- Added a `static_assert` with a clear message for `const` arguments in version 3.13.0.

docs/mkdocs/docs/api/basic_json/sax_parse.md

@@ -69,9 +69,7 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
      [`input_format_t`](input_format_t.md) for more information
 
 `strict` (in)
-:   whether the input has to be consumed completely (optional, `#!cpp true` by default); when `#!cpp false` and the
-    input is a `#!cpp std::istream`, the character that terminates a number is consumed unless
-    [`JSON_PRECISE_STREAM_POSITION`](../macros/json_precise_stream_position.md) is defined to `1`; see [`operator>>`](../operator_gtgt.md#notes)
+:   whether the input has to be consumed completely (optional, `#!cpp true` by default)
 
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
@@ -138,8 +136,6 @@ A UTF-8 byte order mark is silently ignored.
 - Added `ignore_trailing_commas` in version 3.13.0.
 - 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.
-- `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave a `#!cpp std::istream` positioned right
-  after the parsed value when `strict` is `#!cpp false`.
 
 !!! warning "Deprecation"
 

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

@@ -16,8 +16,6 @@ header. See also the [macro overview page](../../features/macros.md).
 
 ## Parsing
 
-- [**JSON_PRECISE_STREAM_POSITION**](json_precise_stream_position.md) - opt in to leaving an input stream positioned
-  right after a parsed number
 - [**JSON_STRICT_NUL_HANDLING**](json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input instead of
   treating it as end of input
 

docs/mkdocs/docs/api/macros/json_no_thread_local.md

@@ -7,16 +7,16 @@
 When defined, the library does not use `#!cpp thread_local` storage. This is relevant for the few environments whose
 toolchain does not support it.
 
-Copying a value and comparing two values both descend into the first levels by letting the containers copy or compare
-themselves, and finish whatever is nested deeper than that without the call stack, so that neither can exhaust the stack
-however deeply the values are nested. Each counts the levels it has descended into in a `#!cpp thread_local` variable, as
-a counter shared between threads would be raced.
+The copy constructor copies the first levels of a value by copying the containers, which copy their elements, and
+completes whatever is nested deeper than that without the call stack, so that copying a value cannot exhaust the stack
+however deeply it is nested. It counts the levels it has descended into in a `#!cpp thread_local` variable, as a counter
+shared between threads would be raced.
 
-Without those counters, no descent can be bounded safely, so objects and arrays are copied and compared without the call
-stack right away. Both keep working exactly as they do otherwise - the same values come out, the same comparisons hold,
-and deeply nested values are handled just as safely - but both are slower, because the containers no longer copy or
-compare themselves. Copying the benchmark documents takes 9% (`canada.json`) to 34% (`twitter.json`) longer, and
-comparing two equal ones 10% (`citm_catalog.json`) to 90% (`canada.json`) longer.
+Without that counter, no descent can be bounded safely, so objects and arrays are copied without the call stack right
+away. Copying keeps working exactly as it does otherwise - the same values come out, and deeply nested values are copied
+just as safely - but copying is slower, because the containers no longer copy themselves. Copying the benchmark
+documents takes 9% (`canada.json`) to 34% (`twitter.json`) longer; values built mostly from objects are affected the
+most.
 
 ## Default definition
 
@@ -28,7 +28,6 @@ By default, `#!cpp JSON_NO_THREAD_LOCAL` is not defined.
 
 The library defines it by itself for Clang targeting MinGW, which does not survive the `#!cpp thread_local` storage:
 copying a value segfaults there, with both old and current Clang versions, while GCC targeting MinGW is unaffected.
-Copying and comparing fall back to working without the call stack there, as they do whenever the macro is defined.
 
 ## Examples
 

docs/mkdocs/docs/api/macros/json_precise_stream_position.md

@@ -1,131 +0,0 @@
-# JSON_PRECISE_STREAM_POSITION
-
-```cpp
-#define JSON_PRECISE_STREAM_POSITION /* value */
-```
-
-When defined to `1`, [`operator>>`](../operator_gtgt.md) and [`sax_parse`](../basic_json/sax_parse.md) with
-`strict = false` leave a `#!cpp std::istream` positioned right after the parsed value for every value type. By default,
-the character that terminates a number is consumed as well.
-
-The macro only affects reading from a `#!cpp std::istream` when the rest of the stream is not required to be consumed.
-[`parse`](../basic_json/parse.md), [`accept`](../basic_json/accept.md), and all other inputs (strings, iterators,
-containers, `#!cpp FILE*`) are never affected.
-
-## Default definition
-
-The default value is `0` (disabled — existing behavior is preserved).
-
-```cpp
-#define JSON_PRECISE_STREAM_POSITION 0
-```
-
-## Notes
-
-!!! note "Background"
-
-    A number is the only JSON value whose end can be detected solely by reading the character that follows it. By
-    default, that character is consumed and not put back, so the stream is left one byte too far after a number, and
-    only after a number:
-
-    ```cpp
-    std::istringstream input("1true");
-    json j;
-    input >> j;  // j == 1, but the stream now starts at "rue"
-    ```
-
-    With this macro, the character is only looked at and left in the stream, so the stream starts at `true`. This
-    does not require the stream buffer to support putting a character back.
-
-    This was not changed unconditionally, because code can depend on the consumed character, even unknowingly (see
-    [#5340](https://github.com/nlohmann/json/issues/5340)). Both of the following work by default only because the
-    character after each number is swallowed, and behave differently with this macro:
-
-    ```cpp
-    std::istringstream input("1,2,3");
-    json j1, j2, j3;
-    input >> j1 >> j2 >> j3;  // default: 1, 2, 3
-                              // with the macro: throws parse_error.101 at the ','
-    ```
-
-    ```cpp
-    std::istringstream input("42\nfoo");
-    json j;
-    std::string line;
-    input >> j;
-    std::getline(input, line);  // default: "foo"
-                                // with the macro: "" (like after reading an int with >>)
-    ```
-
-    In both cases, the behavior with the macro is what you already get today when the value is not a number: `"a","b"`
-    fails at the `,`, and `std::getline` after `{}` returns an empty string. This macro offers an opt-in path to
-    the consistent behavior ahead of version 4.0.0, where it is planned to become the default.
-
-!!! 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 `_psp`), 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.
-
-!!! tip "Workaround without the macro"
-
-    Separate the values in the stream with whitespace. The character consumed after a number is then the separator,
-    and whitespace before the next value is skipped anyway.
-
-## Examples
-
-??? example "Default behavior (macro not defined)"
-
-    Without the macro, the character after a number is consumed:
-
-    ```cpp
-    #include <iostream>
-    #include <sstream>
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        std::istringstream input("1true");
-        json j1, j2;
-        input >> j1;  // j1 == 1
-        input >> j2;  // throws parse_error.101: the stream now starts at "rue"
-    }
-    ```
-
-??? example "Opt-in precise stream position (macro defined to 1)"
-
-    With the macro, the stream is positioned right after the number:
-
-    ```cpp
-    #define JSON_PRECISE_STREAM_POSITION 1
-    #include <iostream>
-    #include <sstream>
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        std::istringstream input("1true");
-        json j1, j2;
-        input >> j1;  // j1 == 1
-        input >> j2;  // j2 == true
-    }
-    ```
-
-## See also
-
-- [**operator>>**](../operator_gtgt.md) - deserialize from stream
-- [**sax_parse**](../basic_json/sax_parse.md) - generate SAX events
-
-## 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/operator_gtgt.md

@@ -67,9 +67,7 @@ input >> j2;  // parses the next value
     Only numbers are affected. Values ending in a self-delimiting character do not read past themselves, so
     `truefalse`, `[1][2]`, `{"a":1}{"b":2}`, and `"a""b"` can be read back to back without a separator.
 
-    Define [`JSON_PRECISE_STREAM_POSITION`](macros/json_precise_stream_position.md) to `1` to leave the terminating character in the stream
-    instead, so that the stream is positioned right after the value for every value type and no separator is
-    needed. This is tracked in [#5340](https://github.com/nlohmann/json/issues/5340).
+    This is tracked in [#5340](https://github.com/nlohmann/json/issues/5340).
 
 Note that reading concatenated values does **not** work for [JSON Lines](../features/parsing/json_lines.md)
 (newline-delimited JSON) input -- see that page for why and for the recommended alternative.
@@ -109,12 +107,9 @@ being read.
 - [parse](basic_json/parse.md) - deserialize from a compatible input
 - [`JSON_STRICT_NUL_HANDLING`](macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
   instead of treating it as end of input
-- [`JSON_PRECISE_STREAM_POSITION`](macros/json_precise_stream_position.md) - opt in to leaving the stream positioned right after a number
 
 ## Version history
 
 - Added in version 1.0.0.
 - `JSON_STRICT_NUL_HANDLING` added in version 3.13.0 to optionally reject a NUL byte in the input instead of treating
   it as end of input; planned to become the default in version 4.0.0.
-- `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave the character that terminates a number in
-  the stream; planned to become the default in version 4.0.0.

docs/mkdocs/docs/community/assurance_case.md

@@ -1,70 +0,0 @@
-# Assurance case
-
-This page argues why the library meets its security requirements. It describes the threats the library faces, where the
-trust boundaries lie, and how the library's design and the [quality assurance](quality_assurance.md) counter these
-threats. To report a vulnerability, see the [security policy](security_policy.md).
-
-## Threat model
-
-The library parses, stores, and serializes JSON values in memory. It does not open network connections, does not open
-files (it only reads from streams or `std::FILE*` handles that the caller has already opened), does not read environment
-variables, and does not implement cryptography or handle credentials.
-
-The primary threat is therefore **untrusted input**: JSON text or binary data (BJData, BSON, CBOR, MessagePack, UBJSON)
-that an attacker controls, passed to [`parse`](../api/basic_json/parse.md), [`accept`](../api/basic_json/accept.md),
-[`sax_parse`](../api/basic_json/sax_parse.md), or one of the `from_*` functions such as
-[`from_cbor`](../api/basic_json/from_cbor.md). Such input may try to
-
-- make the library read or write out of bounds (malformed lengths, truncated input, invalid UTF-8),
-- trigger undefined behavior (integer overflow in sizes or numbers, invalid casts),
-- exhaust memory (huge announced sizes), or
-- exhaust the call stack (deeply nested arrays and objects).
-
-## Trust boundaries
-
-- **Untrusted:** all serialized input read by the parser, the SAX interface, and the binary readers. The library must
-  handle every possible input by either producing a value or throwing a [`parse_error`](../home/exceptions.md#parse-errors)
-  (or returning `false` when exceptions are disabled for the call).
-- **Trusted:** the C++ code that calls the library. Calling a function with violated preconditions, for instance
-  accessing an array with [`operator[]`](../api/basic_json/operator%5B%5D.md) out of range, is a programming error and
-  not a security boundary. Such preconditions are checked with [runtime assertions](../features/assertions.md) in debug
-  builds; functions such as [`at`](../api/basic_json/at.md) offer checked access with exceptions.
-
-## Secure design
-
-- **Strict parsing.** The parser accepts exactly the JSON grammar of [RFC 8259](https://datatracker.ietf.org/doc/html/rfc8259).
-  Extensions such as [comments](../features/comments.md) and [trailing commas](../features/trailing_commas.md) must be
-  enabled explicitly. Invalid UTF-8 is rejected.
-- **Errors are reported, not ignored.** Malformed input results in a [`parse_error`](../home/exceptions.md#parse-errors)
-  with the byte position of the error. Binary readers do not trust announced sizes: strings and binary values grow
-  only as bytes are actually read, arrays reserve at most a fixed number of elements up front, and sizes that no
-  container can hold are rejected.
-- **Memory is owned by values.** Each `basic_json` value owns its content, and there is no manual memory management in
-  user code. The destructor does not recurse, so destroying a deeply nested value does not exhaust the stack.
-- **Bounded recursion.** The JSON parser and the binary readers keep their state in explicit stacks instead of
-  recursing per nesting level. Operations that walk a value, such as [`dump`](../api/basic_json/dump.md), copying,
-  hashing, and [`merge_patch`](../api/basic_json/merge_patch.md), recurse only up to a fixed depth and continue with an
-  explicit stack below it. Some operations, such as comparison, [`diff`](../api/basic_json/diff.md),
-  [`flatten`](../api/basic_json/flatten.md), and the binary writers, still recurse once per nesting level; work on them
-  is in progress. Applications that process untrusted input can limit its nesting depth with a
-  [parser callback](../features/parsing/parser_callbacks.md).
-- **Invariants are checked.** The class invariant (for instance, that the pointer for the stored type is never null) is
-  checked with runtime assertions throughout the test suite.
-
-## Common weaknesses
-
-The following table maps the relevant classes of the [Common Weakness Enumeration](https://cwe.mitre.org) to the
-measures that counter them. The measures are described in detail in [Quality assurance](quality_assurance.md).
-
-| Weakness                                                                  | Countermeasures                                                                                  |
-|---------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------|
-| Out-of-bounds read/write ([CWE-125](https://cwe.mitre.org/data/definitions/125.html), [CWE-787](https://cwe.mitre.org/data/definitions/787.html)) | bounds checks on all reads from the input; AddressSanitizer and Valgrind on the test suite; OSS-Fuzz      |
-| Integer overflow ([CWE-190](https://cwe.mitre.org/data/definitions/190.html)) | UndefinedBehaviorSanitizer with integer overflow detection; Clang-Tidy; Cppcheck                 |
-| Use after free, double free ([CWE-416](https://cwe.mitre.org/data/definitions/416.html), [CWE-415](https://cwe.mitre.org/data/definitions/415.html)) | ownership of all memory by values; AddressSanitizer and Valgrind; Clang Static Analyzer          |
-| Memory leaks ([CWE-401](https://cwe.mitre.org/data/definitions/401.html)) | Valgrind (Memcheck) on the test suite                                                            |
-| Uncontrolled recursion ([CWE-674](https://cwe.mitre.org/data/definitions/674.html)) | iterative parser, binary readers, and destructor; bounded recursion in value operations; tests with deeply nested inputs |
-| Uncontrolled resource consumption ([CWE-400](https://cwe.mitre.org/data/definitions/400.html)) | allocations based on announced sizes are capped; OSS-Fuzz with memory limits                     |
-| Undefined behavior in general ([CWE-758](https://cwe.mitre.org/data/definitions/758.html)) | UndefinedBehaviorSanitizer; runtime assertions; Clang-Tidy, Cppcheck, Clang Static Analyzer, Infer |
-
-In addition, every line of the library is covered by the unit tests, and all parsers are fuzz-tested around the clock
-by [OSS-Fuzz](https://github.com/google/oss-fuzz/tree/master/projects/json).

docs/mkdocs/docs/community/index.md

@@ -5,6 +5,4 @@
 - [Contribution Guidelines](contribution_guidelines.md) - guidelines how to contribute to this project
 - [Governance](governance.md) - the governance model of this project
 - [Quality Assurance](quality_assurance.md) - how the quality of this project is assured
-- [Roadmap](roadmap.md) - what the project will and will not do
 - [Security Policy](security_policy.md) - the security policy of the project
-- [Assurance Case](assurance_case.md) - why the library meets its security requirements

docs/mkdocs/docs/community/quality_assurance.md

@@ -164,9 +164,6 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
 - [x] The parser is tested against extensive correctness suites for JSON compliance.
 - [x] In addition, the library is continuously fuzz-tested at [OSS-Fuzz](https://google.github.io/oss-fuzz/) where the
   library is checked against billions of inputs.
-- [x] Every crash reported by OSS-Fuzz is fixed together with a unit test that reproduces it, and the fix references
-  the OSS-Fuzz issue. The round-trip checks of the fuzzer drivers are also part of the unit tests. See the
-  [fuzz testing documentation](https://github.com/nlohmann/json/blob/develop/tests/fuzzing.md#handling-oss-fuzz-reports).
 
 ## Static analysis
 

docs/mkdocs/docs/community/roadmap.md

@@ -1,43 +0,0 @@
-# Roadmap
-
-This page describes what the project intends to do, and what it does not intend to do, over the next year. Concrete
-work items are tracked in the [GitHub milestones](https://github.com/nlohmann/json/milestones) and the
-[issue tracker](https://github.com/nlohmann/json/issues).
-
-## What the project will do
-
-- **Keep the C++11 baseline.** The library will continue to compile with every
-  [supported C++11 compiler](https://github.com/nlohmann/json/blob/develop/README.md#supported-compilers). Features of
-  later standards are only used when they are guarded by the `JSON_HAS_CPP_*` macros.
-- **Stay conformant to JSON.** The parser and serializer follow [RFC 8259](https://datatracker.ietf.org/doc/html/rfc8259).
-  Extensions such as [comments](../features/comments.md) or [trailing commas](../features/trailing_commas.md) remain
-  opt-in.
-- **Keep the 3.x public API stable.** Releases follow [semantic versioning](https://semver.org). Changes that would
-  break existing code are only added behind a feature macro, so users can opt in and test their code before a next
-  major release.
-- **Support a broad range of compilers and platforms.** The [CI](quality_assurance.md) keeps testing old and new
-  versions of GCC, Clang, MSVC, and other compilers on Linux, macOS, and Windows.
-- **Keep the quality assurance up.** Every change keeps the test coverage at 100%, passes the static and dynamic
-  analysis, and is fuzz-tested by OSS-Fuzz, see [Quality assurance](quality_assurance.md).
-- **Harden the library against hostile input.** Handling deeply nested values without exhausting the call stack is
-  ongoing work.
-- **Fix bugs and security issues** reported through the issue tracker and the [security policy](security_policy.md).
-
-## What the project will not do
-
-- **Break the public API of version 3.x.** See the
-  [contribution guidelines](https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md#break-the-public-api)
-  for what counts as a breaking change.
-- **Require a newer C++ standard than C++11.**
-- **Break JSON conformance** or enable non-standard extensions by default.
-- **Add dependencies** or require a build step. The library remains header-only, and the single header
-  `json.hpp` remains a complete distribution.
-- **Trade simplicity for speed or memory efficiency.** Performance improvements are welcome, but the library is not
-  meant to compete with the fastest JSON libraries, see [Design goals](../home/design_goals.md).
-
-## Version 4.0
-
-There is no decision yet on whether or when a version 4.0 with breaking changes will be released. Proposals that need
-a major version, for instance stricter type conversions, are collected in issue
-[#3453](https://github.com/nlohmann/json/issues/3453). Until then, such changes are only added as opt-in behavior
-behind feature macros.

docs/mkdocs/docs/features/binary_formats/bjdata.md

@@ -208,16 +208,6 @@ The library maps BJData types to JSON value types as follows:
 
     The mapping is **complete** in the sense that any BJData value can be converted to a JSON value.
 
-!!! info "Round trips"
-
-    A value returned by [`from_bjdata`](../../api/basic_json/from_bjdata.md) can be serialized with
-    [`to_bjdata`](../../api/basic_json/to_bjdata.md) using any combination of options and parsed back into an equal
-    value, and serializing that value again with the same options produces the same bytes. The exception is binary
-    values: they are only written as an optimized binary array (`[$B`) if Draft 3 is enabled and both `use_size` and
-    `use_type` are set. Otherwise, they are written as arrays of integers and parsed back as such (see the notes on
-    binary values above), and serializing such an array again may choose different, but equally valid, type markers.
-    The bytes can then differ, but parsing them again yields the same value.
-
 ??? example
 
     ```cpp

docs/mkdocs/docs/features/macros.md

@@ -93,21 +93,11 @@ See [full documentation of `JSON_NO_IO`](../api/macros/json_no_io.md).
 
 ## `JSON_NO_THREAD_LOCAL`
 
-When defined, the library does not use `#!cpp thread_local` storage. Copying a value and comparing two values then
-always avoid the call stack rather than descending into a bounded number of levels first, which is slower but yields the
-same values and the same comparisons.
+When defined, the library does not use `#!cpp thread_local` storage. Copying a value then always avoids the call stack
+rather than descending into a bounded number of levels first, which is slower but yields the same values.
 
 See [full documentation of `JSON_NO_THREAD_LOCAL`](../api/macros/json_no_thread_local.md).
 
-## `JSON_PRECISE_STREAM_POSITION`
-
-When defined to `1`, [`operator>>`](../api/operator_gtgt.md) and non-strict
-[`sax_parse`](../api/basic_json/sax_parse.md) leave an input stream positioned right after the parsed value, instead of
-also consuming the character that terminates a number. The default value is `0`, which preserves the existing behavior;
-this is planned to become the default in version 4.0.0.
-
-See [full documentation of `JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md).
-
 ## `JSON_SKIP_LIBRARY_VERSION_CHECK`
 
 When defined, the library will not create a compiler warning when a different version of the library was already

docs/mkdocs/docs/features/namespace.md

@@ -18,7 +18,6 @@ The complete default namespace name is derived as follows:
     - [`JSON_DIAGNOSTIC_POSITIONS`](../api/macros/json_diagnostic_positions.md) defined non-zero appends `_dp`.
     - [`JSON_BRACE_INIT_COPY_SEMANTICS`](../api/macros/json_brace_init_copy_semantics.md) defined non-zero appends
       `_bics`.
-    - [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md) defined non-zero appends `_psp`.
 - 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/parsing/index.md

@@ -41,8 +41,7 @@ document followed by trailing bytes" is accepted rather than rejected. If you ar
 reject any input that is not exactly one JSON document, prefer `parse`.
 
 When using `operator>>` to read several concatenated values this way, a value that is a number must be followed by
-whitespace, because `operator>>` consumes the character that terminates a number, unless
-[`JSON_PRECISE_STREAM_POSITION`](../../api/macros/json_precise_stream_position.md) is defined to `1` — see the
+whitespace, because `operator>>` consumes the character that terminates a number — see the
 [`operator>>` notes](../../api/operator_gtgt.md#notes) for details and examples.
 
 ## SAX vs. DOM parsing

docs/mkdocs/docs/home/architecture.md

@@ -1,125 +1,34 @@
 # Architecture
 
-This page gives a high-level overview of the library's architecture. It should help new contributors to get an idea of
-the used concepts and where to make changes.
+!!! info
+
+    This page is still under construction. Its goal is to provide a high-level overview of the library's architecture.
+    This should help new contributors to get an idea of the used concepts and where to make changes.
 
 ## Overview
 
-The library is built around a single class template, [`nlohmann::basic_json`](../api/basic_json/index.md). A
-`basic_json` value is a node in a tree of JSON values. All other components either create such a tree from an input
-(parsing), write a tree to an output (serialization), or give access to it (iterators, JSON Pointer, conversions).
+The main structure is class [nlohmann::basic_json](../api/basic_json/index.md).
 
-```mermaid
-flowchart LR
-    input[/"input<br>(string, stream,<br>iterator range, file)"/]
-    ia["input adapter"]
-    lexer["lexer"]
-    parser["parser"]
-    breader["binary_reader"]
-    sax["SAX interface"]
-    value[("basic_json<br>value tree")]
-    serializer["serializer"]
-    bwriter["binary_writer"]
-    oa["output adapter"]
-    output[/"output<br>(string, stream,<br>vector)"/]
+- public API
+- container interface
+- iterators
 
-    input --> ia
-    ia --> lexer --> parser --> sax
-    ia --> breader --> sax
-    sax --> value
-    value --> serializer --> oa
-    value --> bwriter --> oa
-    oa --> output
-```
+## Template specializations
 
-- **JSON text** is read by an [input adapter](#input-adapters), tokenized by the lexer, and turned into SAX events by
-  the parser.
-- **Binary formats** (BJData, BSON, CBOR, MessagePack, UBJSON) are read by an input adapter and turned into the same SAX
-  events by the `binary_reader`.
-- A [SAX consumer](#sax-interface) receives the events. The one used by [`parse`](../api/basic_json/parse.md) builds a
-  `basic_json` value tree.
-- The `serializer` (JSON text) or the `binary_writer` (binary formats) writes a value tree to an
-  [output adapter](#output-adapters).
-
-## Source layout
-
-The public headers are in [`include/nlohmann`](https://github.com/nlohmann/json/tree/develop/include/nlohmann):
-
-- [`json.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/json.hpp) defines class [`basic_json`](../api/basic_json/index.md).
-- [`json_fwd.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/json_fwd.hpp) contains forward declarations.
-- [`adl_serializer.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/adl_serializer.hpp), [`byte_container_with_subtype.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/byte_container_with_subtype.hpp), and [`ordered_map.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/ordered_map.hpp) define
-  [`adl_serializer`](../api/adl_serializer/index.md),
-  [`byte_container_with_subtype`](../api/byte_container_with_subtype/index.md), and
-  [`ordered_map`](../api/ordered_map.md).
-
-Everything else lives in [`detail/`](https://github.com/nlohmann/json/tree/develop/include/nlohmann/detail) and namespace `nlohmann::detail`, which is not part of the public API. Paths
-below are relative to `include/nlohmann`.
-
-| Component | Location |
-|-----------|----------|
-| Value type enumeration | [`detail/value_t.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/value_t.hpp) |
-| Input adapters | [`detail/input/input_adapters.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/input_adapters.hpp) |
-| Lexer | [`detail/input/lexer.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/lexer.hpp), [`detail/input/number_parse.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/number_parse.hpp), [`detail/input/string_scan.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/string_scan.hpp) |
-| Parser | [`detail/input/parser.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/parser.hpp) |
-| SAX interface and DOM builders | [`detail/input/json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp) |
-| Binary format readers | [`detail/input/binary_reader.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/binary_reader.hpp) |
-| JSON serializer | [`detail/output/serializer.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/output/serializer.hpp), [`detail/conversions/to_chars.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/conversions/to_chars.hpp) |
-| Binary format writers | [`detail/output/binary_writer.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/output/binary_writer.hpp) |
-| Output adapters | [`detail/output/output_adapters.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/output/output_adapters.hpp) |
-| Iterators | [`detail/iterators/`](https://github.com/nlohmann/json/tree/develop/include/nlohmann/detail/iterators) |
-| Conversions from/to arbitrary types | [`detail/conversions/from_json.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/conversions/from_json.hpp), [`detail/conversions/to_json.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/conversions/to_json.hpp) |
-| JSON Pointer | [`detail/json_pointer.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/json_pointer.hpp) |
-| Exceptions | [`detail/exceptions.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/exceptions.hpp) |
-| Type traits and C++ feature backports | [`detail/meta/`](https://github.com/nlohmann/json/tree/develop/include/nlohmann/detail/meta) |
-| Macros | [`detail/macro_scope.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/macro_scope.hpp), [`detail/macro_unscope.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/macro_unscope.hpp), [`detail/abi_macros.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/abi_macros.hpp) |
-
-The single-header version [`single_include/nlohmann/json.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json.hpp)
-is generated from these files with `make amalgamate` and must not be edited by hand.
-
-## Template parameters
-
-[`basic_json`](../api/basic_json/index.md) is parameterized by the types it uses to store values and to convert from and to other types:
-
-| Template parameter   | Default                     | Used for                                                          |
-|----------------------|-----------------------------|-------------------------------------------------------------------|
-| `ObjectType`         | `std::map`                  | objects, see [`object_t`](../api/basic_json/object_t.md)          |
-| `ArrayType`          | `std::vector`               | arrays, see [`array_t`](../api/basic_json/array_t.md)             |
-| `StringType`         | `std::string`               | strings and object keys, see [`string_t`](../api/basic_json/string_t.md) |
-| `BooleanType`        | `bool`                      | Booleans, see [`boolean_t`](../api/basic_json/boolean_t.md)       |
-| `NumberIntegerType`  | `std::int64_t`              | signed integers, see [`number_integer_t`](../api/basic_json/number_integer_t.md) |
-| `NumberUnsignedType` | `std::uint64_t`             | unsigned integers, see [`number_unsigned_t`](../api/basic_json/number_unsigned_t.md) |
-| `NumberFloatType`    | `double`                    | floating-point numbers, see [`number_float_t`](../api/basic_json/number_float_t.md) |
-| `AllocatorType`      | `std::allocator`            | allocating objects, arrays, strings, and binary values            |
-| `JSONSerializer`     | `adl_serializer`            | conversions from/to other types, see [`adl_serializer`](../api/adl_serializer/index.md) |
-| `BinaryType`         | `std::vector<std::uint8_t>` | binary values, see [`binary_t`](../api/basic_json/binary_t.md)  |
-| `CustomBaseClass`    | `void`                      | an optional base class, see [`json_base_class_t`](../api/basic_json/json_base_class_t.md) |
-
-The library provides two specializations:
-
-- [`json`](../api/json.md) uses all default template arguments.
-- [`ordered_json`](../api/ordered_json.md) uses [`ordered_map`](../api/ordered_map.md) as `ObjectType` to keep the
-  insertion order of object keys.
-
-The requirements on the template arguments are listed in
-[Template Parameter Requirements](../features/types/template_parameters.md).
+- describe template parameters of `basic_json`
+- [`json`](../api/json.md)
+- [`ordered_json`](../api/ordered_json.md) via [`ordered_map`](../api/ordered_map.md)
 
 ## Value storage
 
-Each [`basic_json`](../api/basic_json/index.md) value stores its content as a tagged union: an enumeration [`value_t`](../api/basic_json/value_t.md)
-names the type of the value, and a union `json_value` holds the value itself. Both are members of the nested struct
-`data`, which is the only data member `m_data` of `basic_json`:
+Values are stored as a tagged union of [value_t](../api/basic_json/value_t.md) and json_value.
 
 ```cpp
-struct data
-{
-    /// the type of the current element
-    value_t m_type = value_t::null;
+/// the type of the current element
+value_t m_type = value_t::null;
 
-    /// the value of the current element
-    json_value m_value = {};
-};
-
-data m_data = {};
+/// the value of the current element
+json_value m_value = {};
 ```
 
 with
@@ -159,83 +68,42 @@ union json_value {
 };
 ```
 
-Objects, arrays, strings, and binary values are allocated on the heap with `AllocatorType`, and the union only stores a
-pointer to them. This keeps a `basic_json` value small: one pointer-sized union and one byte for the type. The class
-maintains the invariant that the pointer matching `m_type` is never null; `assert_invariant()` checks it with
-[runtime assertions](../features/assertions.md).
+## Parsing inputs (deserialization)
 
-## Input adapters
-
-Input is read via **input adapters** that abstract a source. Every input adapter provides this interface:
+Input is read via **input adapters** that abstract a source with a common interface:
 
 ```cpp
-/// the type of the characters in the input
-using char_type = ...;
+/// read a single character
+std::char_traits<char>::int_type get_character() noexcept;
 
-/// read a single character; returns std::char_traits<char_type>::eof() at the end of the input
-typename std::char_traits<char_type>::int_type get_character();
-
-/// read up to count * sizeof(T) bytes into dest and return the number of bytes read
-/// (used by the binary readers)
+/// read multiple characters to a destination buffer and
+/// returns the number of characters successfully read
 template<class T>
 std::size_t get_elements(T* dest, std::size_t count = 1);
 ```
 
-The lexer detects two optional extensions at compile time. Only `iterator_input_adapter` provides them, and only for
-random-access input of single-byte characters:
+List examples of input adapters.
 
-- `supports_seek`, `get_consumed_count()`, and `copy_consumed_range()` let the lexer reconstruct already consumed input
-  for error messages instead of copying every character it reads.
-- `supports_bulk_scan`, `bulk_data()`, `bulk_remaining()`, and `bulk_skip()` let the lexer scan strings directly in
-  contiguous memory, several bytes at a time.
+## SAX Interface
 
-The function `input_adapter` picks the right adapter for the argument passed to `parse`, `accept`, `sax_parse`, or the
-`from_*` functions:
+TODO
 
-- `iterator_input_adapter` reads from an iterator range, which also covers strings, containers, and pointers.
-- `wide_string_input_adapter` reads from ranges of `wchar_t`, `char16_t`, or `char32_t` and converts them to UTF-8.
-  It cannot be used for binary formats; its `get_elements()` throws.
-- `input_stream_adapter` reads from a `std::istream`.
-- `file_input_adapter` reads from a `std::FILE*`.
-
-## SAX interface
-
-The parser does not build values itself. It reports what it reads as events to a [SAX](../features/parsing/sax_interface.md)
-consumer, which implements the interface [`json_sax`](../api/json_sax/index.md): `null`, `boolean`, `number_integer`,
-`number_unsigned`, `number_float`, `string`, `binary`, `start_object`, `key`, `end_object`, `start_array`, `end_array`,
-and `parse_error`.
-
-The library comes with two consumers in `detail/input/json_sax.hpp`:
-
-- `json_sax_dom_parser` builds a [`basic_json`](../api/basic_json/index.md) value tree. [`parse`](../api/basic_json/parse.md) uses it.
-- `json_sax_dom_callback_parser` does the same, but calls a [parser callback](../features/parsing/parser_callbacks.md)
-  for each event, which can skip values. `parse` uses it when a callback is given.
-
-The `binary_reader` emits the same events for binary formats, so [`sax_parse`](../api/basic_json/sax_parse.md) works
-with a user-defined consumer for JSON and for all binary formats alike.
-
-## Output adapters
+## Writing outputs (serialization)
 
 Output is written via **output adapters**:
 
 ```cpp
+template<typename T>
 void write_character(CharType c);
 
+template<typename CharType>
 void write_characters(const CharType* s, std::size_t length);
 ```
 
-The `serializer` (used by [`dump`](../api/basic_json/dump.md) and [`operator<<`](../api/operator_ltlt.md)) and the
-`binary_writer` (used by the `to_*` functions) write to one of these adapters:
-
-- `output_vector_adapter` appends to a `std::vector`.
-- `output_stream_adapter` writes to a `std::ostream`.
-- `output_string_adapter` appends to a string.
+List examples of output adapters.
 
 ## Value conversion
 
-Values are converted from and to other types with the `JSONSerializer` template parameter. The default,
-[`adl_serializer`](../api/adl_serializer/index.md), calls the free functions
-
 ```cpp
 template<class T>
 void to_json(basic_json& j, const T& t);
@@ -244,23 +112,13 @@ template<class T>
 void from_json(const basic_json& j, T& t);
 ```
 
-found by argument-dependent lookup. The library defines them for standard types in `detail/conversions`; users add them
-for their own types, see [Arbitrary Type Conversions](../features/arbitrary_types.md). The
-[serialization macros](../features/macros.md) generate these functions.
-
 ## Additional features
 
-- [JSON Pointer](../features/json_pointer.md) (class `json_pointer`) addresses values inside a tree. It is also the
-  basis of [JSON Patch](../features/json_patch.md).
-- [Binary formats](../features/binary_formats/index.md) are read by `binary_reader` and written by `binary_writer`.
-- A [custom base class](../api/basic_json/json_base_class_t.md) can add members to every [`basic_json`](../api/basic_json/index.md) value.
-- [Serialization macros](../features/macros.md) generate `to_json` and `from_json` functions for user-defined types.
+- JSON Pointers
+- Binary formats
+- Custom base class
+- Conversion macros
 
 ## Details namespace
 
-Namespace `nlohmann::detail` contains all implementation details. It is not part of the public API and may change in any
-release. Besides the components above, it contains:
-
-- type traits to detect the capabilities of user-defined types (`detail/meta/type_traits.hpp`),
-- backports of C++14/17 features to C++11 (`detail/meta/cpp_future.hpp`), and
-- helpers such as `string_concat` and `string_escape`.
+- C++ feature backports

docs/mkdocs/mkdocs.yml

@@ -293,7 +293,6 @@ nav:
           - 'JSON_NOEXCEPTION': api/macros/json_noexception.md
           - 'JSON_NO_IO': api/macros/json_no_io.md
           - 'JSON_NO_THREAD_LOCAL': api/macros/json_no_thread_local.md
-          - 'JSON_PRECISE_STREAM_POSITION': api/macros/json_precise_stream_position.md
           - 'JSON_SKIP_LIBRARY_VERSION_CHECK': api/macros/json_skip_library_version_check.md
           - 'JSON_SKIP_UNSUPPORTED_COMPILER_CHECK': api/macros/json_skip_unsupported_compiler_check.md
           - 'JSON_STRICT_NUL_HANDLING': api/macros/json_strict_nul_handling.md
@@ -318,9 +317,7 @@ nav:
       - community/contribution_guidelines.md
       - community/quality_assurance.md
       - community/governance.md
-      - community/roadmap.md
       - community/security_policy.md
-      - community/assurance_case.md
 
 # Extras
 extra:

include/nlohmann/detail/abi_macros.hpp

@@ -38,10 +38,6 @@
     #define JSON_BRACE_INIT_COPY_SEMANTICS 0
 #endif
 
-#ifndef JSON_PRECISE_STREAM_POSITION
-    #define JSON_PRECISE_STREAM_POSITION 0
-#endif
-
 #if JSON_DIAGNOSTICS
     #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -66,28 +62,21 @@
     #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS
 #endif
 
-#if JSON_PRECISE_STREAM_POSITION
-    #define NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION _psp
-#else
-    #define NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION
-#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) json_abi ## a ## b ## c ## d ## e
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d) json_abi ## a ## b ## c ## d
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
             NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS,              \
-            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
-            NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION)
+            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

include/nlohmann/detail/input/input_adapters.hpp

@@ -101,11 +101,6 @@ class input_stream_adapter
         // maintain ifstream flags, except eof
         if (is != nullptr)
         {
-#if JSON_PRECISE_STREAM_POSITION
-            // consume the character last returned by get_character() unless it
-            // was given back with release_lookahead()
-            commit_lookahead();
-#endif
             is->clear(is->rdstate() & std::ios::eofbit);
         }
     }
@@ -119,58 +114,6 @@ class input_stream_adapter
     input_stream_adapter& operator=(input_stream_adapter&) = delete;
     input_stream_adapter& operator=(input_stream_adapter&&) = delete;
 
-#if JSON_PRECISE_STREAM_POSITION
-    input_stream_adapter(input_stream_adapter&& rhs) noexcept
-        : is(rhs.is), sb(rhs.sb), lookahead(rhs.lookahead)
-    {
-        rhs.is = nullptr;
-        rhs.sb = nullptr;
-        rhs.lookahead = false;
-    }
-
-    // Whether the character last returned by get_character() can be given back
-    // to the input with release_lookahead().
-    static constexpr bool supports_lookahead = true;
-
-    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
-    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
-    // end up as the same value, e.g., 0xFFFFFFFF.
-    //
-    // The character is peeked rather than consumed: it is only stepped over
-    // once the next character is requested, or when the adapter is destroyed.
-    // Until then, release_lookahead() can leave it in the input.
-    std::char_traits<char>::int_type get_character()
-    {
-        if (lookahead)
-        {
-            // step over the character returned by the previous call
-            sb->sbumpc();
-        }
-
-        auto res = sb->sgetc();
-        // set eof manually, as we don't use the istream interface.
-        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
-        {
-            // there is nothing to step over next time
-            lookahead = false;
-            is->clear(is->rdstate() | std::ios::eofbit);
-        }
-        else
-        {
-            lookahead = true;
-        }
-        return res;
-    }
-
-    // Leave the character last returned by get_character() in the input, so
-    // that the next read from the stream - by this adapter or by the caller
-    // once parsing is done - sees it again. Unlike putting a consumed
-    // character back, this cannot fail.
-    void release_lookahead() noexcept
-    {
-        lookahead = false;
-    }
-#else
     input_stream_adapter(input_stream_adapter&& rhs) noexcept
         : is(rhs.is), sb(rhs.sb)
     {
@@ -181,9 +124,6 @@ class input_stream_adapter
     // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
     // ensure that std::char_traits<char>::eof() and the character 0xFF do not
     // end up as the same value, e.g., 0xFFFFFFFF.
-    //
-    // The character is consumed, so the character that terminates a number
-    // stays consumed after parsing; see JSON_PRECISE_STREAM_POSITION.
     std::char_traits<char>::int_type get_character()
     {
         auto res = sb->sbumpc();
@@ -194,14 +134,10 @@ class input_stream_adapter
         }
         return res;
     }
-#endif
 
     template<class T>
     std::size_t get_elements(T* dest, std::size_t count = 1)
     {
-#if JSON_PRECISE_STREAM_POSITION
-        commit_lookahead();
-#endif
         auto res = static_cast<std::size_t>(sb->sgetn(reinterpret_cast<char*>(dest), static_cast<std::streamsize>(count * sizeof(T))));
         if (JSON_HEDLEY_UNLIKELY(res < count * sizeof(T)))
         {
@@ -211,27 +147,9 @@ class input_stream_adapter
     }
 
   private:
-#if JSON_PRECISE_STREAM_POSITION
-    // Step over the character last returned by get_character(). The character
-    // has already been peeked successfully, so for every streambuf with a get
-    // area this is a pointer increment that cannot fail.
-    void commit_lookahead()
-    {
-        if (lookahead)
-        {
-            lookahead = false;
-            sb->sbumpc();
-        }
-    }
-#endif
-
     /// the associated input stream
     std::istream* is = nullptr;
     std::streambuf* sb = nullptr;
-#if JSON_PRECISE_STREAM_POSITION
-    /// whether get_character() peeked a character that is not consumed yet
-    bool lookahead = false;
-#endif
 };
 #endif  // JSON_NO_IO
 

include/nlohmann/detail/input/lexer.hpp

@@ -127,25 +127,6 @@ constexpr bool input_adapter_supports_seek(std::false_type /*detected*/)
     return false;
 }
 
-// Detect whether an input adapter reads with one character of lookahead that
-// can be left in the input (see input_stream_adapter::supports_lookahead,
-// which is only defined with JSON_PRECISE_STREAM_POSITION), detected like
-// supports_seek above.
-template<typename InputAdapterType>
-using detect_supports_lookahead = decltype(InputAdapterType::supports_lookahead);
-
-template<typename InputAdapterType>
-constexpr bool input_adapter_supports_lookahead(std::true_type /*detected*/)
-{
-    return InputAdapterType::supports_lookahead;
-}
-
-template<typename InputAdapterType>
-constexpr bool input_adapter_supports_lookahead(std::false_type /*detected*/)
-{
-    return false;
-}
-
 // Detect whether an input adapter exposes a contiguous byte block that the
 // lexer can scan directly (see iterator_input_adapter::supports_bulk_scan).
 // Adapters without the flag - file, stream, wide-string, user-defined - fall
@@ -186,12 +167,6 @@ class lexer : public lexer_base<BasicJsonType>
     static constexpr bool lazy_token_string =
         input_adapter_supports_seek<InputAdapterType>(is_detected<detect_supports_seek, InputAdapterType> {});
 
-    /// whether a simulated unget can be passed on to the input adapter, which
-    /// then leaves the character in the input; see
-    /// input_adapter_supports_lookahead
-    static constexpr bool can_release_lookahead =
-        input_adapter_supports_lookahead<InputAdapterType>(is_detected<detect_supports_lookahead, InputAdapterType> {});
-
     /// whether string scanning may bulk-consume runs of ordinary characters
     /// directly from a contiguous input buffer (SWAR fast path). This requires
     /// the token to be reconstructible lazily (lazy_token_string), so bypassing
@@ -1923,21 +1898,6 @@ scan_number_done:
         uncapture_char(std::integral_constant<bool, lazy_token_string> {});
     }
 
-    /// adapter without lookahead: nothing to do (see release_lookahead)
-    void release_lookahead_impl(std::false_type /*can_release*/) const noexcept {}
-
-    /// adapter with lookahead: leave the character in the input instead
-    void release_lookahead_impl(std::true_type /*can_release*/)
-    {
-        if (next_unget)
-        {
-            // the character is read from the input again rather than replayed
-            // from current, so the adapter must not step over it
-            next_unget = false;
-            ia.release_lookahead();
-        }
-    }
-
     /// seekable adapter: nothing was captured, so nothing to undo
     void uncapture_char(std::true_type /*lazy*/) const noexcept {}
 
@@ -2001,31 +1961,6 @@ scan_number_done:
         return position;
     }
 
-    /*!
-    @brief pass a pending simulated unget on to the input
-
-    unget() only rewinds the lexer's own bookkeeping, so the character that
-    terminated the last token (e.g. the character after a number) would still
-    be stepped over when the input adapter is done. Callers that hand the
-    input back to the user afterwards - operator>> and non-strict sax_parse -
-    call this once when scanning is done, so that the input is positioned
-    right after the value.
-
-    Adapters without lookahead (see input_adapter_supports_lookahead) are not
-    handed back to the user, so this is a no-op for them. Without
-    JSON_PRECISE_STREAM_POSITION, no adapter has lookahead, so this is always a
-    no-op and the terminating character stays consumed.
-
-    Scanning may continue after this call: @a next_unget is cleared, and the
-    character is read from the input again instead of being replayed from
-    @a current. A pending unget of EOF needs no special case, because reaching
-    EOF leaves no lookahead to release.
-    */
-    void release_lookahead()
-    {
-        release_lookahead_impl(std::integral_constant<bool, can_release_lookahead> {});
-    }
-
 #if JSON_DIAGNOSTIC_POSITIONS
     /// return the offset of the first character of the last read token; unlike
     /// the token's parsed value, this accounts for escape sequences

include/nlohmann/detail/input/parser.hpp

@@ -100,22 +100,13 @@ class parser
             json_sax_dom_callback_parser<BasicJsonType, InputAdapterType> sdp(result, callback, allow_exceptions, &m_lexer);
             sax_parse_internal(&sdp);
 
-            if (strict)
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
             {
-                // in strict mode, input must be completely read
-                if (get_token() != token_type::end_of_input)
-                {
-                    sdp.parse_error(m_lexer.get_position(),
-                                    m_lexer.get_token_string(),
-                                    parse_error::create(101, m_lexer.get_position(),
-                                                        exception_message(token_type::end_of_input, "value"), nullptr));
-                }
-            }
-            else
-            {
-                // the caller keeps using the input: position it right after
-                // the value by leaving the character that terminated it
-                m_lexer.release_lookahead();
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), nullptr));
             }
 
             // in case of an error, return a discarded value
@@ -137,20 +128,12 @@ class parser
             json_sax_dom_parser<BasicJsonType, InputAdapterType> sdp(result, allow_exceptions, &m_lexer);
             sax_parse_internal(&sdp);
 
-            if (strict)
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
             {
-                // in strict mode, input must be completely read
-                if (get_token() != token_type::end_of_input)
-                {
-                    sdp.parse_error(m_lexer.get_position(),
-                                    m_lexer.get_token_string(),
-                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
-                }
-            }
-            else
-            {
-                // see above
-                m_lexer.release_lookahead();
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
             }
 
             // in case of an error, return a discarded value
@@ -183,24 +166,12 @@ class parser
         (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
         const bool result = sax_parse_internal(sax);
 
-        if (result)
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
         {
-            if (strict)
-            {
-                // strict mode: next byte must be EOF
-                if (get_token() != token_type::end_of_input)
-                {
-                    return sax->parse_error(m_lexer.get_position(),
-                                            m_lexer.get_token_string(),
-                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
-                }
-            }
-            else
-            {
-                // the caller keeps using the input: position it right after
-                // the value by leaving the character that terminated it
-                m_lexer.release_lookahead();
-            }
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
         }
 
         return result;

include/nlohmann/detail/macro_unscope.hpp

@@ -45,7 +45,6 @@
     #undef JSON_HAS_STATIC_RTTI
     #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
     #undef JSON_BRACE_INIT_COPY_SEMANTICS
-    #undef JSON_PRECISE_STREAM_POSITION
 #endif
 
 #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>

include/nlohmann/json.hpp

@@ -924,31 +924,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     }
 #endif
 
-    /*!
-    @brief whether a descent must stop here and finish without the call stack
-
-    @a may_descend says whether the operator descends at all; it is a constant
-    at every call site, and is passed rather than tested by the caller so that
-    the test does not become a constant condition there, which MSVC reports as
-    C4127.
-
-    The comparison operators use this rather than @ref nesting_depth_guard::okay,
-    because they are written as a macro and a macro cannot use the preprocessor
-    the way the guard's constructor does; @ref copy_structured, which can, asks
-    the guard instead and never calls this.
-    */
-    static bool nesting_depth_exhausted(bool may_descend = true) noexcept
-    {
-#ifdef JSON_NO_THREAD_LOCAL
-        // without a count of its own per thread, a descent cannot be bounded
-        // without racing another one, so none is made
-        static_cast<void>(may_descend);
-        return true;
-#else
-        return !may_descend || nesting_depth() >= nesting_depth_limit();
-#endif
-    }
-
     /*!
     @brief counts one level of a bounded descent for as long as it runs, and
            reports whether the descent was still within the limit when it began
@@ -1268,274 +1243,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     }
 
 
-    /// the result of comparing two values, including values that cannot be
-    /// ordered at all, such as a discarded value or a NaN
-    enum class compare_result { less, equal, greater, unordered };
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-    /// @brief the ordering that @a result stands for
-    static std::partial_ordering to_partial_ordering(compare_result result) noexcept // *NOPAD*
-    {
-        switch (result)
-        {
-            case compare_result::less:
-                return std::partial_ordering::less;
-            case compare_result::greater:
-                return std::partial_ordering::greater;
-            case compare_result::equal:
-                return std::partial_ordering::equivalent;
-            case compare_result::unordered:
-            default:
-                return std::partial_ordering::unordered;
-        }
-    }
-#endif
-
-    /*!
-    @brief compare two values that are not both an array or both an object
-
-    Such a pair is compared by the operators themselves, which cannot descend
-    into it and therefore cannot recurse.
-
-    That holds for a pair whose types differ as much as for a pair of leaves: an
-    array and an object are told apart by their types alone, because an operator
-    only ever descends into two values of the same type. So `==` reports them as
-    unequal without looking inside either, and an ordering falls back to the
-    order of the types - an object sorts before an array - exactly as it does
-    for a value that is not nested deeply enough to get here.
-    */
-    template<bool Ordered>
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
-    {
-        if (lhs == rhs)
-        {
-            return compare_result::equal;
-        }
-
-        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
-    }
-
-    /*!
-    @brief compare two object keys
-
-    An object compares its entries as pairs of a key and a value, so its keys
-    are compared exactly as std::pair compares them: with < where the objects
-    are being ordered, and with == where they are only checked for equality.
-    Note that this is not the object's own comparator, which for a vector-backed
-    object type such as nlohmann::ordered_map tells equality rather than order.
-    */
-    static compare_result compare_keys(const typename object_t::key_type& lhs,
-                                       const typename object_t::key_type& rhs,
-                                       std::true_type /*ordered*/)
-    {
-        if (lhs < rhs)
-        {
-            return compare_result::less;
-        }
-
-        if (rhs < lhs)
-        {
-            return compare_result::greater;
-        }
-
-        return compare_result::equal;
-    }
-
-    /// @brief check two object keys for equality
-    static compare_result compare_keys(const typename object_t::key_type& lhs,
-                                       const typename object_t::key_type& rhs,
-                                       std::false_type /*ordered*/)
-    {
-        return lhs == rhs ? compare_result::equal : compare_result::unordered;
-    }
-
-    /// @brief tell apart two values that are not equal
-    /// @note only instantiated where the values are being ordered, as a key or
-    ///       string type is not required to be ordered to be compared for equality
-    static compare_result order_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        if (lhs < rhs)
-        {
-            return compare_result::less;
-        }
-
-        if (rhs < lhs)
-        {
-            return compare_result::greater;
-        }
-
-        return compare_result::unordered;
-    }
-
-    /// @brief report two values as not equal without ordering them
-    static compare_result order_leaves(const_reference /*lhs*/, const_reference /*rhs*/, std::false_type /*ordered*/) noexcept
-    {
-        return compare_result::unordered;
-    }
-
-    /*!
-    @brief compare @a lhs and @a rhs without descending into them
-
-    Reached once a comparison has descended @ref nesting_depth_limit levels, so
-    that comparing values cannot exhaust the call stack however deeply they are
-    nested. The two values are walked in lockstep on an explicit stack and
-    compared lexicographically, element by element in the order the containers
-    enumerate them - which is how the container types this library ships compare
-    themselves: a std::map enumerates its entries in key order, and
-    nlohmann::ordered_map in insertion order. An object type that enumerates its
-    entries in an unspecified order, such as std::unordered_map, compares them
-    pairwise instead; the difference could only ever show below the bound.
-
-    Note that the stack this walks with is allocated, while the comparison
-    operators are noexcept and the container comparison this replaces allocated
-    nothing. Failing that allocation therefore ends the process rather than
-    throwing. It only arises for values nested past the bound, and only when
-    memory has run out - where the same comparison used to exhaust the call
-    stack instead - but it is a way to fail that the operators did not have.
-    */
-    template<bool Ordered>
-    static compare_result compare_iteratively(const_reference lhs, const_reference rhs,
-            const bool unordered_compares_equal) noexcept
-    {
-        /// a pair of containers being compared in lockstep
-        struct frame
-        {
-            const basic_json* lhs_value{nullptr};
-            const basic_json* rhs_value{nullptr};
-            typename array_t::const_iterator lhs_array_it{};
-            typename array_t::const_iterator rhs_array_it{};
-            typename object_t::const_iterator lhs_object_it{};
-            typename object_t::const_iterator rhs_object_it{};
-        };
-
-        std::vector<frame> stack;
-        const basic_json* left = &lhs;
-        const basic_json* right = &rhs;
-
-        for (;;)
-        {
-            const auto type = left->m_data.m_type;
-
-            if (type == right->m_data.m_type && (type == value_t::array || type == value_t::object))
-            {
-                // descend: the elements decide, and are compared further down
-                stack.emplace_back();
-                frame& pushed = stack.back();
-                pushed.lhs_value = left;
-                pushed.rhs_value = right;
-
-                if (type == value_t::array)
-                {
-                    pushed.lhs_array_it = left->m_data.m_value.array->cbegin();
-                    pushed.rhs_array_it = right->m_data.m_value.array->cbegin();
-                }
-                else
-                {
-                    pushed.lhs_object_it = left->m_data.m_value.object->cbegin();
-                    pushed.rhs_object_it = right->m_data.m_value.object->cbegin();
-                }
-            }
-            else
-            {
-                const compare_result result = compare_leaves<Ordered>(*left, *right);
-
-                // Values that cannot be ordered - a NaN, say - end an ordered
-                // comparison for std::lexicographical_compare_three_way, but
-                // std::lexicographical_compare treats them as equivalent and
-                // carries on with the next element. Both are reproduced here,
-                // so that a value nested too deeply to descend into compares
-                // exactly as one that is not.
-                if (result != compare_result::equal &&
-                        !(unordered_compares_equal && result == compare_result::unordered))
-                {
-                    return result;
-                }
-            }
-
-            // walk back up past the containers that are exhausted, then take the
-            // next pair of elements from the innermost one that is not
-            for (;;)
-            {
-                if (stack.empty())
-                {
-                    return compare_result::equal;
-                }
-
-                frame& current = stack.back();
-                const bool is_object = current.lhs_value->m_data.m_type == value_t::object;
-
-                const bool lhs_done = is_object
-                                      ? current.lhs_object_it == current.lhs_value->m_data.m_value.object->cend()
-                                      : current.lhs_array_it == current.lhs_value->m_data.m_value.array->cend();
-                const bool rhs_done = is_object
-                                      ? current.rhs_object_it == current.rhs_value->m_data.m_value.object->cend()
-                                      : current.rhs_array_it == current.rhs_value->m_data.m_value.array->cend();
-
-                if (lhs_done || rhs_done)
-                {
-                    // whichever ran out first holds the smaller container; if
-                    // both did, they are equal and the container above decides
-                    if (lhs_done != rhs_done)
-                    {
-                        return lhs_done ? compare_result::less : compare_result::greater;
-                    }
-
-                    stack.pop_back();
-                    continue;
-                }
-
-                if (is_object)
-                {
-                    // an entry is a key and a value, and the key decides first
-                    const compare_result key_result =
-                        compare_keys(current.lhs_object_it->first, current.rhs_object_it->first,
-                                     std::integral_constant<bool, Ordered> {});
-
-                    if (key_result != compare_result::equal)
-                    {
-                        return key_result;
-                    }
-
-                    left = &(current.lhs_object_it->second);
-                    right = &(current.rhs_object_it->second);
-                    ++current.lhs_object_it;
-                    ++current.rhs_object_it;
-                }
-                else
-                {
-                    left = &(*current.lhs_array_it);
-                    right = &(*current.rhs_array_it);
-                    ++current.lhs_array_it;
-                    ++current.rhs_array_it;
-                }
-
-                break;
-            }
-        }
-    }
-
-
-    /// @brief restore the parent pointers after erasing from an object
-    /// ordered_json keeps its members in a vector, and erasing a member
-    /// re-constructs every member after it in place, which resets their
-    /// parent pointers
-    void set_parents_after_object_erase()
-    {
-#if JSON_DIAGNOSTICS
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning(push )
-#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
-#endif
-        if (detail::is_ordered_map<object_t>::value)
-        {
-            set_parents();
-        }
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning( pop )
-#endif
-#endif
-    }
-
   public:
     //////////////////////////
     // JSON parser callback //
@@ -2553,7 +2260,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     ValueType & get_to(ValueType& v) const noexcept(noexcept(
                 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
     {
-        static_assert(!std::is_const<ValueType>::value, "get_to() cannot deserialize into a const value");
         JSONSerializer<ValueType>::from_json(*this, v);
         return v;
     }
@@ -2579,7 +2285,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     noexcept(noexcept(JSONSerializer<Array>::from_json(
                           std::declval<const basic_json_t&>(), v)))
     {
-        static_assert(!std::is_const<T>::value, "get_to() cannot deserialize into a const value");
         JSONSerializer<Array>::from_json(*this, v);
         return v;
     }
@@ -3226,7 +2931,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             case value_t::object:
             {
                 result.m_it.object_iterator = erase_from_object(pos.m_it.object_iterator);
-                set_parents_after_object_erase();
                 break;
             }
 
@@ -3299,7 +3003,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             {
                 result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
                                               last.m_it.object_iterator);
-                set_parents_after_object_erase();
                 break;
             }
 
@@ -3330,9 +3033,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
         }
 
-        const auto erased = m_data.m_value.object->erase(std::forward<KeyType>(key));
-        set_parents_after_object_erase();
-        return erased;
+        return m_data.m_value.object->erase(std::forward<KeyType>(key));
     }
 
     template < typename KeyType, detail::enable_if_t <
@@ -3349,7 +3050,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         if (it != m_data.m_value.object->end())
         {
             m_data.m_value.object->erase(it);
-            set_parents_after_object_erase();
             return 1;
         }
         return 0;
@@ -4261,12 +3961,16 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 if (it2 != m_data.m_value.object->end() && it2->second.is_object())
                 {
                     it2->second.update_members(it.value().cbegin(), it.value().cend(), true, depth + 1);
+#if JSON_DIAGNOSTICS
+                    it2->second.set_parents();
+#endif
                     continue;
                 }
             }
-            // set_parent() also repairs the other members, which ordered_json
-            // relocates when adding a key makes its vector grow
-            set_parent(m_data.m_value.object->operator[](it.key()) = it.value());
+            m_data.m_value.object->operator[](it.key()) = it.value();
+#if JSON_DIAGNOSTICS
+            m_data.m_value.object->operator[](it.key()).m_parent = this;
+#endif
         }
     }
 
@@ -4295,6 +3999,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 }
 
                 // a nested object is merged: continue with its parent
+#if JSON_DIAGNOSTICS
+                target->set_parents();
+#endif
                 target = stack.back().target;
                 first = stack.back().position;
                 last = stack.back().last;
@@ -4316,9 +4023,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                     continue;
                 }
             }
-            // set_parent() also repairs the other members, which ordered_json
-            // relocates when adding a key makes its vector grow
-            target->set_parent(target->m_data.m_value.object->operator[](first.key()) = first.value());
+            target->m_data.m_value.object->operator[](first.key()) = first.value();
+#if JSON_DIAGNOSTICS
+            target->m_data.m_value.object->operator[](first.key()).m_parent = target;
+#endif
             ++first;
         }
     }
@@ -4457,7 +4165,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     // because any negative signed value is smaller than any unsigned value.
     // Otherwise, the non-negative signed value is cast to unsigned before the
     // comparison to avoid wraparound.
-#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result, deep_result, may_descend) \
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
     const auto lhs_type = lhs.type();                                                                    \
     const auto rhs_type = rhs.type();                                                                    \
     \
@@ -4466,25 +4174,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         switch (lhs_type)                                                                                \
         {                                                                                                \
             case value_t::array:                                                                         \
-            {                                                                                            \
-                if (JSON_HEDLEY_UNLIKELY(nesting_depth_exhausted(may_descend)))                        \
-                {                                                                                        \
-                    return (deep_result);                                                                \
-                }                                                                                        \
-                const nesting_depth_guard guard;                                                         \
                 return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
-            }                                                                                            \
-            \
+                \
             case value_t::object:                                                                        \
-            {                                                                                            \
-                if (JSON_HEDLEY_UNLIKELY(nesting_depth_exhausted(may_descend)))                        \
-                {                                                                                        \
-                    return (deep_result);                                                                \
-                }                                                                                        \
-                const nesting_depth_guard guard;                                                         \
                 return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
-            }                                                                                            \
-            \
+                \
             case value_t::null:                                                                          \
                 return (null_result);                                                                    \
                 \
@@ -4584,8 +4278,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
         const_reference lhs = *this;
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
-                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
 #ifdef __GNUC__
         JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
@@ -4610,8 +4303,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
                                 std::partial_ordering::equivalent,
                                 std::partial_ordering::unordered,
-                                lhs_type <=> rhs_type, // *NOPAD*
-                                to_partial_ordering(compare_iteratively<true>(lhs, rhs, false)), true)
+                                lhs_type <=> rhs_type) // *NOPAD*
     }
 
     /// @brief comparison: 3-way
@@ -4678,8 +4370,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         JSON_HEDLEY_DIAGNOSTIC_PUSH
         JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
-                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
 #ifdef __GNUC__
         JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
@@ -4735,8 +4426,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         // default_result is used if we cannot compare values. In that case,
         // we compare types. Note we have to call the operator explicitly,
         // because MSVC has problems otherwise.
-        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type),
-                                 compare_iteratively<true>(lhs, rhs, true) == compare_result::less, false)
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
     }
 
     /// @brief comparison: less than

single_include/nlohmann/json.hpp

@@ -95,10 +95,6 @@
     #define JSON_BRACE_INIT_COPY_SEMANTICS 0
 #endif
 
-#ifndef JSON_PRECISE_STREAM_POSITION
-    #define JSON_PRECISE_STREAM_POSITION 0
-#endif
-
 #if JSON_DIAGNOSTICS
     #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -123,28 +119,21 @@
     #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS
 #endif
 
-#if JSON_PRECISE_STREAM_POSITION
-    #define NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION _psp
-#else
-    #define NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION
-#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) json_abi ## a ## b ## c ## d ## e
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d) json_abi ## a ## b ## c ## d
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
             NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS,              \
-            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
-            NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION)
+            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -7430,11 +7419,6 @@ class input_stream_adapter
         // maintain ifstream flags, except eof
         if (is != nullptr)
         {
-#if JSON_PRECISE_STREAM_POSITION
-            // consume the character last returned by get_character() unless it
-            // was given back with release_lookahead()
-            commit_lookahead();
-#endif
             is->clear(is->rdstate() & std::ios::eofbit);
         }
     }
@@ -7448,58 +7432,6 @@ class input_stream_adapter
     input_stream_adapter& operator=(input_stream_adapter&) = delete;
     input_stream_adapter& operator=(input_stream_adapter&&) = delete;
 
-#if JSON_PRECISE_STREAM_POSITION
-    input_stream_adapter(input_stream_adapter&& rhs) noexcept
-        : is(rhs.is), sb(rhs.sb), lookahead(rhs.lookahead)
-    {
-        rhs.is = nullptr;
-        rhs.sb = nullptr;
-        rhs.lookahead = false;
-    }
-
-    // Whether the character last returned by get_character() can be given back
-    // to the input with release_lookahead().
-    static constexpr bool supports_lookahead = true;
-
-    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
-    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
-    // end up as the same value, e.g., 0xFFFFFFFF.
-    //
-    // The character is peeked rather than consumed: it is only stepped over
-    // once the next character is requested, or when the adapter is destroyed.
-    // Until then, release_lookahead() can leave it in the input.
-    std::char_traits<char>::int_type get_character()
-    {
-        if (lookahead)
-        {
-            // step over the character returned by the previous call
-            sb->sbumpc();
-        }
-
-        auto res = sb->sgetc();
-        // set eof manually, as we don't use the istream interface.
-        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
-        {
-            // there is nothing to step over next time
-            lookahead = false;
-            is->clear(is->rdstate() | std::ios::eofbit);
-        }
-        else
-        {
-            lookahead = true;
-        }
-        return res;
-    }
-
-    // Leave the character last returned by get_character() in the input, so
-    // that the next read from the stream - by this adapter or by the caller
-    // once parsing is done - sees it again. Unlike putting a consumed
-    // character back, this cannot fail.
-    void release_lookahead() noexcept
-    {
-        lookahead = false;
-    }
-#else
     input_stream_adapter(input_stream_adapter&& rhs) noexcept
         : is(rhs.is), sb(rhs.sb)
     {
@@ -7510,9 +7442,6 @@ class input_stream_adapter
     // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
     // ensure that std::char_traits<char>::eof() and the character 0xFF do not
     // end up as the same value, e.g., 0xFFFFFFFF.
-    //
-    // The character is consumed, so the character that terminates a number
-    // stays consumed after parsing; see JSON_PRECISE_STREAM_POSITION.
     std::char_traits<char>::int_type get_character()
     {
         auto res = sb->sbumpc();
@@ -7523,14 +7452,10 @@ class input_stream_adapter
         }
         return res;
     }
-#endif
 
     template<class T>
     std::size_t get_elements(T* dest, std::size_t count = 1)
     {
-#if JSON_PRECISE_STREAM_POSITION
-        commit_lookahead();
-#endif
         auto res = static_cast<std::size_t>(sb->sgetn(reinterpret_cast<char*>(dest), static_cast<std::streamsize>(count * sizeof(T))));
         if (JSON_HEDLEY_UNLIKELY(res < count * sizeof(T)))
         {
@@ -7540,27 +7465,9 @@ class input_stream_adapter
     }
 
   private:
-#if JSON_PRECISE_STREAM_POSITION
-    // Step over the character last returned by get_character(). The character
-    // has already been peeked successfully, so for every streambuf with a get
-    // area this is a pointer increment that cannot fail.
-    void commit_lookahead()
-    {
-        if (lookahead)
-        {
-            lookahead = false;
-            sb->sbumpc();
-        }
-    }
-#endif
-
     /// the associated input stream
     std::istream* is = nullptr;
     std::streambuf* sb = nullptr;
-#if JSON_PRECISE_STREAM_POSITION
-    /// whether get_character() peeked a character that is not consumed yet
-    bool lookahead = false;
-#endif
 };
 #endif  // JSON_NO_IO
 
@@ -8972,25 +8879,6 @@ constexpr bool input_adapter_supports_seek(std::false_type /*detected*/)
     return false;
 }
 
-// Detect whether an input adapter reads with one character of lookahead that
-// can be left in the input (see input_stream_adapter::supports_lookahead,
-// which is only defined with JSON_PRECISE_STREAM_POSITION), detected like
-// supports_seek above.
-template<typename InputAdapterType>
-using detect_supports_lookahead = decltype(InputAdapterType::supports_lookahead);
-
-template<typename InputAdapterType>
-constexpr bool input_adapter_supports_lookahead(std::true_type /*detected*/)
-{
-    return InputAdapterType::supports_lookahead;
-}
-
-template<typename InputAdapterType>
-constexpr bool input_adapter_supports_lookahead(std::false_type /*detected*/)
-{
-    return false;
-}
-
 // Detect whether an input adapter exposes a contiguous byte block that the
 // lexer can scan directly (see iterator_input_adapter::supports_bulk_scan).
 // Adapters without the flag - file, stream, wide-string, user-defined - fall
@@ -9031,12 +8919,6 @@ class lexer : public lexer_base<BasicJsonType>
     static constexpr bool lazy_token_string =
         input_adapter_supports_seek<InputAdapterType>(is_detected<detect_supports_seek, InputAdapterType> {});
 
-    /// whether a simulated unget can be passed on to the input adapter, which
-    /// then leaves the character in the input; see
-    /// input_adapter_supports_lookahead
-    static constexpr bool can_release_lookahead =
-        input_adapter_supports_lookahead<InputAdapterType>(is_detected<detect_supports_lookahead, InputAdapterType> {});
-
     /// whether string scanning may bulk-consume runs of ordinary characters
     /// directly from a contiguous input buffer (SWAR fast path). This requires
     /// the token to be reconstructible lazily (lazy_token_string), so bypassing
@@ -10768,21 +10650,6 @@ scan_number_done:
         uncapture_char(std::integral_constant<bool, lazy_token_string> {});
     }
 
-    /// adapter without lookahead: nothing to do (see release_lookahead)
-    void release_lookahead_impl(std::false_type /*can_release*/) const noexcept {}
-
-    /// adapter with lookahead: leave the character in the input instead
-    void release_lookahead_impl(std::true_type /*can_release*/)
-    {
-        if (next_unget)
-        {
-            // the character is read from the input again rather than replayed
-            // from current, so the adapter must not step over it
-            next_unget = false;
-            ia.release_lookahead();
-        }
-    }
-
     /// seekable adapter: nothing was captured, so nothing to undo
     void uncapture_char(std::true_type /*lazy*/) const noexcept {}
 
@@ -10846,31 +10713,6 @@ scan_number_done:
         return position;
     }
 
-    /*!
-    @brief pass a pending simulated unget on to the input
-
-    unget() only rewinds the lexer's own bookkeeping, so the character that
-    terminated the last token (e.g. the character after a number) would still
-    be stepped over when the input adapter is done. Callers that hand the
-    input back to the user afterwards - operator>> and non-strict sax_parse -
-    call this once when scanning is done, so that the input is positioned
-    right after the value.
-
-    Adapters without lookahead (see input_adapter_supports_lookahead) are not
-    handed back to the user, so this is a no-op for them. Without
-    JSON_PRECISE_STREAM_POSITION, no adapter has lookahead, so this is always a
-    no-op and the terminating character stays consumed.
-
-    Scanning may continue after this call: @a next_unget is cleared, and the
-    character is read from the input again instead of being replayed from
-    @a current. A pending unget of EOF needs no special case, because reaching
-    EOF leaves no lookahead to release.
-    */
-    void release_lookahead()
-    {
-        release_lookahead_impl(std::integral_constant<bool, can_release_lookahead> {});
-    }
-
 #if JSON_DIAGNOSTIC_POSITIONS
     /// return the offset of the first character of the last read token; unlike
     /// the token's parsed value, this accounts for escape sequences
@@ -16118,22 +15960,13 @@ class parser
             json_sax_dom_callback_parser<BasicJsonType, InputAdapterType> sdp(result, callback, allow_exceptions, &m_lexer);
             sax_parse_internal(&sdp);
 
-            if (strict)
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
             {
-                // in strict mode, input must be completely read
-                if (get_token() != token_type::end_of_input)
-                {
-                    sdp.parse_error(m_lexer.get_position(),
-                                    m_lexer.get_token_string(),
-                                    parse_error::create(101, m_lexer.get_position(),
-                                                        exception_message(token_type::end_of_input, "value"), nullptr));
-                }
-            }
-            else
-            {
-                // the caller keeps using the input: position it right after
-                // the value by leaving the character that terminated it
-                m_lexer.release_lookahead();
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), nullptr));
             }
 
             // in case of an error, return a discarded value
@@ -16155,20 +15988,12 @@ class parser
             json_sax_dom_parser<BasicJsonType, InputAdapterType> sdp(result, allow_exceptions, &m_lexer);
             sax_parse_internal(&sdp);
 
-            if (strict)
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
             {
-                // in strict mode, input must be completely read
-                if (get_token() != token_type::end_of_input)
-                {
-                    sdp.parse_error(m_lexer.get_position(),
-                                    m_lexer.get_token_string(),
-                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
-                }
-            }
-            else
-            {
-                // see above
-                m_lexer.release_lookahead();
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
             }
 
             // in case of an error, return a discarded value
@@ -16201,24 +16026,12 @@ class parser
         (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
         const bool result = sax_parse_internal(sax);
 
-        if (result)
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
         {
-            if (strict)
-            {
-                // strict mode: next byte must be EOF
-                if (get_token() != token_type::end_of_input)
-                {
-                    return sax->parse_error(m_lexer.get_position(),
-                                            m_lexer.get_token_string(),
-                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
-                }
-            }
-            else
-            {
-                // the caller keeps using the input: position it right after
-                // the value by leaving the character that terminated it
-                m_lexer.release_lookahead();
-            }
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
         }
 
         return result;
@@ -25569,31 +25382,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     }
 #endif
 
-    /*!
-    @brief whether a descent must stop here and finish without the call stack
-
-    @a may_descend says whether the operator descends at all; it is a constant
-    at every call site, and is passed rather than tested by the caller so that
-    the test does not become a constant condition there, which MSVC reports as
-    C4127.
-
-    The comparison operators use this rather than @ref nesting_depth_guard::okay,
-    because they are written as a macro and a macro cannot use the preprocessor
-    the way the guard's constructor does; @ref copy_structured, which can, asks
-    the guard instead and never calls this.
-    */
-    static bool nesting_depth_exhausted(bool may_descend = true) noexcept
-    {
-#ifdef JSON_NO_THREAD_LOCAL
-        // without a count of its own per thread, a descent cannot be bounded
-        // without racing another one, so none is made
-        static_cast<void>(may_descend);
-        return true;
-#else
-        return !may_descend || nesting_depth() >= nesting_depth_limit();
-#endif
-    }
-
     /*!
     @brief counts one level of a bounded descent for as long as it runs, and
            reports whether the descent was still within the limit when it began
@@ -25913,274 +25701,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     }
 
 
-    /// the result of comparing two values, including values that cannot be
-    /// ordered at all, such as a discarded value or a NaN
-    enum class compare_result { less, equal, greater, unordered };
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-    /// @brief the ordering that @a result stands for
-    static std::partial_ordering to_partial_ordering(compare_result result) noexcept // *NOPAD*
-    {
-        switch (result)
-        {
-            case compare_result::less:
-                return std::partial_ordering::less;
-            case compare_result::greater:
-                return std::partial_ordering::greater;
-            case compare_result::equal:
-                return std::partial_ordering::equivalent;
-            case compare_result::unordered:
-            default:
-                return std::partial_ordering::unordered;
-        }
-    }
-#endif
-
-    /*!
-    @brief compare two values that are not both an array or both an object
-
-    Such a pair is compared by the operators themselves, which cannot descend
-    into it and therefore cannot recurse.
-
-    That holds for a pair whose types differ as much as for a pair of leaves: an
-    array and an object are told apart by their types alone, because an operator
-    only ever descends into two values of the same type. So `==` reports them as
-    unequal without looking inside either, and an ordering falls back to the
-    order of the types - an object sorts before an array - exactly as it does
-    for a value that is not nested deeply enough to get here.
-    */
-    template<bool Ordered>
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
-    {
-        if (lhs == rhs)
-        {
-            return compare_result::equal;
-        }
-
-        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
-    }
-
-    /*!
-    @brief compare two object keys
-
-    An object compares its entries as pairs of a key and a value, so its keys
-    are compared exactly as std::pair compares them: with < where the objects
-    are being ordered, and with == where they are only checked for equality.
-    Note that this is not the object's own comparator, which for a vector-backed
-    object type such as nlohmann::ordered_map tells equality rather than order.
-    */
-    static compare_result compare_keys(const typename object_t::key_type& lhs,
-                                       const typename object_t::key_type& rhs,
-                                       std::true_type /*ordered*/)
-    {
-        if (lhs < rhs)
-        {
-            return compare_result::less;
-        }
-
-        if (rhs < lhs)
-        {
-            return compare_result::greater;
-        }
-
-        return compare_result::equal;
-    }
-
-    /// @brief check two object keys for equality
-    static compare_result compare_keys(const typename object_t::key_type& lhs,
-                                       const typename object_t::key_type& rhs,
-                                       std::false_type /*ordered*/)
-    {
-        return lhs == rhs ? compare_result::equal : compare_result::unordered;
-    }
-
-    /// @brief tell apart two values that are not equal
-    /// @note only instantiated where the values are being ordered, as a key or
-    ///       string type is not required to be ordered to be compared for equality
-    static compare_result order_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        if (lhs < rhs)
-        {
-            return compare_result::less;
-        }
-
-        if (rhs < lhs)
-        {
-            return compare_result::greater;
-        }
-
-        return compare_result::unordered;
-    }
-
-    /// @brief report two values as not equal without ordering them
-    static compare_result order_leaves(const_reference /*lhs*/, const_reference /*rhs*/, std::false_type /*ordered*/) noexcept
-    {
-        return compare_result::unordered;
-    }
-
-    /*!
-    @brief compare @a lhs and @a rhs without descending into them
-
-    Reached once a comparison has descended @ref nesting_depth_limit levels, so
-    that comparing values cannot exhaust the call stack however deeply they are
-    nested. The two values are walked in lockstep on an explicit stack and
-    compared lexicographically, element by element in the order the containers
-    enumerate them - which is how the container types this library ships compare
-    themselves: a std::map enumerates its entries in key order, and
-    nlohmann::ordered_map in insertion order. An object type that enumerates its
-    entries in an unspecified order, such as std::unordered_map, compares them
-    pairwise instead; the difference could only ever show below the bound.
-
-    Note that the stack this walks with is allocated, while the comparison
-    operators are noexcept and the container comparison this replaces allocated
-    nothing. Failing that allocation therefore ends the process rather than
-    throwing. It only arises for values nested past the bound, and only when
-    memory has run out - where the same comparison used to exhaust the call
-    stack instead - but it is a way to fail that the operators did not have.
-    */
-    template<bool Ordered>
-    static compare_result compare_iteratively(const_reference lhs, const_reference rhs,
-            const bool unordered_compares_equal) noexcept
-    {
-        /// a pair of containers being compared in lockstep
-        struct frame
-        {
-            const basic_json* lhs_value{nullptr};
-            const basic_json* rhs_value{nullptr};
-            typename array_t::const_iterator lhs_array_it{};
-            typename array_t::const_iterator rhs_array_it{};
-            typename object_t::const_iterator lhs_object_it{};
-            typename object_t::const_iterator rhs_object_it{};
-        };
-
-        std::vector<frame> stack;
-        const basic_json* left = &lhs;
-        const basic_json* right = &rhs;
-
-        for (;;)
-        {
-            const auto type = left->m_data.m_type;
-
-            if (type == right->m_data.m_type && (type == value_t::array || type == value_t::object))
-            {
-                // descend: the elements decide, and are compared further down
-                stack.emplace_back();
-                frame& pushed = stack.back();
-                pushed.lhs_value = left;
-                pushed.rhs_value = right;
-
-                if (type == value_t::array)
-                {
-                    pushed.lhs_array_it = left->m_data.m_value.array->cbegin();
-                    pushed.rhs_array_it = right->m_data.m_value.array->cbegin();
-                }
-                else
-                {
-                    pushed.lhs_object_it = left->m_data.m_value.object->cbegin();
-                    pushed.rhs_object_it = right->m_data.m_value.object->cbegin();
-                }
-            }
-            else
-            {
-                const compare_result result = compare_leaves<Ordered>(*left, *right);
-
-                // Values that cannot be ordered - a NaN, say - end an ordered
-                // comparison for std::lexicographical_compare_three_way, but
-                // std::lexicographical_compare treats them as equivalent and
-                // carries on with the next element. Both are reproduced here,
-                // so that a value nested too deeply to descend into compares
-                // exactly as one that is not.
-                if (result != compare_result::equal &&
-                        !(unordered_compares_equal && result == compare_result::unordered))
-                {
-                    return result;
-                }
-            }
-
-            // walk back up past the containers that are exhausted, then take the
-            // next pair of elements from the innermost one that is not
-            for (;;)
-            {
-                if (stack.empty())
-                {
-                    return compare_result::equal;
-                }
-
-                frame& current = stack.back();
-                const bool is_object = current.lhs_value->m_data.m_type == value_t::object;
-
-                const bool lhs_done = is_object
-                                      ? current.lhs_object_it == current.lhs_value->m_data.m_value.object->cend()
-                                      : current.lhs_array_it == current.lhs_value->m_data.m_value.array->cend();
-                const bool rhs_done = is_object
-                                      ? current.rhs_object_it == current.rhs_value->m_data.m_value.object->cend()
-                                      : current.rhs_array_it == current.rhs_value->m_data.m_value.array->cend();
-
-                if (lhs_done || rhs_done)
-                {
-                    // whichever ran out first holds the smaller container; if
-                    // both did, they are equal and the container above decides
-                    if (lhs_done != rhs_done)
-                    {
-                        return lhs_done ? compare_result::less : compare_result::greater;
-                    }
-
-                    stack.pop_back();
-                    continue;
-                }
-
-                if (is_object)
-                {
-                    // an entry is a key and a value, and the key decides first
-                    const compare_result key_result =
-                        compare_keys(current.lhs_object_it->first, current.rhs_object_it->first,
-                                     std::integral_constant<bool, Ordered> {});
-
-                    if (key_result != compare_result::equal)
-                    {
-                        return key_result;
-                    }
-
-                    left = &(current.lhs_object_it->second);
-                    right = &(current.rhs_object_it->second);
-                    ++current.lhs_object_it;
-                    ++current.rhs_object_it;
-                }
-                else
-                {
-                    left = &(*current.lhs_array_it);
-                    right = &(*current.rhs_array_it);
-                    ++current.lhs_array_it;
-                    ++current.rhs_array_it;
-                }
-
-                break;
-            }
-        }
-    }
-
-
-    /// @brief restore the parent pointers after erasing from an object
-    /// ordered_json keeps its members in a vector, and erasing a member
-    /// re-constructs every member after it in place, which resets their
-    /// parent pointers
-    void set_parents_after_object_erase()
-    {
-#if JSON_DIAGNOSTICS
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning(push )
-#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
-#endif
-        if (detail::is_ordered_map<object_t>::value)
-        {
-            set_parents();
-        }
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning( pop )
-#endif
-#endif
-    }
-
   public:
     //////////////////////////
     // JSON parser callback //
@@ -27198,7 +26718,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     ValueType & get_to(ValueType& v) const noexcept(noexcept(
             JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
     {
-        static_assert(!std::is_const<ValueType>::value, "get_to() cannot deserialize into a const value");
         JSONSerializer<ValueType>::from_json(*this, v);
         return v;
     }
@@ -27224,7 +26743,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     noexcept(noexcept(JSONSerializer<Array>::from_json(
                           std::declval<const basic_json_t&>(), v)))
     {
-        static_assert(!std::is_const<T>::value, "get_to() cannot deserialize into a const value");
         JSONSerializer<Array>::from_json(*this, v);
         return v;
     }
@@ -27871,7 +27389,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             case value_t::object:
             {
                 result.m_it.object_iterator = erase_from_object(pos.m_it.object_iterator);
-                set_parents_after_object_erase();
                 break;
             }
 
@@ -27944,7 +27461,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             {
                 result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
                                               last.m_it.object_iterator);
-                set_parents_after_object_erase();
                 break;
             }
 
@@ -27975,9 +27491,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
         }
 
-        const auto erased = m_data.m_value.object->erase(std::forward<KeyType>(key));
-        set_parents_after_object_erase();
-        return erased;
+        return m_data.m_value.object->erase(std::forward<KeyType>(key));
     }
 
     template < typename KeyType, detail::enable_if_t <
@@ -27994,7 +27508,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         if (it != m_data.m_value.object->end())
         {
             m_data.m_value.object->erase(it);
-            set_parents_after_object_erase();
             return 1;
         }
         return 0;
@@ -28906,12 +28419,16 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 if (it2 != m_data.m_value.object->end() && it2->second.is_object())
                 {
                     it2->second.update_members(it.value().cbegin(), it.value().cend(), true, depth + 1);
+#if JSON_DIAGNOSTICS
+                    it2->second.set_parents();
+#endif
                     continue;
                 }
             }
-            // set_parent() also repairs the other members, which ordered_json
-            // relocates when adding a key makes its vector grow
-            set_parent(m_data.m_value.object->operator[](it.key()) = it.value());
+            m_data.m_value.object->operator[](it.key()) = it.value();
+#if JSON_DIAGNOSTICS
+            m_data.m_value.object->operator[](it.key()).m_parent = this;
+#endif
         }
     }
 
@@ -28940,6 +28457,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 }
 
                 // a nested object is merged: continue with its parent
+#if JSON_DIAGNOSTICS
+                target->set_parents();
+#endif
                 target = stack.back().target;
                 first = stack.back().position;
                 last = stack.back().last;
@@ -28961,9 +28481,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                     continue;
                 }
             }
-            // set_parent() also repairs the other members, which ordered_json
-            // relocates when adding a key makes its vector grow
-            target->set_parent(target->m_data.m_value.object->operator[](first.key()) = first.value());
+            target->m_data.m_value.object->operator[](first.key()) = first.value();
+#if JSON_DIAGNOSTICS
+            target->m_data.m_value.object->operator[](first.key()).m_parent = target;
+#endif
             ++first;
         }
     }
@@ -29102,7 +28623,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     // because any negative signed value is smaller than any unsigned value.
     // Otherwise, the non-negative signed value is cast to unsigned before the
     // comparison to avoid wraparound.
-#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result, deep_result, may_descend) \
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
     const auto lhs_type = lhs.type();                                                                    \
     const auto rhs_type = rhs.type();                                                                    \
     \
@@ -29111,25 +28632,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         switch (lhs_type)                                                                                \
         {                                                                                                \
             case value_t::array:                                                                         \
-            {                                                                                            \
-                if (JSON_HEDLEY_UNLIKELY(nesting_depth_exhausted(may_descend)))                        \
-                {                                                                                        \
-                    return (deep_result);                                                                \
-                }                                                                                        \
-                const nesting_depth_guard guard;                                                         \
                 return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
-            }                                                                                            \
-            \
+                \
             case value_t::object:                                                                        \
-            {                                                                                            \
-                if (JSON_HEDLEY_UNLIKELY(nesting_depth_exhausted(may_descend)))                        \
-                {                                                                                        \
-                    return (deep_result);                                                                \
-                }                                                                                        \
-                const nesting_depth_guard guard;                                                         \
                 return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
-            }                                                                                            \
-            \
+                \
             case value_t::null:                                                                          \
                 return (null_result);                                                                    \
                 \
@@ -29229,8 +28736,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
         const_reference lhs = *this;
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
-                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
 #ifdef __GNUC__
         JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
@@ -29255,8 +28761,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
                                 std::partial_ordering::equivalent,
                                 std::partial_ordering::unordered,
-                                lhs_type <=> rhs_type, // *NOPAD*
-                                to_partial_ordering(compare_iteratively<true>(lhs, rhs, false)), true)
+                                lhs_type <=> rhs_type) // *NOPAD*
     }
 
     /// @brief comparison: 3-way
@@ -29323,8 +28828,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         JSON_HEDLEY_DIAGNOSTIC_PUSH
         JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
-                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
 #ifdef __GNUC__
         JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
@@ -29380,8 +28884,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         // default_result is used if we cannot compare values. In that case,
         // we compare types. Note we have to call the operator explicitly,
         // because MSVC has problems otherwise.
-        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type),
-                                 compare_iteratively<true>(lhs, rhs, true) == compare_result::less, false)
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
     }
 
     /// @brief comparison: less than
@@ -31244,7 +30747,6 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
     #undef JSON_HAS_STATIC_RTTI
     #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
     #undef JSON_BRACE_INIT_COPY_SEMANTICS
-    #undef JSON_PRECISE_STREAM_POSITION
 #endif
 
 // #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>

single_include/nlohmann/json_fwd.hpp

@@ -56,10 +56,6 @@
     #define JSON_BRACE_INIT_COPY_SEMANTICS 0
 #endif
 
-#ifndef JSON_PRECISE_STREAM_POSITION
-    #define JSON_PRECISE_STREAM_POSITION 0
-#endif
-
 #if JSON_DIAGNOSTICS
     #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -84,28 +80,21 @@
     #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS
 #endif
 
-#if JSON_PRECISE_STREAM_POSITION
-    #define NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION _psp
-#else
-    #define NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION
-#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) json_abi ## a ## b ## c ## d ## e
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d) json_abi ## a ## b ## c ## d
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
             NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS,              \
-            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
-            NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION)
+            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

tests/CMakeLists.txt

@@ -80,10 +80,7 @@ target_compile_options(test_main PUBLIC
     #                              std::allocator_traits<...>::construct for the custom-base-class
     #                              test's map type past VS2015's limit. The name is only used for
     #                              debug info, so truncation does not affect the build.
-    #       Disable warning C5285: cannot declare a specialization for 'std::tuple'; MSVC 19.51
-    #                              reports the forward declarations of standard library
-    #                              templates in the vendored doctest.h
-    $<$<CXX_COMPILER_ID:MSVC>:/W4;/wd4566;/wd4996;/wd4702;/wd4503;/wd5285>
+    $<$<CXX_COMPILER_ID:MSVC>:/W4;/wd4566;/wd4996;/wd4702;/wd4503>
     # https://github.com/nlohmann/json/issues/1114
     $<$<CXX_COMPILER_ID:MSVC>:/bigobj> $<$<BOOL:${MINGW}>:-Wa,-mbig-obj>
 

tests/abi/config/default.cpp

@@ -36,10 +36,6 @@ TEST_CASE("default namespace")
         expected += "_bics";
 #endif
 
-#if JSON_PRECISE_STREAM_POSITION
-        expected += "_psp";
-#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

@@ -37,10 +37,6 @@ TEST_CASE("default namespace without version component")
         expected += "_bics";
 #endif
 
-#if JSON_PRECISE_STREAM_POSITION
-        expected += "_psp";
-#endif
-
         expected += "::basic_json";
 
         // fallback for Clang

tests/fuzzing.md

@@ -79,26 +79,3 @@ the same `fuzzers` target as above and also relies on the `FUZZER_ENGINE` variab
 [build script](https://github.com/google/oss-fuzz/blob/master/projects/json/build.sh) for more information.
 
 In case the build at OSS-Fuzz fails, an issue will be created automatically.
-
-### Handling OSS-Fuzz reports
-
-OSS-Fuzz files the crashes it finds in its own [issue tracker](https://issues.oss-fuzz.com), not on GitHub. So that
-each report can be traced to the change that fixed it, and each fix to the report it answers, fixes follow these
-conventions:
-
-- **Reference the OSS-Fuzz issue in the pull request**, next to any GitHub issue it closes, as `OSS-Fuzz: <id>` (for
-  example, `OSS-Fuzz: 563659413`), and in the commit message. The ID alone does not disclose the crash. If the report
-  was triaged into a GitHub issue, link the OSS-Fuzz issue there too.
-- **Turn the reproducer into a unit test.** Download the testcase from the OSS-Fuzz report, reduce it if possible, and
-  add it as a regression test to the unit test of the affected format (e.g., `tests/src/unit-bjdata.cpp`), with a
-  comment naming the OSS-Fuzz issue. This way the input is checked by every CI run rather than only by OSS-Fuzz, and
-  it stays covered even if OSS-Fuzz later closes the report as not reproducible.
-- **Keep the fuzzer drivers and the unit tests in sync.** The round-trip checks of the UBJSON and BJData drivers are
-  also run on a fixed corpus in the unit tests (see `tests/src/round_trip_corpus.hpp` and the "round-trip invariants"
-  test cases), so a regression shows up in CI first. When a driver's checks change, change the unit tests with them.
-- **Record in the report whether the bug shipped.** OSS-Fuzz asks whether a crash was a short-lived regression or
-  affects a released version; answer it when the fix is merged, as it decides whether the fix needs a release note or
-  a security advisory (see the [security policy](../.github/SECURITY.md)).
-
-After the fix is merged, OSS-Fuzz re-runs the reproducer on its next build and marks the report as verified and
-closed. If it does not, the fix is incomplete.

tests/src/fuzzer-parse_bjdata.cpp

@@ -42,9 +42,6 @@ dump() serializes any non-finite double the same deterministic way (as JSON
 `null`, since JSON itself cannot represent NaN/Infinity), so comparing
 dumps is stable under exactly the same values that break operator==.
 
-The unit tests run the same checks on a fixed corpus (see the "BJData round-trip
-invariants" test case), so keep both in sync.
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */

tests/src/fuzzer-parse_ubjson.cpp

@@ -21,9 +21,6 @@ array data, it performs the following steps:
 - j4 = from_ubjson(vec3)
 - assert(j1 == j4)
 
-The unit tests run the same checks on a fixed corpus (see the "UBJSON round-trip
-invariants" test case), so keep both in sync.
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */

tests/src/round_trip_corpus.hpp

@@ -1,213 +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
-
-#pragma once
-
-#include <cmath> // nan
-#include <cstddef> // size_t
-#include <cstdint> // int32_t, int64_t, uint32_t, uint64_t
-#include <limits> // numeric_limits
-#include <random> // mt19937
-#include <string> // string, to_string
-#include <utility> // move
-#include <vector> // vector
-
-#include <nlohmann/json.hpp>
-
-// Values for the round-trip property tests of the UBJSON and BJData writers.
-//
-// The fuzzer drivers (tests/src/fuzzer-parse_ubjson.cpp and
-// fuzzer-parse_bjdata.cpp) check that anything the library parses can be
-// serialized, parsed back, and serialized again without loss. Those checks
-// only run at OSS-Fuzz, so a regression used to surface days later as an
-// external report. The unit tests run the same checks on this corpus in CI.
-//
-// The corpus is deterministic: std::mt19937's output sequence is fixed by
-// the standard, and it is used directly rather than through a distribution
-// (whose results are implementation-defined).
-namespace utils
-{
-
-class round_trip_corpus
-{
-  public:
-    using json = nlohmann::json;
-
-    static std::vector<json> values()
-    {
-        round_trip_corpus corpus;
-        return corpus.build();
-    }
-
-    // whether a value contains a binary value, which a BJData or UBJSON round
-    // trip may turn into an array of integers
-    static bool contains_binary(const json& j)
-    {
-        if (j.is_binary())
-        {
-            return true;
-        }
-        if (j.is_structured())
-        {
-            for (const auto& element : j)
-            {
-                if (contains_binary(element))
-                {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-  private:
-    std::vector<json> atoms;
-    // a fixed seed is the point: the corpus must be the same in every run
-    std::mt19937 generator{42}; // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
-
-    round_trip_corpus()
-        : atoms
-    {
-        nullptr, true, false,
-        // integers at the boundaries of every UBJSON/BJData integer type
-        0, 1, -1, 127, 128, 255, 256, -128, -129,
-        32767, 32768, 65535, 65536, -32768, -32769,
-        (std::numeric_limits<std::int32_t>::min)(), (std::numeric_limits<std::int32_t>::max)(),
-        (std::numeric_limits<std::uint32_t>::max)(),
-        (std::numeric_limits<std::int64_t>::min)(), (std::numeric_limits<std::int64_t>::max)(),
-        static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()) + 1u,
-        (std::numeric_limits<std::uint64_t>::max)(),
-        // floating-point numbers, including non-finite ones
-        0.0, -0.0, 1.5, -2.25, 3.4e38, (std::numeric_limits<double>::max)(),
-        std::nan(""), std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity(),
-        // strings, including a non-ASCII one and one longer than 255 bytes
-        "", "a", "\xC3\xA4", std::string(300, 'x'),
-        // binary values with and without subtype
-        json::binary({}), json::binary({1, 2, 255}), json::binary({0x80, 0x7F}, 42), json::binary({1}, 0)
-    }
-    {}
-
-    std::vector<json> build()
-    {
-        std::vector<json> result = atoms;
-
-        // each atom inside containers, including homogeneous ones that the
-        // writers encode as optimized (typed) containers
-        result.emplace_back(json::array());
-        result.emplace_back(json::object());
-        for (const auto& atom : atoms)
-        {
-            result.push_back(json::array({atom}));
-            result.push_back(json::array({atom, atom, atom}));
-            result.push_back(json::array({json::array({atom})}));
-            result.push_back(json::object({{"key", atom}}));
-        }
-        result.push_back(json::array({1, 1.5}));
-        result.push_back(json::array({-1, 255}));
-        result.push_back(json::array({"a", "b"}));
-
-        // deep, but well below any recursion or depth limit
-        json nested_array = 1;
-        json nested_object = 1;
-        for (int i = 0; i < 300; ++i)
-        {
-            nested_array = json::array({nested_array});
-            nested_object = json::object({{"key", nested_object}});
-        }
-        result.push_back(nested_array);
-        result.push_back(nested_object);
-
-        add_annotated_arrays(result);
-        add_random_values(result);
-        return result;
-    }
-
-    // objects in the JData annotated array format, which the BJData writer
-    // encodes as ND-arrays when the annotation describes a packed array, and
-    // as plain objects otherwise (see #5398, #5399, #5403, #5404, and #5542)
-    static void add_annotated_arrays(std::vector<json>& result)
-    {
-        const std::vector<json> types =
-        {
-            "uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64",
-            "single", "double", "char", "byte", "bool", "unknown", 5, nullptr
-        };
-        const std::vector<json> sizes =
-        {
-            json::array(), {3}, {1, 3}, {3, 1}, {2, 3}, {2, 0}, {0, 2}, {2, 2, 2}, {-1, 2}, {2, 1.5},
-            "3", 3, nullptr, json::binary({})
-        };
-        const std::vector<json> data =
-        {
-            nullptr, 5, "s", json::object({{"a", 1}}), json::array(),
-            {1, 2, 3}, {1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6, 7, 8},
-            {1.5, 2.5, 3.5, 4.5, 5.5, 6.5}, {300, -300, 70000, -70000, 1, 2},
-            {"a", "b", "c", "d", "e", "f"}, {json::array({1, 2, 3}), json::array({4, 5, 6})}
-        };
-
-        for (const auto& type : types)
-        {
-            for (const auto& size : sizes)
-            {
-                for (const auto& d : data)
-                {
-                    result.push_back({{"_ArrayType_", type}, {"_ArraySize_", size}, {"_ArrayData_", d}});
-                }
-            }
-        }
-
-        // incomplete annotations and annotations with an extra key
-        result.push_back({{"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}});
-        result.push_back({{"_ArrayType_", "uint8"}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}});
-        result.push_back({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 3}}});
-        result.push_back({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}, {"extra", 1}});
-    }
-
-    // random containers of atoms, both homogeneous and mixed
-    void add_random_values(std::vector<json>& result)
-    {
-        for (int i = 0; i < 1000; ++i)
-        {
-            result.push_back(random_value(0));
-        }
-    }
-
-    std::size_t random_below(std::size_t bound)
-    {
-        return generator() % bound;
-    }
-
-    json random_value(int depth)
-    {
-        const auto kind = random_below(10);
-        if (depth > 3 || kind < 5)
-        {
-            return atoms[random_below(atoms.size())];
-        }
-
-        json result = kind < 8 ? json::array() : json::object();
-        const auto count = random_below(5);
-        const bool homogeneous = random_below(2) == 0;
-        const json fixed = atoms[random_below(atoms.size())];
-        for (std::size_t i = 0; i < count; ++i)
-        {
-            json element = homogeneous ? fixed : random_value(depth + 1);
-            if (result.is_array())
-            {
-                result.push_back(std::move(element));
-            }
-            else
-            {
-                result[std::to_string(i)] = std::move(element);
-            }
-        }
-        return result;
-    }
-};
-
-} // namespace utils

tests/src/unit-allocator.cpp

@@ -37,12 +37,6 @@ struct bad_allocator : std::allocator<T>
 };
 } // namespace
 
-TEST_CASE("get_allocator")
-{
-    const auto alloc = nlohmann::json::get_allocator();
-    CHECK(alloc == std::allocator<nlohmann::json>());
-}
-
 TEST_CASE("bad_alloc")
 {
     SECTION("bad_alloc")

tests/src/unit-bjdata.cpp

@@ -19,7 +19,6 @@ using nlohmann::json;
 #include <fstream>
 #include <set>
 #include "make_test_data_available.hpp"
-#include "round_trip_corpus.hpp"
 #include "test_utils.hpp"
 
 namespace
@@ -2868,21 +2867,6 @@ TEST_CASE("BJData")
                 const auto out_num = json::to_bjdata(j_num);
                 CHECK(out_num.at(0) == '{');
                 CHECK(json::from_bjdata(out_num) == j_num);
-
-                // OSS-Fuzz issue 474400817: an empty object _ArraySize_ was
-                // written as the ND-array header length, which from_bjdata()
-                // could not read back
-                const std::vector<uint8_t> input =
-                {
-                    '[', '{', 'U', 11, '_', 'A', 'r', 'r', 'a', 'y', 'D', 'a', 't', 'a', '_', 'Z',
-                    'U', 11, '_', 'A', 'r', 'r', 'a', 'y', 'T', 'y', 'p', 'e', '_', 'S', 'i', 5, 'i', 'n', 't', '1', '6',
-                    'U', 11, '_', 'A', 'r', 'r', 'a', 'y', 'S', 'i', 'z', 'e', '_', '{', '}', '}', ']'
-                };
-                const json j1 = json::from_bjdata(input);
-                CHECK(j1 == json::parse(R"([{"_ArrayType_":"int16","_ArraySize_":{},"_ArrayData_":null}])"));
-                json j2;
-                CHECK_NOTHROW(j2 = json::from_bjdata(json::to_bjdata(j1, false, false)));
-                CHECK(j2 == j1);
             }
 
             SECTION("ndarray with out-of-range _ArrayData_ elements stays as object")
@@ -3763,49 +3747,6 @@ TEST_CASE("BJData")
     }
 }
 
-TEST_CASE("BJData input that cannot be read is discarded by every overload")
-{
-    std::vector<std::uint8_t> input = json::to_bjdata(json({{"a", {1, 2}}}));
-    input.pop_back();
-
-    json _;
-    CHECK_THROWS_AS(_ = json::from_bjdata(input.begin(), input.end()), json::parse_error&);
-    CHECK(json::from_bjdata(input, true, false).is_discarded());
-    CHECK(json::from_bjdata(input.begin(), input.end(), true, false).is_discarded());
-}
-
-TEST_CASE("BJData SAX parsing stops at every event")
-{
-    // Containers are opened and closed by the loop that reads them; a SAX
-    // handler that rejects any event - including the end of a nested
-    // container - must stop the parse right there.
-    const auto count_events = [](const std::vector<std::uint8_t>& input)
-    {
-        int events = 0;
-        while (true)
-        {
-            SaxCountdown scp(events);
-            if (json::sax_parse(input, &scp, json::input_format_t::bjdata))
-            {
-                return events;
-            }
-            ++events;
-            REQUIRE(events < 1000);
-        }
-    };
-
-    // 20 events: every container kind closes inside another one
-    const json j = json::parse(R"({"a": [1, {"b": []}], "c": {"d": [[2]]}})");
-    CHECK(count_events(json::to_bjdata(j)) == 20);
-    CHECK(count_events(json::to_bjdata(j, true)) == 20);
-    CHECK(count_events(json::to_bjdata(j, true, true)) == 20);
-
-    // an ND-array is announced as an annotated object: start_object, then
-    // _ArrayType_, _ArraySize_ and _ArrayData_ with its elements
-    const json ndarray = json::parse(R"({"_ArrayType_": "uint8", "_ArraySize_": [2, 2], "_ArrayData_": [1, 2, 3, 4]})");
-    CHECK(count_events(json::to_bjdata(ndarray, true, true)) == 16);
-}
-
 TEST_CASE("issue #5405 - array reserve for definite-length BJData arrays")
 {
 #if !defined(JSON_NOEXCEPTION)
@@ -4290,54 +4231,6 @@ TEST_CASE("all BJData first bytes")
 }
 #endif
 
-TEST_CASE("BJData and UBJSON can be written to a string")
-{
-    const std::vector<json> values =
-    {
-        {{"a", {1, 2.5, "x", nullptr}}, {"b", json::binary({1, 2})}},
-        // an annotated ND-array, and objects that only look like one
-        json::parse(R"({"_ArrayType_": "uint8", "_ArraySize_": [2, 2], "_ArrayData_": [1, 2, 3, 4]})"),
-        json::parse(R"({"_ArrayType_": 1, "_ArraySize_": [2, 2], "_ArrayData_": [1, 2, 3, 4]})"),
-        json::parse(R"({"_ArrayType_": "uint8", "_ArraySize_": 4, "_ArrayData_": [1, 2, 3, 4]})"),
-        json::parse(R"({"_ArrayType_": "uint8", "_ArraySize_": [2, -2], "_ArrayData_": [1, 2, 3, 4]})"),
-        json::parse(R"({"_ArrayType_": "uint8", "_ArraySize_": [2, 2], "_ArrayData_": [1, 2, 3]})"),
-        json::parse(R"({"_ArrayType_": "uint8", "_ArraySize_": [2, 2], "_ArrayData_": 1})"),
-    };
-
-    for (const auto& j : values)
-    {
-        CAPTURE(j.dump());
-        for (const bool use_size :
-                {
-                    false, true
-                })
-        {
-            for (const bool use_type :
-                    {
-                        false, true
-                    })
-            {
-                if (use_type && !use_size)
-                {
-                    continue;
-                }
-                CAPTURE(use_size);
-                CAPTURE(use_type);
-
-                const auto bjdata = json::to_bjdata(j, use_size, use_type);
-                std::string bjdata_string;
-                json::to_bjdata(j, bjdata_string, use_size, use_type);
-                CHECK(bjdata_string == std::string(bjdata.begin(), bjdata.end()));
-
-                const auto ubjson = json::to_ubjson(j, use_size, use_type);
-                std::string ubjson_string;
-                json::to_ubjson(j, ubjson_string, use_size, use_type);
-                CHECK(ubjson_string == std::string(ubjson.begin(), ubjson.end()));
-            }
-        }
-    }
-}
-
 TEST_CASE("BJData use_type requires use_size")
 {
     SECTION("non-empty object throws other_error.502")
@@ -4356,17 +4249,6 @@ TEST_CASE("BJData use_type requires use_size")
                              json::other_error&);
     }
 
-    SECTION("non-empty binary value throws other_error.502")
-    {
-        const json j = json::binary({1, 2, 3});
-        CHECK_THROWS_WITH_AS(json::to_bjdata(j, false, true),
-                             "[json.exception.other_error.502] use_type requires use_size = true",
-                             json::other_error&);
-        CHECK_THROWS_WITH_AS(json::to_ubjson(j, false, true),
-                             "[json.exception.other_error.502] use_type requires use_size = true",
-                             json::other_error&);
-    }
-
     SECTION("scalars do not throw with use_type=true, use_count=false")
     {
         CHECK_NOTHROW(json::to_bjdata(42, false, true));
@@ -4391,93 +4273,6 @@ TEST_CASE("BJData use_type requires use_size")
     }
 }
 
-TEST_CASE("BJData round-trip invariants")
-{
-    // This checks what the parse_bjdata_fuzzer driver checks (see
-    // tests/src/fuzzer-parse_bjdata.cpp), so that a regression shows up in CI
-    // rather than as an OSS-Fuzz report: every value from_bjdata() returns
-    // (j1) can be serialized with any combination of options, the result can
-    // be parsed back (j2), and serializing j2 again with the same options
-    // yields a value-equal result.
-    //
-    // Beyond the driver, this also checks that j2 equals j1 and that
-    // serializing j2 reproduces the exact bytes, both except for values that
-    // contain a binary value: a binary value is only written as a binary
-    // value with Draft 3's optimized binary array, and otherwise read back as
-    // an array of integers, for which the writer may choose different (but
-    // equally valid) type markers when it is serialized again (see #5494).
-    //
-    // Values are compared with dump() rather than operator==, because a NaN
-    // never compares equal to itself.
-    struct options
-    {
-        bool use_size;
-        bool use_type;
-        json::bjdata_version_t version;
-    };
-    const std::vector<options> all_options =
-    {
-        {false, false, json::bjdata_version_t::draft2},
-        {true, false, json::bjdata_version_t::draft2},
-        {true, true, json::bjdata_version_t::draft2},
-        {false, false, json::bjdata_version_t::draft3},
-        {true, false, json::bjdata_version_t::draft3},
-        {true, true, json::bjdata_version_t::draft3},
-    };
-
-    for (const auto& j0 : utils::round_trip_corpus::values())
-    {
-        // turn the corpus value into a value as from_bjdata() returns it
-        for (const auto& initial : all_options)
-        {
-            const json j1 = json::from_bjdata(json::to_bjdata(j0, initial.use_size, initial.use_type, initial.version));
-            const bool has_binary = utils::round_trip_corpus::contains_binary(j1);
-
-            for (const auto& o : all_options)
-            {
-                INFO("j1 = " << j1.dump() << ", use_size = " << o.use_size << ", use_type = " << o.use_type
-                     << ", draft3 = " << (o.version == json::bjdata_version_t::draft3));
-
-                const std::vector<std::uint8_t> vec = json::to_bjdata(j1, o.use_size, o.use_type, o.version);
-                json j2;
-                // anything the library writes must be parsable by the library
-                REQUIRE_NOTHROW(j2 = json::from_bjdata(vec));
-                const std::vector<std::uint8_t> vec2 = json::to_bjdata(j2, o.use_size, o.use_type, o.version);
-                CHECK(json::from_bjdata(vec2).dump() == j2.dump());
-
-                if (!has_binary)
-                {
-                    CHECK(j2.dump() == j1.dump());
-                    CHECK(vec2 == vec);
-                }
-            }
-        }
-    }
-}
-
-TEST_CASE("BJData round trip of a binary value is value-stable, not byte-stable")
-{
-    // OSS-Fuzz issue 474480402: a Draft 3 optimized binary array is read as a
-    // binary value, which to_bjdata() writes in the default Draft 2 mode as a
-    // plain array of uint8 numbers. That is read back as an array of numbers,
-    // for which the writer then picks the smallest type marker, int8 ('i'),
-    // so re-serializing changes the bytes, but not the value. This is the
-    // exception described in the "Round trips" note of the BJData
-    // documentation, and why the fuzzer checks value stability (see #5494).
-    const std::vector<uint8_t> input = {'[', '$', 'B', '#', 'U', 1, 0x20};
-    const json j1 = json::from_bjdata(input);
-    CHECK(j1 == json::binary({0x20}));
-
-    const std::vector<uint8_t> vec = json::to_bjdata(j1, false, false);
-    CHECK(vec == std::vector<uint8_t>({'[', 'U', 0x20, ']'}));
-    const json j2 = json::from_bjdata(vec);
-    CHECK(j2 == json::array({0x20}));
-
-    const std::vector<uint8_t> vec2 = json::to_bjdata(j2, false, false);
-    CHECK(vec2 == std::vector<uint8_t>({'[', 'i', 0x20, ']'}));
-    CHECK(json::from_bjdata(vec2) == j2);
-}
-
 TEST_CASE("BJData roundtrips" * doctest::skip())
 {
     SECTION("input from self-generated BJData files")

tests/src/unit-bson.cpp

@@ -1244,44 +1244,6 @@ TEST_CASE("BSON nesting does not consume the call stack")
     }
 }
 
-TEST_CASE("BSON input that cannot be read is discarded by every overload")
-{
-    std::vector<std::uint8_t> input = json::to_bson(json({{"a", {1, 2}}}));
-    input.pop_back();
-
-    json _;
-    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());
-    CHECK(json::from_bson(input.data(), input.size(), true, false).is_discarded());
-    CHECK(json::from_bson({input.data(), input.size()}, true, false).is_discarded());
-}
-
-TEST_CASE("BSON SAX parsing stops at every event")
-{
-    // Containers are opened and closed by the loop that reads them; a SAX
-    // handler that rejects any event - including the end of a nested
-    // container - must stop the parse right there.
-    const auto count_events = [](const std::vector<std::uint8_t>& input)
-    {
-        int events = 0;
-        while (true)
-        {
-            SaxCountdown scp(events);
-            if (json::sax_parse(input, &scp, json::input_format_t::bson))
-            {
-                return events;
-            }
-            ++events;
-            REQUIRE(events < 1000);
-        }
-    };
-
-    // 20 events: every container kind closes inside another one
-    const json j = json::parse(R"({"a": [1, {"b": []}], "c": {"d": [[2]]}})");
-    CHECK(count_events(json::to_bson(j)) == 20);
-}
-
 TEST_CASE("BSON numerical data")
 {
     SECTION("number")

tests/src/unit-cbor.cpp

@@ -15,7 +15,6 @@ using nlohmann::json;
 #include <sstream>
 #include <iomanip>
 #include <limits>
-#include <list>
 #include <set>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
@@ -2123,52 +2122,6 @@ TEST_CASE("CBOR nesting does not consume the call stack")
     }
 }
 
-TEST_CASE("CBOR input that cannot be read is discarded by every overload")
-{
-    std::vector<std::uint8_t> input = json::to_cbor(json({{"a", {1, 2}}}));
-    input.pop_back();
-
-    json _;
-    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());
-    CHECK(json::from_cbor(input.data(), input.size(), true, false).is_discarded());
-    CHECK(json::from_cbor({input.data(), input.size()}, true, false).is_discarded());
-
-    // a string that ends early, read through iterators that are not
-    // contiguous and have to be copied from one element at a time
-    const std::list<std::uint8_t> truncated_string = {0x63, 'a', 'b'};
-    CHECK(json::from_cbor(truncated_string.begin(), truncated_string.end(), true, false).is_discarded());
-    const std::list<std::uint8_t> complete_string = {0x63, 'a', 'b', 'c'};
-    CHECK(json::from_cbor(complete_string.begin(), complete_string.end()) == "abc");
-}
-
-TEST_CASE("CBOR SAX parsing stops at every event")
-{
-    // Containers are opened and closed by the loop that reads them; a SAX
-    // handler that rejects any event - including the end of a nested
-    // container - must stop the parse right there.
-    const auto count_events = [](const std::vector<std::uint8_t>& input)
-    {
-        int events = 0;
-        while (true)
-        {
-            SaxCountdown scp(events);
-            if (json::sax_parse(input, &scp, json::input_format_t::cbor))
-            {
-                return events;
-            }
-            ++events;
-            REQUIRE(events < 1000);
-        }
-    };
-
-    // 20 events: every container kind closes inside another one
-    const json j = json::parse(R"({"a": [1, {"b": []}], "c": {"d": [[2]]}})");
-    CHECK(count_events(json::to_cbor(j)) == 20);
-    CHECK(count_events(std::vector<std::uint8_t>({0xBF, 0x61, 'a', 0x9F, 0x01, 0xFF, 0xFF})) == 6);
-}
-
 TEST_CASE("CBOR indefinite-length strings do not recurse per chunk")
 {
     // Reading an indefinite-length string or byte array used to call itself

tests/src/unit-class_const_iterator.cpp

@@ -43,13 +43,6 @@ TEST_CASE("const_iterator class")
             json::const_iterator const it(&j);
             json::const_iterator it2(&j);
             it2 = it;
-
-            // assigning an iterator to itself leaves it unchanged
-            json const a = {1, 2, 3};
-            json::const_iterator it3 = a.cbegin() + 1;
-            const json::const_iterator& same = it3;
-            it3 = same;
-            CHECK(*it3 == 2);
         }
 
         SECTION("copy constructor from non-const iterator")

tests/src/unit-class_lexer.cpp

@@ -12,7 +12,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
-#include <cfloat> // FLT_EVAL_METHOD
 #include <cstdlib> // strtod
 #include <sstream> // stringstream
 #include <string> // string
@@ -658,45 +657,3 @@ TEST_CASE("lexer string fast path")
         }
     }
 }
-
-TEST_CASE("parse_float_fast declines what it cannot convert exactly")
-{
-    // The lexer only hands well-formed numbers to parse_float_fast, so the
-    // malformed ones below can only be passed to it directly. Declining is
-    // always safe: the caller then falls back to a slower, exact conversion.
-    const auto fast = [](const std::string & s, double & out)
-    {
-        return nlohmann::detail::parse_float_fast(s.data(), s.data() + s.size(), '.', out);
-    };
-    double out = 0;
-
-#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
-    // without true double precision, the fast path declines everything
-    CHECK_FALSE(fast("1.5", out));
-#else
-    CHECK(fast("1.5", out));
-    CHECK(out == 1.5);
-    CHECK(fast("+2.5e1", out));
-    CHECK(out == 25.0);
-    CHECK(fast("-25E-1", out));
-    CHECK(out == -2.5);
-    CHECK(fast("1e", out));
-    CHECK(out == 1.0);
-#endif
-
-    // not a number
-    CHECK_FALSE(fast("", out));
-    CHECK_FALSE(fast("-", out));
-    CHECK_FALSE(fast(".", out));
-    CHECK_FALSE(fast("1.2.3", out));
-    CHECK_FALSE(fast("1x", out));
-    CHECK_FALSE(fast("1e+", out));
-    CHECK_FALSE(fast("1e1x", out));
-
-    // numbers that are not represented exactly on the fast path
-    CHECK_FALSE(fast("12345678901234567890", out));
-    CHECK_FALSE(fast("1e10000", out));
-    CHECK_FALSE(fast("9007199254740993", out));
-    CHECK_FALSE(fast("1e23", out));
-    CHECK_FALSE(fast("1e-23", out));
-}

tests/src/unit-comparison.cpp

@@ -359,15 +359,6 @@ TEST_CASE("lexicographical comparison operators")
             CHECK(json(1) < json(1.5));
             CHECK(json(1.5) < json(2));
             CHECK(json(2) > json(1.5));
-            CHECK(json(-1) > json(-1.5));
-            CHECK(json(-1.5) < json(-1));
-            CHECK(json(-2) < json(-1.5));
-
-            // a float below the range of the integer type
-            CHECK(json(0) > json(-1e30));
-            CHECK(json(-1e30) < json(0));
-            CHECK(json(0u) > json(-0.5));
-            CHECK(json(-0.5) < json(0u));
 
             // a NaN operand stays unordered against either integer kind
             CHECK_FALSE(json(1) == json(nan));
@@ -744,84 +735,3 @@ TEST_CASE("regression #3868 - heterogeneous comparisons compile under C++20 (P24
     }
 }
 #endif
-
-TEST_CASE("containers are compared element by element")
-{
-    // Containers nested deeper than a bound are compared without the call
-    // stack, by code of their own; every relation is checked both at the top
-    // level and below that bound.
-    const auto deep = [](const json & j, const std::size_t depth)
-    {
-        json result = j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            result = json::array({std::move(result)});
-        }
-        return result;
-    };
-
-    for (const std::size_t depth : std::vector<std::size_t> {0, 200})
-    {
-        CAPTURE(depth);
-
-        // objects with different keys
-        {
-            const json a = deep({{"a", 1}}, depth);
-            const json b = deep({{"b", 1}}, depth);
-            CHECK_FALSE(a == b);
-            CHECK(a != b);
-            CHECK(a < b);
-            CHECK(b > a);
-            CHECK_FALSE(b < a);
-#if JSON_HAS_THREE_WAY_COMPARISON
-            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
-            CHECK((a <=> b) == std::partial_ordering::less); // *NOPAD*
-            CHECK((b <=> a) == std::partial_ordering::greater); // *NOPAD*
-            CHECK((a <=> a) == std::partial_ordering::equivalent); // *NOPAD*
-#endif
-        }
-
-        // a container that is a prefix of the other one
-        {
-            // the one that runs out of elements first is the smaller one
-            const json shorter = deep({1}, depth);
-            const json longer = deep({1, 2}, depth);
-            CHECK(shorter < longer);
-            CHECK(longer > shorter);
-            CHECK_FALSE(longer < shorter);
-            CHECK_FALSE(shorter == longer);
-
-            const json smaller_object = deep({{"a", 1}}, depth);
-            const json larger_object = deep({{"a", 1}, {"b", 2}}, depth);
-            CHECK(smaller_object < larger_object);
-            CHECK(larger_object > smaller_object);
-            CHECK_FALSE(smaller_object == larger_object);
-#if JSON_HAS_THREE_WAY_COMPARISON
-            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
-            CHECK((shorter <=> longer) == std::partial_ordering::less); // *NOPAD*
-            CHECK((longer <=> shorter) == std::partial_ordering::greater); // *NOPAD*
-#endif
-        }
-
-        // elements that cannot be ordered
-        {
-            const double nan = std::numeric_limits<double>::quiet_NaN();
-            const json lhs = deep({nan, 1}, depth);
-            const json rhs = deep({nan, 2}, depth);
-
-            CHECK_FALSE(lhs == lhs);
-            CHECK_FALSE(rhs < lhs);
-#if JSON_HAS_THREE_WAY_COMPARISON
-            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
-            // operator<=> stops there, as std::lexicographical_compare_three_way
-            // does, and operator< is derived from it
-            CHECK((lhs <=> rhs) == std::partial_ordering::unordered); // *NOPAD*
-            CHECK_FALSE(lhs < rhs);
-#else
-            // operator< skips a pair of elements that cannot be ordered, as
-            // std::lexicographical_compare does, and the next pair decides
-            CHECK(lhs < rhs);
-#endif
-        }
-    }
-}

tests/src/unit-custom-binary-type.cpp

@@ -49,16 +49,6 @@ TEST_CASE("binary type whose value type is not std::uint8_t")
         CHECK(char_binary_json::binary({}).dump() == R"({"bytes":[],"subtype":null})");
     }
 
-    SECTION("a value is converted to the binary type if it is binary or an array")
-    {
-        const std::vector<char> chars{'\0', '\x01', '\x7F'};
-        CHECK(char_binary_json::binary(chars).get<std::vector<char>>() == chars);
-        CHECK(char_binary_json({0, 1, 127}).get<std::vector<char>>() == chars);
-        CHECK_THROWS_WITH_AS(char_binary_json(1).get<std::vector<char>>(),
-                             "[json.exception.type_error.302] type must be binary or array, but is number",
-                             char_binary_json::type_error&);
-    }
-
     SECTION("the default binary type is unchanged")
     {
         CHECK(nlohmann::json::binary({0, 1, 255}, 42).dump() == R"({"bytes":[0,1,255],"subtype":42})");

tests/src/unit-deserialization.cpp

@@ -25,7 +25,6 @@ using nlohmann::json;
 #include <iostream>
 #include <iterator>
 #include <sstream>
-#include <string>
 #include <valarray>
 
 #if defined(_WIN32)
@@ -1234,57 +1233,6 @@ TEST_CASE("deserialization")
         }
     }
 
-    SECTION("stream position after extraction without JSON_PRECISE_STREAM_POSITION (#5340)")
-    {
-        // By default, the character that terminates a number is consumed, so
-        // the stream is left one byte too far after a number (and only after a
-        // number). JSON_PRECISE_STREAM_POSITION changes this; see
-        // unit-precise-stream-position.cpp. These checks pin the default.
-        const auto remaining = [](std::istream & is)
-        {
-            return std::string(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>());
-        };
-
-        SECTION("the character after a number is consumed")
-        {
-            std::istringstream ss("1true");
-            json j;
-            ss >> j;
-            CHECK(j == 1);
-            CHECK(remaining(ss) == "rue");
-        }
-
-        SECTION("the character after other values is not consumed")
-        {
-            std::istringstream ss("[1]true");
-            json j;
-            ss >> j;
-            CHECK(j == json::parse("[1]"));
-            CHECK(remaining(ss) == "true");
-        }
-
-        SECTION("comma-separated numbers can be read one by one")
-        {
-            std::istringstream ss("1,2,3");
-            json j1, j2, j3;
-            ss >> j1 >> j2 >> j3;
-            CHECK(j1 == 1);
-            CHECK(j2 == 2);
-            CHECK(j3 == 3);
-        }
-
-        SECTION("std::getline after a number skips the line break")
-        {
-            std::istringstream ss("42\nfoo");
-            json j;
-            std::string line;
-            ss >> j;
-            std::getline(ss, line);
-            CHECK(j == 42);
-            CHECK(line == "foo");
-        }
-    }
-
     // build with C++20
     // JSON_HAS_CPP_20
 #if defined(__cpp_char8_t)

tests/src/unit-diagnostic-positions.cpp

@@ -156,38 +156,3 @@ TEST_CASE("Better diagnostics with positions")
 #endif
     }
 }
-
-TEST_CASE("values read from a binary format have no positions")
-{
-    // only the JSON lexer knows where a value started and ended
-    const json source = {{"a", {1, "x", json::binary({1})}}, {"b", {{"c", true}}}, {"d", nullptr}, {"e", 1.5}};
-    const std::vector<std::uint8_t> cbor = json::to_cbor(source);
-
-    const auto check_no_positions = [](const json & j)
-    {
-        CHECK(j.start_pos() == std::string::npos);
-        CHECK(j.end_pos() == std::string::npos);
-        CHECK(j.at("a").start_pos() == std::string::npos);
-        CHECK(j.at("a").at(1).end_pos() == std::string::npos);
-        CHECK(j.at("b").at("c").start_pos() == std::string::npos);
-    };
-
-    SECTION("DOM parser")
-    {
-        const json j = json::from_cbor(cbor);
-        CHECK(j == source);
-        check_no_positions(j);
-    }
-
-    SECTION("DOM parser with a callback")
-    {
-        json j;
-        nlohmann::detail::json_sax_dom_callback_parser<json, decltype(nlohmann::detail::input_adapter(cbor))> sdp(j, [](int /*unused*/, json::parse_event_t /*unused*/, const json& /*unused*/) noexcept
-        {
-            return true;
-        });
-        CHECK(json::sax_parse(cbor, &sdp, json::input_format_t::cbor));
-        CHECK(j == source);
-        check_no_positions(j);
-    }
-}

tests/src/unit-diagnostics.cpp

@@ -361,106 +361,6 @@ TEST_CASE("Regression tests for extended diagnostics")
             CHECK(p == o);
         }
     }
-
-    SECTION("Regression test - erase() and update() must keep JSON_DIAGNOSTICS parent pointers of ordered_json members")
-    {
-        // ordered_json keeps its members in a vector: erasing a member
-        // re-constructs all members after it in place, and adding a key may
-        // reallocate the vector; both reset the parent pointers of the members
-        // that were moved
-        using nlohmann::ordered_json;
-
-        const auto check_parents = [](const ordered_json & j)
-        {
-            // const access, so operator[] cannot repair the parent pointers
-            CHECK_THROWS_WITH_AS(j["z"]["x"].at(0), "[json.exception.type_error.304] (/z/x) cannot use at() with number", ordered_json::type_error);
-
-            // must not trigger assert_invariant() in a debug/assert-enabled build
-            ordered_json const copy = j; // NOLINT(performance-unnecessary-copy-initialization)
-            CHECK(copy == j);
-        };
-
-        // erase(key)
-        {
-            ordered_json j = {{"a", 1}, {"z", {{"x", 1}}}};
-            CHECK(j.erase("a") == 1);
-            check_parents(j);
-        }
-
-        // erase(iterator)
-        {
-            ordered_json j = {{"a", 1}, {"z", {{"x", 1}}}};
-            j.erase(j.begin());
-            check_parents(j);
-        }
-
-        // erase(iterator, iterator)
-        {
-            ordered_json j = {{"a", 1}, {"b", 2}, {"z", {{"x", 1}}}};
-            j.erase(j.begin(), j.find("z"));
-            check_parents(j);
-        }
-
-        // patch() removes via erase(iterator)
-        {
-            ordered_json j = {{"a", 1}, {"z", {{"x", 1}}}};
-            j.patch_inplace(ordered_json::parse(R"([{"op": "remove", "path": "/a"}])"));
-            check_parents(j);
-        }
-
-        // update(j)
-        {
-            ordered_json j = {{"z", {{"x", 1}}}};
-            j.update({{"a", 1}, {"b", 2}});
-            check_parents(j);
-        }
-
-        // update(j, true), the outer and the nested vector both grow
-        {
-            ordered_json j = {{"z", {{"x", 1}}}};
-            j.update({{"z", {{"y", 2}}}, {"a", 1}}, true);
-            check_parents(j);
-        }
-
-        // update(j, true) around its descent bound, where the nested vectors
-        // grow while the objects are merged without recursing
-        for (const std::size_t depth :
-                {
-                    nlohmann::detail::recursion_depth_limit() - 1, nlohmann::detail::recursion_depth_limit(), nlohmann::detail::recursion_depth_limit() + 2
-                })
-        {
-            ordered_json j = {{"z", {{"x", 1}}}};
-            ordered_json patch = {{"a", 1}, {"b", 2}, {"c", {{"d", 3}}}};
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                j = ordered_json{{"k", 0}, {"n", std::move(j)}};
-                patch = ordered_json{{"n", std::move(patch)}, {"l", 1}, {"m", 2}};
-            }
-            j.update(patch, true);
-
-            // must not trigger assert_invariant() on any level in a
-            // debug/assert-enabled build
-            ordered_json const copy = j; // NOLINT(performance-unnecessary-copy-initialization)
-            CHECK(copy == j);
-        }
-
-        // merge_patch() inserts "c" and removes "d" at /a/c, then inserts "e"
-        // at /a, which copies /a/c
-        {
-            auto j = ordered_json::parse(R"({"a": {"c": {"d": {}}}})");
-            j.merge_patch(ordered_json::parse(R"({"a": {"c": {"c": "s", "d": null}, "e": "s"}})"));
-            CHECK(j.dump() == R"({"a":{"c":{"c":"s"},"e":"s"}})");
-
-            auto const& constJ = j;
-#if JSON_DIAGNOSTIC_POSITIONS
-            CHECK_THROWS_WITH_AS(constJ["a"]["c"]["c"].at(0), "[json.exception.type_error.304] (/a/c/c) (bytes 18-21) cannot use at() with string", ordered_json::type_error);
-#else
-            CHECK_THROWS_WITH_AS(constJ["a"]["c"]["c"].at(0), "[json.exception.type_error.304] (/a/c/c) cannot use at() with string", ordered_json::type_error);
-#endif
-            ordered_json const copy = j;
-            CHECK(copy == j);
-        }
-    }
 }
 
 TEST_CASE("Better diagnostics past the descent bound of update() and merge_patch()")

tests/src/unit-element_access2.cpp

@@ -1517,16 +1517,6 @@ TEST_CASE_TEMPLATE("element access 2 (throwing tests)", Json, nlohmann::json, nl
                     CHECK(j.value("/not/existing"_json_pointer, Json({{"foo", "bar"}})) == Json({{"foo", "bar"}}));
                     CHECK(j.value("/not/existing"_json_pointer, Json({10, 100})) == Json({10, 100}));
 
-                    // an array index that is out of range, too large to be
-                    // represented, or "-", and a token below a scalar
-                    CHECK(j.value("/array/3"_json_pointer, 2) == 2);
-                    CHECK(j.value("/array/-"_json_pointer, 2) == 2);
-                    CHECK(j.value("/array/99999999999999999999999999"_json_pointer, 2) == 2);
-                    CHECK(j.value("/integer/0"_json_pointer, 2) == 2);
-                    CHECK(j.value("/string/x"_json_pointer, 2) == 2);
-                    CHECK(j.value("/null/x"_json_pointer, 2) == 2);
-                    CHECK(j.value("/array/0"_json_pointer, 2) == 1);
-
                     CHECK(j_const.value("/not/existing"_json_pointer, 2) == 2);
                     CHECK(j_const.value("/not/existing"_json_pointer, 2u) == 2u);
                     CHECK(j_const.value("/not/existing"_json_pointer, false) == false);

tests/src/unit-json_patch.cpp

@@ -1751,98 +1751,3 @@ TEST_CASE("JSON patch - diff emits array removals in descending index order")
         CHECK(source.patch(patch) == target);
     }
 }
-
-TEST_CASE("JSON patch - every operation on ordered_json")
-{
-    using nlohmann::ordered_json;
-
-    const ordered_json doc = {{"foo", "bar"}, {"arr", {1, 2, 3}}, {"obj", {{"a", 1}}}};
-
-    SECTION("successful operations")
-    {
-        const ordered_json patch = ordered_json::parse(R"([
-            {"op": "add", "path": "/obj/b", "value": 2},
-            {"op": "add", "path": "/arr/1", "value": 9},
-            {"op": "add", "path": "/arr/-", "value": 4},
-            {"op": "remove", "path": "/arr/0"},
-            {"op": "remove", "path": "/obj/a"},
-            {"op": "replace", "path": "/foo", "value": "baz"},
-            {"op": "move", "from": "/foo", "path": "/moved"},
-            {"op": "copy", "from": "/obj", "path": "/copied"},
-            {"op": "test", "path": "/copied/b", "value": 2}
-        ])");
-
-        const ordered_json expected = ordered_json::parse(R"({
-            "arr": [9, 2, 3, 4], "obj": {"b": 2}, "moved": "baz", "copied": {"b": 2}
-        })");
-
-        CHECK(doc.patch(patch) == expected);
-
-        // adding to the root replaces the document
-        CHECK(doc.patch(ordered_json::parse(R"([{"op": "add", "path": "", "value": [1]}])")) == ordered_json({1}));
-    }
-
-    SECTION("failing operations")
-    {
-        ordered_json _;
-#if JSON_DIAGNOSTICS
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "add", "path": "/arr/4", "value": 1}])")),
-                             "[json.exception.out_of_range.401] (/arr) array index 4 is out of range", ordered_json::out_of_range&);
-#else
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "add", "path": "/arr/4", "value": 1}])")),
-                             "[json.exception.out_of_range.401] array index 4 is out of range", ordered_json::out_of_range&);
-#endif
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "add", "path": "/nope/x", "value": 1}])")),
-                             "[json.exception.out_of_range.403] key 'nope' not found", ordered_json::out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "remove", "path": "/obj/nope"}])")),
-                             "[json.exception.out_of_range.403] key 'nope' not found", ordered_json::out_of_range&);
-#if JSON_DIAGNOSTICS
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "remove", "path": "/arr/3"}])")),
-                             "[json.exception.out_of_range.401] (/arr) array index 3 is out of range", ordered_json::out_of_range&);
-#else
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "remove", "path": "/arr/3"}])")),
-                             "[json.exception.out_of_range.401] array index 3 is out of range", ordered_json::out_of_range&);
-#endif
-#if JSON_DIAGNOSTICS
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "test", "path": "/foo", "value": "qux"}])")),
-                             "[json.exception.other_error.501] (/0) unsuccessful: {\"op\":\"test\",\"path\":\"/foo\",\"value\":\"qux\"}", ordered_json::other_error&);
-#elif JSON_DIAGNOSTIC_POSITIONS
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "test", "path": "/foo", "value": "qux"}])")),
-                             "[json.exception.other_error.501] (bytes 1-47) unsuccessful: {\"op\":\"test\",\"path\":\"/foo\",\"value\":\"qux\"}", ordered_json::other_error&);
-#else
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "test", "path": "/foo", "value": "qux"}])")),
-                             "[json.exception.other_error.501] unsuccessful: {\"op\":\"test\",\"path\":\"/foo\",\"value\":\"qux\"}", ordered_json::other_error&);
-#endif
-#if JSON_DIAGNOSTICS
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "add", "path": "/foo"}])")),
-                             "[json.exception.parse_error.105] parse error: (/0) operation 'add' must have member 'value'", ordered_json::parse_error&);
-#elif JSON_DIAGNOSTIC_POSITIONS
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "add", "path": "/foo"}])")),
-                             "[json.exception.parse_error.105] parse error: (bytes 1-30) operation 'add' must have member 'value'", ordered_json::parse_error&);
-#else
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "add", "path": "/foo"}])")),
-                             "[json.exception.parse_error.105] parse error: operation 'add' must have member 'value'", ordered_json::parse_error&);
-#endif
-        CHECK_THROWS_WITH_AS(_ = doc.patch(ordered_json::parse(R"([{"op": "move", "from": "/obj", "path": "/obj/a/b"}])")),
-                             "[json.exception.out_of_range.414] cannot move value: 'from' path '/obj' is a proper prefix of 'path' '/obj/a/b'", ordered_json::out_of_range&);
-    }
-
-    SECTION("diff reproduces the target")
-    {
-        const ordered_json source = {{"a", 1}, {"b", 2}, {"c", {{"x", 1}}}, {"l", {1, 2, 3}}};
-        const std::vector<ordered_json> targets =
-        {
-            // a key removed, a key added, a nested change, a shorter array
-            {{"a", 1}, {"c", {{"x", 2}}}, {"l", {1}}, {"d", 4}},
-            // the same keys in another order
-            {{"c", {{"x", 1}}}, {"a", 1}, {"b", 2}, {"l", {1, 2, 3}}},
-            // new keys ahead of the common ones
-            {{"new", true}, {"a", 1}, {"b", 3}, {"c", {{"x", 1}}}, {"l", {1, 2, 3}}},
-        };
-        for (const auto& target : targets)
-        {
-            CAPTURE(target.dump());
-            CHECK(source.patch(ordered_json::diff(source, target)) == target);
-        }
-    }
-}

tests/src/unit-json_pointer.cpp

@@ -872,16 +872,3 @@ TEST_CASE("JSON pointers")
     }
 #endif
 }
-
-TEST_CASE("unescaping keeps a '~' that does not start an escape sequence")
-{
-    // the parser of a JSON pointer rejects such reference tokens before it
-    // unescapes them, so this is only reachable by calling unescape directly
-    std::string s = "a~2b~";
-    nlohmann::detail::unescape(s);
-    CHECK(s == "a~2b~");
-
-    s = "~0~1~";
-    nlohmann::detail::unescape(s);
-    CHECK(s == "~/~");
-}

tests/src/unit-large_json.cpp

@@ -157,54 +157,6 @@ TEST_CASE("tests on deeply nested JSONs")
             CHECK(deep_depth == depth);
         }
 
-        SECTION("comparing")
-        {
-            // Comparing used to descend once per level, and an ordered
-            // comparison used to compare every pair of elements twice, once in
-            // each direction, which took exponentially long in the nesting
-            // depth. Both are gone: these finish in milliseconds, where the
-            // second used to take longer than anyone would wait even for a
-            // value nested only a few dozen levels deep.
-            const std::string text = std::string(depth, '[') + '0' + std::string(depth, ']');
-            const json j = json::parse(text);
-            const json same = json::parse(text);
-            const json larger = json::parse(std::string(depth, '[') + '1' + std::string(depth, ']'));
-
-            CHECK(j == same);
-            CHECK_FALSE(j == larger);
-            CHECK(j != larger);
-
-            CHECK(j < larger);
-            CHECK_FALSE(larger < j);
-            CHECK(larger > j);
-            CHECK(j <= same);
-            CHECK(j >= same);
-
-            // a value that ends earlier is the smaller one
-            const json shorter = json::parse(std::string(depth - 1, '[') + '0' + std::string(depth - 1, ']'));
-            CHECK_FALSE(j == shorter);
-        }
-
-        SECTION("comparing objects")
-        {
-            std::string text;
-            text.reserve((6 * depth) + 1);
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                text += "{\"a\":";
-            }
-            text += '1';
-            text.append(depth, '}');
-
-            const json j = json::parse(text);
-            const json same = json::parse(text);
-
-            CHECK(j == same);
-            CHECK_FALSE(j != same);
-            CHECK(j <= same);
-            CHECK(j >= same);
-        }
-
         SECTION("the copy is independent of the original")
         {
             const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));

tests/src/unit-locale-cpp.cpp

@@ -158,17 +158,6 @@ TEST_CASE("locale-dependent test (LC_NUMERIC=de_DE)")
             json::sax_parse("12.34", &sax);
             CHECK(sax.float_string_copy == "12.34");
         }
-
-        SECTION("serializing a long double")
-        {
-            // a floating-point type that is not a float or a double is written
-            // with snprintf, whose locale-specific decimal point and thousands
-            // separator are undone afterwards
-            using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
-            CHECK(long_double_json(12345.5L).dump() == "12345.5");
-            CHECK(long_double_json(1.0L).dump() == "1.0");
-            CHECK(long_double_json(-0.25L).dump() == "-0.25");
-        }
     }
     else
     {

tests/src/unit-merge_patch.cpp

@@ -62,7 +62,7 @@ std::string nested_objects(const std::size_t depth, const int variant)
         }
         text += "\"a\":";
     }
-    text += variant == 1 ? R"({"x":1,"y":null})" : "{\"y\":2}";
+    text += variant == 1 ? "{\"x\":1,\"y\":null}" : "{\"y\":2}";
     text.append(depth, '}');
     return text;
 }
@@ -345,32 +345,3 @@ TEST_CASE("JSON Merge Patch on deeply nested values")
         CHECK(p->at("x") == 1);
     }
 }
-
-TEST_CASE("JSON Merge Patch and update on ordered_json")
-{
-    using nlohmann::ordered_json;
-
-    SECTION("merge_patch")
-    {
-        ordered_json target = ordered_json::parse(R"({"a": {"b": 1, "c": 2}, "d": 3, "e": [1]})");
-        target.merge_patch(ordered_json::parse(R"({"a": {"b": null, "f": 4}, "d": {"x": {"y": null}}, "e": null, "g": {"h": 5}})"));
-        CHECK(target == ordered_json::parse(R"({"a": {"c": 2, "f": 4}, "d": {"x": {}}, "g": {"h": 5}})"));
-
-        // a patch that is not an object replaces the target
-        target.merge_patch(ordered_json({1, 2}));
-        CHECK(target == ordered_json({1, 2}));
-        // an object patch turns a target that is not an object into one
-        target.merge_patch(ordered_json::parse(R"({"k": {"l": null}})"));
-        CHECK(target == ordered_json::parse(R"({"k": {}})"));
-    }
-
-    SECTION("update with merge_objects")
-    {
-        ordered_json target = ordered_json::parse(R"({"a": {"b": 1, "c": {"d": 2}}, "e": 3})");
-        target.update(ordered_json::parse(R"({"a": {"c": {"x": 1}, "f": 4}, "e": {"y": 5}, "g": 6})"), true);
-        CHECK(target == ordered_json::parse(R"({"a": {"b": 1, "c": {"d": 2, "x": 1}, "f": 4}, "e": {"y": 5}, "g": 6})"));
-
-        target.update(ordered_json::parse(R"({"a": 1})"), false);
-        CHECK(target == ordered_json::parse(R"({"a": 1, "e": {"y": 5}, "g": 6})"));
-    }
-}

tests/src/unit-modifiers.cpp

@@ -48,7 +48,7 @@ std::string nested_objects(const std::size_t depth, const int variant)
         if (variant == 2 && i % 5 == 0)
         {
             // an object replacing a primitive, which is not merged
-            text += R"("s0":{"o":1},)";
+            text += "\"s0\":{\"o\":1},";
         }
         text += "\"a\":";
     }

tests/src/unit-msgpack.cpp

@@ -1759,44 +1759,6 @@ TEST_CASE("MessagePack nesting does not consume the call stack")
     }
 }
 
-TEST_CASE("MessagePack input that cannot be read is discarded by every overload")
-{
-    std::vector<std::uint8_t> input = json::to_msgpack(json({{"a", {1, 2}}}));
-    input.pop_back();
-
-    json _;
-    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());
-    CHECK(json::from_msgpack(input.data(), input.size(), true, false).is_discarded());
-    CHECK(json::from_msgpack({input.data(), input.size()}, true, false).is_discarded());
-}
-
-TEST_CASE("MessagePack SAX parsing stops at every event")
-{
-    // Containers are opened and closed by the loop that reads them; a SAX
-    // handler that rejects any event - including the end of a nested
-    // container - must stop the parse right there.
-    const auto count_events = [](const std::vector<std::uint8_t>& input)
-    {
-        int events = 0;
-        while (true)
-        {
-            SaxCountdown scp(events);
-            if (json::sax_parse(input, &scp, json::input_format_t::msgpack))
-            {
-                return events;
-            }
-            ++events;
-            REQUIRE(events < 1000);
-        }
-    };
-
-    // 20 events: every container kind closes inside another one
-    const json j = json::parse(R"({"a": [1, {"b": []}], "c": {"d": [[2]]}})");
-    CHECK(count_events(json::to_msgpack(j)) == 20);
-}
-
 TEST_CASE("single MessagePack roundtrip")
 {
     SECTION("sample.json")

tests/src/unit-precise-stream-position.cpp

@@ -1,237 +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_PRECISE_STREAM_POSITION, so it defines the
-// macro itself rather than relying on a -D flag, and runs in every build. The
-// default behavior is pinned in unit-deserialization.cpp.
-#ifdef JSON_PRECISE_STREAM_POSITION
-    #undef JSON_PRECISE_STREAM_POSITION
-#endif
-
-#define JSON_PRECISE_STREAM_POSITION 1
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstddef>
-#include <sstream>
-#include <streambuf>
-#include <string>
-#include <utility>
-#include <vector>
-
-#define STRINGIZE_EX(x) #x
-#define STRINGIZE(x) STRINGIZE_EX(x)
-
-namespace
-{
-// A streambuf that keeps no get area at all and refuses every putback: with an
-// empty get area, sungetc() always ends up in pbackfail(). Used to check that
-// the character terminating a number is left in the input without relying on
-// the streambuf being able to put a consumed character back.
-class no_putback_streambuf : public std::streambuf
-{
-  public:
-    explicit no_putback_streambuf(std::string s) : m_data(std::move(s)) {}
-
-  protected:
-    // peek at the next character without consuming it
-    int_type underflow() override
-    {
-        if (m_pos >= m_data.size())
-        {
-            return traits_type::eof();
-        }
-        return traits_type::to_int_type(m_data[m_pos]);
-    }
-
-    // consume the next character
-    int_type uflow() override
-    {
-        if (m_pos >= m_data.size())
-        {
-            return traits_type::eof();
-        }
-        return traits_type::to_int_type(m_data[m_pos++]);
-    }
-
-    int_type pbackfail(int_type /*c*/) override
-    {
-        return traits_type::eof();
-    }
-
-  private:
-    std::string m_data;
-    std::size_t m_pos = 0;
-};
-
-// read the characters that are left in a stream
-std::string remaining(std::istream& is)
-{
-    std::string result;
-    char c = 0;
-    while (is.get(c))
-    {
-        result += c;
-    }
-    return result;
-}
-}  // namespace
-
-TEST_CASE("JSON_PRECISE_STREAM_POSITION")
-{
-    SECTION("the macro is part of the ABI tag")
-    {
-        const std::string ns = STRINGIZE(NLOHMANN_JSON_NAMESPACE);
-        // other tags may come before it, e.g. json_abi_diag_psp
-        CHECK(ns.find("_psp") != std::string::npos);
-    }
-
-    SECTION("a number does not consume the character that terminates it")
-    {
-        // a number is only terminated by the character following it; that
-        // character must be given back so the stream is positioned right
-        // after the value
-        const std::vector<std::pair<std::string, std::string>> tests =
-        {
-            {"1true", "true"},
-            {"1[2]", "[2]"},
-            {"1{}", "{}"},
-            {R"(1"a")", R"("a")"},
-            {"1 true", " true"},
-            {"12,", ","},
-            {"-0.5e3x", "x"},
-            {"1null", "null"}
-        };
-
-        for (const auto& test : tests)
-        {
-            CAPTURE(test.first);
-            std::istringstream ss(test.first);
-            json j;
-            ss >> j;
-            CHECK(j == json::parse(test.first.substr(0, test.first.size() - test.second.size())));
-            CHECK(remaining(ss) == test.second);
-        }
-    }
-
-    SECTION("values that are self-delimiting are unaffected")
-    {
-        const std::vector<std::pair<std::string, std::string>> tests =
-        {
-            {"truefalse", "false"},
-            {"[1][2]", "[2]"},
-            {R"({"a":1}{"b":2})", R"({"b":2})"},
-            {R"("a""b")", R"("b")"},
-            {"null null", " null"}
-        };
-
-        for (const auto& test : tests)
-        {
-            CAPTURE(test.first);
-            std::istringstream ss(test.first);
-            json j;
-            ss >> j;
-            CHECK(remaining(ss) == test.second);
-        }
-    }
-
-    SECTION("a number at the end of the input leaves nothing behind")
-    {
-        for (const std::string s :
-                {"1", "12", "-3.5e2", " 7 "
-                })
-        {
-            CAPTURE(s);
-            std::istringstream ss(s);
-            json j;
-            ss >> j;
-            CHECK(remaining(ss).find_first_not_of(" \t\n\r") == std::string::npos);
-        }
-    }
-
-    SECTION("repeated extraction of concatenated values")
-    {
-        std::istringstream ss(R"(1true[2]3"x"{"a":4}5)");
-        const std::vector<json> expected =
-        {
-            json(1), json(true), json::parse("[2]"), json(3),
-            json("x"), json::parse(R"({"a":4})"), json(5)
-        };
-
-        for (const auto& e : expected)
-        {
-            json j;
-            ss >> j;
-            CHECK(j == e);
-        }
-    }
-
-    SECTION("differences to the default behavior")
-    {
-        // both of these work by accident without the macro, because the
-        // character after a number is swallowed; see unit-deserialization.cpp
-
-        SECTION("a separator after a number is not skipped")
-        {
-            std::istringstream ss("1,2");
-            json j;
-            ss >> j;
-            CHECK(j == 1);
-            CHECK_THROWS_AS(ss >> j, json::parse_error&);
-        }
-
-        SECTION("std::getline after a number sees the line break")
-        {
-            std::istringstream ss("42\nfoo");
-            json j;
-            std::string line;
-            ss >> j;
-            std::getline(ss, line);
-            CHECK(j == 42);
-            CHECK(line.empty());
-            std::getline(ss, line);
-            CHECK(line == "foo");
-        }
-    }
-
-    SECTION("sax_parse with strict == false")
-    {
-        std::istringstream ss("1true");
-        json j;
-        nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::input_stream_adapter> sdp(j, true);
-        CHECK(json::sax_parse(ss, &sdp, nlohmann::detail::input_format_t::json, false));
-        CHECK(j == 1);
-        CHECK(remaining(ss) == "true");
-    }
-
-    SECTION("strict parsing still rejects trailing data")
-    {
-        std::istringstream ss("1true");
-        json _;
-        CHECK_THROWS_WITH_AS(_ = json::parse(ss),
-                             "[json.exception.parse_error.101] parse error at line 1, column 5: syntax error while parsing value - unexpected true literal; expected end of input", json::parse_error&);
-
-        std::istringstream ss2("1true");
-        CHECK_FALSE(json::accept(ss2));
-    }
-
-    SECTION("a streambuf that cannot put back is not needed")
-    {
-        // the terminating character is never consumed, so no putback
-        // position is required
-        no_putback_streambuf buf("1true");
-        std::istream is(&buf);
-        json j;
-        is >> j;
-        CHECK(j == json(1));
-        CHECK(remaining(is) == "true");
-    }
-}

tests/src/unit-serialization.cpp

@@ -629,153 +629,3 @@ TEST_CASE("serialization of deeply nested values")
         }
     }
 }
-
-namespace
-{
-// wraps @a inner into @a depth single-element arrays
-json wrap_in_arrays(const json& inner, const std::size_t depth)
-{
-    json j = inner;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        j = json::array({std::move(j)});
-    }
-    return j;
-}
-
-// what wrap_in_arrays(inner, depth).dump(2) is expected to be: the arrays
-// around inner.dump(2), with inner's own lines indented by the depth
-std::string expected_pretty_in_arrays(const json& inner, const std::size_t depth)
-{
-    std::string expected;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        expected += std::string(2 * i, ' ') + "[\n";
-    }
-
-    const std::string indent(2 * depth, ' ');
-    expected += indent;
-    for (const char c : inner.dump(2))
-    {
-        expected += c;
-        if (c == '\n')
-        {
-            expected += indent;
-        }
-    }
-
-    for (std::size_t i = depth; i > 0; --i)
-    {
-        expected += '\n' + std::string(2 * (i - 1), ' ') + ']';
-    }
-    return expected;
-}
-} // namespace
-
-TEST_CASE("serialization of every kind of value below the bound of the descent")
-{
-    // Values nested deeper than the bound are written without the call stack,
-    // by code of their own; each kind of value must come out the same there as
-    // it does at the top level, compact and pretty-printed.
-    std::vector<json> values =
-    {
-        json::parse(R"({"a": 1, "b": [1, 2, {"c": "x"}], "d": {}, "e": []})"),
-        json::parse(R"([1, [2, 3], {"k": null}, "s"])"),
-        json::object(),
-        json::array(),
-        json::binary({1, 2, 3}, 42),
-        json::binary({1, 2, 3}),
-        json::binary({}, 7),
-        json::binary({}),
-        "a string with \"escapes\"\n",
-        true,
-        false,
-        -42,
-        42u,
-        1.5,
-        nullptr,
-        json(json::value_t::discarded),
-    };
-    // a pretty-printed object whose members are themselves deep
-    values.push_back({{"x", wrap_in_arrays(1, 5)}, {"y", {{"z", 2}}}});
-
-    for (const std::size_t depth : std::vector<std::size_t> {1, 200})
-    {
-        CAPTURE(depth);
-        for (const auto& inner : values)
-        {
-            CAPTURE(inner.dump());
-            const json j = wrap_in_arrays(inner, depth);
-            CHECK(j.dump() == std::string(depth, '[') + inner.dump() + std::string(depth, ']'));
-            CHECK(j.dump(2) == expected_pretty_in_arrays(inner, depth));
-        }
-    }
-
-    SECTION("pretty-printed objects across the bound")
-    {
-        for (std::size_t d = 120; d <= 140; ++d)
-        {
-            CAPTURE(d);
-
-            // built from the inside out: {"k": <level below>, "n": <level>}
-            json j = 7;
-            std::string expected = "7";
-            for (std::size_t i = d; i > 0; --i)
-            {
-                j = json({{"k", std::move(j)}, {"n", i}});
-
-                const std::string indent(2 * i, ' ');
-                const std::string outer_indent(2 * (i - 1), ' ');
-                expected = "{\n" + indent + "\"k\": " + expected + ",\n"
-                           + indent + "\"n\": " + std::to_string(i) + "\n" + outer_indent + "}";
-            }
-
-            CHECK(j.dump(2) == expected);
-            CHECK(json::parse(j.dump(2)) == j);
-            CHECK(json::parse(j.dump()) == j);
-        }
-    }
-}
-
-TEST_CASE("serializer buffers are flushed mid-string and mid-binary")
-{
-    SECTION("a long run of escaped characters")
-    {
-        // each character is escaped on its own, so the escape buffer fills up
-        const json newlines = std::string(600, '\n');
-        std::string expected = "\"";
-        for (int i = 0; i < 600; ++i)
-        {
-            expected += "\\n";
-        }
-        expected += '"';
-        CHECK(newlines.dump() == expected);
-
-        // every character is \u-escaped under ensure_ascii
-        std::string umlauts;
-        std::string escaped_umlauts = "\"";
-        for (int i = 0; i < 300; ++i)
-        {
-            umlauts += "\xC3\xA4";
-            escaped_umlauts += "\\u00e4";
-        }
-        escaped_umlauts += '"';
-        CHECK(json(umlauts).dump(-1, ' ', true) == escaped_umlauts);
-    }
-
-    SECTION("a large binary value")
-    {
-        std::vector<std::uint8_t> bytes(3000);
-        std::string expected_bytes;
-        std::string expected_pretty_bytes;
-        for (std::size_t i = 0; i < bytes.size(); ++i)
-        {
-            bytes[i] = static_cast<std::uint8_t>(i % 256);
-            expected_bytes += (i == 0 ? "" : ",") + std::to_string(i % 256);
-            expected_pretty_bytes += (i == 0 ? "" : ", ") + std::to_string(i % 256);
-        }
-        const json j = json::binary(bytes);
-        CHECK(j.dump() == "{\"bytes\":[" + expected_bytes + "],\"subtype\":null}");
-        CHECK(j.dump(2) == "{\n  \"bytes\": [" + expected_pretty_bytes + "],\n  \"subtype\": null\n}");
-    }
-}

tests/src/unit-std-format.cpp

@@ -102,29 +102,6 @@ TEST_CASE("std::formatter<nlohmann::json>")
         CHECK_THROWS_AS(std::vformat("{:{}}", std::make_format_args(j, dynamic_width)), std::format_error); // dynamic width
     }
 
-    SECTION("a format spec may run to the end of the parse context")
-    {
-        // std::format always hands parse() a range that still holds the closing
-        // '}', but a parse context may also end right after the spec
-        const auto parse = [](const char* spec)
-        {
-            std::format_parse_context ctx(spec);
-            std::formatter<json> f;
-            CHECK(f.parse(ctx) == ctx.end());
-            return f;
-        };
-
-        CHECK(parse("").indent == -1);
-        CHECK(parse(">").indent == -1);
-        CHECK(parse("#").indent == 4);
-        CHECK(parse("3").indent == 3);
-        CHECK(parse("#12").indent == 12);
-
-        const auto f = parse(".>");
-        CHECK(f.indent == -1);
-        CHECK(f.indent_char == '.');
-    }
-
     SECTION("std::format_to writes through an arbitrary output iterator")
     {
         const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};

tests/src/unit-ubjson.cpp

@@ -15,7 +15,6 @@ using nlohmann::json;
 #include <fstream>
 #include <set>
 #include "make_test_data_available.hpp"
-#include "round_trip_corpus.hpp"
 #include "test_utils.hpp"
 
 namespace
@@ -1640,29 +1639,6 @@ TEST_CASE("UBJSON")
                 });
                 CHECK_THROWS_AS(_ = json::sax_parse(v_ubjson, &scp, json::input_format_t::ubjson), json::out_of_range&);
             }
-
-            SECTION("array with a known size, read with a callback")
-            {
-                // a sized array announces its length to start_array()
-                std::vector<uint8_t> const v_ubjson = {'[', '#', 'i', 2, 'i', 1, 'i', 2};
-                json j;
-                nlohmann::detail::json_sax_dom_callback_parser<json, decltype(nlohmann::detail::input_adapter(v_ubjson))> scp(j, [](int /*unused*/, json::parse_event_t /*unused*/, const json& /*unused*/) noexcept
-                {
-                    return true;
-                });
-                CHECK(json::sax_parse(v_ubjson, &scp, json::input_format_t::ubjson));
-                CHECK(j == json({1, 2}));
-
-                // the readers reject a size this large before they announce
-                // it, so it can only reach start_array() directly (the largest
-                // value stands for an unknown size and is never checked)
-                json k;
-                nlohmann::detail::json_sax_dom_callback_parser<json, decltype(nlohmann::detail::input_adapter(v_ubjson))> scp2(k, [](int /*unused*/, json::parse_event_t /*unused*/, const json& /*unused*/) noexcept
-                {
-                    return true;
-                });
-                CHECK_THROWS_AS(scp2.start_array((std::numeric_limits<std::size_t>::max)() - 1), json::out_of_range&);
-            }
         }
     }
 
@@ -2278,46 +2254,6 @@ TEST_CASE("UBJSON nesting does not consume the call stack")
     }
 }
 
-TEST_CASE("UBJSON input that cannot be read is discarded by every overload")
-{
-    std::vector<std::uint8_t> input = json::to_ubjson(json({{"a", {1, 2}}}));
-    input.pop_back();
-
-    json _;
-    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());
-    CHECK(json::from_ubjson(input.data(), input.size(), true, false).is_discarded());
-    CHECK(json::from_ubjson({input.data(), input.size()}, true, false).is_discarded());
-}
-
-TEST_CASE("UBJSON SAX parsing stops at every event")
-{
-    // Containers are opened and closed by the loop that reads them; a SAX
-    // handler that rejects any event - including the end of a nested
-    // container - must stop the parse right there.
-    const auto count_events = [](const std::vector<std::uint8_t>& input)
-    {
-        int events = 0;
-        while (true)
-        {
-            SaxCountdown scp(events);
-            if (json::sax_parse(input, &scp, json::input_format_t::ubjson))
-            {
-                return events;
-            }
-            ++events;
-            REQUIRE(events < 1000);
-        }
-    };
-
-    // 20 events: every container kind closes inside another one
-    const json j = json::parse(R"({"a": [1, {"b": []}], "c": {"d": [[2]]}})");
-    CHECK(count_events(json::to_ubjson(j)) == 20);
-    CHECK(count_events(json::to_ubjson(j, true)) == 20);
-    CHECK(count_events(json::to_ubjson(j, true, true)) == 20);
-}
-
 TEST_CASE("UBJSON optimized arrays of a valueless type are bounded")
 {
     // An element of type 'Z', 'T' or 'F' is encoded by its marker alone, so an
@@ -2329,9 +2265,7 @@ TEST_CASE("UBJSON optimized arrays of a valueless type are bounded")
 
     SECTION("an excessive count is rejected")
     {
-        // 'l' is a big-endian int32: 0x7FFFFFFF elements, about 34 GB of value;
-        // OSS-Fuzz reported this shape as a parse_ubjson_fuzzer timeout
-        // (testcase 6347769435193344, no issue filed)
+        // 'l' is a big-endian int32: 0x7FFFFFFF elements, about 34 GB of value
         for (const auto marker :
                 {'Z', 'T', 'F'
                 })
@@ -2883,51 +2817,6 @@ TEST_CASE("UBJSON use_type requires use_size")
     }
 }
 
-TEST_CASE("UBJSON round-trip invariants")
-{
-    // This checks what the parse_ubjson_fuzzer driver checks (see
-    // tests/src/fuzzer-parse_ubjson.cpp), so that a regression shows up in CI
-    // rather than as an OSS-Fuzz report: every value from_ubjson() returns
-    // (j1) can be serialized with any combination of options, the result can
-    // be parsed back (j2), and serializing j2 again with the same options
-    // reproduces the exact bytes. Beyond the driver, this also checks that j2
-    // equals j1. Values are compared with dump() rather than operator==,
-    // because a NaN never compares equal to itself.
-    struct options
-    {
-        bool use_size;
-        bool use_type;
-    };
-    const std::vector<options> all_options =
-    {
-        {false, false},
-        {true, false},
-        {true, true},
-    };
-
-    for (const auto& j0 : utils::round_trip_corpus::values())
-    {
-        // turn the corpus value into a value as from_ubjson() returns it; this
-        // has no binary values, as UBJSON writes them as arrays of integers
-        for (const auto& initial : all_options)
-        {
-            const json j1 = json::from_ubjson(json::to_ubjson(j0, initial.use_size, initial.use_type));
-
-            for (const auto& o : all_options)
-            {
-                INFO("j1 = " << j1.dump() << ", use_size = " << o.use_size << ", use_type = " << o.use_type);
-
-                const std::vector<std::uint8_t> vec = json::to_ubjson(j1, o.use_size, o.use_type);
-                json j2;
-                // anything the library writes must be parsable by the library
-                REQUIRE_NOTHROW(j2 = json::from_ubjson(vec));
-                CHECK(j2.dump() == j1.dump());
-                CHECK(json::to_ubjson(j2, o.use_size, o.use_type) == vec);
-            }
-        }
-    }
-}
-
 TEST_CASE("UBJSON roundtrips" * doctest::skip())
 {
     SECTION("input from self-generated UBJSON files")

tests/src/unit-wstring.cpp

@@ -70,8 +70,6 @@ TEST_CASE("wide strings")
             CHECK_THROWS_WITH_AS(_ = json::parse(std::wstring{L'"', static_cast<wchar_t>(0xDC00), L'"'}), error_low_surrogate, json::parse_error&);
             // a high surrogate followed by a non-low-surrogate unit is invalid
             CHECK_THROWS_WITH_AS(_ = json::parse(std::wstring{L'"', static_cast<wchar_t>(0xD800), L'a', L'"'}), error_high_surrogate, json::parse_error&);
-            // ... also when the unit is above the low surrogates
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::wstring{L'"', static_cast<wchar_t>(0xD800), static_cast<wchar_t>(0xE000), L'"'}), error_high_surrogate, json::parse_error&);
             // a lone low surrogate must not swallow the following unit: pairing
             // it with any second unit would produce valid UTF-8, so the error
             // has to report an ill-formed byte at the surrogate's own position
@@ -101,8 +99,6 @@ TEST_CASE("wide strings")
             CHECK_THROWS_WITH_AS(_ = json::parse(std::u16string{u'"', 0xDC00, u'"'}), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"<U+0000>'", json::parse_error&);
             // a high surrogate followed by a non-low-surrogate unit is invalid
             CHECK_THROWS_WITH_AS(_ = json::parse(std::u16string{u'"', 0xD800, u'a', u'"'}), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"<U+0000>'", json::parse_error&);
-            // ... also when the unit is above the low surrogates
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::u16string{u'"', 0xD800, 0xE000, u'"'}), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"<U+0000>'", json::parse_error&);
             // a lone low surrogate must not swallow the following unit: pairing
             // it with any second unit would produce valid UTF-8, so the error
             // has to report an ill-formed byte at the surrogate's own position

tools/generate_natvis/generate_natvis.py

@@ -20,7 +20,7 @@ if __name__ == '__main__':
 
     namespaces = ['nlohmann']
     abi_prefix = 'json_abi'
-    abi_tags = ['_diag', '_ldvcmp', '_dp', '_bics', '_psp']
+    abi_tags = ['_diag', '_ldvcmp', '_dp', '_bics']
     version = '_v' + args.version.replace('.', '_')
     inline_namespaces = []