Merge remote-tracking branch 'origin/develop' into fix/develop-ci-after-merges

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

README.md

@@ -494,7 +494,7 @@ bool key(string_t& val);
 bool parse_error(std::size_t position, const std::string& last_token, const detail::exception& ex);
 ```
 
-The return value of each function determines whether parsing should proceed. For `parse_error`, returning `true` [recovers from the error](https://json.nlohmann.me/features/parsing/error_recovery/): the parser repairs the input and continues.
+The return value of each function determines whether parsing should proceed.
 
 To implement your own SAX handler, proceed as follows:
 
@@ -502,7 +502,7 @@ To implement your own SAX handler, proceed as follows:
 2. Create an object of your SAX interface class, e.g. `my_sax`.
 3. Call `bool json::sax_parse(input, &my_sax)`; where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.
 
-Note the `sax_parse` function only returns a `bool` indicating whether the input was parsed without errors and no SAX event returned `false`. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).
+Note the `sax_parse` function only returns a `bool` indicating the result of the last executed SAX event. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).
 
 ### STL-like access
 

cmake/ci.cmake

@@ -596,8 +596,9 @@ foreach(SRC_FILE ${SRC_FILES})
     add_executable(single_${RELATIVE_SRC_FILE} EXCLUDE_FROM_ALL ${PROJECT_BINARY_DIR}/src_single/${RELATIVE_SRC_FILE}.cpp)
     target_include_directories(single_${RELATIVE_SRC_FILE} PRIVATE ${PROJECT_SOURCE_DIR}/include)
     target_compile_features(single_${RELATIVE_SRC_FILE} PRIVATE cxx_std_11)
-    if(RELATIVE_SRC_FILE STREQUAL "json")
+    if(RELATIVE_SRC_FILE STREQUAL "json" OR RELATIVE_SRC_FILE STREQUAL "json_literals")
-        # see below: report json.hpp's diagnostics without --error, so they do not fail the build
+        # see below: report the diagnostics of json.hpp and json_literals.hpp without --error, so they
+        # do not fail the build
         set_property(TARGET single_${RELATIVE_SRC_FILE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE ${IWYU_TOOL} -Xiwyu --max_line_length=300)
     else()
         set_property(TARGET single_${RELATIVE_SRC_FILE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE "${iwyu_path_and_options}")
@@ -611,7 +612,10 @@ foreach(SRC_FILE ${SRC_FILES})
     # reporting its diagnostics (informational, via CXX_INCLUDE_WHAT_YOU_USE above) but exclude it
     # from the hard gate below so a fresh IWYU/compiler combination does not fail this target on a
     # nondeterministic suggestion for a header that already re-exports everything on purpose.
-    if(NOT RELATIVE_SRC_FILE STREQUAL "json")
+    # json_literals.hpp and json.hpp include each other on purpose (json.hpp includes it at its end
+    # unless JSON_NO_AUTOMATIC_UDLS is defined), and IWYU, not following the cycle, suggests replacing
+    # json.hpp with json_fwd.hpp although the literals need the complete basic_json; exclude it, too.
+    if(NOT RELATIVE_SRC_FILE STREQUAL "json" AND NOT RELATIVE_SRC_FILE STREQUAL "json_literals")
         list(APPEND single_binaries_tus src_single/${RELATIVE_SRC_FILE}.cpp)
     endif()
 endforeach()

docs/docset/docSet.sql

@@ -242,6 +242,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_NO_THREAD_LOCAL', 'Macro
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_PRECISE_STREAM_POSITION', 'Macro', 'api/macros/json_precise_stream_position/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_SKIP_LIBRARY_VERSION_CHECK', 'Macro', 'api/macros/json_skip_library_version_check/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_SKIP_UNSUPPORTED_COMPILER_CHECK', 'Macro', 'api/macros/json_skip_unsupported_compiler_check/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('JSON_STRICT_BINARY_UTF8', 'Macro', 'api/macros/json_strict_binary_utf8/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_STRICT_NUL_HANDLING', 'Macro', 'api/macros/json_strict_nul_handling/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_THROW_USER', 'Macro', 'api/macros/json_throw_user/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_TRY_USER', 'Macro', 'api/macros/json_throw_user/index.html');

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

@@ -90,9 +90,7 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
 
 ## Return value
 
-`#!cpp true` if the input was parsed without errors and no SAX event returned `#!cpp false`; `#!cpp false` otherwise.
+return value of the last processed SAX event
-In particular, the result is `#!cpp false` for input with errors, even if the SAX parser recovered from all of them
-(see [error recovery](../../features/parsing/error_recovery.md)).
 
 ## Exception safety
 
@@ -140,7 +138,6 @@ A UTF-8 byte order mark is silently ignored.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
 - 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.
-- Recovering from parse errors (see [`parse_error`](../json_sax/parse_error.md)) added 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`.

docs/mkdocs/docs/api/json_sax/index.md

@@ -7,8 +7,7 @@ struct json_sax;
 
 This class describes the SAX interface used by [sax_parse](../basic_json/sax_parse.md). Each function is called in
 different situations while the input is parsed. The boolean return value informs the parser whether to continue
-processing the input; for [`parse_error`](parse_error.md), it decides whether to
+processing the input.
-[recover from the error](../../features/parsing/error_recovery.md).
 
 For instance, parsing the JSON text `{"a": [1, true]}` triggers the following callbacks, in order:
 

docs/mkdocs/docs/api/json_sax/parse_error.md

@@ -21,18 +21,11 @@ A parse error occurred.
 
 ## Return value
 
-Whether to recover from the error:
+Whether parsing should proceed (**must return `#!cpp false`**).
-
-- `#!cpp false` stops parsing.
-- `#!cpp true` recovers from the error: the error is repaired and parsing continues. If that is not possible, which
-  happens in the binary formats when the end of the item with the error is unknown, the value read so far is completed
-  and parsing stops. See [error recovery](../../features/parsing/error_recovery.md) for how errors are repaired.
-
-Either way, [`sax_parse`](../basic_json/sax_parse.md) returns `#!cpp false`.
 
 ## Examples
 
-??? example "Example: (1) the SAX interface"
+??? example
 
     The example below shows how the SAX interface is used.
 
@@ -46,29 +39,12 @@ Either way, [`sax_parse`](../basic_json/sax_parse.md) returns `#!cpp false`.
     --8<-- "examples/sax_parse.output"
     ```
 
-??? example "Example: (2) recovering from errors"
-
-    The example below shows how a SAX parser recovers from errors.
-
-    ```cpp
-    --8<-- "examples/sax_parse__error_recovery.cpp"
-    ```
-    
-    Output:
-    
-    ```
-    --8<-- "examples/sax_parse__error_recovery.output"
-    ```
-
 ## See also
 
 - [sax_parse](../basic_json/sax_parse.md) - SAX parser
 - [Parsing and Exceptions](../../features/parsing/parse_exceptions.md) - the article on handling parse errors without
   exceptions
-- [Error Recovery](../../features/parsing/error_recovery.md) - the article on recovering from parse errors
 
 ## Version history
 
 - Added in version 3.2.0.
-- Returning `#!cpp true` recovers from the error since version 3.13.0; before, parsing stopped, but the result of
-  [`sax_parse`](../basic_json/sax_parse.md) could be wrong.

docs/mkdocs/docs/api/macros/json_no_automatic_udls.md

@@ -43,9 +43,9 @@ By default, `#!cpp JSON_NO_AUTOMATIC_UDLS` is not defined, and `<nlohmann/json.h
 
     ```cpp
     // compiled with -DJSON_NO_AUTOMATIC_UDLS for the whole project
-    #include <nlohmann/json.hpp>
 
     // this file uses the literals, so it includes them explicitly
+    // (the header includes <nlohmann/json.hpp> itself)
     #include <nlohmann/json_literals.hpp>
 
     int main()
@@ -62,6 +62,7 @@ By default, `#!cpp JSON_NO_AUTOMATIC_UDLS` is not defined, and `<nlohmann/json.h
 - [`operator""_json`](../operator_literal_json.md)
 - [`operator""_json_pointer`](../operator_literal_json_pointer.md)
 - [`JSON_USE_GLOBAL_UDLS`](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
+- [Compile times](../../integration/compile_times.md) - options to reduce compile times
 
 ## Version history
 

docs/mkdocs/docs/api/macros/json_strict_binary_utf8.md

@@ -54,7 +54,7 @@ The default value is `0` (disabled, the behavior of version 3.12.0 and earlier i
 
 ## Examples
 
-??? example "Default behavior (macro not defined)"
+??? example "Example: default behavior (macro not defined)"
 
     Without the macro, the bytes are written unchanged:
 
@@ -70,7 +70,7 @@ The default value is `0` (disabled, the behavior of version 3.12.0 and earlier i
     }
     ```
 
-??? example "Opt-in check (macro defined to 1)"
+??? example "Example: opt-in check (macro defined to 1)"
 
     With the macro, ill-formed UTF-8 is rejected:
 

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

@@ -44,7 +44,7 @@ By default, implicit conversions are enabled.
 
 ## Examples
 
-??? example
+??? example "Example: implicit conversion"
 
     This is an example for an implicit conversion:
 
@@ -61,7 +61,7 @@ By default, implicit conversions are enabled.
     auto s = j.get<std::string>();
     ```
 
-??? example "Conversion between `basic_json` specializations"
+??? example "Example: conversion between `basic_json` specializations"
 
     A `basic_json` specialization with a different string type is also no longer converted implicitly when
     `JSON_USE_IMPLICIT_CONVERSIONS` is defined to `0`:

docs/mkdocs/docs/examples/sax_parse__error_recovery.cpp

@@ -1,43 +0,0 @@
-#include <iostream>
-#include <iomanip>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-// a SAX parser that creates a JSON value like json::parse does, but that
-// recovers from parse errors instead of stopping at the first one
-class recovering_parser : public nlohmann::detail::json_sax_dom_parser<json>
-{
-  public:
-    explicit recovering_parser(json& result)
-        : nlohmann::detail::json_sax_dom_parser<json>(result, false)
-    {}
-
-    bool parse_error(std::size_t position,
-                     const std::string& /*last_token*/,
-                     const json::exception& ex)
-    {
-        std::cout << "byte " << position << ": " << ex.what() << '\n';
-
-        // repair the input and continue
-        return true;
-    }
-};
-
-int main()
-{
-    // JSON text with several mistakes that ends too early
-    const std::string text = R"({
-    "name": "Hello World",
-    "tags": ["a" "b",],
-    "valid": tru,
-    "size": 1.,
-    "nested": {"x": 1)";
-
-    json result;
-    recovering_parser sax(result);
-    const bool valid = json::sax_parse(text, &sax);
-
-    std::cout << "\nvalid JSON: " << std::boolalpha << valid << '\n'
-              << std::setw(4) << result << std::endl;
-}

docs/mkdocs/docs/examples/sax_parse__error_recovery.output

@@ -1,19 +0,0 @@
-byte 49: [json.exception.parse_error.101] parse error at line 3, column 20: syntax error while parsing array - unexpected string literal; expected ']'
-byte 51: [json.exception.parse_error.101] parse error at line 3, column 22: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal
-byte 70: [json.exception.parse_error.101] parse error at line 4, column 17: syntax error while parsing value - invalid literal; last read: '"valid": tru,'
-byte 86: [json.exception.parse_error.101] parse error at line 5, column 15: syntax error while parsing value - invalid number; expected digit after '.'; last read: '1.,'
-byte 109: [json.exception.parse_error.101] parse error at line 6, column 22: syntax error while parsing object - unexpected end of input; expected '}'
-
-valid JSON: false
-{
-    "name": "Hello World",
-    "nested": {
-        "x": 1
-    },
-    "size": 1,
-    "tags": [
-        "a",
-        "b"
-    ],
-    "valid": null
-}

docs/mkdocs/docs/features/parsing/error_recovery.md

@@ -1,122 +0,0 @@
-# Error Recovery
-
-By default, parsing stops at the first error. With the [SAX interface](sax_interface.md), you can instead ask the
-parser to *recover*: to repair the error and continue, so that you get as much as possible out of malformed input, for
-instance a file that was cut off, JSON edited by hand, or the output of a language model.
-
-## Recovering from errors
-
-The SAX parser's [`parse_error`](../../api/json_sax/parse_error.md) function is called for every error. Its return value
-decides what happens next:
-
-- `#!cpp false` stops parsing. This is what the SAX parsers of the library do, so [`parse`](../../api/basic_json/parse.md)
-  and [`accept`](../../api/basic_json/accept.md) never recover.
-- `#!cpp true` repairs the error and continues parsing.
-
-When recovering, the SAX parser still receives well-formed events: every `start_object` or `start_array` is followed by
-the matching `end_object` or `end_array`, and every `key` is followed by exactly one value. A SAX parser that creates a
-JSON value, such as the one in the example below, therefore gets a complete value. Parsing always ends, and
-[`sax_parse`](../../api/basic_json/sax_parse.md) returns `#!cpp false` for input that is not valid JSON, even if every
-error was repaired. Each token is reported at most once, and the SAX parser can stop at any error by returning
-`#!cpp false`.
-
-!!! example
-
-    The example below derives a SAX parser from the library's parser for `json` values (`json_sax_dom_parser`),
-    and recovers from all errors.
-
-    ```cpp
-    --8<-- "examples/sax_parse__error_recovery.cpp"
-    ```
-    
-    Output:
-    
-    ```
-    --8<-- "examples/sax_parse__error_recovery.output"
-    ```
-
-## How errors are repaired
-
-Each error is repaired with the smallest local edit: a missing separator is inserted, a stray token is removed, what can
-be read of a broken string or number is kept, and a value that cannot be read at all becomes `#!json null`.
-
-| Mistake                   | Repair                                                                         | Example                                  | Result                     |
-|---------------------------|--------------------------------------------------------------------------------|------------------------------------------|----------------------------|
-| missing `,` or `:`        | inserted                                                                       | `#!json [1 2]`, `#!json {"a" 1}`         | `[1,2]`, `{"a":1}`         |
-| missing value             | `#!json null` for an object key or between commas in an array                  | `#!json {"a":}`, `#!json [1,,2]`         | `{"a":null}`, `[1,null,2]` |
-| trailing comma            | removed                                                                        | `#!json [1,2,]`                          | `[1,2]`                    |
-| broken string             | invalid escapes and bytes are replaced (see below); a line break ends the string | `#!json ["a\qb"]`                        | `["aqb"]`                  |
-| broken number             | the longest valid beginning is kept                                            | `#!json [1., 2e+]`                       | `[1,2]`                    |
-| unreadable value          | `#!json null`                                                                  | `#!json [1, NaN, tru]`                   | `[1,null,null]`            |
-| number too large          | passed as infinity, together with its text                                     | `#!json [1e999]`                         | infinity (see below)       |
-| stray `:`                 | removed                                                                        | `#!json ["a":1]`                         | `["a",1]`                  |
-| member without a key      | skipped up to the next `,` or `}`                                              | `#!json {1:2, "b":3}`                    | `{"b":3}`                  |
-| wrong closing bracket     | closes the innermost array or object                                           | `#!json {"a":[1,2}, "b":3}`              | `{"a":[1,2],"b":3}`        |
-| input ends too early      | all open arrays and objects are closed                                         | `#!json {"a":[1,2`                       | `{"a":[1,2]}`              |
-| text before the value     | skipped                                                                        | `#!json )]}'{"a":1}`                     | `{"a":1}`                  |
-
-In a string, an unknown escape like `\q` stands for the escaped character (`q`), as in JavaScript. An invalid `\u`
-escape, a lone surrogate, and ill-formed UTF-8 are each replaced by U+FFFD (REPLACEMENT CHARACTER), and control
-characters are kept. A string without its closing quote ends at the next line break or at the end of the input.
-
-The input after the top-level value is not repaired: as without recovery, it is reported as an error, and parsing stops.
-
-## Binary formats
-
-The binary formats ([BJData](../binary_formats/bjdata.md), [BON8](../binary_formats/bon8.md),
-[BSON](../binary_formats/bson.md), [CBOR](../binary_formats/cbor.md), [MessagePack](../binary_formats/messagepack.md),
-and [UBJSON](../binary_formats/ubjson.md)) have no delimiters to find the next value by. So what can be repaired depends
-on whether the end of the item with the error is known, a distinction that
-[RFC 8949, Section 5.3](https://www.rfc-editor.org/rfc/rfc8949.html#section-5.3) makes for CBOR, too.
-
-If the item is complete, but cannot be passed on as it is, it is replaced, and parsing continues after it:
-
-| Mistake                                                             | Formats                 | Repair                                                                  |
-|---------------------------------------------------------------------|-------------------------|-------------------------------------------------------------------------|
-| tag                                                                 | CBOR                    | ignored                                                                 |
-| simple value other than `false`, `true`, and `null`, like undefined | CBOR                    | `#!json null`                                                           |
-| negative integer below the range of `number_integer_t`              | CBOR                    | the nearest floating-point number                                       |
-| character (`C`) that is not ASCII                                   | BJData, UBJSON          | U+FFFD                                                                  |
-| invalid high-precision number (`H`)                                 | BJData, UBJSON          | the longest valid beginning is kept, as for JSON text, or `#!json null` |
-| high-precision number too large                                     | BJData, UBJSON          | passed as infinity, together with its text                              |
-| object key that is not a string                                     | BON8, CBOR, MessagePack | the member is skipped                                                   |
-| element of a type the library does not read, like ObjectId or date  | BSON                    | `#!json null`                                                           |
-| string without its terminator                                       | BSON                    | kept                                                                    |
-| document whose size does not match its content                      | BSON                    | kept                                                                    |
-
-CBOR tags and simple values are repaired as [RFC 8949, Section 6.1](https://www.rfc-editor.org/rfc/rfc8949.html#section-6.1)
-suggests for converting CBOR to JSON. Note that [`sax_parse`](../../api/basic_json/sax_parse.md) has no parameter for
-CBOR tags, so every tag is an error there; when recovering, tags are ignored like with
-[`cbor_tag_handler_t::ignore`](../../api/basic_json/cbor_tag_handler_t.md). Strings that are not valid UTF-8 are no
-error: like [`from_cbor`](../../api/basic_json/from_cbor.md) and the other functions by default, `sax_parse` passes
-them on as they are.
-
-After any other error, the end of the item is unknown: the input ended, a byte is not a valid type marker, or a size
-cannot be right. Parsing then stops, and the value read so far is completed: a key that waits for its value gets
-`#!json null`, and all open arrays and objects are closed. This keeps everything before the error of an input that was
-cut off. The exception is BSON, which stores the size of every document: an element whose end is unknown gets
-`#!json null`, the rest of its document is skipped, and parsing continues after the document.
-
-## Limitations
-
-- A repair is a guess. For example, `#!json {"a" "b": 1}` could be meant as `#!json {"a": "b"}` or as
-  `#!json {"a": null, "b": 1}`; it is repaired to the former. Treat recovered values as a best effort, and check the
-  reported errors.
-- A closing bracket always closes the innermost array or object. If a bracket is missing rather than wrong, the
-  repair differs from the intention: `#!json {"a": {"b": [1, 2}, "c": 3}` is repaired to
-  `#!json {"a": {"b": [1, 2], "c": 3}}`, although `#!json {"a": {"b": [1, 2]}, "c": 3}` may have been meant.
-- Keys without quotes, and strings in single quotes, are not supported; such members are skipped.
-- In the binary formats, a member that is skipped because its key is not a string is lost, and so are the elements of a
-  BSON document after one whose end is unknown.
-- A number that is too large for `number_float_t` is passed as positive or negative infinity. The SAX parser's
-  `number_float` also gets the number's text, but a JSON value cannot store it, and
-  [`dump`](../../api/basic_json/dump.md) serializes infinity as `#!json null`.
-- When parsing is not strict (see [`sax_parse`](../../api/basic_json/sax_parse.md)), a repair may read parts of the
-  input after the value, for instance of the next value in a stream of concatenated values.
-
-## See also
-
-- [SAX interface](sax_interface.md) - implement a custom SAX handler
-- [`parse_error`](../../api/json_sax/parse_error.md) - the SAX event for parse errors
-- [`sax_parse`](../../api/basic_json/sax_parse.md) - generate SAX events
-- [parsing and exceptions](parse_exceptions.md) - control error handling

docs/mkdocs/docs/features/parsing/index.md

@@ -75,7 +75,7 @@ You can influence a DOM parse without switching to the SAX interface by passing
 When the input is not valid JSON, the `parse` function throws an exception by default. If exceptions are undesired or
 unavailable, the parser can instead return a discarded value, or [`accept`](../../api/basic_json/accept.md) can be used
 to only check whether an input is valid JSON. See [parsing and exceptions](parse_exceptions.md) for the available
-options. To get as much as possible out of malformed input, a SAX parser can [recover from errors](error_recovery.md).
+options.
 
 ## See also
 
@@ -86,5 +86,4 @@ options. To get as much as possible out of malformed input, a SAX parser can [re
 - [parser callbacks](parser_callbacks.md) - influence the parsing by a callback function
 - [SAX interface](sax_interface.md) - implement a custom SAX handler
 - [parsing and exceptions](parse_exceptions.md) - control error handling
-- [error recovery](error_recovery.md) - get as much as possible out of malformed input
 - [parsing untrusted input](untrusted_input.md) - what to consider when parsing input from untrusted sources

docs/mkdocs/docs/features/parsing/parse_exceptions.md

@@ -64,8 +64,7 @@ bool parse_error(std::size_t position,
                  const json::exception& ex);
 ```
 
-The return value decides whether to stop parsing (`#!cpp false`) or to repair the error and continue
+The return value indicates whether the parsing should continue, so the function should usually return `#!cpp false`.
-(`#!cpp true`); see [error recovery](error_recovery.md) for the latter.
 
 ??? example "Example: report parse errors without exceptions"
 

docs/mkdocs/docs/features/parsing/sax_interface.md

@@ -60,8 +60,7 @@ bool key(string_t& val);
 bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex);
 ```
 
-The return value of each function determines whether parsing should proceed. For `parse_error`, returning
+The return value of each function determines whether parsing should proceed.
-`#!cpp true` [recovers from the error](error_recovery.md).
 
 To implement your own SAX handler, proceed as follows:
 
@@ -69,7 +68,7 @@ To implement your own SAX handler, proceed as follows:
 2. Create an object of your SAX interface class, e.g. `my_sax`.
 3. Call `#!cpp bool json::sax_parse(input, &my_sax);` where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.
 
-Note the `sax_parse` function only returns a `#!cpp bool` indicating whether the input was parsed without errors and no SAX event returned `#!cpp false`. It does not return `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file `json_sax.hpp`.
+Note the `sax_parse` function only returns a `#!cpp bool` indicating the result of the last executed SAX event. It does not return `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file `json_sax.hpp`.
 
 ## See also
 

docs/mkdocs/docs/integration/compile_times.md

@@ -0,0 +1,149 @@
+# Compile times
+
+The library is header-only and makes heavy use of templates, so every translation unit that includes
+`<nlohmann/json.hpp>` pays for parsing the header and instantiating what it uses. This page lists the options to reduce
+that cost, ordered by how much they typically save.
+
+!!! info "Measurements"
+
+    The numbers below are medians of nine runs compiling a single translation unit with `-std=c++17 -c` against the
+    single-header version, with Apple clang and GCC 16 on macOS (Apple silicon). They show the order of magnitude to
+    expect; measure your own code before and after a change.
+
+## Include `json_fwd.hpp` in headers
+
+Header files that only need to *name* the `json` type — for function declarations, members held by pointer or
+reference, or friend declarations — can include `<nlohmann/json_fwd.hpp>` instead of `<nlohmann/json.hpp>`. It only
+forward-declares `basic_json`, `json`, `ordered_json`, `json_pointer`, and `adl_serializer`. The translation units that
+actually use the values then include `<nlohmann/json.hpp>`.
+
+```cpp title="person.hpp"
+#pragma once
+#include <nlohmann/json_fwd.hpp>
+
+struct person;
+void to_json(nlohmann::json& j, const person& p);
+void from_json(const nlohmann::json& j, person& p);
+```
+
+```cpp title="person.cpp"
+#include "person.hpp"
+#include <nlohmann/json.hpp>
+
+void to_json(nlohmann::json& j, const person& p) { /* ... */ }
+void from_json(const nlohmann::json& j, person& p) { /* ... */ }
+```
+
+| Compiler    | `json.hpp` (`-O0`) | `json_fwd.hpp` (`-O0`) | Change |
+|-------------|-------------------:|-----------------------:|-------:|
+| Apple clang |             704 ms |                 329 ms |   −53% |
+| GCC 16      |             779 ms |                 242 ms |   −69% |
+
+This is the most effective option, because it avoids the full header in every translation unit that includes
+*your* headers.
+
+## Opt out of the automatic user-defined string literals
+
+The user-defined string literals [`operator""_json`](../api/operator_literal_json.md) and
+[`operator""_json_pointer`](../api/operator_literal_json_pointer.md) are ordinary inline functions whose bodies call the
+parser. As `<nlohmann/json.hpp>` includes them by default, every translation unit instantiates the parser, even if it
+never parses anything itself.
+
+Define [`JSON_NO_AUTOMATIC_UDLS`](../api/macros/json_no_automatic_udls.md) for the whole project and include
+`<nlohmann/json_literals.hpp>` instead of `<nlohmann/json.hpp>` in the files that use the literals (it includes
+`<nlohmann/json.hpp>` itself):
+
+```cmake
+target_compile_definitions(my_target PRIVATE JSON_NO_AUTOMATIC_UDLS)
+```
+
+```cpp
+#include <nlohmann/json_literals.hpp> // only where "..."_json is used; includes <nlohmann/json.hpp>
+```
+
+The saving applies to translation units that do not parse JSON, for example ones that define types and their
+conversions or only pass `json` values around:
+
+| Compiler    | Translation unit | Default (`-O0` / `-O2`) | `JSON_NO_AUTOMATIC_UDLS` (`-O0` / `-O2`) | Change      |
+|-------------|------------------|------------------------:|-----------------------------------------:|------------:|
+| Apple clang | model            |         776 ms / 846 ms |                          629 ms / 692 ms | −19% / −18% |
+| GCC 16      | model            |       1022 ms / 1120 ms |                          882 ms / 965 ms | −14% / −14% |
+| Apple clang | parsing          |       992 ms / 1815 ms |                        1006 ms / 1823 ms |   +1% / 0% |
+| GCC 16      | parsing          |      2018 ms / 3420 ms |                        1990 ms / 3454 ms |   −1% / +1% |
+
+Translation units that include only the header save up to a third. Translation units that parse anyway instantiate
+the parser regardless and see no difference.
+
+## Instantiate `basic_json` once
+
+Each translation unit instantiates the member functions of `nlohmann::json` it uses. An explicit instantiation
+declaration tells the compiler that the non-template members are instantiated elsewhere, so it can skip them:
+
+```cpp title="json_instance.hpp"
+#pragma once
+#include <nlohmann/json.hpp>
+
+extern template class nlohmann::basic_json<>;
+```
+
+```cpp title="json_instance.cpp"
+#include "json_instance.hpp"
+
+template class nlohmann::basic_json<>;
+```
+
+Include `json_instance.hpp` instead of `<nlohmann/json.hpp>` and compile and link `json_instance.cpp` once.
+
+| Compiler    | Translation unit    | Default (`-O0` / `-O2`) | `extern template` (`-O0` / `-O2`) | Change      |
+|-------------|---------------------|------------------------:|----------------------------------:|------------:|
+| Apple clang | parsing             |        992 ms / 1815 ms |                  953 ms / 1625 ms |  −4% / −10% |
+| GCC 16      | parsing             |       2018 ms / 3420 ms |                 1522 ms / 2728 ms | −25% / −20% |
+| Apple clang | `json_instance.cpp` |                       — |                 2166 ms / 4660 ms |           — |
+| GCC 16      | `json_instance.cpp` |                       — |                5085 ms / 10616 ms |           — |
+
+Notes:
+
+- The saving grows with the number of translation units that use `json`, while the instantiation translation unit is
+  compiled only once (and is rarely recompiled, as it does not depend on your code).
+- Member function templates (such as `get<T>()`, `parse(InputType&&)`, or `value(key, default)`) are not covered by
+  the explicit instantiation and are still instantiated where they are used.
+- The declaration covers exactly `nlohmann::json`. Add the same lines for `nlohmann::ordered_json`
+  (`nlohmann::basic_json<nlohmann::ordered_map>`) or your own `basic_json` specializations if you use them.
+
+## Use C++20 modules
+
+With a toolchain that supports named modules, `import nlohmann.json;` compiles the library once into a module and
+avoids parsing the header in every translation unit. See [Modules](../features/modules.md) for requirements and known
+issues. Module support is experimental and currently depends heavily on the compiler version.
+
+## Use precompiled headers
+
+Build systems can precompile `<nlohmann/json.hpp>` together with other stable headers, for example with CMake's
+[`target_precompile_headers`](https://cmake.org/cmake/help/latest/command/target_precompile_headers.html):
+
+```cmake
+target_precompile_headers(my_target PRIVATE <nlohmann/json.hpp>)
+```
+
+This removes the cost of parsing the header, but not of instantiating templates in each translation unit, so it
+combines well with the options above.
+
+## Options without effect on compile times
+
+Some configuration macros change what the library declares, but do not measurably change compile times:
+
+| Macro                                                                  | Apple clang, model (`-O0` / `-O2`) | GCC 16, model (`-O0` / `-O2`) |
+|------------------------------------------------------------------------|-----------------------------------:|------------------------------:|
+| default                                                                |                    776 ms / 846 ms |             1022 ms / 1120 ms |
+| [`JSON_NO_IO`](../api/macros/json_no_io.md)                            |                    764 ms / 836 ms |             1022 ms / 1117 ms |
+| [`JSON_USE_GLOBAL_UDLS`](../api/macros/json_use_global_udls.md)`=0`    |                    763 ms / 852 ms |             1019 ms / 1106 ms |
+
+`JSON_USE_GLOBAL_UDLS` only controls *where* the literals are declared; to avoid their cost, use
+`JSON_NO_AUTOMATIC_UDLS` instead.
+
+## See also
+
+- [`JSON_NO_AUTOMATIC_UDLS`](../api/macros/json_no_automatic_udls.md) - do not include the user-defined string
+  literals automatically
+- [Modules](../features/modules.md) - C++20 module support
+- [Header only](index.md) - including the library

docs/mkdocs/docs/integration/index.md

@@ -45,7 +45,7 @@ Clang).
 
 You can further use file
 [`single_include/nlohmann/json_fwd.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json_fwd.hpp)
-for forward declarations, and file
+for forward declarations (see [Compile times](compile_times.md)), and file
 [`single_include/nlohmann/json_literals.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json_literals.hpp)
 for the user-defined string literals if you define
 [`JSON_NO_AUTOMATIC_UDLS`](../api/macros/json_no_automatic_udls.md).

docs/mkdocs/mkdocs.yml

@@ -88,7 +88,6 @@ nav:
       - features/performance.md
       - Parsing:
           - features/parsing/index.md
-          - features/parsing/error_recovery.md
           - features/parsing/json_lines.md
           - features/parsing/parse_exceptions.md
           - features/parsing/parser_callbacks.md
@@ -109,6 +108,7 @@ nav:
       - integration/cmake.md
       - integration/package_managers.md
       - integration/pkg-config.md
+      - integration/compile_times.md
   - API Documentation:
       - basic_json:
           - 'Overview': api/basic_json/index.md

include/nlohmann/detail/input/json_sax.hpp

@@ -132,9 +132,7 @@ struct json_sax
     @param[in] position    the position in the input where the error occurs
     @param[in] last_token  the last read token
     @param[in] ex          an exception object describing the error
-    @return whether to recover from the error: false stops parsing; true
+    @return whether parsing should proceed (must return false)
-            repairs the error and continues, or, if that is not possible,
-            stops after completing the value read so far
     */
     virtual bool parse_error(std::size_t position,
                              const std::string& last_token,
@@ -271,12 +269,9 @@ a pointer to the respective array or object for each recursion depth.
 After successful parsing, the value that is passed by reference to the
 constructor contains the parsed value.
 
-@tparam BasicJsonType     the JSON type
+@tparam BasicJsonType  the JSON type
-@tparam InputAdapterType  the input adapter of the lexer that can be passed to
-                          the constructor to record diagnostic positions; it
-                          does not matter if no lexer is passed
 */
-template<typename BasicJsonType, typename InputAdapterType = string_input_adapter_type>
+template<typename BasicJsonType, typename InputAdapterType>
 class json_sax_dom_parser
 {
   public:
@@ -523,7 +518,7 @@ class json_sax_dom_parser
     lexer_t* m_lexer_ref = nullptr;
 };
 
-template<typename BasicJsonType, typename InputAdapterType = string_input_adapter_type>
+template<typename BasicJsonType, typename InputAdapterType>
 class json_sax_dom_callback_parser
 {
   public:

include/nlohmann/detail/input/lexer.hpp

@@ -10,7 +10,7 @@
 
 #include <array> // array
 #include <cstddef> // size_t
-#include <cstdint> // uint8_t, uint32_t
+#include <cstdint> // uint32_t
 #include <cstdio> // snprintf
 #include <initializer_list> // initializer_list
 #include <string> // char_traits, string
@@ -439,16 +439,8 @@ class lexer : public lexer_base<BasicJsonType>
                             if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
                             {
                                 // expect next \uxxxx entry
-                                if (JSON_HEDLEY_LIKELY(get() == '\\'))
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
                                 {
-                                    if (JSON_HEDLEY_UNLIKELY(get() != 'u'))
-                                    {
-                                        // current is the character escaped by the backslash
-                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
-                                        string_error_resume = resume_kind::escaped_character;
-                                        return token_type::parse_error;
-                                    }
-
                                     const int codepoint2 = get_codepoint();
 
                                     if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
@@ -473,11 +465,7 @@ class lexer : public lexer_base<BasicJsonType>
                                     }
                                     else
                                     {
-                                        // the second escape was read completely and is a
-                                        // code point of its own
                                         error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
-                                        string_error_resume = resume_kind::after_escape;
-                                        string_error_codepoint = codepoint2;
                                         return token_type::parse_error;
                                     }
                                 }
@@ -491,9 +479,7 @@ class lexer : public lexer_base<BasicJsonType>
                             {
                                 if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
                                 {
-                                    // the escape was read completely
                                     error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
-                                    string_error_resume = resume_kind::after_escape;
                                     return token_type::parse_error;
                                 }
                             }
@@ -2114,573 +2100,6 @@ scan_number_done:
         }
     }
 
-    /////////////////////
-    // error recovery
-    /////////////////////
-
-    /*!
-    @brief make the best of the token that scan() rejected
-
-    Called by the parser after scan() returned token_type::parse_error and the
-    SAX parser asked to recover from the error (see #3989). Keeps what can be
-    read of the token and skips the rest:
-
-    - A string keeps its characters. An unknown escape stands for the escaped
-      character itself (as in JavaScript), an invalid Unicode escape and ill-formed
-      UTF-8 become U+FFFD, and a control character is kept. A line break or the
-      end of the input ends a string that lacks its closing quote.
-    - A number keeps its longest valid prefix, e.g. `1` for `1.` or `1e+`.
-    - A block comment that is not closed runs to the end of the input.
-    - Anything else is skipped.
-
-    The rest of an invalid token is skipped up to the next delimiter
-    (whitespace, a structural character, or a quote). A delimiter that the
-    invalid token consumed is returned to the input, so that the next scan()
-    reads it.
-
-    @return token_type::value_string or a number token type if a string or a
-            number could be read, token_type::end_of_input for a block comment
-            that is not closed, token_type::uninitialized otherwise
-    */
-    token_type recover_token()
-    {
-        const resume_kind resume = string_error_resume;
-        const int codepoint = string_error_codepoint;
-        string_error_resume = resume_kind::character;
-        string_error_codepoint = -1;
-
-        if (error_message_starts_with("invalid string"))
-        {
-            return recover_string(resume, codepoint);
-        }
-
-        if (error_message_starts_with("invalid number"))
-        {
-            return recover_number();
-        }
-
-        if (error_message_starts_with("invalid comment; missing"))
-        {
-            // the comment runs to the end of the input
-            return token_type::end_of_input;
-        }
-
-        skip_to_delimiter();
-        return token_type::uninitialized;
-    }
-
-    /*!
-    @brief return the token that scan() read last to the input, so that the
-           next scan() reads it again
-
-    Called by the parser when recovering from an error. The token must be a
-    single character (',', ':', '[', ']', '{', or '}') or the end of the
-    input, and scan() must have read it last.
-    */
-    void unget_token()
-    {
-        JSON_ASSERT(!next_unget);
-        unget();
-    }
-
-    /*!
-    @brief let the token string for the next error begin at the current character
-
-    The token string of an error reaches back to the beginning of the last
-    string or number. After an error, the parser calls this function so that
-    the next error does not report (and, with many errors, copy) everything
-    read since then.
-    */
-    void restart_token_string()
-    {
-        restart_token_string_impl(std::integral_constant<bool, lazy_token_string> {});
-    }
-
-  private:
-    /// how recover_string() continues after the error scan_string() reported
-    enum class resume_kind : std::uint8_t
-    {
-        /// current is the next character of the string (or the end of input)
-        character,
-        /// current is the character escaped by the preceding backslash
-        escaped_character,
-        /// current is the last character of a complete escape
-        after_escape
-    };
-
-    /// whether error_message begins with @a prefix
-    bool error_message_starts_with(const char* prefix) const noexcept
-    {
-        const char* message = error_message;
-        while (*prefix != '\0')
-        {
-            if (*message++ != *prefix++)
-            {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /// whether current ends an invalid token (see recover_token())
-    bool current_is_delimiter() const noexcept
-    {
-        switch (current)
-        {
-            case ' ':
-            case '\t':
-            case '\n':
-            case '\r':
-            case '[':
-            case ']':
-            case '{':
-            case '}':
-            case ',':
-            case ':':
-            case '\"':
-#if !JSON_STRICT_NUL_HANDLING
-            case '\0':
-#endif
-            case char_traits<char_type>::eof():
-                return true;
-
-            case '/':
-                return ignore_comments;
-
-            default:
-                return false;
-        }
-    }
-
-    /// skip the rest of an invalid token and return its delimiter to the input
-    void skip_to_delimiter()
-    {
-        while (!current_is_delimiter())
-        {
-            get();
-        }
-
-        if (current != char_traits<char_type>::eof())
-        {
-            unget();
-        }
-    }
-
-    /// append U+FFFD REPLACEMENT CHARACTER to token_buffer
-    void add_replacement_character()
-    {
-        add(0xEF);
-        add(0xBF);
-        add(0xBD);
-    }
-
-    /// append the UTF-8 encoding of @a codepoint (not a surrogate) to token_buffer
-    void add_codepoint(const int codepoint)
-    {
-        JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
-        const auto cp = static_cast<unsigned int>(codepoint);
-        if (cp < 0x80)
-        {
-            add(static_cast<char_int_type>(cp));
-        }
-        else if (cp <= 0x7FF)
-        {
-            add(static_cast<char_int_type>(0xC0u | (cp >> 6u)));
-            add(static_cast<char_int_type>(0x80u | (cp & 0x3Fu)));
-        }
-        else if (cp <= 0xFFFF)
-        {
-            add(static_cast<char_int_type>(0xE0u | (cp >> 12u)));
-            add(static_cast<char_int_type>(0x80u | ((cp >> 6u) & 0x3Fu)));
-            add(static_cast<char_int_type>(0x80u | (cp & 0x3Fu)));
-        }
-        else
-        {
-            add(static_cast<char_int_type>(0xF0u | (cp >> 18u)));
-            add(static_cast<char_int_type>(0x80u | ((cp >> 12u) & 0x3Fu)));
-            add(static_cast<char_int_type>(0x80u | ((cp >> 6u) & 0x3Fu)));
-            add(static_cast<char_int_type>(0x80u | (cp & 0x3Fu)));
-        }
-    }
-
-    /// append a code point read from a Unicode escape; a surrogate becomes U+FFFD
-    void add_escaped_codepoint(const int codepoint)
-    {
-        if (0xD800 <= codepoint && codepoint <= 0xDFFF)
-        {
-            add_replacement_character();
-        }
-        else
-        {
-            add_codepoint(codepoint);
-        }
-    }
-
-    /*!
-    @brief remove an incomplete UTF-8 sequence from the end of token_buffer
-
-    next_byte_in_range() adds the bytes of a sequence as it checks them, so
-    when it rejects a byte, the beginning of the sequence is already in
-    token_buffer, which otherwise holds only complete sequences.
-
-    @return whether an incomplete sequence was removed
-    */
-    bool remove_incomplete_utf8_sequence()
-    {
-        std::size_t lead = token_buffer.size();
-        std::size_t continuation_bytes = 0;
-        while (lead > 0 && continuation_bytes < 3
-                && (static_cast<unsigned char>(token_buffer[lead - 1]) & 0xC0u) == 0x80u)
-        {
-            --lead;
-            ++continuation_bytes;
-        }
-        if (lead == 0)
-        {
-            return false;
-        }
-
-        const auto lead_byte = static_cast<unsigned char>(token_buffer[lead - 1]);
-        std::size_t expected = 0;
-        if (lead_byte >= 0xF0)
-        {
-            expected = 3;
-        }
-        else if (lead_byte >= 0xE0)
-        {
-            expected = 2;
-        }
-        else if (lead_byte >= 0xC0)
-        {
-            expected = 1;
-        }
-        if (continuation_bytes >= expected)
-        {
-            return false;
-        }
-
-        token_buffer.resize(lead - 1);
-        return true;
-    }
-
-    /*!
-    @brief read the UTF-8 sequence that begins with current, which is not ASCII
-    @return whether the next character must be read; false if current still
-            needs to be handled, because it does not belong to the sequence
-    */
-    bool recover_utf8_sequence()
-    {
-        // the number of continuation bytes and the range of the first one;
-        // see the ranges in scan_string()
-        std::size_t count = 0;
-        char_int_type low = 0x80;
-        char_int_type high = 0xBF;
-        if (current >= 0xC2 && current <= 0xDF)
-        {
-            count = 1;
-        }
-        else if (current >= 0xE0 && current <= 0xEF)
-        {
-            count = 2;
-            low = (current == 0xE0) ? 0xA0 : 0x80;
-            high = (current == 0xED) ? 0x9F : 0xBF;
-        }
-        else if (current >= 0xF0 && current <= 0xF4)
-        {
-            count = 3;
-            low = (current == 0xF0) ? 0x90 : 0x80;
-            high = (current == 0xF4) ? 0x8F : 0xBF;
-        }
-        else
-        {
-            // an ill-formed byte
-            add_replacement_character();
-            return true;
-        }
-
-        const std::size_t start = token_buffer.size();
-        add(current);
-        for (std::size_t i = 0; i < count; ++i)
-        {
-            get();
-            if (current < low || current > high)
-            {
-                token_buffer.resize(start);
-                add_replacement_character();
-                return false;
-            }
-            add(current);
-            low = 0x80;
-            high = 0xBF;
-        }
-        return true;
-    }
-
-    /*!
-    @brief read the low surrogate that must follow the high surrogate @a high
-    @return whether the next character must be read; false if current still
-            needs to be handled
-    */
-    bool recover_low_surrogate(int high)
-    {
-        while (true)
-        {
-            if (get() != '\\')
-            {
-                add_replacement_character();
-                return false;
-            }
-            if (get() != 'u')
-            {
-                add_replacement_character();
-                // not 'u', so this does not come back here
-                return recover_escape();
-            }
-
-            const int low = get_codepoint();
-            if (low == -1)
-            {
-                add_replacement_character();
-                return false;
-            }
-            if (0xDC00 <= low && low <= 0xDFFF)
-            {
-                add_codepoint(static_cast<int>((static_cast<unsigned int>(high) << 10u)
-                                               + static_cast<unsigned int>(low) - 0x35FDC00u));
-                return true;
-            }
-
-            // high has no low surrogate
-            add_replacement_character();
-            if (low < 0xD800 || low > 0xDBFF)
-            {
-                add_codepoint(low);
-                return true;
-            }
-            // another high surrogate
-            high = low;
-        }
-    }
-
-    /*!
-    @brief read the escape whose backslash was read; current is the escaped character
-    @return whether the next character must be read; false if current still
-            needs to be handled
-    */
-    bool recover_escape()
-    {
-        switch (current)
-        {
-            case '\"':
-                add('\"');
-                return true;
-            case '\\':
-                add('\\');
-                return true;
-            case '/':
-                add('/');
-                return true;
-            case 'b':
-                add('\b');
-                return true;
-            case 'f':
-                add('\f');
-                return true;
-            case 'n':
-                add('\n');
-                return true;
-            case 'r':
-                add('\r');
-                return true;
-            case 't':
-                add('\t');
-                return true;
-
-            case 'u':
-            {
-                const int codepoint = get_codepoint();
-                if (codepoint == -1)
-                {
-                    add_replacement_character();
-                    return false;
-                }
-                if (0xD800 <= codepoint && codepoint <= 0xDBFF)
-                {
-                    return recover_low_surrogate(codepoint);
-                }
-                add_escaped_codepoint(codepoint);
-                return true;
-            }
-
-            // an unknown escape stands for the escaped character
-            default:
-                return false;
-        }
-    }
-
-    /*!
-    @brief read the rest of a string after scan_string() rejected it
-
-    token_buffer holds what scan_string() read before the error. See
-    recover_token() for how errors are repaired.
-
-    @param[in] resume     how to continue, see resume_kind
-    @param[in] codepoint  for a high surrogate followed by an escape of another
-                          code point: that code point; -1 otherwise
-    */
-    token_type recover_string(const resume_kind resume, const int codepoint)
-    {
-        // whether the next character must be read before it can be handled
-        bool fetch = false;
-
-        if (error_message_starts_with("invalid string: surrogate")
-                || error_message_starts_with("invalid string: '\\u'")
-                || (error_message_starts_with("invalid string: ill-formed UTF-8")
-                    && remove_incomplete_utf8_sequence()))
-        {
-            add_replacement_character();
-        }
-
-        switch (resume)
-        {
-            case resume_kind::escaped_character:
-                fetch = recover_escape();
-                break;
-            case resume_kind::after_escape:
-                if (0xD800 <= codepoint && codepoint <= 0xDBFF)
-                {
-                    fetch = recover_low_surrogate(codepoint);
-                }
-                else
-                {
-                    if (codepoint != -1)
-                    {
-                        add_escaped_codepoint(codepoint);
-                    }
-                    fetch = true;
-                }
-                break;
-            case resume_kind::character:
-            default:
-                break;
-        }
-
-        while (true)
-        {
-            if (fetch)
-            {
-                get();
-            }
-            fetch = true;
-
-            switch (current)
-            {
-                case '\"':
-                // a line break or the end of the input ends a string that
-                // lacks its closing quote
-                case '\n':
-                case '\r':
-                case char_traits<char_type>::eof():
-                    return token_type::value_string;
-
-#if !JSON_STRICT_NUL_HANDLING
-                case '\0':
-                    // the end of the input, see scan()
-                    unget();
-                    return token_type::value_string;
-#endif
-
-                case '\\':
-                    get();
-                    fetch = recover_escape();
-                    break;
-
-                default:
-                    if (current < 0x80)
-                    {
-                        // including control characters
-                        add(current);
-                    }
-                    else
-                    {
-                        fetch = recover_utf8_sequence();
-                    }
-                    break;
-            }
-        }
-    }
-
-    /*!
-    @brief keep the longest valid prefix of a number that scan_number() rejected
-
-    token_buffer holds the characters scan_number() accepted before the error,
-    so the prefix ends at its last digit.
-    */
-    token_type recover_number()
-    {
-        // only size(), operator[], and resize() are used, which every string
-        // type the library supports provides
-        std::size_t length = token_buffer.size();
-        while (length != 0 && (token_buffer[length - 1] < '0' || token_buffer[length - 1] > '9'))
-        {
-            --length;
-        }
-        token_buffer.resize(length);
-
-        if (length == 0)
-        {
-            skip_to_delimiter();
-            return token_type::uninitialized;
-        }
-
-        if (decimal_point_position >= length)
-        {
-            decimal_point_position = std::string::npos;
-        }
-
-        std::size_t exponent = std::string::npos;
-        for (std::size_t i = 0; i < length; ++i)
-        {
-            if (token_buffer[i] == 'e' || token_buffer[i] == 'E')
-            {
-                exponent = i;
-                break;
-            }
-        }
-        const std::size_t mantissa_end = (exponent == std::string::npos) ? length : exponent;
-        token_type number_type = token_type::value_unsigned;
-        if (decimal_point_position != std::string::npos || exponent != std::string::npos)
-        {
-            number_type = token_type::value_float;
-        }
-        else if (token_buffer[0] == '-')
-        {
-            number_type = token_type::value_integer;
-        }
-
-        const token_type result = convert_number(number_type, mantissa_end);
-        skip_to_delimiter();
-        return result;
-    }
-
-    /// seekable adapter: the token string begins at current, which was consumed
-    void restart_token_string_impl(std::true_type /*lazy*/) noexcept
-    {
-        const std::size_t consumed = ia.get_consumed_count();
-        token_string_start = (consumed > 0 && current != char_traits<char_type>::eof()) ? consumed - 1 : consumed;
-    }
-
-    /// streaming adapter: the token string begins at current; a character
-    /// that was put back is copied again when it is read again
-    void restart_token_string_impl(std::false_type /*lazy*/)
-    {
-        token_string.clear();
-        if (!next_unget && current != char_traits<char_type>::eof())
-        {
-            token_string.push_back(char_traits<char_type>::to_char_type(current));
-        }
-    }
-
   private:
     /// input adapter
     InputAdapterType ia;
@@ -2721,13 +2140,6 @@ scan_number_done:
     /// a description of occurred lexer errors
     const char* error_message = "";
 
-    /// how recover_token() continues a string that scan_string() rejected;
-    /// set only on the error paths that need more than error_message
-    resume_kind string_error_resume = resume_kind::character;
-    /// the code point of the second escape when a high surrogate is followed
-    /// by an escape that is not a low surrogate; -1 otherwise
-    int string_error_codepoint = -1;
-
     // number values
     number_integer_t value_integer = 0;
     number_unsigned_t value_unsigned = 0;

include/nlohmann/detail/input/parser.hpp

@@ -139,59 +139,26 @@ class parser
     bool accept(const bool strict = true)
     {
         json_sax_acceptor<BasicJsonType> sax_acceptor;
-        return sax_parse_impl<false>(&sax_acceptor, strict);
+        return sax_parse(&sax_acceptor, strict);
     }
 
-    /*!
-    @brief public SAX interface
-
-    If the SAX parser's parse_error() returns true, the parser recovers from
-    the error: it repairs the input and continues (see #3989).
-
-    @param[in] sax     the SAX parser
-    @param[in] strict  whether to expect the last token to be EOF
-    @return whether the input was parsed without errors and no SAX event
-            returned false
-    */
     template<typename SAX>
     JSON_HEDLEY_NON_NULL(2)
     bool sax_parse(SAX* sax, const bool strict = true)
-    {
-        return sax_parse_impl<true>(sax, strict);
-    }
-
-  private:
-    /// what sax_parse_internal() does after an object key was expected
-    enum class next_step : std::uint8_t
-    {
-        /// stop parsing
-        stop,
-        /// parse a value that begins with last_token
-        parse_value,
-        /// evaluate the state of the innermost container, which reads
-        /// last_token again
-        evaluate_state
-    };
-
-    template<bool AllowRecovery, typename SAX>
-    JSON_HEDLEY_NON_NULL(2)
-    bool sax_parse_impl(SAX* sax, const bool strict)
     {
         (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
-        const bool result = sax_parse_internal<AllowRecovery>(sax);
+        const bool result = sax_parse_internal(sax);
 
         if (result)
         {
             if (strict)
             {
-                // strict mode: next byte must be EOF; after recovering from an
+                // strict mode: next byte must be EOF
-                // error, the end of the input may already have been read
+                if (get_token() != token_type::end_of_input)
-                if (last_token != token_type::end_of_input && get_token() != token_type::end_of_input)
                 {
-                    // the value is complete, so there is nothing to recover
+                    return sax->parse_error(m_lexer.get_position(),
-                    static_cast<void>(report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr),
+                                            m_lexer.get_token_string(),
-                                                   std::integral_constant<bool, AllowRecovery> {}));
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
-                    return false;
                 }
             }
             else
@@ -202,9 +169,10 @@ class parser
             }
         }
 
-        return result && !error_reported;
+        return result;
     }
 
+  private:
     /*!
     @brief run a DOM SAX parser to completion and position the lexer
 
@@ -222,7 +190,7 @@ class parser
     template<typename DomSax>
     bool parse_dom(DomSax& sdp, const bool strict)
     {
-        sax_parse_internal<false>(&sdp);
+        sax_parse_internal(&sdp);
 
         if (strict)
         {
@@ -245,20 +213,10 @@ class parser
         return !sdp.is_errored();
     }
 
-    /*!
+    template<typename SAX>
-    @brief parse a JSON value and pass it to a SAX parser
-
-    @tparam AllowRecovery  whether to recover from an error if the SAX parser's
-                           parse_error() returns true; false for the SAX parsers
-                           of parse() and accept(), which never do, so that no
-                           code for recovering is generated for them
-    */
-    template<bool AllowRecovery, typename SAX>
     JSON_HEDLEY_NON_NULL(2)
     bool sax_parse_internal(SAX* sax)
     {
-        const std::integral_constant<bool, AllowRecovery> allow_recovery{};
-
         // stack to remember the hierarchy of structured values we are parsing
         // true = array; false = object
         std::vector<bool> states;
@@ -289,18 +247,12 @@ class parser
                             break;
                         }
 
-                        // remember we are now inside an object
+                        // parse key
-                        states.push_back(false);
-
-                        // parse key (the steps of parse_key(), which are
-                        // repeated here and below for speed)
                         if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                         {
-                            if (!continue_after(key_error(sax, allow_recovery, false), skip_to_state_evaluation))
+                            return sax->parse_error(m_lexer.get_position(),
-                            {
+                                                    m_lexer.get_token_string(),
-                                return false;
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
-                            }
-                            continue;
                         }
                         if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
                         {
@@ -310,13 +262,14 @@ class parser
                         // parse separator (:)
                         if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                         {
-                            if (!continue_after(key_error(sax, allow_recovery, true), skip_to_state_evaluation))
+                            return sax->parse_error(m_lexer.get_position(),
-                            {
+                                                    m_lexer.get_token_string(),
-                                return false;
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
-                            }
-                            continue;
                         }
 
+                        // remember we are now inside an object
+                        states.push_back(false);
+
                         // parse values
                         get_token();
                         continue;
@@ -352,11 +305,9 @@ class parser
 
                         if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
                         {
-                            if (!overflow_error(sax, res, allow_recovery))
+                            return sax->parse_error(m_lexer.get_position(),
-                            {
+                                                    m_lexer.get_token_string(),
-                                return false;
+                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
-                            }
-                            break;
                         }
 
                         if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
@@ -424,63 +375,23 @@ class parser
                     case token_type::parse_error:
                     {
                         // using "uninitialized" to avoid an "expected" message
-                        if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr), allow_recovery))
+                        return sax->parse_error(m_lexer.get_position(),
-                        {
+                                                m_lexer.get_token_string(),
-                            return false;
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
-                        }
-
-                        // recover: keep what can be read of the token
-                        recover_token();
-                        if (last_token != token_type::uninitialized)
-                        {
-                            // a string or a number
-                            continue;
-                        }
-                        if (states.empty())
-                        {
-                            // look for the value after the garbage
-                            if (!skip_to_value())
-                            {
-                                return false;
-                            }
-                            continue;
-                        }
-                        // nothing could be read
-                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
-                        {
-                            return false;
-                        }
-                        break;
                     }
                     case token_type::end_of_input:
                     {
                         if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
                         {
-                            // there is nothing to recover
+                            return sax->parse_error(m_lexer.get_position(),
-                            static_cast<void>(report_error(sax, parse_error::create(101, m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
-                                                           "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr), allow_recovery));
+                                                    parse_error::create(101, m_lexer.get_position(),
-                            return false;
+                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
                         }
 
-                        if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr), allow_recovery))
+                        return sax->parse_error(m_lexer.get_position(),
-                        {
+                                                m_lexer.get_token_string(),
-                            return false;
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
-                        }
-
-                        // recover: the input ends where a value is missing
-                        if (states.empty())
-                        {
-                            // there is no value
-                            return false;
-                        }
-                        if (!recover_missing_value(sax, states))
-                        {
-                            return false;
-                        }
-                        // the state evaluation reads the token again
-                        m_lexer.unget_token();
-                        skip_to_state_evaluation = true;
-                        continue;
                     }
                     case token_type::uninitialized:
                     case token_type::end_array:
@@ -490,35 +401,9 @@ class parser
                     case token_type::literal_or_value:
                     default: // the last token was unexpected
                     {
-                        if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr), allow_recovery))
+                        return sax->parse_error(m_lexer.get_position(),
-                        {
+                                                m_lexer.get_token_string(),
-                            return false;
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
-                        }
-
-                        // recover
-                        if (states.empty())
-                        {
-                            // look for the value after the garbage
-                            if (!skip_to_value())
-                            {
-                                return false;
-                            }
-                            continue;
-                        }
-                        if (last_token == token_type::name_separator)
-                        {
-                            // a stray ':'; the value may follow
-                            get_token();
-                            continue;
-                        }
-                        if (!recover_missing_value(sax, states))
-                        {
-                            return false;
-                        }
-                        // the state evaluation reads the token again
-                        m_lexer.unget_token();
-                        skip_to_state_evaluation = true;
-                        continue;
                     }
                 }
             }
@@ -569,30 +454,9 @@ class parser
                     continue;
                 }
 
-                if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr), allow_recovery))
+                return sax->parse_error(m_lexer.get_position(),
-                {
+                                        m_lexer.get_token_string(),
-                    return false;
+                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
-                }
-
-                // recover
-                if (last_token == token_type::end_of_input)
-                {
-                    // the input ends inside the array
-                    return close_containers(sax, states);
-                }
-                if (last_token == token_type::end_object)
-                {
-                    // a wrong closing bracket closes the innermost container
-                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
-                    {
-                        return false;
-                    }
-                    states.pop_back();
-                    skip_to_state_evaluation = true;
-                }
-                // otherwise, a missing ',' (or a stray ':', which value
-                // parsing drops): the next value begins here
-                continue;
             }
 
             // states.back() is false -> object
@@ -609,12 +473,11 @@ class parser
                     // parse key
                     if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                     {
-                        if (!continue_after(key_error(sax, allow_recovery, false), skip_to_state_evaluation))
+                        return sax->parse_error(m_lexer.get_position(),
-                        {
+                                                m_lexer.get_token_string(),
-                            return false;
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
-                        }
-                        continue;
                     }
+
                     if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
                     {
                         return false;
@@ -623,11 +486,9 @@ class parser
                     // parse separator (:)
                     if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                     {
-                        if (!continue_after(key_error(sax, allow_recovery, true), skip_to_state_evaluation))
+                        return sax->parse_error(m_lexer.get_position(),
-                        {
+                                                m_lexer.get_token_string(),
-                            return false;
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
-                        }
-                        continue;
                     }
 
                     // parse values
@@ -655,479 +516,12 @@ class parser
                 continue;
             }
 
-            if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr), allow_recovery))
+            return sax->parse_error(m_lexer.get_position(),
-            {
+                                    m_lexer.get_token_string(),
-                return false;
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
-            }
-
-            // recover
-            if (last_token == token_type::end_of_input)
-            {
-                // the input ends inside the object
-                return close_containers(sax, states);
-            }
-            if (last_token == token_type::end_array)
-            {
-                // a wrong closing bracket closes the innermost container
-                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
-                {
-                    return false;
-                }
-                states.pop_back();
-                skip_to_state_evaluation = true;
-                continue;
-            }
-            if (!continue_after(recover_member(sax, allow_recovery), skip_to_state_evaluation))
-            {
-                return false;
-            }
         }
     }
 
-    /*!
-    @brief continue sax_parse_internal() after a recovery
-    @return whether to continue parsing
-    */
-    bool continue_after(const next_step step, bool& skip_to_state_evaluation)
-    {
-        if (step == next_step::evaluate_state)
-        {
-            // the state evaluation reads the token again
-            m_lexer.unget_token();
-            skip_to_state_evaluation = true;
-        }
-        return step != next_step::stop;
-    }
-
-    /// the parser for parse() and accept() never recovers: stop parsing
-    static std::false_type continue_after(std::false_type /*step*/, bool& /*skip_to_state_evaluation*/) noexcept
-    {
-        return {};
-    }
-
-    /*!
-    @brief parse an object key and the name separator (:) after it
-
-    last_token is the token where the key is expected. sax_parse_internal()
-    repeats these steps rather than calling this function, which is used
-    when recovering from an error.
-
-    @return next_step::parse_value if the value follows, with last_token its
-            first token; next_step::evaluate_state if the object's state is
-            to be evaluated after recovering from an error; next_step::stop
-            to stop parsing
-    */
-    template<typename SAX>
-    next_step parse_key(SAX* sax)
-    {
-        const std::true_type allow_recovery{};
-
-        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
-        {
-            return key_error(sax, allow_recovery, false);
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
-        {
-            return next_step::stop;
-        }
-
-        // parse separator (:)
-        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
-        {
-            return key_error(sax, allow_recovery, true);
-        }
-
-        // the value begins with the next token
-        get_token();
-        return next_step::parse_value;
-    }
-
-    /*!
-    @brief report a number that is too large for number_float_t, and recover
-           from the error by passing the value on; the SAX parser gets the
-           number's text as well
-
-    This is a separate function, as reading other numbers is measurably
-    slower if the error is handled where they are read.
-
-    @param[in] sax    the SAX parser
-    @param[in] value  the value that is not finite
-    @return whether to continue parsing
-    */
-    template<typename SAX, typename AllowRecovery>
-    bool overflow_error(SAX* sax, const number_float_t value, AllowRecovery allow_recovery)
-    {
-        if (!report_error(sax, out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr), allow_recovery))
-        {
-            return false;
-        }
-        return sax->number_float(value, m_lexer.get_string());
-    }
-
-    /*!
-    @brief report a missing key, or a missing name separator (:) after the
-           key; the parser for parse() and accept() never recovers
-
-    @param[in] key_read  whether the key was read, so that the name separator
-                         is missing
-    @return std::false_type, see report_error()
-    */
-    template<typename SAX>
-    std::false_type key_error(SAX* sax, std::false_type allow_recovery, const bool key_read)
-    {
-        return report_error(sax, parse_error::create(101, m_lexer.get_position(), key_read
-                            ? exception_message(token_type::name_separator, "object separator")
-                            : exception_message(token_type::value_string, "object key"), nullptr), allow_recovery);
-    }
-
-    /*!
-    @brief report a missing key, or a missing name separator (:) after the
-           key, and recover from it
-
-    @param[in] key_read  whether the key was read, so that the name separator
-                         is missing
-    */
-    template<typename SAX>
-    next_step key_error(SAX* sax, std::true_type allow_recovery, const bool key_read)
-    {
-        if (!key_read)
-        {
-            if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr), allow_recovery))
-            {
-                return next_step::stop;
-            }
-            return recover_key(sax);
-        }
-
-        if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr), allow_recovery))
-        {
-            return next_step::stop;
-        }
-        return recover_name_separator(sax);
-    }
-
-    /////////////////////
-    // error recovery
-    /////////////////////
-
-    /*
-    The functions below repair an error after the SAX parser's parse_error()
-    returned true (see #3989). Each mistake is repaired by the smallest local
-    edit: a missing ',' or ':' is inserted, a stray token is removed, what can
-    be read of an invalid string or number is kept (see
-    lexer::recover_token()), a missing value becomes null, a wrong closing
-    bracket closes the innermost container, and the end of the input closes
-    all of them. The events stay balanced, and every key() is followed by
-    exactly one value.
-
-    A repair hands a token to the state evaluation, by returning it to the
-    lexer (lexer::unget_token()) so that the state evaluation reads it again,
-    only if it is ',', ']', '}', or the end of the input. The state evaluation
-    hands a token to value or key parsing only if it is none of them, so a
-    token is never handed back and forth. Every other step reads a token or
-    closes a container, so parsing always ends.
-    */
-
-    /*!
-    @brief report an error to the SAX parser; the parser for parse() and
-           accept() never recovers
-
-    @return std::false_type rather than false: its value is known where the
-            function is called even if the call is not inlined, so the code
-            for recovering is not generated
-    */
-    template<typename SAX, typename Exception>
-    std::false_type report_error(SAX* sax, const Exception& ex, std::false_type /*allow_recovery*/)
-    {
-        error_reported = true;
-        static_cast<void>(sax->parse_error(m_lexer.get_position(), m_lexer.get_token_string(), ex));
-        return {};
-    }
-
-    /*!
-    @brief report an error to the SAX parser
-    @return whether to recover from the error
-    */
-    template<typename SAX, typename Exception>
-    bool report_error(SAX* sax, const Exception& ex, std::true_type /*allow_recovery*/)
-    {
-        const std::size_t position = m_lexer.get_position().chars_read_total;
-        if (error_reported && position == last_error_position && last_token == last_error_token)
-        {
-            // a repair handed on the token of the error it repaired; the
-            // token was reported already, and the SAX parser asked to recover
-            return true;
-        }
-
-        error_reported = true;
-        last_error_position = position;
-        last_error_token = last_token;
-
-        if (!sax->parse_error(m_lexer.get_position(), m_lexer.get_token_string(), ex))
-        {
-            return false;
-        }
-
-        // the token string of the next error begins here
-        m_lexer.restart_token_string();
-        return true;
-    }
-
-    /*!
-    @brief keep what can be read of the token that the lexer rejected
-
-    The error was reported for the rejected token, so it is not reported again
-    for the token it is repaired to (see lexer::recover_token()).
-    */
-    token_type recover_token()
-    {
-        last_token = m_lexer.recover_token();
-        last_error_position = m_lexer.get_position().chars_read_total;
-        last_error_token = last_token;
-        return last_token;
-    }
-
-    /// pass the end events of all open containers
-    template<typename SAX>
-    bool close_containers(SAX* sax, std::vector<bool>& states)
-    {
-        while (!states.empty())
-        {
-            const bool is_array = states.back();
-            states.pop_back();
-            if (JSON_HEDLEY_UNLIKELY(is_array ? !sax->end_array() : !sax->end_object()))
-            {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /*!
-    @brief read tokens until one begins a value, skipping everything before
-           the top-level value
-    @return whether a value begins with last_token
-    */
-    bool skip_to_value()
-    {
-        while (true)
-        {
-            switch (get_token())
-            {
-                case token_type::begin_array:
-                case token_type::begin_object:
-                case token_type::literal_false:
-                case token_type::literal_null:
-                case token_type::literal_true:
-                case token_type::value_float:
-                case token_type::value_integer:
-                case token_type::value_string:
-                case token_type::value_unsigned:
-                    return true;
-
-                case token_type::end_of_input:
-                    return false;
-
-                case token_type::parse_error:
-                    recover_token();
-                    if (last_token != token_type::uninitialized)
-                    {
-                        return true;
-                    }
-                    break;
-
-                case token_type::uninitialized:
-                case token_type::end_array:
-                case token_type::end_object:
-                case token_type::name_separator:
-                case token_type::value_separator:
-                case token_type::literal_or_value:
-                default:
-                    break;
-            }
-        }
-    }
-
-    /*!
-    @brief skip the rest of an object member that cannot be read
-
-    Reads tokens, beginning with last_token, until a ',', '}', or ']' that is
-    not inside a container that begins in the skipped tokens, or the end of
-    the input.
-    */
-    void skip_member()
-    {
-        std::size_t depth = 0;
-        while (true)
-        {
-            switch (last_token)
-            {
-                case token_type::begin_array:
-                case token_type::begin_object:
-                    ++depth;
-                    break;
-
-                case token_type::end_array:
-                case token_type::end_object:
-                    if (depth == 0)
-                    {
-                        return;
-                    }
-                    --depth;
-                    break;
-
-                case token_type::value_separator:
-                    if (depth == 0)
-                    {
-                        return;
-                    }
-                    break;
-
-                case token_type::end_of_input:
-                    return;
-
-                case token_type::parse_error:
-                    recover_token();
-                    break;
-
-                case token_type::uninitialized:
-                case token_type::literal_true:
-                case token_type::literal_false:
-                case token_type::literal_null:
-                case token_type::value_string:
-                case token_type::value_unsigned:
-                case token_type::value_integer:
-                case token_type::value_float:
-                case token_type::name_separator:
-                case token_type::literal_or_value:
-                default:
-                    break;
-            }
-            get_token();
-        }
-    }
-
-    /*!
-    @brief pass a value where it is missing
-
-    last_token is ',', ']', '}', or the end of the input, where a value was
-    expected. In an object, the key gets null; in an array, a ',' where a
-    value is missing stands for null (as in JavaScript), while an array that
-    ends there just ends.
-    */
-    template<typename SAX>
-    bool recover_missing_value(SAX* sax, const std::vector<bool>& states)
-    {
-        JSON_ASSERT(!states.empty());
-        if (!states.back() || last_token == token_type::value_separator)
-        {
-            return sax->null();
-        }
-        return true;
-    }
-
-    /// recover from a missing key; last_token is where it was expected
-    template<typename SAX>
-    next_step recover_key(SAX* sax)
-    {
-        switch (last_token)
-        {
-            case token_type::value_separator:
-            case token_type::end_object:
-            case token_type::end_array:
-            case token_type::end_of_input:
-                // no member: the object's state handles the token
-                return next_step::evaluate_state;
-
-            case token_type::parse_error:
-                recover_token();
-                if (last_token == token_type::value_string)
-                {
-                    // a key that could be repaired
-                    return parse_key(sax);
-                }
-                skip_member();
-                return next_step::evaluate_state;
-
-            case token_type::uninitialized:
-            case token_type::literal_true:
-            case token_type::literal_false:
-            case token_type::literal_null:
-            case token_type::value_string:
-            case token_type::value_unsigned:
-            case token_type::value_integer:
-            case token_type::value_float:
-            case token_type::begin_array:
-            case token_type::begin_object:
-            case token_type::name_separator:
-            case token_type::literal_or_value:
-            default:
-                // a member without a key
-                skip_member();
-                return next_step::evaluate_state;
-        }
-    }
-
-    /// recover from a missing name separator (:) after the key; last_token
-    /// is where it was expected
-    template<typename SAX>
-    next_step recover_name_separator(SAX* sax)
-    {
-        switch (last_token)
-        {
-            case token_type::value_separator:
-            case token_type::end_object:
-            case token_type::end_array:
-            case token_type::end_of_input:
-                // the value is missing as well
-                return sax->null() ? next_step::evaluate_state : next_step::stop;
-
-            case token_type::uninitialized:
-            case token_type::literal_true:
-            case token_type::literal_false:
-            case token_type::literal_null:
-            case token_type::value_string:
-            case token_type::value_unsigned:
-            case token_type::value_integer:
-            case token_type::value_float:
-            case token_type::begin_array:
-            case token_type::begin_object:
-            case token_type::name_separator:
-            case token_type::parse_error:
-            case token_type::literal_or_value:
-            default:
-                // a missing ':'; the value begins here
-                return next_step::parse_value;
-        }
-    }
-
-    /// recover from a token after an object member that is neither ',' nor
-    /// '}' (nor ']' or the end of the input, which the caller handles)
-    template<typename SAX>
-    next_step recover_member(SAX* sax, std::true_type /*allow_recovery*/)
-    {
-        if (last_token == token_type::parse_error)
-        {
-            recover_token();
-        }
-        if (last_token == token_type::value_string)
-        {
-            // a missing ','; the next key begins here
-            return parse_key(sax);
-        }
-        skip_member();
-        return next_step::evaluate_state;
-    }
-
-    /// the parser for parse() and accept() never recovers (and does not come
-    /// here, as report_error() returned false)
-    template<typename SAX>
-    std::false_type recover_member(SAX* /*sax*/, std::false_type /*allow_recovery*/) const noexcept
-    {
-        return {};
-    }
-
     /// get next token from lexer
     token_type get_token()
     {
@@ -1174,12 +568,6 @@ class parser
     const bool allow_exceptions = true;
     /// whether trailing commas in objects and arrays should be ignored (true) or signaled as errors (false)
     const bool ignore_trailing_commas = false;
-    /// whether an error was reported to the SAX parser
-    bool error_reported = false;
-    /// the position of the last reported error
-    std::size_t last_error_position = 0;
-    /// the token of the last reported error
-    token_type last_error_token = token_type::uninitialized;
 };
 
 }  // namespace detail

include/nlohmann/detail/json_pointer.hpp

@@ -322,6 +322,8 @@ class json_pointer
         typename BasicJsonType::size_type idx{};
         switch (parse_array_index<BasicJsonType>(s, idx))
         {
+            // the branches differ in their messages, not after JSON_THROW's expansion
+            // NOLINTNEXTLINE(bugprone-branch-clone)
             case array_index_status::leading_zero:
                 JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
             case array_index_status::not_a_number:
@@ -685,6 +687,8 @@ class json_pointer
                     typename BasicJsonType::size_type idx{};
                     switch (parse_array_index<BasicJsonType>(reference_token, idx))
                     {
+                        // the branches differ in their messages, not after JSON_THROW's expansion
+                        // NOLINTNEXTLINE(bugprone-branch-clone)
                         case array_index_status::leading_zero:
                             JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", reference_token, "' must not begin with '0'"), nullptr));
                         case array_index_status::not_a_number:

include/nlohmann/detail/output/binary_writer.hpp

@@ -2260,18 +2260,18 @@ class binary_writer
         switch (error_handler)
         {
             case error_handler_t::keep:
-                return s;
+                return s; // NOLINT(bugprone-return-const-ref-from-parameter): callers pass lvalues that outlive the call
 
             case error_handler_t::strict:
                 check_utf8(s, context);
-                return s;
+                return s; // NOLINT(bugprone-return-const-ref-from-parameter): callers pass lvalues that outlive the call
 
             case error_handler_t::replace:
             case error_handler_t::ignore:
             default:
                 if (is_valid_utf8(s))
                 {
-                    return s;
+                    return s; // NOLINT(bugprone-return-const-ref-from-parameter): callers pass lvalues that outlive the call
                 }
                 storage = sanitize_utf8(s, error_handler);
                 return storage;

include/nlohmann/detail/output/serializer.hpp

@@ -706,6 +706,11 @@ class serializer
     @a ensure_ascii is a template parameter here so that the branch on it is
     resolved once, outside the loop; see @ref dump_escaped.
     */
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push)
+    // EnsureAscii is a template parameter; C++11 has no if constexpr
+#pragma warning(disable : 4127) // conditional expression is constant
+#endif
     template<bool EnsureAscii>
     void dump_escaped_impl(const string_t& s)
     {
@@ -1055,6 +1060,9 @@ class serializer
             }
         }
     }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(pop)
+#endif
 
   private:
     /*!

include/nlohmann/detail/string_utils.hpp

@@ -13,7 +13,6 @@
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint32_t
 #include <string> // string, to_string
-#include <utility> // move
 
 #include <nlohmann/detail/abi_macros.hpp>
 #include <nlohmann/detail/macro_scope.hpp>

include/nlohmann/json.hpp

@@ -149,7 +149,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     friend class ::nlohmann::detail::iter_impl;
     template<typename BasicJsonType, typename CharType, typename OutputSinkType>
     friend class ::nlohmann::detail::binary_writer;
-    template<typename BasicJsonType, typename InputType, typename SAX, bool AllowRecovery>
+    template<typename BasicJsonType, typename InputType, typename SAX>
     friend class ::nlohmann::detail::binary_reader;
     template<typename BasicJsonType, typename InputAdapterType>
     friend class ::nlohmann::detail::json_sax_dom_parser;
@@ -1048,6 +1048,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
           never name it to call this constructor itself.
     */
     basic_json(copy_construct_tag /*unused*/, const basic_json& src)
+    noexcept(std::is_nothrow_copy_constructible<json_base_class_t>::value)
         : json_base_class_t(src)
 #if JSON_DIAGNOSTIC_POSITIONS
         , start_position(src.start_position)
@@ -1442,7 +1443,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     be destroyed.
     */
     template<typename BasicJsonType>
-    void convert_iteratively(const BasicJsonType& val)
+    void convert_iteratively(const BasicJsonType& val, std::true_type /*unused*/)
     {
         using other_const_iterator = typename BasicJsonType::const_iterator;
 
@@ -1536,21 +1537,38 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
         if (JSON_HEDLEY_LIKELY(guard.okay()))
         {
-            // every element comes back to the converting constructor
+            convert_by_serializers(val);
-            if (val.is_object())
-            {
-                using other_object_t = typename BasicJsonType::object_t;
-                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
-            }
-            else
-            {
-                using other_array_t = typename BasicJsonType::array_t;
-                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
-            }
             return;
         }
 
-        convert_iteratively(val);
+        // the iterative conversion needs to construct this object type's keys
+        // from those of @a val; if it cannot, neither can the range constructor,
+        // and the serializers convert @a val some other way (see #3425)
+        convert_iteratively(val, std::is_constructible<typename object_t::key_type, const typename BasicJsonType::string_t&> {});
+    }
+
+    /// @brief convert the object or array @a val with the serializers; every
+    /// element comes back to the converting constructor
+    template<typename BasicJsonType>
+    void convert_by_serializers(const BasicJsonType& val)
+    {
+        if (val.is_object())
+        {
+            using other_object_t = typename BasicJsonType::object_t;
+            JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+        }
+        else
+        {
+            using other_array_t = typename BasicJsonType::array_t;
+            JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+        }
+    }
+
+    /// @brief convert @a val whose keys cannot be converted, see @ref convert_structured
+    template<typename BasicJsonType>
+    void convert_iteratively(const BasicJsonType& val, std::false_type /*unused*/)
+    {
+        convert_by_serializers(val);
     }
 
 
@@ -1624,15 +1642,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
     {
         const std::partial_ordering order = lhs <=> rhs; // *NOPAD*
-        if (order == 0)
+        if (std::is_eq(order))
         {
             return compare_result::equal;
         }
-        if (order < 0)
+        if (std::is_lt(order))
         {
             return compare_result::less;
         }
-        if (order > 0)
+        if (std::is_gt(order))
         {
             return compare_result::greater;
         }
@@ -5058,7 +5076,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
     template<typename ScalarType>
     requires std::is_scalar_v<ScalarType>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) <= rhs;
     }
@@ -5067,7 +5085,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
     template<typename ScalarType>
     requires std::is_scalar_v<ScalarType>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
     {
         return basic_json(lhs) >= rhs;
     }
@@ -5393,7 +5411,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         auto ia = detail::input_adapter(std::forward<InputType>(i));
         return format == input_format_t::json
                ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict);
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict);
     }
 
     /// @brief generate SAX events (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -5410,7 +5428,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         auto ia = detail::input_adapter(std::move(first), std::move(last));
         return format == input_format_t::json
                ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict);
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict);
     }
 
     /// @brief generate SAX events
@@ -5445,7 +5463,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
                ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
                // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict);
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict);
     }
 #if defined(__clang__)
 #pragma clang diagnostic pop

include/nlohmann/ordered_map.hpp

@@ -12,7 +12,7 @@
 #include <functional> // equal_to, less
 #include <initializer_list> // initializer_list
 #include <iterator> // input_iterator_tag, iterator_traits
-#include <memory> // allocator
+#include <memory> // allocator // IWYU pragma: keep
 #include <new> // for operator new (placement new)
 #include <stdexcept> // for out_of_range
 #include <tuple> // forward_as_tuple
@@ -78,7 +78,7 @@ private:
     /// @brief find the entry for @a key, for either constness of @a self
     /// @note the single place that performs the linear key search
     template<typename Self, typename KeyType>
-    static auto find_impl(Self& self, KeyType&& key) -> decltype(self.begin())
+    static auto find_impl(Self& self, const KeyType& key) -> decltype(self.begin())
     {
         for (auto it = self.begin(); it != self.end(); ++it)
         {

src/modules/json.cppm

@@ -47,7 +47,6 @@ inline namespace json_literals
 namespace detail
 {
     using NLOHMANN_JSON_NAMESPACE::detail::json_sax_dom_callback_parser;
-    using NLOHMANN_JSON_NAMESPACE::detail::json_sax_dom_parser;
     using NLOHMANN_JSON_NAMESPACE::detail::unknown_size;
 } // namespace detail
 

tests/src/fuzzer-parse_bjdata.cpp

@@ -45,10 +45,6 @@ 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.
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bjdata() fails (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -61,8 +57,6 @@ drivers.
     #error "the fuzzer drivers must be built without NDEBUG"
 #endif
 
-#include "fuzzer-recovering_checker.hpp"
-
 using json = nlohmann::json;
 
 // value-stable comparison for the round-trip checks below; see the note
@@ -75,15 +69,11 @@ static bool is_value_stable(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // step 0: recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bjdata).errors == 0;
-
     try
     {
         // step 1: parse input
         std::vector<uint8_t> const vec1(data, data + size);
         json const j1 = json::from_bjdata(vec1);
-        assert(recovered_without_errors);
 
         try
         {
@@ -117,7 +107,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::parse_error&)
     {
         // parse errors are ok, because input may be random bytes
-        assert(!recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -126,7 +115,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::out_of_range&)
     {
         // out of range errors may happen if provided sizes are excessive
-        assert(!recovered_without_errors);
     }
 
     // return 0 - non-zero return values are reserved for future use

tests/src/fuzzer-parse_bon8.cpp

@@ -19,10 +19,6 @@ It also checks that reading the data from a stream, which reads strings byte by
 byte, gives the same value or error as reading it from contiguous memory, which
 copies strings in bulk.
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bon8() fails (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -36,8 +32,6 @@ drivers.
     #error "the fuzzer drivers must be built without NDEBUG"
 #endif
 
-#include "fuzzer-recovering_checker.hpp"
-
 using json = nlohmann::json;
 
 namespace
@@ -61,9 +55,6 @@ std::string read_bon8(InputType&& input)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // step 0: recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bon8).errors == 0;
-
     // contiguous and stream input must be read alike
     {
         std::istringstream stream(std::string(reinterpret_cast<const char*>(data), size));
@@ -75,7 +66,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // step 1: parse input
         std::vector<uint8_t> const vec1(data, data + size);
         json const j1 = json::from_bon8(vec1);
-        assert(recovered_without_errors);
 
         try
         {
@@ -97,7 +87,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::parse_error&)
     {
         // parse errors are ok, because input may be random bytes
-        assert(!recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -106,7 +95,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::out_of_range&)
     {
         // out of range errors may happen if provided sizes are excessive
-        assert(!recovered_without_errors);
     }
 
     // return 0 - non-zero return values are reserved for future use

tests/src/fuzzer-parse_bson.cpp

@@ -15,10 +15,6 @@ array data, it performs the following steps:
 - j2 = from_bson(vec)
 - assert(to_bson(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bson() fails (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -31,22 +27,16 @@ drivers.
     #error "the fuzzer drivers must be built without NDEBUG"
 #endif
 
-#include "fuzzer-recovering_checker.hpp"
-
 using json = nlohmann::json;
 
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // step 0: recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bson).errors == 0;
-
     try
     {
         // step 1: parse input
         std::vector<uint8_t> const vec1(data, data + size);
         json const j1 = json::from_bson(vec1);
-        assert(recovered_without_errors);
 
         try
         {
@@ -68,7 +58,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::parse_error&)
     {
         // parse errors are ok, because input may be random bytes
-        assert(!recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -77,7 +66,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::out_of_range&)
     {
         // out of range errors can occur during parsing, too
-        assert(!recovered_without_errors);
     }
 
     // return 0 - non-zero return values are reserved for future use

tests/src/fuzzer-parse_cbor.cpp

@@ -15,10 +15,6 @@ array data, it performs the following steps:
 - j2 = from_cbor(vec)
 - assert(to_cbor(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_cbor() fails (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -31,22 +27,16 @@ drivers.
     #error "the fuzzer drivers must be built without NDEBUG"
 #endif
 
-#include "fuzzer-recovering_checker.hpp"
-
 using json = nlohmann::json;
 
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // step 0: recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::cbor).errors == 0;
-
     try
     {
         // step 1: parse input
         std::vector<uint8_t> const vec1(data, data + size);
         json const j1 = json::from_cbor(vec1);
-        assert(recovered_without_errors);
 
         try
         {
@@ -68,7 +58,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::parse_error&)
     {
         // parse errors are ok, because input may be random bytes
-        assert(!recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -77,7 +66,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::out_of_range&)
     {
         // out of range errors can occur during parsing, too
-        assert(!recovered_without_errors);
     }
 
     // return 0 - non-zero return values are reserved for future use

tests/src/fuzzer-parse_json.cpp

@@ -16,10 +16,6 @@ array data, it performs the following steps:
 - s2 = serialize(j2)
 - assert(s1 == s2)
 
-Furthermore, it parses data with a SAX parser that recovers from every error
-and checks that the events are balanced, that parsing ends, and that valid
-input is parsed without errors (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -32,20 +28,11 @@ drivers.
     #error "the fuzzer drivers must be built without NDEBUG"
 #endif
 
-#include "fuzzer-recovering_checker.hpp"
-
 using json = nlohmann::json;
 
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // step 0: recover from all errors, reading from memory and from a stream
-    {
-        const auto checker = check_recovering_parse(data, size, json::input_format_t::json);
-        assert(checker.events <= (4 * size) + 4);
-        assert((checker.errors == 0) == json::accept(data, data + size));
-    }
-
     try
     {
         // step 1: parse input

tests/src/fuzzer-parse_msgpack.cpp

@@ -15,10 +15,6 @@ array data, it performs the following steps:
 - j2 = from_msgpack(vec)
 - assert(to_msgpack(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_msgpack() fails (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -31,22 +27,16 @@ drivers.
     #error "the fuzzer drivers must be built without NDEBUG"
 #endif
 
-#include "fuzzer-recovering_checker.hpp"
-
 using json = nlohmann::json;
 
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // step 0: recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::msgpack).errors == 0;
-
     try
     {
         // step 1: parse input
         std::vector<uint8_t> const vec1(data, data + size);
         json const j1 = json::from_msgpack(vec1);
-        assert(recovered_without_errors);
 
         try
         {
@@ -68,7 +58,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::parse_error&)
     {
         // parse errors are ok, because input may be random bytes
-        assert(!recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -77,7 +66,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::out_of_range&)
     {
         // out of range errors may happen if provided sizes are excessive
-        assert(!recovered_without_errors);
     }
 
     // return 0 - non-zero return values are reserved for future use

tests/src/fuzzer-parse_ubjson.cpp

@@ -24,10 +24,6 @@ array data, it performs the following steps:
 The unit tests run the same checks on a fixed corpus (see the "UBJSON round-trip
 invariants" test case), so keep both in sync.
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_ubjson() fails (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -40,22 +36,16 @@ drivers.
     #error "the fuzzer drivers must be built without NDEBUG"
 #endif
 
-#include "fuzzer-recovering_checker.hpp"
-
 using json = nlohmann::json;
 
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // step 0: recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::ubjson).errors == 0;
-
     try
     {
         // step 1: parse input
         std::vector<uint8_t> const vec1(data, data + size);
         json const j1 = json::from_ubjson(vec1);
-        assert(recovered_without_errors);
 
         try
         {
@@ -87,7 +77,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::parse_error&)
     {
         // parse errors are ok, because input may be random bytes
-        assert(!recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -96,7 +85,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     catch (const json::out_of_range&)
     {
         // out of range errors may happen if provided sizes are excessive
-        assert(!recovered_without_errors);
     }
 
     // return 0 - non-zero return values are reserved for future use

tests/src/fuzzer-recovering_checker.hpp

@@ -1,154 +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 <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <sstream>
-#include <string>
-#include <vector>
-#include <nlohmann/json.hpp>
-
-namespace
-{
-// a SAX parser that recovers from every error and checks that the events are
-// balanced and that every key is followed by exactly one value
-class recovering_checker : public nlohmann::json_sax<nlohmann::json>
-{
-  public:
-    bool null() override
-    {
-        return value();
-    }
-
-    bool boolean(bool /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_integer(number_integer_t /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_unsigned(number_unsigned_t /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_float(number_float_t /*val*/, const string_t& /*s*/) override
-    {
-        return value();
-    }
-
-    bool string(string_t& /*val*/) override
-    {
-        return value();
-    }
-
-    bool binary(binary_t& /*val*/) override
-    {
-        return value();
-    }
-
-    bool start_object(std::size_t /*elements*/) override
-    {
-        value();
-        stack.push_back('o');
-        return true;
-    }
-
-    bool key(string_t& /*val*/) override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'o');
-        stack.back() = 'v';
-        return true;
-    }
-
-    bool end_object() override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'o');
-        stack.pop_back();
-        return true;
-    }
-
-    bool start_array(std::size_t /*elements*/) override
-    {
-        value();
-        stack.push_back('a');
-        return true;
-    }
-
-    bool end_array() override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'a');
-        stack.pop_back();
-        return true;
-    }
-
-    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const nlohmann::detail::exception& /*ex*/) override
-    {
-        ++errors;
-        return true;
-    }
-
-    bool complete() const
-    {
-        return stack.empty();
-    }
-
-    std::size_t events = 0;
-    std::size_t errors = 0;
-
-  private:
-    bool value()
-    {
-        ++events;
-        if (!stack.empty())
-        {
-            // an array element, or the value of a key
-            assert(stack.back() != 'o');
-            if (stack.back() == 'v')
-            {
-                stack.back() = 'o';
-            }
-        }
-        return true;
-    }
-
-    // 'a' for an array, 'o' for an object that expects a key, 'v' for an
-    // object that expects the value of a key
-    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
-};
-
-/// parses @a data with a recovering_checker from memory and from a stream,
-/// checks that both see the same, that the events are balanced, and that the
-/// number of errors is bounded, and returns the checker (see #3989)
-inline recovering_checker check_recovering_parse(const std::uint8_t* data, const std::size_t size, const nlohmann::json::input_format_t format)
-{
-    recovering_checker checker;
-    const bool ok = nlohmann::json::sax_parse(data, data + size, &checker, format);
-    assert(checker.complete());
-    assert(checker.errors <= size + 1);
-    assert(ok == (checker.errors == 0));
-
-    std::istringstream stream(std::string(reinterpret_cast<const char*>(data), size));
-    recovering_checker stream_checker;
-    assert(nlohmann::json::sax_parse(stream, &stream_checker, format) == ok);
-    assert(stream_checker.complete());
-    assert(stream_checker.events == checker.events);
-    assert(stream_checker.errors == checker.errors);
-
-    return checker;
-}
-} // namespace

tests/src/test_utils.hpp

@@ -10,7 +10,8 @@
 
 #include <cstdint> // uint8_t
 #include <cstddef> // size_t
-#include <fstream> // ifstream, istreambuf_iterator, ios
+#include <fstream> // ifstream, ios
+#include <iterator> // istream_iterator
 #include <vector> // vector
 
 namespace utils

tests/src/unit-allocator.cpp

@@ -567,7 +567,7 @@ struct allocator_no_forward : std::allocator<T>
 {
     allocator_no_forward() = default;
     template <class U>
-    allocator_no_forward(allocator_no_forward<U> /*unused*/) {}
+    allocator_no_forward(const allocator_no_forward<U>& /*unused*/) {}
 
     template <class U>
     struct rebind

tests/src/unit-alt-string.cpp

@@ -424,46 +424,6 @@ TEST_CASE("alternative string type")
         CHECK(j2.dump() == R"({"/foo/0":"bar","/foo/1":"baz"})");
     }
 
-    SECTION("error recovery")
-    {
-        // a SAX parser that recovers from every error (see #3989)
-        struct recovering_parser : nlohmann::detail::json_sax_dom_parser<alt_json>
-        {
-            explicit recovering_parser(alt_json& j)
-                : nlohmann::detail::json_sax_dom_parser<alt_json>(j, false)
-            {}
-
-            // sax_parse() calls the SAX parser's own parse_error(), so hiding
-            // the one of the base class is what recovering takes
-            // NOLINTNEXTLINE(bugprone-derived-method-shadowing-base-method)
-            bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const nlohmann::detail::exception& /*unused*/)
-            {
-                ++errors;
-                return true;
-            }
-
-            std::size_t errors = 0;
-        };
-
-        alt_json j;
-        recovering_parser sax(j);
-        // not inside CHECK(): MSVC reads the escape in a stringized raw string
-        const std::string input = R"([1., "a\qb", tru, {"k" 2}])";
-        CHECK(!alt_json::sax_parse(input, &sax));
-        CHECK(sax.errors == 4);
-        CHECK(j.dump() == R"([1,"aqb",null,{"k":2}])");
-
-        // a UBJSON high-precision number, a CBOR key that is not a string
-        alt_json u;
-        recovering_parser ubjson_sax(u);
-        CHECK(!alt_json::sax_parse(std::vector<std::uint8_t> {'[', 'H', 'i', 2, '1', '.', ']'}, &ubjson_sax, alt_json::input_format_t::ubjson));
-        CHECK(u.dump() == "[1]");
-        alt_json c;
-        recovering_parser cbor_sax(c);
-        CHECK(!alt_json::sax_parse(std::vector<std::uint8_t> {0xA2, 0x01, 0x02, 0x61, 'a', 0x03}, &cbor_sax, alt_json::input_format_t::cbor));
-        CHECK(c.dump() == R"({"a":3})");
-    }
-
     SECTION("conversion between basic_json specializations (#2649)")
     {
         // explicit conversions are always possible

tests/src/unit-binary_utf8_error_handler.cpp

@@ -7,6 +7,7 @@
 // SPDX-License-Identifier: MIT
 
 #include "doctest_compatibility.h"
+#include "test_utils.hpp"
 
 #include <nlohmann/json.hpp>
 using nlohmann::json;
@@ -25,18 +26,27 @@ struct ill_formed_case
 
 // RFC 3629 ill-formed sequences used throughout this file, plus one
 // well-formed sequence for contrast
-const std::vector<ill_formed_case> ill_formed_cases =
+std::vector<ill_formed_case> ill_formed_cases()
 {
-    {"overlong", "\xC0\xAE"},
+    return
-    {"lone_0xFF", "\xFF"},
+    {
-    {"truncated", "\xE2\x82"},
+        {"overlong", "\xC0\xAE"},
-    {"surrogate", "\xED\xA0\x80"},
+        {"lone_0xFF", "\xFF"},
-};
+        {"truncated", "\xE2\x82"},
+        {"surrogate", "\xED\xA0\x80"},
+    };
+}
 
-const std::string valid_sequence = "\xC3\xA9"; // U+00E9, "é"
+std::string valid_sequence()
+{
+    return "\xC3\xA9"; // U+00E9, "é"
+}
 
 using eh = json::error_handler_t;
-const std::vector<eh> all_handlers = {eh::strict, eh::replace, eh::ignore, eh::keep};
+std::vector<eh> all_handlers()
+{
+    return {eh::strict, eh::replace, eh::ignore, eh::keep};
+}
 
 // what dump()+parse() produces for a sanitizing error_handler; this is the
 // ground truth every binary writer/reader is checked against
@@ -51,9 +61,9 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
 {
     SECTION("writers: string value")
     {
-        for (const auto& c : ill_formed_cases)
+        for (const auto& c : ill_formed_cases())
         {
-            CAPTURE(c.name);
+            CAPTURE(c.name)
             const json jval = c.bytes;
 
             CHECK_THROWS_AS(json::to_cbor(jval, eh::strict), json::type_error&);
@@ -71,7 +81,7 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
                         eh::replace, eh::ignore
                     })
             {
-                CAPTURE(static_cast<int>(h));
+                CAPTURE(static_cast<int>(h))
                 const std::string expected = dump_and_parse(c.bytes, h);
 
                 CHECK(json::from_cbor(json::to_cbor(jval, h)).get<std::string>() == expected);
@@ -103,9 +113,9 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
 
     SECTION("writers: object key")
     {
-        for (const auto& c : ill_formed_cases)
+        for (const auto& c : ill_formed_cases())
         {
-            CAPTURE(c.name);
+            CAPTURE(c.name)
             json jobj;
             jobj[c.bytes] = 1;
 
@@ -120,7 +130,7 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
                         eh::replace, eh::ignore
                     })
             {
-                CAPTURE(static_cast<int>(h));
+                CAPTURE(static_cast<int>(h))
                 const std::string expected = dump_and_parse(c.bytes, h);
 
                 CHECK(json::from_cbor(json::to_cbor(jobj, h)).begin().key() == expected);
@@ -141,9 +151,9 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
 
     SECTION("readers: string value")
     {
-        for (const auto& c : ill_formed_cases)
+        for (const auto& c : ill_formed_cases())
         {
-            CAPTURE(c.name);
+            CAPTURE(c.name)
 
             // bytes produced the lenient (keep) way, as any binary reader
             // accepted them before this parameter existed
@@ -166,15 +176,15 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
             CHECK(json::from_bson(bson_bytes)["k"].get<std::string>() == c.bytes);
 
             // strict: parse_error.113, discarded (not thrown) when allow_exceptions is false
-            CHECK_THROWS_AS(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, eh::strict)), json::parse_error&);
             CHECK(json::from_cbor(cbor_bytes, true, false, json::cbor_tag_handler_t::error, eh::strict).is_discarded());
-            CHECK_THROWS_AS(json::from_msgpack(msgpack_bytes, true, true, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_msgpack(msgpack_bytes, true, true, eh::strict)), json::parse_error&);
             CHECK(json::from_msgpack(msgpack_bytes, true, false, eh::strict).is_discarded());
-            CHECK_THROWS_AS(json::from_ubjson(ubjson_bytes, true, true, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_ubjson(ubjson_bytes, true, true, eh::strict)), json::parse_error&);
             CHECK(json::from_ubjson(ubjson_bytes, true, false, eh::strict).is_discarded());
-            CHECK_THROWS_AS(json::from_bjdata(bjdata_bytes, true, true, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_bjdata(bjdata_bytes, true, true, eh::strict)), json::parse_error&);
             CHECK(json::from_bjdata(bjdata_bytes, true, false, eh::strict).is_discarded());
-            CHECK_THROWS_AS(json::from_bson(bson_bytes, true, true, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_bson(bson_bytes, true, true, eh::strict)), json::parse_error&);
             CHECK(json::from_bson(bson_bytes, true, false, eh::strict).is_discarded());
 
             // replace / ignore: match what dump() would have sanitized the same bytes to
@@ -183,7 +193,7 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
                         eh::replace, eh::ignore
                     })
             {
-                CAPTURE(static_cast<int>(h));
+                CAPTURE(static_cast<int>(h))
                 const std::string expected = dump_and_parse(c.bytes, h);
 
                 CHECK(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, h).get<std::string>() == expected);
@@ -197,9 +207,9 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
 
     SECTION("readers: object key")
     {
-        for (const auto& c : ill_formed_cases)
+        for (const auto& c : ill_formed_cases())
         {
-            CAPTURE(c.name);
+            CAPTURE(c.name)
 
             json jobj;
             jobj[c.bytes] = 1;
@@ -215,18 +225,18 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
             CHECK(json::from_bjdata(bjdata_bytes).begin().key() == c.bytes);
             CHECK(json::from_bson(bson_bytes).begin().key() == c.bytes);
 
-            CHECK_THROWS_AS(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, eh::strict)), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(msgpack_bytes, true, true, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_msgpack(msgpack_bytes, true, true, eh::strict)), json::parse_error&);
-            CHECK_THROWS_AS(json::from_ubjson(ubjson_bytes, true, true, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_ubjson(ubjson_bytes, true, true, eh::strict)), json::parse_error&);
-            CHECK_THROWS_AS(json::from_bjdata(bjdata_bytes, true, true, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_bjdata(bjdata_bytes, true, true, eh::strict)), json::parse_error&);
-            CHECK_THROWS_AS(json::from_bson(bson_bytes, true, true, eh::strict), json::parse_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(json::from_bson(bson_bytes, true, true, eh::strict)), json::parse_error&);
 
             for (const auto h :
                     {
                         eh::replace, eh::ignore
                     })
             {
-                CAPTURE(static_cast<int>(h));
+                CAPTURE(static_cast<int>(h))
                 const std::string expected = dump_and_parse(c.bytes, h);
 
                 CHECK(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, h).begin().key() == expected);
@@ -240,30 +250,30 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
 
     SECTION("well-formed UTF-8 is unaffected by error_handler")
     {
-        const json jval = valid_sequence;
+        const json jval = valid_sequence();
         json jobj;
-        jobj[valid_sequence] = valid_sequence;
+        jobj[valid_sequence()] = valid_sequence();
 
-        for (const auto h : all_handlers)
+        for (const auto h : all_handlers())
         {
-            CAPTURE(static_cast<int>(h));
+            CAPTURE(static_cast<int>(h))
 
-            CHECK(json::from_cbor(json::to_cbor(jval, h)).get<std::string>() == valid_sequence);
+            CHECK(json::from_cbor(json::to_cbor(jval, h)).get<std::string>() == valid_sequence());
-            CHECK(json::from_msgpack(json::to_msgpack(jval, h)).get<std::string>() == valid_sequence);
+            CHECK(json::from_msgpack(json::to_msgpack(jval, h)).get<std::string>() == valid_sequence());
-            CHECK(json::from_ubjson(json::to_ubjson(jval, false, false, h)).get<std::string>() == valid_sequence);
+            CHECK(json::from_ubjson(json::to_ubjson(jval, false, false, h)).get<std::string>() == valid_sequence());
-            CHECK(json::from_bjdata(json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, h)).get<std::string>() == valid_sequence);
+            CHECK(json::from_bjdata(json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, h)).get<std::string>() == valid_sequence());
-            CHECK(json::from_bson(json::to_bson(jobj, h)).begin().key() == valid_sequence);
+            CHECK(json::from_bson(json::to_bson(jobj, h)).begin().key() == valid_sequence());
 
-            CHECK(json::from_cbor(json::to_cbor(jval, eh::keep), true, true, json::cbor_tag_handler_t::error, h).get<std::string>() == valid_sequence);
+            CHECK(json::from_cbor(json::to_cbor(jval, eh::keep), true, true, json::cbor_tag_handler_t::error, h).get<std::string>() == valid_sequence());
-            CHECK(json::from_msgpack(json::to_msgpack(jval), true, true, h).get<std::string>() == valid_sequence);
+            CHECK(json::from_msgpack(json::to_msgpack(jval), true, true, h).get<std::string>() == valid_sequence());
         }
     }
 
     SECTION("dump() with error_handler_t::keep writes raw bytes as is")
     {
-        for (const auto& c : ill_formed_cases)
+        for (const auto& c : ill_formed_cases())
         {
-            CAPTURE(c.name);
+            CAPTURE(c.name)
 
             const json jval = c.bytes;
             const std::string dumped = jval.dump(-1, ' ', false, eh::keep);
@@ -276,10 +286,10 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
 
         // well-formed characters around an ill-formed sequence are still
         // escaped as usual under ensure_ascii
-        const json mixed = valid_sequence + ill_formed_cases[1].bytes; // "é" + lone 0xFF
+        const json mixed = valid_sequence() + ill_formed_cases()[1].bytes; // "é" + lone 0xFF
         const std::string dumped_mixed = mixed.dump(-1, ' ', true, eh::keep);
         CHECK(dumped_mixed.find("\\u00e9") != std::string::npos);
-        CHECK(dumped_mixed.find(ill_formed_cases[1].bytes) != std::string::npos);
+        CHECK(dumped_mixed.find(ill_formed_cases()[1].bytes) != std::string::npos);
 
         // the byte that ends an ill-formed sequence is read again, so a quote,
         // a backslash, or a control character after it is still escaped, and
@@ -289,7 +299,7 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
                     false, true
                 })
         {
-            CAPTURE(ensure_ascii);
+            CAPTURE(ensure_ascii)
             CHECK(json("\xC3\"").dump(-1, ' ', ensure_ascii, eh::keep) == "\"\xC3\\\"\"");
             CHECK(json("\xC3\\").dump(-1, ' ', ensure_ascii, eh::keep) == "\"\xC3\\\\\"");
             CHECK(json("\xC3\n").dump(-1, ' ', ensure_ascii, eh::keep) == "\"\xC3\\n\"");
@@ -303,12 +313,12 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
 
     SECTION("to_msgpack defaults to keep; to_bon8 is not affected by error_handler")
     {
-        const json jval = ill_formed_cases[1].bytes; // lone 0xFF
+        const json jval = ill_formed_cases()[1].bytes; // lone 0xFF
 
         // to_msgpack's error_handler defaults to keep, as MessagePack's spec
         // allows any bytes in a str, so the bytes are passed through
         CHECK(json::to_msgpack(jval) == json::to_msgpack(jval, eh::keep));
-        CHECK(json::from_msgpack(json::to_msgpack(jval)).get<std::string>() == ill_formed_cases[1].bytes);
+        CHECK(json::from_msgpack(json::to_msgpack(jval)).get<std::string>() == ill_formed_cases()[1].bytes);
 
         // the diagnostics context of an ill-formed key is the object
         json jobj;
@@ -322,14 +332,14 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
 
     SECTION("allow_exceptions=false with error_handler_t::strict discards the value")
     {
-        const auto bytes = json::to_cbor(json(ill_formed_cases[0].bytes), eh::keep);
+        const auto bytes = json::to_cbor(json(ill_formed_cases()[0].bytes), eh::keep);
         const json result = json::from_cbor(bytes, true, false, json::cbor_tag_handler_t::error, eh::strict);
         CHECK(result.is_discarded());
     }
 
     SECTION("default parameters are unchanged")
     {
-        const json jval = ill_formed_cases[0].bytes;
+        const json jval = ill_formed_cases()[0].bytes;
 
         // to_*: the default error_handler is keep, so ill-formed bytes are
         // written unchanged, exactly as in release 3.12.0 (it is strict only
@@ -347,16 +357,16 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
         // from_*: the default error_handler is keep, so ill-formed bytes are
         // still accepted unchanged, exactly as in release 3.12.0
         const auto cbor_bytes = json::to_cbor(jval, eh::keep);
-        CHECK(json::from_cbor(cbor_bytes).get<std::string>() == ill_formed_cases[0].bytes);
+        CHECK(json::from_cbor(cbor_bytes).get<std::string>() == ill_formed_cases()[0].bytes);
         const auto ubjson_bytes = json::to_ubjson(jval, false, false, eh::keep);
-        CHECK(json::from_ubjson(ubjson_bytes).get<std::string>() == ill_formed_cases[0].bytes);
+        CHECK(json::from_ubjson(ubjson_bytes).get<std::string>() == ill_formed_cases()[0].bytes);
         const auto bjdata_bytes = json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, eh::keep);
-        CHECK(json::from_bjdata(bjdata_bytes).get<std::string>() == ill_formed_cases[0].bytes);
+        CHECK(json::from_bjdata(bjdata_bytes).get<std::string>() == ill_formed_cases()[0].bytes);
         const auto msgpack_bytes = json::to_msgpack(jval);
-        CHECK(json::from_msgpack(msgpack_bytes).get<std::string>() == ill_formed_cases[0].bytes);
+        CHECK(json::from_msgpack(msgpack_bytes).get<std::string>() == ill_formed_cases()[0].bytes);
         json bson_obj;
         bson_obj["k"] = jval;
         const auto bson_bytes = json::to_bson(bson_obj, eh::keep);
-        CHECK(json::from_bson(bson_bytes)["k"].get<std::string>() == ill_formed_cases[0].bytes);
+        CHECK(json::from_bson(bson_bytes)["k"].get<std::string>() == ill_formed_cases()[0].bytes);
     }
 }

tests/src/unit-binary_utf8_strict.cpp

@@ -83,21 +83,45 @@ TEST_CASE("JSON_STRICT_BINARY_UTF8 (see #5529, #5651)")
         // any bytes reach the output adapter (the BSON document length
         // prefix must be known up front, so nothing is written incrementally)
         std::vector<std::uint8_t> out{0x42}; // a sentinel byte the writer must not touch
-        CHECK_THROWS_WITH_AS(json::to_bson(json{{"s", "\xFF"}}, nlohmann::detail::output_adapter<std::uint8_t>(out)), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#if JSON_DIAGNOSTICS
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xFF"}}, nlohmann::detail::output_adapter<std::uint8_t>(out)), "[json.exception.type_error.316] (/s) invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#else
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xFF"}}, nlohmann::detail::output_adapter<std::uint8_t>(out)), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#endif
         CHECK(out == std::vector<std::uint8_t> {0x42});
 
-        CHECK_THROWS_WITH_AS(json::to_bson(json{{"s", "\xFF"}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#if JSON_DIAGNOSTICS
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xFF"}}), "[json.exception.type_error.316] (/s) invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#else
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xFF"}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#endif
         // a truncated multi-byte sequence
-        CHECK_THROWS_WITH_AS(json::to_bson(json{{"s", "\xC3"}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xC3", json::type_error&);
+#if JSON_DIAGNOSTICS
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xC3"}}), "[json.exception.type_error.316] (/s) invalid UTF-8 byte at index 0: 0xC3", json::type_error&);
+#else
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xC3"}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xC3", json::type_error&);
+#endif
         // an encoded surrogate half (U+D800)
-        CHECK_THROWS_WITH_AS(json::to_bson(json{{"s", "\xED\xA0\x80"}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xED", json::type_error&);
+#if JSON_DIAGNOSTICS
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xED\xA0\x80"}}), "[json.exception.type_error.316] (/s) invalid UTF-8 byte at index 0: 0xED", json::type_error&);
+#else
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xED\xA0\x80"}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xED", json::type_error&);
+#endif
         // an overlong encoding of '.'
-        CHECK_THROWS_WITH_AS(json::to_bson(json{{"s", "\xC0\xAF"}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xC0", json::type_error&);
+#if JSON_DIAGNOSTICS
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xC0\xAF"}}), "[json.exception.type_error.316] (/s) invalid UTF-8 byte at index 0: 0xC0", json::type_error&);
+#else
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"s", "\xC0\xAF"}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xC0", json::type_error&);
+#endif
 
         // an object key with ill-formed UTF-8 is rejected as well; unlike
         // the reader (which never validates element names), the writer
         // checks both string values and object keys
-        CHECK_THROWS_WITH_AS(json::to_bson(json{{"\xFF", 1}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#if JSON_DIAGNOSTICS
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"\xFF", 1}}), "[json.exception.type_error.316] (/\xFF) invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#else
+        CHECK_THROWS_WITH_AS(json::to_bson(json {{"\xFF", 1}}), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
+#endif
     }
 
     SECTION("an explicit error_handler overrides the default")

tests/src/unit-bjdata.cpp

@@ -3921,7 +3921,7 @@ TEST_CASE("Universal Binary JSON Specification Examples 1")
             CHECK_NOTHROW(j = json::from_bjdata(v));
             REQUIRE(j.is_string());
             CHECK(j.get_ref<const json::string_t&>() == std::string("\xc0\xae"));
-            CHECK_THROWS_AS(j.dump(), json::type_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
             CHECK(json::from_bjdata(json::to_bjdata(j)) == j);
 
             // the same bytes as an object key round-trip as well

tests/src/unit-bon8.cpp

@@ -786,6 +786,7 @@ TEST_CASE("Parse BON8 directly from a file using iterator and sentinel")
     CHECK((parsed.is_object() || parsed.is_array()));
 }
 
+#if !defined(JSON_NOEXCEPTION) // corpus values that do not survive the round trip are skipped by catching the exception
 TEST_CASE("BON8 round-trip invariants")
 {
     // This checks what the parse_bon8_fuzzer driver checks (see
@@ -818,6 +819,7 @@ TEST_CASE("BON8 round-trip invariants")
         CHECK(json::to_bon8(j2) == vec);
     }
 }
+#endif
 
 TEST_CASE("BON8 roundtrips" * doctest::skip())
 {

tests/src/unit-bson.cpp

@@ -62,6 +62,8 @@ class huge_string_t : public std::string
 {
   public:
     using std::string::string;
+    // inheriting std::string's constructors does not inherit its default constructor
+    huge_string_t() = default;
     huge_string_t(const std::string& s) : std::string(s) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
 
     // returns a copy of @a s whose size() pretends to be huge
@@ -174,7 +176,7 @@ TEST_CASE("BSON")
         REQUIRE(j.contains("s"));
         CHECK(j["s"].get_ref<const json::string_t&>() == std::string("\xc0\xae"));
         // dump() still requires valid UTF-8 and throws for such a value
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
         // to_bson() writes the bytes back unchanged, as before 3.13.0,
         // unless JSON_STRICT_BINARY_UTF8 is enabled (see unit-binary_utf8_strict.cpp)
         CHECK(json::from_bson(json::to_bson(j)) == j);

tests/src/unit-cbor.cpp

@@ -1820,7 +1820,7 @@ TEST_CASE("CBOR")
             // dump() still requires valid UTF-8 and throws for such a value,
             // unless an error handler that replaces or ignores the bytes is
             // passed
-            CHECK_THROWS_AS(j_value.dump(), json::type_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(j_value.dump()), json::type_error&);
             // to_cbor() writes the bytes back unchanged, as before 3.13.0,
             // unless JSON_STRICT_BINARY_UTF8 is enabled (see unit-binary_utf8_strict.cpp)
             CHECK(json::from_cbor(json::to_cbor(j_value)) == j_value);
@@ -1878,13 +1878,13 @@ TEST_CASE("CBOR")
             // a truncated code point is kept as is
             CHECK_NOTHROW(_ = json::from_cbor(std::vector<uint8_t>({0x7f, 0x61, 0xc3, 0xff})));
             CHECK(_ == "\xc3");
-            CHECK_THROWS_AS(_.dump(), json::type_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(_.dump()), json::type_error&);
             CHECK(json::from_cbor(json::to_cbor(_)) == _);
 
             // an ill-formed later chunk is kept after valid ones
             CHECK_NOTHROW(_ = json::from_cbor(std::vector<uint8_t>({0x7f, 0x62, 0xc3, 0xa9, 0x62, 0xc0, 0xae, 0xff})));
             CHECK(_ == "\xc3\xa9\xc0\xae");
-            CHECK_THROWS_AS(_.dump(), json::type_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(_.dump()), json::type_error&);
 
             // valid multi-byte chunks are accepted
             CHECK(json::from_cbor(std::vector<uint8_t>({0x7f, 0x62, 0xc3, 0xa9, 0x62, 0xc3, 0xb6, 0xff})) == "\xc3\xa9\xc3\xb6");
@@ -2390,6 +2390,7 @@ TEST_CASE("issue #5405 - array reserve for definite-length CBOR arrays")
     }
 }
 
+#if !defined(JSON_NOEXCEPTION) // corpus values that do not survive the round trip are skipped by catching the exception
 TEST_CASE("CBOR round-trip invariants")
 {
     // This checks what the parse_cbor_fuzzer driver checks (see
@@ -2422,6 +2423,7 @@ TEST_CASE("CBOR round-trip invariants")
         CHECK(json::to_cbor(j2) == vec);
     }
 }
+#endif
 
 TEST_CASE("CBOR roundtrips" * doctest::skip())
 {

tests/src/unit-class_parser.cpp

@@ -143,13 +143,11 @@ class SaxEventLogger
     {
         errored = true;
         events.push_back("parse_error(" + std::to_string(position) + ")");
-        return recover;
+        return false;
     }
 
     std::vector<std::string> events {}; // NOLINT(readability-redundant-member-init)
     bool errored = false;
-    /// whether parse_error() asks the parser to recover from the error (see #3989)
-    bool recover = false;
 };
 
 class SaxCountdown : public nlohmann::json::json_sax_t
@@ -2706,9 +2704,9 @@ TEST_CASE("diagnostic positions: value lifetime, input adapters, and SAX")
             CHECK(b["b"].end_pos() == nested_end);
 
             // the moved-from value is reset to a null and reports npos
-            CHECK(a.is_null()); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
+            CHECK(a.is_null()); // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved,clang-analyzer-cplusplus.Move)
-            CHECK(a.start_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
+            CHECK(a.start_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved,clang-analyzer-cplusplus.Move)
-            CHECK(a.end_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
+            CHECK(a.end_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved,clang-analyzer-cplusplus.Move)
         }
 
         SECTION("swap() exchanges positions along with values")
@@ -2976,583 +2974,3 @@ TEST_CASE("diagnostic positions: value lifetime, input adapters, and SAX")
     }
 }
 #endif
-
-namespace
-{
-/// builds a value like json::parse(), but asks the parser to recover from
-/// errors (see #3989), and checks that the events it receives are balanced
-class RecoveringDomParser
-{
-  public:
-    explicit RecoveringDomParser(json& j, std::size_t max_errors_ = static_cast<std::size_t>(-1))
-        : dom(j, false)
-        , max_errors(max_errors_)
-    {}
-
-    bool null()
-    {
-        value();
-        return dom.null();
-    }
-
-    bool boolean(bool val)
-    {
-        value();
-        return dom.boolean(val);
-    }
-
-    bool number_integer(json::number_integer_t val)
-    {
-        value();
-        return dom.number_integer(val);
-    }
-
-    bool number_unsigned(json::number_unsigned_t val)
-    {
-        value();
-        return dom.number_unsigned(val);
-    }
-
-    bool number_float(json::number_float_t val, const std::string& s)
-    {
-        value();
-        return dom.number_float(val, s);
-    }
-
-    bool string(std::string& val)
-    {
-        value();
-        return dom.string(val);
-    }
-
-    bool binary(json::binary_t& val)
-    {
-        value();
-        return dom.binary(val);
-    }
-
-    bool start_object(std::size_t elements)
-    {
-        value();
-        stack.push_back('o');
-        return dom.start_object(elements);
-    }
-
-    bool key(std::string& val)
-    {
-        ++events;
-        if (stack.empty() || stack.back() != 'o')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.back() = 'v';
-        return dom.key(val);
-    }
-
-    bool end_object()
-    {
-        ++events;
-        if (stack.empty() || stack.back() != 'o')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.pop_back();
-        return dom.end_object();
-    }
-
-    bool start_array(std::size_t elements)
-    {
-        value();
-        stack.push_back('a');
-        return dom.start_array(elements);
-    }
-
-    bool end_array()
-    {
-        ++events;
-        if (stack.empty() || stack.back() != 'a')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.pop_back();
-        return dom.end_array();
-    }
-
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const json::exception& ex)
-    {
-        errors.emplace_back(ex.what());
-        return errors.size() < max_errors;
-    }
-
-    /// whether the events were balanced and every key was followed by a value
-    bool balanced() const
-    {
-        return well_formed && stack.empty();
-    }
-
-    /// builds the value
-    nlohmann::detail::json_sax_dom_parser<json> dom;
-    std::vector<std::string> errors {}; // NOLINT(readability-redundant-member-init)
-    std::size_t events = 0;
-    /// the open containers: 'a' for an array, 'o' for an object that expects
-    /// a key, 'v' for an object that expects the value of a key
-    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
-    bool well_formed = true;
-    std::size_t max_errors;
-
-  private:
-    /// a value is passed: it is an array element, or the value of a key
-    void value()
-    {
-        ++events;
-        if (!stack.empty())
-        {
-            if (stack.back() == 'v')
-            {
-                stack.back() = 'o';
-            }
-            else if (stack.back() == 'o')
-            {
-                // a value without a key
-                well_formed = false;
-            }
-        }
-    }
-
-};
-
-struct RecoveryResult
-{
-    json value;
-    std::vector<std::string> errors;
-    std::size_t events;
-    bool ok;
-    bool balanced;
-};
-
-template<typename InputType>
-RecoveryResult parse_recovering(InputType&& input, const bool strict = true,
-                                const bool ignore_comments = false, const bool ignore_trailing_commas = false)
-{
-    json j;
-    RecoveringDomParser sax(j);
-    const bool ok = json::sax_parse(std::forward<InputType>(input), &sax, json::input_format_t::json,
-                                    strict, ignore_comments, ignore_trailing_commas);
-    return {j, sax.errors, sax.events, ok, sax.balanced()};
-}
-
-/// stops after a number of events, but recovers from errors
-class RecoveringCountdown : public SaxCountdown
-{
-  public:
-    using SaxCountdown::SaxCountdown;
-
-    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const json::exception& /*ex*/) override
-    {
-        return true;
-    }
-};
-
-/// a repaired input: the value it is repaired to, and the number of errors
-struct Repair
-{
-    const char* input;
-    const char* expected;
-    std::size_t errors;
-};
-} // namespace
-
-TEST_CASE("parser error recovery (#3989)")
-{
-    SECTION("repairs")
-    {
-        const std::vector<Repair> repairs =
-        {
-            // a missing separator is inserted
-            {"[1 2]", "[1,2]", 1},
-            {R"({"a":1 "b":2})", R"({"a":1,"b":2})", 1},
-            {R"({"a" 1})", R"({"a":1})", 1},
-            {"[1 tru 2]", "[1,null,2]", 2},
-            {R"({"a" "b": 1})", R"({"a":"b"})", 2},
-
-            // a missing value is null in an object; in an array, a ',' stands
-            // for null, while an array that ends there just ends
-            {R"({"a":})", R"({"a":null})", 1},
-            {R"({"a"})", R"({"a":null})", 1},
-            {R"({"a","b":1})", R"({"a":null,"b":1})", 1},
-            {"[1,,2]", "[1,null,2]", 1},
-            {"[,1]", "[null,1]", 1},
-            {"[1,]", "[1]", 1},
-            {"[1,2,3,]", "[1,2,3]", 1},
-            {R"({"a":1,})", R"({"a":1})", 1},
-
-            // a broken string keeps what can be read
-            {R"(["a\qb"])", R"(["aqb"])", 1},
-            {R"({"na\me":1})", R"({"name":1})", 1},
-            {"[\"\xFF\"]", R"(["\uFFFD"])", 1},
-            {"[\"a\xC3(\"]", R"(["a\uFFFD("])", 1},
-            {"[\"\xE2\x82\"]", R"(["\uFFFD"])", 1},
-            {"[\"\xC3\\\\\", 1]", R"(["\uFFFD\\",1])", 1},
-            {R"(["\u12"])", R"(["\uFFFD"])", 1},
-            {R"(["\u12G4"])", R"(["\uFFFDG4"])", 1},
-            {R"(["\uDC00x"])", R"(["\uFFFDx"])", 1},
-            {R"(["\uD800x"])", R"(["\uFFFDx"])", 1},
-            {R"(["\uD800\u0041"])", R"(["\uFFFDA"])", 1},
-            {R"(["\uD800\uD800\uDC00"])", R"(["\uFFFD\uD800\uDC00"])", 1},
-            {R"(["\uD800\uD800\uD800x"])", R"(["\uFFFD\uFFFD\uFFFDx"])", 1},
-            {
-                R"(["\uD800\"x", 1])", R"(["\uFFFD\"x",1])", 1
-            },
-            {R"(["\uD800\q"])", R"(["\uFFFDq"])", 1},
-            {"[\"a\tb\"]", R"(["a\tb"])", 1},
-            {R"(["a\qb\u0041\x"])", R"(["aqbAx"])", 1},
-
-            // a broken number keeps its longest valid prefix
-            {"[1.]", "[1]", 1},
-            {"[-2.]", "[-2]", 1},
-            {"[1.5e]", "[1.5]", 1},
-            {"[1e+]", "[1]", 1},
-            {"[1.x2, 3]", "[1,3]", 1},
-
-            // what cannot be read at all is null
-            {"[1,NaN,3]", "[1,null,3]", 1},
-            {"[tru]", "[null]", 1},
-            {"[-]", "[null]", 1},
-            {R"({"a":Infinity})", R"({"a":null})", 1},
-
-            // a stray token is dropped
-            {"[:1]", "[1]", 1},
-            {R"(["a":1])", R"(["a",1])", 1},
-            {R"({"a"::1})", R"({"a":1})", 1},
-
-            // a member that cannot be read is skipped
-            {R"({1:2,"b":3})", R"({"b":3})", 1},
-            {R"({"a":1 2})", R"({"a":1})", 1},
-            {R"({,"a":1})", R"({"a":1})", 1},
-            {R"({"a":1,,"b":2})", R"({"a":1,"b":2})", 1},
-            {"{a:1}", "{}", 1},
-            {R"({"a":1 [1,{"b":2}], "c":3})", R"({"a":1,"c":3})", 1},
-            {R"([{1}, "a"])", R"([{},"a"])", 1},
-
-            // a wrong closing bracket closes the innermost container
-            {R"({"a":[1,2}, "b":3})", R"({"a":[1,2],"b":3})", 1},
-            {R"([{"a":1], 2])", R"([{"a":1},2])", 1},
-            {"{]", "{}", 1},
-            {"[}", "[]", 1},
-
-            // the end of the input closes all containers
-            {R"({"a":[1,2)", R"({"a":[1,2]})", 1},
-            {"[", "[]", 1},
-            {"{", "{}", 1},
-            {R"({"a")", R"({"a":null})", 1},
-            {R"({"a":)", R"({"a":null})", 1},
-            {"[1,", "[1]", 1},
-            {"[[[1", "[[[1]]]", 1},
-            {
-                R"(["abc)", R"(["abc"])", 2
-            },
-            {"[1,tr", "[1,null]", 2},
-            {"\"abc", "\"abc\"", 1},
-            {"[\"ab\ncd\"]", R"(["ab",null,"]"])", 4},
-
-            // what comes before the top-level value is skipped
-            {")]}'\n{\"a\":1}", R"({"a":1})", 1},
-            {R"(data: {"a":1})", R"({"a":1})", 1},
-            {"\xEF\xBB[1]", "[1]", 1},
-
-            // what comes after it is an error that ends parsing
-            {R"({"a":1}})", R"({"a":1})", 1},
-            {"[1}]", "[1]", 2},
-            {"[1] [2]", "[1]", 1},
-        };
-
-        for (const auto& repair : repairs)
-        {
-            CAPTURE(repair.input)
-            const auto result = parse_recovering(std::string(repair.input));
-            CHECK(!result.ok);
-            CHECK(result.balanced);
-            CHECK(result.value == json::parse(repair.expected));
-            CHECK(result.errors.size() == repair.errors);
-        }
-    }
-
-    SECTION("number overflow")
-    {
-        const auto result = parse_recovering(std::string("[1e999,-1e999]"));
-        CHECK(!result.ok);
-        CHECK(result.balanced);
-        CHECK(result.errors.size() == 2);
-        CHECK(result.errors[0] == "[json.exception.out_of_range.406] number overflow parsing '1e999'");
-        REQUIRE(result.value.size() == 2);
-        CHECK(result.value[0].is_number_float());
-        CHECK(result.value[0].get<double>() == std::numeric_limits<double>::infinity());
-        CHECK(result.value[1].get<double>() == -std::numeric_limits<double>::infinity());
-
-        // the SAX parser gets the number's text
-        SaxEventLogger logger;
-        logger.recover = true;
-        CHECK(!json::sax_parse("1e999", &logger));
-        CHECK(logger.events == std::vector<std::string>({"parse_error(5)", "number_float(1e999)"}));
-    }
-
-    SECTION("nothing to recover")
-    {
-        for (const std::string s :
-                {
-                    "", "   ", "]", "tru", "NaN", ",:", "/* comment"
-                })
-        {
-            CAPTURE(s)
-            const auto result = parse_recovering(s, true, true);
-            CHECK(!result.ok);
-            CHECK(result.balanced);
-            CHECK(result.events == 0);
-            CHECK(result.value == nullptr);
-            CHECK(result.errors.size() == 1);
-        }
-    }
-
-    SECTION("error messages")
-    {
-        // the first error is reported as without recovery
-        for (const std::string s :
-                {
-                    "[1 2]", R"({"a":1 "b":2})", R"({"a" 1})", R"({"a":})", "[1,]", "[1.]",
-                    R"(["a\qb"])", "[1e999]", "{1:2}", R"({"a":[1,2}})", "[1,", "[1] [2]", "{a:1}"
-                })
-        {
-            CAPTURE(s)
-            const auto result = parse_recovering(s);
-            REQUIRE(!result.errors.empty());
-            json _;
-            CHECK_THROWS_WITH_STD_STR(_ = json::parse(s), result.errors.front());
-        }
-
-        // the token of an error begins where the previous error was
-        const auto result = parse_recovering(std::string("[tru, fals, nul]"));
-        CHECK(result.errors == std::vector<std::string>(
-        {
-            "[json.exception.parse_error.101] parse error at line 1, column 5: syntax error while parsing value - invalid literal; last read: '[tru,'",
-            "[json.exception.parse_error.101] parse error at line 1, column 11: syntax error while parsing value - invalid literal; last read: ', fals,'",
-            "[json.exception.parse_error.101] parse error at line 1, column 16: syntax error while parsing value - invalid literal; last read: ', nul]'"
-        }));
-        CHECK(result.value == json::parse("[null,null,null]"));
-    }
-
-    SECTION("events")
-    {
-        // see #4522
-        SaxEventLogger logger;
-        logger.recover = true;
-        CHECK(!json::sax_parse(R"([{1}, "a"])", &logger));
-        CHECK(logger.events == std::vector<std::string>(
-        {
-            "start_array()", "start_object()", "parse_error(3)", "end_object()", "string(a)", "end_array()"
-        }));
-    }
-
-    SECTION("options")
-    {
-        SECTION("strict")
-        {
-            const auto result = parse_recovering(std::string("[1 2] [3]"), false);
-            CHECK(!result.ok);
-            CHECK(result.value == json::parse("[1,2]"));
-            CHECK(result.errors.size() == 1);
-        }
-
-        SECTION("ignore_trailing_commas")
-        {
-            for (const std::string s :
-                    {
-                        "[1,]", R"({"a":1,})", "[[1,],]"
-                    })
-            {
-                CAPTURE(s)
-                const auto result = parse_recovering(s, true, false, true);
-                CHECK(result.ok);
-                CHECK(result.errors.empty());
-            }
-
-            auto result = parse_recovering(std::string("[1,,]"), true, false, true);
-            CHECK(result.value == json::parse("[1,null]"));
-            CHECK(result.errors.size() == 1);
-
-            result = parse_recovering(std::string(R"({"a":1,,})"), true, false, true);
-            CHECK(result.value == json::parse(R"({"a":1})"));
-            CHECK(result.errors.size() == 1);
-        }
-
-        SECTION("ignore_comments")
-        {
-            auto result = parse_recovering(std::string("[1 /* one */ 2]"), true, true);
-            CHECK(result.value == json::parse("[1,2]"));
-            CHECK(result.errors.size() == 1);
-
-            // a comment that is not closed runs to the end of the input, which
-            // is not reported again
-            result = parse_recovering(std::string("[1, 2 /* unterminated"), true, true);
-            CHECK(result.balanced);
-            CHECK(result.value == json::parse("[1,2]"));
-            CHECK(result.errors.size() == 1);
-
-            // a '/' that does not begin a comment is garbage
-            result = parse_recovering(std::string("[1, /x, 2]"), true, true);
-            CHECK(result.balanced);
-            CHECK(result.value == json::parse("[1,null,2]"));
-            CHECK(result.errors.size() == 1);
-        }
-    }
-
-    SECTION("null bytes")
-    {
-        // a null byte ends the input, unless JSON_STRICT_NUL_HANDLING is set
-        const auto result = parse_recovering(std::string("[1,\0x", 5));
-        CHECK(result.balanced);
-        CHECK(!result.ok);
-#ifdef JSON_TEST_STRICT_NUL_HANDLING_ENABLED
-        CHECK(result.value == json::parse("[1,null]"));
-#else
-        CHECK(result.value == json::parse("[1]"));
-        CHECK(result.errors.size() == 1);
-#endif
-
-        const auto in_string = parse_recovering(std::string("[\"a\0b\"]", 7));
-        CHECK(in_string.balanced);
-#ifdef JSON_TEST_STRICT_NUL_HANDLING_ENABLED
-        CHECK(in_string.value == json::array({std::string("a\0b", 3)}));
-#else
-        CHECK(in_string.value == json::parse(R"(["a"])"));
-#endif
-    }
-
-    SECTION("the SAX parser stops recovering")
-    {
-        json j;
-        RecoveringDomParser sax(j, 2);
-        CHECK(!json::sax_parse("[1 2 3 4 5]", &sax));
-        CHECK(sax.errors.size() == 2);
-
-        // an error at a delimiter that an invalid token consumed is reported
-        // to the SAX parser, too
-        json j2;
-        RecoveringDomParser sax2(j2, 2);
-        CHECK(!json::sax_parse("[tru}, 1]", &sax2));
-        CHECK(sax2.errors.size() == 2);
-    }
-
-    SECTION("an event stops parsing during a repair")
-    {
-        // start_object() and key() are passed, then null() for the missing
-        // value returns false
-        RecoveringCountdown countdown(2);
-        CHECK(!json::sax_parse(R"({"a":})", &countdown));
-
-        // the end of the input: end_array() for the second array returns false
-        RecoveringCountdown countdown2(4);
-        CHECK(!json::sax_parse("[[1", &countdown2));
-    }
-
-    SECTION("input adapters")
-    {
-        // the lexer reads contiguous and streaming input differently, and it
-        // puts back a character that ended an invalid token
-        for (const std::string s :
-                {
-                    "[1 2]", "[tru}, 1]", R"({"a" "b\q", "c":[1.x, 2}})", "[\"\xFF\xC3(\", -, 1e+]", "{a:1,\"b\":2", ")]}' [1]"
-                })
-        {
-            CAPTURE(s)
-            const auto reference = parse_recovering(s);
-            CHECK(reference.balanced);
-
-            const auto from_c_string = parse_recovering(s.c_str());
-            CHECK(from_c_string.value == reference.value);
-            CHECK(from_c_string.errors == reference.errors);
-
-            const std::list<char> l(s.begin(), s.end());
-            json j;
-            RecoveringDomParser sax(j);
-            CHECK(!json::sax_parse(l.begin(), l.end(), &sax));
-            CHECK(j == reference.value);
-            CHECK(sax.errors == reference.errors);
-
-            std::istringstream ss(s);
-            const auto from_stream = parse_recovering(ss);
-            CHECK(from_stream.value == reference.value);
-            CHECK(from_stream.errors == reference.errors);
-        }
-    }
-
-    SECTION("long runs of errors")
-    {
-        // no error may copy all the input read before it
-        const auto closing = parse_recovering("[" + std::string(100000, '}'));
-        CHECK(closing.balanced);
-        CHECK(closing.value == json::array());
-
-        const auto garbage = parse_recovering("[" + std::string(100000, 'x') + "]");
-        CHECK(garbage.balanced);
-        CHECK(garbage.errors.size() == 1);
-
-        const auto commas = parse_recovering("{" + std::string(100000, ',') + "}");
-        CHECK(commas.balanced);
-        CHECK(commas.value == json::object());
-    }
-
-    SECTION("mutations of valid input")
-    {
-        // whatever the input, the events are balanced, every error is reported
-        // at most once, and valid input is parsed as usual
-        const std::vector<std::string> documents =
-        {
-            R"({"name": "value", "list": [1, -2.5, true, null, {"x": [[]]}], "e": "\u00e9"})",
-            R"([{"a": [1, 2, {"b": "c"}]}, [], {}, "\ud83d\ude00", 1e10])",
-            "{\"\xC3\xA9\": \"\xF0\x9F\x98\x80\"}",
-            R"(  {"k" : [ "v" , 0 ] }  )",
-        };
-        // each character that can be inserted, including a null byte
-        const std::string insertions("[]{},:\"x\\\0\xFF", 11);
-
-        std::vector<std::string> inputs;
-        for (const auto& doc : documents)
-        {
-            for (std::size_t i = 0; i <= doc.size(); ++i)
-            {
-                inputs.push_back(doc.substr(0, i));
-                if (i < doc.size())
-                {
-                    inputs.push_back(doc.substr(0, i) + doc.substr(i + 1));
-                }
-                for (const char c : insertions)
-                {
-                    inputs.push_back(doc.substr(0, i) + c + doc.substr(i));
-                }
-            }
-        }
-
-        for (const auto& s : inputs)
-        {
-            CAPTURE(s)
-            const auto result = parse_recovering(s);
-            CHECK(result.balanced);
-            CHECK(result.errors.size() <= s.size() + 1);
-            CHECK(result.events <= (4 * s.size()) + 4);
-            if (json::accept(s))
-            {
-                CHECK(result.ok);
-                CHECK(result.errors.empty());
-                CHECK(result.value == json::parse(s));
-            }
-            else
-            {
-                CHECK(!result.ok);
-                CHECK(!result.errors.empty());
-            }
-        }
-    }
-}

tests/src/unit-comparison.cpp

@@ -969,7 +969,7 @@ TEST_CASE("copying an object preserves its comparator's state")
 
     for (const std::size_t depth : std::vector<std::size_t> {0, 127, 128, 200})
     {
-        CAPTURE(depth);
+        CAPTURE(depth)
 
         key_case_json original = object;
         for (std::size_t i = 0; i < depth; ++i)
@@ -1138,7 +1138,7 @@ TEST_CASE("operator<=> of binary values with a different subtype does not depend
     // and must still agree with the levels that do
     for (const std::size_t depth : std::vector<std::size_t> {0, 127, 128, 200})
     {
-        CAPTURE(depth);
+        CAPTURE(depth)
         const json x = deep(a, depth);
         const json y = deep(b, depth);
         CHECK((x <=> y) == std::partial_ordering::less); // *NOPAD*

tests/src/unit-conversions1.cpp

@@ -15,11 +15,6 @@
 
 #include "doctest_compatibility.h"
 
-// skip tests if JSON_DisableEnumSerialization=ON (#4384)
-#if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
-    #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
-#endif
-
 #define JSON_TESTS_PRIVATE
 #include <nlohmann/json.hpp>
 using nlohmann::json;
@@ -1259,808 +1254,8 @@ TEST_CASE("value conversion")
         }
     }
 #endif
-
-    SECTION("get a binary value (explicit)")
-    {
-        json::binary_t const n_reference{{1, 2, 3}};
-        json j(n_reference);
-
-        SECTION("binary_t")
-        {
-            json::binary_t const b = j.get<json::binary_t>();
-            CHECK(*json(b).m_data.m_value.binary == *j.m_data.m_value.binary);
-        }
-
-        SECTION("get_binary()")
-        {
-            SECTION("non-const")
-            {
-                auto& b = j.get_binary();
-                CHECK(*json(b).m_data.m_value.binary == *j.m_data.m_value.binary);
-            }
-
-            SECTION("non-const")
-            {
-                const json j_const = j; // NOLINT(performance-unnecessary-copy-initialization)
-                const auto& b = j_const.get_binary();
-                CHECK(*json(b).m_data.m_value.binary == *j.m_data.m_value.binary);
-            }
-        }
-
-        SECTION("exception in case of a non-string type")
-        {
-            json j_null(json::value_t::null);
-            json j_object(json::value_t::object);
-            json j_array(json::value_t::array);
-            json j_string(json::value_t::string);
-            json j_boolean(json::value_t::boolean);
-            const json j_null_const(json::value_t::null);
-            const json j_object_const(json::value_t::object);
-            const json j_array_const(json::value_t::array);
-            const json j_string_const(json::value_t::string);
-            const json j_boolean_const(json::value_t::boolean);
-
-            CHECK_THROWS_WITH_AS(j_null.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is null",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_object.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is object",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_array.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is array",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_string.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is string",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_boolean.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is boolean",
-                                 json::type_error&);
-
-            CHECK_THROWS_WITH_AS(j_null_const.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is null",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_object_const.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is object",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_array_const.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is array",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_string_const.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is string",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_boolean_const.get<json::binary_t>(),
-                                 "[json.exception.type_error.302] type must be binary, but is boolean",
-                                 json::type_error&);
-
-            CHECK_THROWS_WITH_AS(j_null.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is null",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_object.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is object",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_array.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is array",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_string.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is string",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_boolean.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is boolean",
-                                 json::type_error&);
-
-            CHECK_THROWS_WITH_AS(j_null_const.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is null",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_object_const.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is object",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_array_const.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is array",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_string_const.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is string",
-                                 json::type_error&);
-            CHECK_THROWS_WITH_AS(j_boolean_const.get_binary(),
-                                 "[json.exception.type_error.302] type must be binary, but is boolean",
-                                 json::type_error&);
-        }
-    }
-
-#if JSON_USE_IMPLICIT_CONVERSIONS
-    SECTION("get a binary value (implicit)")
-    {
-        json::binary_t const n_reference{{1, 2, 3}};
-        json const j(n_reference);
-
-        SECTION("binary_t")
-        {
-            json::binary_t const b = j;
-            CHECK(*json(b).m_data.m_value.binary == *j.m_data.m_value.binary);
-        }
-    }
-#endif
-
-#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
-    SECTION("get an enum")
-    {
-        enum c_enum { value_1, value_2 }; // NOLINT(cppcoreguidelines-use-enum-class)
-        enum class cpp_enum { value_1, value_2 };
-
-        CHECK(json(value_1).get<c_enum>() == value_1);
-        CHECK(json(cpp_enum::value_1).get<cpp_enum>() == cpp_enum::value_1);
-    }
-
-    SECTION("get an enum with underlying type bool (#5671)")
-    {
-        enum class bool_enum : bool { off, on };
-
-        CHECK(json(bool_enum::off).get<bool_enum>() == bool_enum::off);
-        CHECK(json(bool_enum::on).get<bool_enum>() == bool_enum::on);
-    }
-#endif
-
-    SECTION("more involved conversions")
-    {
-        SECTION("object-like STL containers")
-        {
-            json const j1 = {{"one", 1}, {"two", 2}, {"three", 3}};
-            json const j2 = {{"one", 1u}, {"two", 2u}, {"three", 3u}};
-            json const j3 = {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}};
-            json const j4 = {{"one", true}, {"two", false}, {"three", true}};
-            json const j5 = {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}};
-
-            SECTION("std::map")
-            {
-                CHECK(j1.get<std::map<std::string, int>>() == (std::map<std::string, int> {{"one", 1}, {"two", 2}, {"three", 3}}));
-                CHECK(j2.get<std::map<std::string, unsigned int>>() == (std::map<std::string, unsigned int> {{"one", 1u}, {"two", 2u}, {"three", 3u}}));
-                CHECK(j3.get<std::map<std::string, double>>() == (std::map<std::string, double> {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}}));
-                CHECK(j4.get<std::map<std::string, bool>>() == (std::map<std::string, bool> {{"one", true}, {"two", false}, {"three", true}}));
-                CHECK(j5.get<std::map<std::string, std::string>>() == (std::map<std::string, std::string> {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}}));
-            }
-
-            SECTION("std::unordered_map")
-            {
-                CHECK(j1.get<std::unordered_map<std::string, int>>() == (std::unordered_map<std::string, int> {{"one", 1}, {"two", 2}, {"three", 3}}));
-                CHECK(j2.get<std::unordered_map<std::string, unsigned int>>() == (std::unordered_map<std::string, unsigned int> {{"one", 1u}, {"two", 2u}, {"three", 3u}}));
-                CHECK(j3.get<std::unordered_map<std::string, double>>() == (std::unordered_map<std::string, double> {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}}));
-                CHECK(j4.get<std::unordered_map<std::string, bool>>() == (std::unordered_map<std::string, bool> {{"one", true}, {"two", false}, {"three", true}}));
-                const auto m5 = j5.get<std::unordered_map<std::string, std::string>>();
-                CHECK(m5 == (std::unordered_map<std::string, std::string> {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}}));
-                CHECK(m5.at("one") == "eins");
-            }
-
-            SECTION("reserve is called on containers that support it (#5406)")
-            {
-                // build a larger object so that a missing/incorrect reserve()
-                // call would be more likely to corrupt or drop elements
-                json j_large;
-                for (int i = 0; i < 100; ++i)
-                {
-                    j_large[std::to_string(i)] = i;
-                }
-
-                SECTION("std::unordered_map (supports reserve)")
-                {
-                    const auto m = j_large.get<std::unordered_map<std::string, int>>();
-                    CHECK(m.size() == 100);
-                    for (int i = 0; i < 100; ++i)
-                    {
-                        CHECK(m.at(std::to_string(i)) == i);
-                    }
-                }
-
-                SECTION("std::map (no reserve, fallback path)")
-                {
-                    const auto m = j_large.get<std::map<std::string, int>>();
-                    CHECK(m.size() == 100);
-                    for (int i = 0; i < 100; ++i)
-                    {
-                        CHECK(m.at(std::to_string(i)) == i);
-                    }
-                }
-            }
-
-            SECTION("std::multimap")
-            {
-                CHECK(j1.get<std::multimap<std::string, int>>() == (std::multimap<std::string, int> {{"one", 1}, {"two", 2}, {"three", 3}}));
-                CHECK(j2.get<std::multimap<std::string, unsigned int>>() == (std::multimap<std::string, unsigned int> {{"one", 1u}, {"two", 2u}, {"three", 3u}}));
-                CHECK(j3.get<std::multimap<std::string, double>>() == (std::multimap<std::string, double> {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}}));
-                CHECK(j4.get<std::multimap<std::string, bool>>() == (std::multimap<std::string, bool> {{"one", true}, {"two", false}, {"three", true}}));
-                const auto m5 = j5.get<std::multimap<std::string, std::string>>();
-                CHECK(m5 == (std::multimap<std::string, std::string> {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}}));
-                CHECK(m5.find("one")->second == "eins");
-            }
-
-            SECTION("std::unordered_multimap")
-            {
-                CHECK(j1.get<std::unordered_multimap<std::string, int>>() == (std::unordered_multimap<std::string, int> {{"one", 1}, {"two", 2}, {"three", 3}}));
-                CHECK(j2.get<std::unordered_multimap<std::string, unsigned int>>() == (std::unordered_multimap<std::string, unsigned int> {{"one", 1u}, {"two", 2u}, {"three", 3u}}));
-                CHECK(j3.get<std::unordered_multimap<std::string, double>>() == (std::unordered_multimap<std::string, double> {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}}));
-                CHECK(j4.get<std::unordered_multimap<std::string, bool>>() == (std::unordered_multimap<std::string, bool> {{"one", true}, {"two", false}, {"three", true}}));
-                const auto m5 = j5.get<std::unordered_multimap<std::string, std::string>>();
-                CHECK(m5 == (std::unordered_multimap<std::string, std::string> {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}}));
-                CHECK(m5.find("one")->second == "eins");
-            }
-
-            SECTION("exception in case of a non-object type")
-            {
-                CHECK_THROWS_WITH_AS(
-                    (json().get<std::map<std::string, int>>()),
-                    "[json.exception.type_error.302] type must be object, but is null", json::type_error&);
-            }
-        }
-
-        SECTION("array-like STL containers")
-        {
-            json const j1 = {1, 2, 3, 4};
-            json const j2 = {1u, 2u, 3u, 4u};
-            json const j3 = {1.2, 2.3, 3.4, 4.5};
-            json const j4 = {true, false, true};
-            json const j5 = {"one", "two", "three"};
-
-            SECTION("std::list")
-            {
-                CHECK(j1.get<std::list<int>>() == (std::list<int> {1, 2, 3, 4}));
-                CHECK(j2.get<std::list<unsigned int>>() == (std::list<unsigned int> {1u, 2u, 3u, 4u}));
-                CHECK(j3.get<std::list<double>>() == (std::list<double> {1.2, 2.3, 3.4, 4.5}));
-                CHECK(j4.get<std::list<bool>>() == (std::list<bool> {true, false, true}));
-                CHECK(j5.get<std::list<std::string>>() == (std::list<std::string> {"one", "two", "three"}));
-            }
-
-            SECTION("std::forward_list")
-            {
-                CHECK(j1.get<std::forward_list<int>>() == (std::forward_list<int> {1, 2, 3, 4}));
-                CHECK(j2.get<std::forward_list<unsigned int>>() == (std::forward_list<unsigned int> {1u, 2u, 3u, 4u}));
-                CHECK(j3.get<std::forward_list<double>>() == (std::forward_list<double> {1.2, 2.3, 3.4, 4.5}));
-                CHECK(j4.get<std::forward_list<bool>>() == (std::forward_list<bool> {true, false, true}));
-                CHECK(j5.get<std::forward_list<std::string>>() == (std::forward_list<std::string> {"one", "two", "three"}));
-            }
-
-            SECTION("std::array")
-            {
-                CHECK(j1.get<std::array<int, 4>>() == (std::array<int, 4> {{1, 2, 3, 4}}));
-                // only the first 3 elements of j2 are converted, since the target array is smaller
-                CHECK(j2.get<std::array<unsigned int, 3>>() == (std::array<unsigned int, 3> {{1u, 2u, 3u}}));
-                CHECK(j3.get<std::array<double, 4>>() == (std::array<double, 4> {{1.2, 2.3, 3.4, 4.5}}));
-                CHECK(j4.get<std::array<bool, 3>>() == (std::array<bool, 3> {{true, false, true}}));
-                CHECK(j5.get<std::array<std::string, 3>>() == (std::array<std::string, 3> {{"one", "two", "three"}}));
-
-                SECTION("std::array is larger than JSON")
-                {
-                    std::array<int, 6> arr6 = {{1, 2, 3, 4, 5, 6}};
-                    CHECK_THROWS_WITH_AS(j1.get_to(arr6), "[json.exception.out_of_range.401] "
-                                         "array index 4 is out of range", json::out_of_range&);
-                }
-
-                SECTION("std::array is smaller than JSON")
-                {
-                    std::array<int, 2> arr2 = {{8, 9}};
-                    j1.get_to(arr2);
-                    CHECK(arr2[0] == 1);
-                    CHECK(arr2[1] == 2);
-                }
-            }
-
-            SECTION("std::valarray")
-            {
-                // valarray has no operator== that returns bool, so compare via a vector copy
-                const auto v1 = j1.get<std::valarray<int>>();
-                CHECK((std::vector<int>(std::begin(v1), std::end(v1)) == std::vector<int> {1, 2, 3, 4}));
-                const auto v2 = j2.get<std::valarray<unsigned int>>();
-                CHECK((std::vector<unsigned int>(std::begin(v2), std::end(v2)) == std::vector<unsigned int> {1u, 2u, 3u, 4u}));
-                const auto v3 = j3.get<std::valarray<double>>();
-                CHECK((std::vector<double>(std::begin(v3), std::end(v3)) == std::vector<double> {1.2, 2.3, 3.4, 4.5}));
-                const auto v4 = j4.get<std::valarray<bool>>();
-                CHECK((std::vector<bool>(std::begin(v4), std::end(v4)) == std::vector<bool> {true, false, true}));
-                const auto v5 = j5.get<std::valarray<std::string>>();
-                CHECK((std::vector<std::string>(std::begin(v5), std::end(v5)) == std::vector<std::string> {"one", "two", "three"}));
-            }
-
-            SECTION("std::vector")
-            {
-                CHECK(j1.get<std::vector<int>>() == (std::vector<int> {1, 2, 3, 4}));
-                CHECK(j2.get<std::vector<unsigned int>>() == (std::vector<unsigned int> {1u, 2u, 3u, 4u}));
-                CHECK(j3.get<std::vector<double>>() == (std::vector<double> {1.2, 2.3, 3.4, 4.5}));
-                CHECK(j4.get<std::vector<bool>>() == (std::vector<bool> {true, false, true}));
-                CHECK(j5.get<std::vector<std::string>>() == (std::vector<std::string> {"one", "two", "three"}));
-            }
-
-            SECTION("std::deque")
-            {
-                CHECK(j1.get<std::deque<int>>() == (std::deque<int> {1, 2, 3, 4}));
-                CHECK(j2.get<std::deque<unsigned int>>() == (std::deque<unsigned int> {1u, 2u, 3u, 4u}));
-                CHECK(j3.get<std::deque<double>>() == (std::deque<double> {1.2, 2.3, 3.4, 4.5}));
-                CHECK(j4.get<std::deque<bool>>() == (std::deque<bool> {true, false, true}));
-                CHECK(j5.get<std::deque<std::string>>() == (std::deque<std::string> {"one", "two", "three"}));
-            }
-
-            SECTION("std::set")
-            {
-                CHECK(j1.get<std::set<int>>() == (std::set<int> {1, 2, 3, 4}));
-                CHECK(j2.get<std::set<unsigned int>>() == (std::set<unsigned int> {1u, 2u, 3u, 4u}));
-                CHECK(j3.get<std::set<double>>() == (std::set<double> {1.2, 2.3, 3.4, 4.5}));
-                CHECK(j4.get<std::set<bool>>() == (std::set<bool> {true, false, true}));
-                CHECK(j5.get<std::set<std::string>>() == (std::set<std::string> {"one", "two", "three"}));
-            }
-
-            SECTION("std::unordered_set")
-            {
-                CHECK(j1.get<std::unordered_set<int>>() == (std::unordered_set<int> {1, 2, 3, 4}));
-                CHECK(j2.get<std::unordered_set<unsigned int>>() == (std::unordered_set<unsigned int> {1u, 2u, 3u, 4u}));
-                CHECK(j3.get<std::unordered_set<double>>() == (std::unordered_set<double> {1.2, 2.3, 3.4, 4.5}));
-                CHECK(j4.get<std::unordered_set<bool>>() == (std::unordered_set<bool> {true, false, true}));
-                CHECK(j5.get<std::unordered_set<std::string>>() == (std::unordered_set<std::string> {"one", "two", "three"}));
-            }
-
-            SECTION("std::map (array of pairs)")
-            {
-                const std::map<int, int> m{{0, 1}, {1, 2}, {2, 3}};
-                json const j6 = m;
-
-                auto m2 = j6.get<std::map<int, int>>();
-                CHECK(m == m2);
-
-                json const j7 = {0, 1, 2, 3};
-                json const j8 = 2;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS((j7.get<std::map<int, int>>()),
-                                     "[json.exception.type_error.302] (/0) type must be array, "
-                                     "but is number", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS((j7.get<std::map<int, int>>()),
-                                     "[json.exception.type_error.302] type must be array, "
-                                     "but is number", json::type_error&);
-#endif
-                CHECK_THROWS_WITH_AS((j8.get<std::map<int, int>>()),
-                                     "[json.exception.type_error.302] type must be array, "
-                                     "but is number", json::type_error&);
-
-                SECTION("superfluous entries")
-                {
-                    json const j9 = {{0, 1, 2}, {1, 2, 3}, {2, 3, 4}};
-                    m2 = j9.get<std::map<int, int>>();
-                    CHECK(m == m2);
-                }
-            }
-
-            SECTION("std::unordered_map (array of pairs)")
-            {
-                const std::unordered_map<int, int> m{{0, 1}, {1, 2}, {2, 3}};
-                json const j6 = m;
-
-                auto m2 = j6.get<std::unordered_map<int, int>>();
-                CHECK(m == m2);
-
-                json const j7 = {0, 1, 2, 3};
-                json const j8 = 2;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS((j7.get<std::unordered_map<int, int>>()),
-                                     "[json.exception.type_error.302] (/0) type must be array, "
-                                     "but is number", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS((j7.get<std::unordered_map<int, int>>()),
-                                     "[json.exception.type_error.302] type must be array, "
-                                     "but is number", json::type_error&);
-#endif
-                CHECK_THROWS_WITH_AS((j8.get<std::unordered_map<int, int>>()),
-                                     "[json.exception.type_error.302] type must be array, "
-                                     "but is number", json::type_error&);
-
-                SECTION("superfluous entries")
-                {
-                    json const j9{{0, 1, 2}, {1, 2, 3}, {2, 3, 4}};
-                    m2 = j9.get<std::unordered_map<int, int>>();
-                    CHECK(m == m2);
-                }
-            }
-
-            SECTION("exception in case of a non-object type")
-            {
-                // does type really must be an array? or it rather must not be null?
-                // that's what I thought when other test like this one broke
-                CHECK_THROWS_WITH_AS(
-                    (json().get<std::list<int>>()),
-                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
-                CHECK_THROWS_WITH_AS(
-                    (json().get<std::vector<int>>()),
-                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
-                CHECK_THROWS_WITH_AS(
-                    (json().get<std::vector<json>>()),
-                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
-                CHECK_THROWS_WITH_AS(
-                    (json().get<std::list<json>>()),
-                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
-                CHECK_THROWS_WITH_AS(
-                    (json().get<std::valarray<int>>()),
-                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
-                CHECK_THROWS_WITH_AS(
-                    (json().get<std::map<int, int>>()),
-                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
-            }
-        }
-    }
 }
 
-enum class cards {kreuz, pik, herz, karo};
-
-// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(cards,
-{
-    {cards::kreuz, "kreuz"},
-    {cards::pik, "pik"},
-    {cards::pik, "puk"},  // second entry for cards::puk; will not be used
-    {cards::herz, "herz"},
-    {cards::karo, "karo"}
-})
-
-enum TaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
-{
-    TS_STOPPED,
-    TS_RUNNING,
-    TS_COMPLETED,
-    TS_INVALID = -1,
-};
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(TaskState,
-{
-    {TS_INVALID, nullptr},
-    {TS_STOPPED, "stopped"},
-    {TS_RUNNING, "running"},
-    {TS_COMPLETED, "completed"},
-})
-
-TEST_CASE("JSON to enum mapping")
-{
-    SECTION("enum class")
-    {
-        // enum -> json
-        CHECK(json(cards::kreuz) == "kreuz");
-        CHECK(json(cards::pik) == "pik");
-        CHECK(json(cards::herz) == "herz");
-        CHECK(json(cards::karo) == "karo");
-
-        // json -> enum
-        CHECK(cards::kreuz == json("kreuz"));
-        CHECK(cards::pik == json("pik"));
-        CHECK(cards::herz == json("herz"));
-        CHECK(cards::karo == json("karo"));
-
-        // invalid json -> first enum
-        CHECK(cards::kreuz == json("what?").get<cards>());
-    }
-
-    SECTION("traditional enum")
-    {
-        // enum -> json
-        CHECK(json(TS_STOPPED) == "stopped");
-        CHECK(json(TS_RUNNING) == "running");
-        CHECK(json(TS_COMPLETED) == "completed");
-        CHECK(json(TS_INVALID) == json());
-
-        // json -> enum
-        CHECK(TS_STOPPED == json("stopped"));
-        CHECK(TS_RUNNING == json("running"));
-        CHECK(TS_COMPLETED == json("completed"));
-        CHECK(TS_INVALID == json());
-
-        // invalid json -> first enum
-        CHECK(TS_INVALID == json("what?").get<TaskState>());
-    }
-}
-
-enum class strict_cards {kreuz, pik, herz, karo, andere}; // andere not included in mapping
-
-// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_cards,
-{
-    {strict_cards::kreuz, "kreuz"},
-    {strict_cards::pik, "pik"},
-    {strict_cards::pik, "puk"},  // second entry for cards::pik; will not be used
-    {strict_cards::herz, "herz"},
-    {strict_cards::karo, "karo"}
-})
-
-enum StrictTaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
-{
-    STRICT_TS_STOPPED,
-    STRICT_TS_RUNNING,
-    STRICT_TS_COMPLETED,
-    STRICT_TS_OTHER, // STRICT_TS_OTHER not in mapping
-    STRICT_TS_INVALID = -1,
-};
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(StrictTaskState,
-{
-    {STRICT_TS_INVALID, nullptr},
-    {STRICT_TS_STOPPED, "stopped"},
-    {STRICT_TS_RUNNING, "running"},
-    {STRICT_TS_COMPLETED, "completed"},
-})
-
-// regression test for #5708 item 2: NLOHMANN_JSON_SERIALIZE_ENUM_STRICT must not rely on
-// unqualified lookup of a helper name that a user's own namespace may also declare
-namespace ns_with_colliding_name
-{
-// NOLINTNEXTLINE(misc-use-internal-linkage) - used to shadow the library's internal helper name
-inline void templated_json_throw(int /*unused*/) {}
-
-enum class colliding_enum { a, b };
-
-// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(colliding_enum,
-{
-    {colliding_enum::a, "a"},
-    {colliding_enum::b, "b"}
-})
-} // namespace ns_with_colliding_name
-
-TEST_CASE("NLOHMANN_JSON_SERIALIZE_ENUM_STRICT in a namespace with a colliding name")
-{
-    using ns_with_colliding_name::colliding_enum;
-
-    CHECK(json(colliding_enum::a) == "a");
-    CHECK(colliding_enum::b == json("b"));
-
-    json _;
-    CHECK_THROWS_WITH_AS(_ = json("nope").get<colliding_enum>(), "[json.exception.out_of_range.410] enum value out of range for colliding_enum: \"nope\"", json::out_of_range&);
-}
-
-TEST_CASE("Strict JSON to enum mapping")
-{
-    SECTION("enum class")
-    {
-        // enum -> json
-        CHECK(json(strict_cards::kreuz) == "kreuz");
-        CHECK(json(strict_cards::pik) == "pik");
-        CHECK(json(strict_cards::herz) == "herz");
-        CHECK(json(strict_cards::karo) == "karo");
-
-        // json -> enum
-        CHECK(json("kreuz").get<strict_cards>() == strict_cards::kreuz);
-        CHECK(json("pik").get<strict_cards>() == strict_cards::pik);
-        CHECK(json("herz").get<strict_cards>() == strict_cards::herz);
-        CHECK(json("karo").get<strict_cards>() == strict_cards::karo);
-
-        // comparison of enum and json
-        CHECK(strict_cards::kreuz == json("kreuz"));
-        CHECK(strict_cards::pik == json("pik"));
-        CHECK(strict_cards::herz == json("herz"));
-        CHECK(strict_cards::karo == json("karo"));
-
-        // invalid json -> exception thrown
-        json _;
-        CHECK_THROWS_WITH_AS(_ = json("what?").get<strict_cards>(), "[json.exception.out_of_range.410] enum value out of range for strict_cards: \"what?\"", json::out_of_range&);
-
-        // conversion of unmapped enum -> exception thrown
-        CHECK_THROWS_WITH_AS(json(strict_cards::andere), "[json.exception.out_of_range.410] enum value out of range for strict_cards", json::out_of_range&);
-
-        // comparing an unmapped enum with json throws the same exception
-        // (the scalar comparison operators used to be noexcept, so this
-        // called std::terminate)
-        CHECK_THROWS_WITH_AS(static_cast<void>(strict_cards::andere == json("andere")), "[json.exception.out_of_range.410] enum value out of range for strict_cards", json::out_of_range&);
-        CHECK_THROWS_WITH_AS(static_cast<void>(json("andere") != strict_cards::andere), "[json.exception.out_of_range.410] enum value out of range for strict_cards", json::out_of_range&);
-
-        // invalid UTF-8 -> out_of_range.410, not the type_error.316 thrown while building the
-        // message (regression test for #5667); such strings can reach get<Enum>() unvalidated,
-        // e.g. from from_cbor()/from_msgpack() (#5529)
-        const json j_invalid_utf8 = "\xFF";
-        CHECK_THROWS_WITH_AS(_ = j_invalid_utf8.get<strict_cards>(), "[json.exception.out_of_range.410] enum value out of range for strict_cards: \"\xEF\xBF\xBD\"", json::out_of_range&);
-    }
-
-    SECTION("traditional enum")
-    {
-        // enum -> json
-        CHECK(json(STRICT_TS_STOPPED) == "stopped");
-        CHECK(json(STRICT_TS_RUNNING) == "running");
-        CHECK(json(STRICT_TS_COMPLETED) == "completed");
-        CHECK(json(STRICT_TS_INVALID) == json());
-
-        // json -> enum
-        CHECK(json("stopped").get<StrictTaskState>() == STRICT_TS_STOPPED);
-        CHECK(json("running").get<StrictTaskState>() == STRICT_TS_RUNNING);
-        CHECK(json("completed").get<StrictTaskState>() == STRICT_TS_COMPLETED);
-        CHECK(json().get<StrictTaskState>() == STRICT_TS_INVALID);
-
-        // comparison of enum and json
-        CHECK(STRICT_TS_STOPPED == json("stopped"));
-        CHECK(STRICT_TS_RUNNING == json("running"));
-        CHECK(STRICT_TS_COMPLETED == json("completed"));
-        CHECK(STRICT_TS_INVALID == json());
-
-        // invalid json -> exception thrown
-        json _;
-        CHECK_THROWS_WITH_AS(_ = json("what?").get<StrictTaskState>(), "[json.exception.out_of_range.410] enum value out of range for StrictTaskState: \"what?\"", json::out_of_range&);
-
-        // conversion of unmapped enum -> exception thrown
-        CHECK_THROWS_WITH_AS(json(STRICT_TS_OTHER), "[json.exception.out_of_range.410] enum value out of range for StrictTaskState", json::out_of_range&);
-
-        // comparing an unmapped enum with json throws the same exception
-        CHECK_THROWS_WITH_AS(static_cast<void>(STRICT_TS_OTHER < json("x")), "[json.exception.out_of_range.410] enum value out of range for StrictTaskState", json::out_of_range&);
-    }
-}
-
-
-#ifdef JSON_HAS_CPP_17
-#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
-TEST_CASE("std::filesystem::path")
-{
-    SECTION("ascii")
-    {
-        json const j_string = "Path";
-        auto p = j_string.template get<nlohmann::detail::std_fs::path>();
-        json const j_path = p;
-
-        CHECK(j_path.template get<std::string>() ==
-              j_string.template get<std::string>());
-    }
-
-    SECTION("utf-8")
-    {
-        json const j_string = "P\xc4\x9b\xc5\xa1ina";
-        auto p = j_string.template get<nlohmann::detail::std_fs::path>();
-        json const j_path = p;
-
-        CHECK(j_path.template get<std::string>() ==
-              j_string.template get<std::string>());
-    }
-}
-#endif
-
-// the ADL to_json overload for std::u8string only exists under the same guard
-// as std::filesystem::path support (it is otherwise only reached indirectly,
-// via std::filesystem::path::u8string()) -- mirror both #if conditions from
-// include/nlohmann/detail/conversions/to_json.hpp exactly
-#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#if defined(__cpp_lib_char8_t)
-TEST_CASE("std::u8string")
-{
-    SECTION("ascii")
-    {
-        const std::u8string s = u8"Path";
-        json const j = s;
-
-        CHECK(j.template get<std::string>() == "Path");
-    }
-
-    SECTION("utf-8")
-    {
-        // use \u universal-character-names (rather than raw \x byte escapes
-        // or literal non-ASCII source bytes) to compose the multi-byte UTF-8
-        // encoding -- MSVC treats \x escapes used that way inside a u8
-        // literal as a nonstandard extension (warning C5321), which some of
-        // our CI configs promote to an error; \u is portable and produces
-        // the exact same encoded bytes without depending on the source
-        // file's encoding
-        const std::u8string s = u8"P\u011B\u0161ina";
-        json const j = s;
-
-        CHECK(j.template get<std::string>() == "P\xc4\x9b\xc5\xa1ina");
-    }
-}
-#endif
-#endif
-
-#if !defined(JSON_NOEXCEPTION)
-namespace
-{
-// a type whose to_json reports an error by throwing, used below to check that
-// converting a std::optional<T> to JSON propagates an exception thrown while
-// converting its contained value instead of calling std::terminate (#5642)
-struct throwing_to_json_type {};
-
-[[noreturn]] void to_json(json& /*unused*/, const throwing_to_json_type& /*unused*/)
-{
-    throw std::runtime_error("cannot serialize throwing_to_json_type");
-}
-}  // namespace
-#endif
-
-TEST_CASE("std::optional")
-{
-    SECTION("null")
-    {
-        const json j_null;
-        const std::optional<std::string> opt_null;
-
-        CHECK(json(opt_null) == j_null);
-        CHECK(j_null.get<std::optional<std::string>>() == std::nullopt);
-
-        // Constructing std::optional<T> directly from JSON null throws because
-        // std::optional's own converting constructor is chosen over basic_json's
-        // operator T(). This is a language-level limitation (std::optional<T> is
-        // constructible from T, and T is constructible from basic_json via the
-        // operator); there is no SFINAE path that distinguishes "call from inside
-        // std::optional's constructor" from "direct call". Use get<std::optional<T>>()
-        // or get_to() instead for correct null handling. See #4864 and #5246.
-        CHECK_THROWS_WITH_AS(std::optional<std::string>(j_null),
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-        CHECK_THROWS_WITH_AS(std::optional<int>(j_null),
-                             "[json.exception.type_error.302] type must be number, but is null", json::type_error&);
-
-        // Assignment goes through the same overload resolution as direct
-        // construction, so it throws for the same reason. This relies on
-        // basic_json's implicit conversion operator, so it only applies
-        // when JSON_USE_IMPLICIT_CONVERSIONS is enabled (the default).
-#if JSON_USE_IMPLICIT_CONVERSIONS
-        std::optional<std::string> opt_assign;
-        CHECK_THROWS_WITH_AS(opt_assign = j_null,
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-#endif
-
-        // get_to() is the correct way to obtain std::nullopt from a JSON null.
-        std::optional<std::string> opt_get_to = "placeholder";
-        j_null.get_to(opt_get_to);
-        CHECK(opt_get_to == std::nullopt);
-    }
-
-    SECTION("string")
-    {
-        json j_string = "string";
-        std::optional<std::string> opt_string = "string";
-
-        CHECK(json(opt_string) == j_string);
-        CHECK(std::optional<std::string>(j_string) == opt_string);
-        // false positive: Infer attributes the destruction of the temporaries above to opt_string
-        // @infer-ignore USE_AFTER_DELETE
-    }
-
-    SECTION("bool")
-    {
-        json j_bool = true;
-        std::optional<bool> opt_bool = true;
-
-        CHECK(json(opt_bool) == j_bool);
-        CHECK(std::optional<bool>(j_bool) == opt_bool);
-    }
-
-    SECTION("number")
-    {
-        json j_number = 1;
-        std::optional<int> opt_int = 1;
-
-        CHECK(json(opt_int) == j_number);
-        CHECK(j_number.get<std::optional<int>>() == opt_int);
-    }
-
-    SECTION("array")
-    {
-        json j_array = {1, 2, nullptr};
-        std::vector<std::optional<int>> opt_array = {{1, 2, std::nullopt}};
-
-        CHECK(json(opt_array) == j_array);
-        CHECK(j_array.get<std::vector<std::optional<int>>>() == opt_array);
-    }
-
-    SECTION("object")
-    {
-        json j_object = {{"one", 1}, {"two", 2}, {"zero", nullptr}};
-        std::map<std::string, std::optional<int>> opt_object {{"one", 1}, {"two", 2}, {"zero", std::nullopt}};
-
-        CHECK(json(opt_object) == j_object);
-        CHECK(std::map<std::string, std::optional<int>>(j_object) == opt_object);
-    }
-
-#if !defined(JSON_NOEXCEPTION)
-    SECTION("exception from contained value's to_json propagates (#5642)")
-    {
-        // to_json(BasicJsonType&, const std::optional<T>&) must not be
-        // noexcept: it calls T's to_json, which may throw (a user-defined
-        // to_json that reports an error, or std::bad_alloc for T =
-        // std::string/vector/json). Before the fix, this called
-        // std::terminate() instead of letting the exception propagate.
-        const std::optional<throwing_to_json_type> opt = throwing_to_json_type{};
-        CHECK_THROWS_WITH_AS(json(opt), "cannot serialize throwing_to_json_type", std::runtime_error&);
-
-        // the conversion is noexcept exactly when converting the contained value is
-        static_assert(!std::is_nothrow_constructible<json, const std::optional<throwing_to_json_type>&>::value);
-        static_assert(std::is_nothrow_constructible<json, const std::optional<int>&>::value);
-    }
-#endif
-}
-#endif
-
 #ifdef JSON_HAS_CPP_17
     #undef JSON_HAS_CPP_17
 #endif

tests/src/unit-conversions2.cpp

@@ -0,0 +1,868 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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
+
+// cmake/test.cmake selects the C++ standard versions with which to build a
+// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
+// When using macros that are only defined for particular versions of the standard
+// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
+// version macro in a comment close by, like this:
+// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
+
+#include "doctest_compatibility.h"
+
+// skip tests if JSON_DisableEnumSerialization=ON (#4384)
+#if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
+    #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
+#endif
+
+#define JSON_TESTS_PRIVATE
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <valarray>
+
+// NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
+DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
+
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+    #define JSON_HAS_CPP_14
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #if __has_include(<optional>)
+        #include <optional>
+    #elif __has_include(<experimental/optional>)
+        #include <experimental/optional>
+    #endif
+#endif
+
+#if defined(JSON_HAS_CPP_17)
+    #include <string_view>
+#endif
+
+TEST_CASE("value conversion")
+{
+    SECTION("get a binary value (explicit)")
+    {
+        json::binary_t const n_reference{{1, 2, 3}};
+        json j(n_reference);
+
+        SECTION("binary_t")
+        {
+            json::binary_t const b = j.get<json::binary_t>();
+            CHECK(*json(b).m_data.m_value.binary == *j.m_data.m_value.binary);
+        }
+
+        SECTION("get_binary()")
+        {
+            SECTION("non-const")
+            {
+                auto& b = j.get_binary();
+                CHECK(*json(b).m_data.m_value.binary == *j.m_data.m_value.binary);
+            }
+
+            SECTION("non-const")
+            {
+                const json j_const = j; // NOLINT(performance-unnecessary-copy-initialization)
+                const auto& b = j_const.get_binary();
+                CHECK(*json(b).m_data.m_value.binary == *j.m_data.m_value.binary);
+            }
+        }
+
+        SECTION("exception in case of a non-string type")
+        {
+            json j_null(json::value_t::null);
+            json j_object(json::value_t::object);
+            json j_array(json::value_t::array);
+            json j_string(json::value_t::string);
+            json j_boolean(json::value_t::boolean);
+            const json j_null_const(json::value_t::null);
+            const json j_object_const(json::value_t::object);
+            const json j_array_const(json::value_t::array);
+            const json j_string_const(json::value_t::string);
+            const json j_boolean_const(json::value_t::boolean);
+
+            CHECK_THROWS_WITH_AS(j_null.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is null",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_object.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is object",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_array.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is array",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_string.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is string",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_boolean.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is boolean",
+                                 json::type_error&);
+
+            CHECK_THROWS_WITH_AS(j_null_const.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is null",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_object_const.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is object",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_array_const.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is array",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_string_const.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is string",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_boolean_const.get<json::binary_t>(),
+                                 "[json.exception.type_error.302] type must be binary, but is boolean",
+                                 json::type_error&);
+
+            CHECK_THROWS_WITH_AS(j_null.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is null",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_object.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is object",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_array.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is array",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_string.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is string",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_boolean.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is boolean",
+                                 json::type_error&);
+
+            CHECK_THROWS_WITH_AS(j_null_const.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is null",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_object_const.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is object",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_array_const.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is array",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_string_const.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is string",
+                                 json::type_error&);
+            CHECK_THROWS_WITH_AS(j_boolean_const.get_binary(),
+                                 "[json.exception.type_error.302] type must be binary, but is boolean",
+                                 json::type_error&);
+        }
+    }
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    SECTION("get a binary value (implicit)")
+    {
+        json::binary_t const n_reference{{1, 2, 3}};
+        json const j(n_reference);
+
+        SECTION("binary_t")
+        {
+            json::binary_t const b = j;
+            CHECK(*json(b).m_data.m_value.binary == *j.m_data.m_value.binary);
+        }
+    }
+#endif
+
+#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
+    SECTION("get an enum")
+    {
+        enum c_enum { value_1, value_2 }; // NOLINT(cppcoreguidelines-use-enum-class)
+        enum class cpp_enum { value_1, value_2 };
+
+        CHECK(json(value_1).get<c_enum>() == value_1);
+        CHECK(json(cpp_enum::value_1).get<cpp_enum>() == cpp_enum::value_1);
+    }
+
+    SECTION("get an enum with underlying type bool (#5671)")
+    {
+        enum class bool_enum : bool { off, on };
+
+        CHECK(json(bool_enum::off).get<bool_enum>() == bool_enum::off);
+        CHECK(json(bool_enum::on).get<bool_enum>() == bool_enum::on);
+    }
+#endif
+
+    SECTION("more involved conversions")
+    {
+        SECTION("object-like STL containers")
+        {
+            json const j1 = {{"one", 1}, {"two", 2}, {"three", 3}};
+            json const j2 = {{"one", 1u}, {"two", 2u}, {"three", 3u}};
+            json const j3 = {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}};
+            json const j4 = {{"one", true}, {"two", false}, {"three", true}};
+            json const j5 = {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}};
+
+            SECTION("std::map")
+            {
+                CHECK(j1.get<std::map<std::string, int>>() == (std::map<std::string, int> {{"one", 1}, {"two", 2}, {"three", 3}}));
+                CHECK(j2.get<std::map<std::string, unsigned int>>() == (std::map<std::string, unsigned int> {{"one", 1u}, {"two", 2u}, {"three", 3u}}));
+                CHECK(j3.get<std::map<std::string, double>>() == (std::map<std::string, double> {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}}));
+                CHECK(j4.get<std::map<std::string, bool>>() == (std::map<std::string, bool> {{"one", true}, {"two", false}, {"three", true}}));
+                CHECK(j5.get<std::map<std::string, std::string>>() == (std::map<std::string, std::string> {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}}));
+            }
+
+            SECTION("std::unordered_map")
+            {
+                CHECK(j1.get<std::unordered_map<std::string, int>>() == (std::unordered_map<std::string, int> {{"one", 1}, {"two", 2}, {"three", 3}}));
+                CHECK(j2.get<std::unordered_map<std::string, unsigned int>>() == (std::unordered_map<std::string, unsigned int> {{"one", 1u}, {"two", 2u}, {"three", 3u}}));
+                CHECK(j3.get<std::unordered_map<std::string, double>>() == (std::unordered_map<std::string, double> {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}}));
+                CHECK(j4.get<std::unordered_map<std::string, bool>>() == (std::unordered_map<std::string, bool> {{"one", true}, {"two", false}, {"three", true}}));
+                const auto m5 = j5.get<std::unordered_map<std::string, std::string>>();
+                CHECK(m5 == (std::unordered_map<std::string, std::string> {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}}));
+                CHECK(m5.at("one") == "eins");
+            }
+
+            SECTION("reserve is called on containers that support it (#5406)")
+            {
+                // build a larger object so that a missing/incorrect reserve()
+                // call would be more likely to corrupt or drop elements
+                json j_large;
+                for (int i = 0; i < 100; ++i)
+                {
+                    j_large[std::to_string(i)] = i;
+                }
+
+                SECTION("std::unordered_map (supports reserve)")
+                {
+                    const auto m = j_large.get<std::unordered_map<std::string, int>>();
+                    CHECK(m.size() == 100);
+                    for (int i = 0; i < 100; ++i)
+                    {
+                        CHECK(m.at(std::to_string(i)) == i);
+                    }
+                }
+
+                SECTION("std::map (no reserve, fallback path)")
+                {
+                    const auto m = j_large.get<std::map<std::string, int>>();
+                    CHECK(m.size() == 100);
+                    for (int i = 0; i < 100; ++i)
+                    {
+                        CHECK(m.at(std::to_string(i)) == i);
+                    }
+                }
+            }
+
+            SECTION("std::multimap")
+            {
+                CHECK(j1.get<std::multimap<std::string, int>>() == (std::multimap<std::string, int> {{"one", 1}, {"two", 2}, {"three", 3}}));
+                CHECK(j2.get<std::multimap<std::string, unsigned int>>() == (std::multimap<std::string, unsigned int> {{"one", 1u}, {"two", 2u}, {"three", 3u}}));
+                CHECK(j3.get<std::multimap<std::string, double>>() == (std::multimap<std::string, double> {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}}));
+                CHECK(j4.get<std::multimap<std::string, bool>>() == (std::multimap<std::string, bool> {{"one", true}, {"two", false}, {"three", true}}));
+                const auto m5 = j5.get<std::multimap<std::string, std::string>>();
+                CHECK(m5 == (std::multimap<std::string, std::string> {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}}));
+                CHECK(m5.find("one")->second == "eins");
+            }
+
+            SECTION("std::unordered_multimap")
+            {
+                CHECK(j1.get<std::unordered_multimap<std::string, int>>() == (std::unordered_multimap<std::string, int> {{"one", 1}, {"two", 2}, {"three", 3}}));
+                CHECK(j2.get<std::unordered_multimap<std::string, unsigned int>>() == (std::unordered_multimap<std::string, unsigned int> {{"one", 1u}, {"two", 2u}, {"three", 3u}}));
+                CHECK(j3.get<std::unordered_multimap<std::string, double>>() == (std::unordered_multimap<std::string, double> {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}}));
+                CHECK(j4.get<std::unordered_multimap<std::string, bool>>() == (std::unordered_multimap<std::string, bool> {{"one", true}, {"two", false}, {"three", true}}));
+                const auto m5 = j5.get<std::unordered_multimap<std::string, std::string>>();
+                CHECK(m5 == (std::unordered_multimap<std::string, std::string> {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}}));
+                CHECK(m5.find("one")->second == "eins");
+            }
+
+            SECTION("exception in case of a non-object type")
+            {
+                CHECK_THROWS_WITH_AS(
+                    (json().get<std::map<std::string, int>>()),
+                    "[json.exception.type_error.302] type must be object, but is null", json::type_error&);
+            }
+        }
+
+        SECTION("array-like STL containers")
+        {
+            json const j1 = {1, 2, 3, 4};
+            json const j2 = {1u, 2u, 3u, 4u};
+            json const j3 = {1.2, 2.3, 3.4, 4.5};
+            json const j4 = {true, false, true};
+            json const j5 = {"one", "two", "three"};
+
+            SECTION("std::list")
+            {
+                CHECK(j1.get<std::list<int>>() == (std::list<int> {1, 2, 3, 4}));
+                CHECK(j2.get<std::list<unsigned int>>() == (std::list<unsigned int> {1u, 2u, 3u, 4u}));
+                CHECK(j3.get<std::list<double>>() == (std::list<double> {1.2, 2.3, 3.4, 4.5}));
+                CHECK(j4.get<std::list<bool>>() == (std::list<bool> {true, false, true}));
+                CHECK(j5.get<std::list<std::string>>() == (std::list<std::string> {"one", "two", "three"}));
+            }
+
+            SECTION("std::forward_list")
+            {
+                CHECK(j1.get<std::forward_list<int>>() == (std::forward_list<int> {1, 2, 3, 4}));
+                CHECK(j2.get<std::forward_list<unsigned int>>() == (std::forward_list<unsigned int> {1u, 2u, 3u, 4u}));
+                CHECK(j3.get<std::forward_list<double>>() == (std::forward_list<double> {1.2, 2.3, 3.4, 4.5}));
+                CHECK(j4.get<std::forward_list<bool>>() == (std::forward_list<bool> {true, false, true}));
+                CHECK(j5.get<std::forward_list<std::string>>() == (std::forward_list<std::string> {"one", "two", "three"}));
+            }
+
+            SECTION("std::array")
+            {
+                CHECK(j1.get<std::array<int, 4>>() == (std::array<int, 4> {{1, 2, 3, 4}}));
+                // only the first 3 elements of j2 are converted, since the target array is smaller
+                CHECK(j2.get<std::array<unsigned int, 3>>() == (std::array<unsigned int, 3> {{1u, 2u, 3u}}));
+                CHECK(j3.get<std::array<double, 4>>() == (std::array<double, 4> {{1.2, 2.3, 3.4, 4.5}}));
+                CHECK(j4.get<std::array<bool, 3>>() == (std::array<bool, 3> {{true, false, true}}));
+                CHECK(j5.get<std::array<std::string, 3>>() == (std::array<std::string, 3> {{"one", "two", "three"}}));
+
+                SECTION("std::array is larger than JSON")
+                {
+                    std::array<int, 6> arr6 = {{1, 2, 3, 4, 5, 6}};
+                    CHECK_THROWS_WITH_AS(j1.get_to(arr6), "[json.exception.out_of_range.401] "
+                                         "array index 4 is out of range", json::out_of_range&);
+                }
+
+                SECTION("std::array is smaller than JSON")
+                {
+                    std::array<int, 2> arr2 = {{8, 9}};
+                    j1.get_to(arr2);
+                    CHECK(arr2[0] == 1);
+                    CHECK(arr2[1] == 2);
+                }
+            }
+
+            SECTION("std::valarray")
+            {
+                // valarray has no operator== that returns bool, so compare via a vector copy
+                const auto v1 = j1.get<std::valarray<int>>();
+                CHECK((std::vector<int>(std::begin(v1), std::end(v1)) == std::vector<int> {1, 2, 3, 4}));
+                const auto v2 = j2.get<std::valarray<unsigned int>>();
+                CHECK((std::vector<unsigned int>(std::begin(v2), std::end(v2)) == std::vector<unsigned int> {1u, 2u, 3u, 4u}));
+                const auto v3 = j3.get<std::valarray<double>>();
+                CHECK((std::vector<double>(std::begin(v3), std::end(v3)) == std::vector<double> {1.2, 2.3, 3.4, 4.5}));
+                const auto v4 = j4.get<std::valarray<bool>>();
+                CHECK((std::vector<bool>(std::begin(v4), std::end(v4)) == std::vector<bool> {true, false, true}));
+                const auto v5 = j5.get<std::valarray<std::string>>();
+                CHECK((std::vector<std::string>(std::begin(v5), std::end(v5)) == std::vector<std::string> {"one", "two", "three"}));
+            }
+
+            SECTION("std::vector")
+            {
+                CHECK(j1.get<std::vector<int>>() == (std::vector<int> {1, 2, 3, 4}));
+                CHECK(j2.get<std::vector<unsigned int>>() == (std::vector<unsigned int> {1u, 2u, 3u, 4u}));
+                CHECK(j3.get<std::vector<double>>() == (std::vector<double> {1.2, 2.3, 3.4, 4.5}));
+                CHECK(j4.get<std::vector<bool>>() == (std::vector<bool> {true, false, true}));
+                CHECK(j5.get<std::vector<std::string>>() == (std::vector<std::string> {"one", "two", "three"}));
+            }
+
+            SECTION("std::deque")
+            {
+                CHECK(j1.get<std::deque<int>>() == (std::deque<int> {1, 2, 3, 4}));
+                CHECK(j2.get<std::deque<unsigned int>>() == (std::deque<unsigned int> {1u, 2u, 3u, 4u}));
+                CHECK(j3.get<std::deque<double>>() == (std::deque<double> {1.2, 2.3, 3.4, 4.5}));
+                CHECK(j4.get<std::deque<bool>>() == (std::deque<bool> {true, false, true}));
+                CHECK(j5.get<std::deque<std::string>>() == (std::deque<std::string> {"one", "two", "three"}));
+            }
+
+            SECTION("std::set")
+            {
+                CHECK(j1.get<std::set<int>>() == (std::set<int> {1, 2, 3, 4}));
+                CHECK(j2.get<std::set<unsigned int>>() == (std::set<unsigned int> {1u, 2u, 3u, 4u}));
+                CHECK(j3.get<std::set<double>>() == (std::set<double> {1.2, 2.3, 3.4, 4.5}));
+                CHECK(j4.get<std::set<bool>>() == (std::set<bool> {true, false, true}));
+                CHECK(j5.get<std::set<std::string>>() == (std::set<std::string> {"one", "two", "three"}));
+            }
+
+            SECTION("std::unordered_set")
+            {
+                CHECK(j1.get<std::unordered_set<int>>() == (std::unordered_set<int> {1, 2, 3, 4}));
+                CHECK(j2.get<std::unordered_set<unsigned int>>() == (std::unordered_set<unsigned int> {1u, 2u, 3u, 4u}));
+                CHECK(j3.get<std::unordered_set<double>>() == (std::unordered_set<double> {1.2, 2.3, 3.4, 4.5}));
+                CHECK(j4.get<std::unordered_set<bool>>() == (std::unordered_set<bool> {true, false, true}));
+                CHECK(j5.get<std::unordered_set<std::string>>() == (std::unordered_set<std::string> {"one", "two", "three"}));
+            }
+
+            SECTION("std::map (array of pairs)")
+            {
+                const std::map<int, int> m{{0, 1}, {1, 2}, {2, 3}};
+                json const j6 = m;
+
+                auto m2 = j6.get<std::map<int, int>>();
+                CHECK(m == m2);
+
+                json const j7 = {0, 1, 2, 3};
+                json const j8 = 2;
+#if JSON_DIAGNOSTICS
+                CHECK_THROWS_WITH_AS((j7.get<std::map<int, int>>()),
+                                     "[json.exception.type_error.302] (/0) type must be array, "
+                                     "but is number", json::type_error&);
+#else
+                CHECK_THROWS_WITH_AS((j7.get<std::map<int, int>>()),
+                                     "[json.exception.type_error.302] type must be array, "
+                                     "but is number", json::type_error&);
+#endif
+                CHECK_THROWS_WITH_AS((j8.get<std::map<int, int>>()),
+                                     "[json.exception.type_error.302] type must be array, "
+                                     "but is number", json::type_error&);
+
+                SECTION("superfluous entries")
+                {
+                    json const j9 = {{0, 1, 2}, {1, 2, 3}, {2, 3, 4}};
+                    m2 = j9.get<std::map<int, int>>();
+                    CHECK(m == m2);
+                }
+            }
+
+            SECTION("std::unordered_map (array of pairs)")
+            {
+                const std::unordered_map<int, int> m{{0, 1}, {1, 2}, {2, 3}};
+                json const j6 = m;
+
+                auto m2 = j6.get<std::unordered_map<int, int>>();
+                CHECK(m == m2);
+
+                json const j7 = {0, 1, 2, 3};
+                json const j8 = 2;
+#if JSON_DIAGNOSTICS
+                CHECK_THROWS_WITH_AS((j7.get<std::unordered_map<int, int>>()),
+                                     "[json.exception.type_error.302] (/0) type must be array, "
+                                     "but is number", json::type_error&);
+#else
+                CHECK_THROWS_WITH_AS((j7.get<std::unordered_map<int, int>>()),
+                                     "[json.exception.type_error.302] type must be array, "
+                                     "but is number", json::type_error&);
+#endif
+                CHECK_THROWS_WITH_AS((j8.get<std::unordered_map<int, int>>()),
+                                     "[json.exception.type_error.302] type must be array, "
+                                     "but is number", json::type_error&);
+
+                SECTION("superfluous entries")
+                {
+                    json const j9{{0, 1, 2}, {1, 2, 3}, {2, 3, 4}};
+                    m2 = j9.get<std::unordered_map<int, int>>();
+                    CHECK(m == m2);
+                }
+            }
+
+            SECTION("exception in case of a non-object type")
+            {
+                // does type really must be an array? or it rather must not be null?
+                // that's what I thought when other test like this one broke
+                CHECK_THROWS_WITH_AS(
+                    (json().get<std::list<int>>()),
+                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
+                CHECK_THROWS_WITH_AS(
+                    (json().get<std::vector<int>>()),
+                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
+                CHECK_THROWS_WITH_AS(
+                    (json().get<std::vector<json>>()),
+                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
+                CHECK_THROWS_WITH_AS(
+                    (json().get<std::list<json>>()),
+                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
+                CHECK_THROWS_WITH_AS(
+                    (json().get<std::valarray<int>>()),
+                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
+                CHECK_THROWS_WITH_AS(
+                    (json().get<std::map<int, int>>()),
+                    "[json.exception.type_error.302] type must be array, but is null", json::type_error&);
+            }
+        }
+    }
+}
+
+enum class cards {kreuz, pik, herz, karo};
+
+// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM(cards,
+{
+    {cards::kreuz, "kreuz"},
+    {cards::pik, "pik"},
+    {cards::pik, "puk"},  // second entry for cards::puk; will not be used
+    {cards::herz, "herz"},
+    {cards::karo, "karo"}
+})
+
+enum TaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
+{
+    TS_STOPPED,
+    TS_RUNNING,
+    TS_COMPLETED,
+    TS_INVALID = -1,
+};
+
+// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM(TaskState,
+{
+    {TS_INVALID, nullptr},
+    {TS_STOPPED, "stopped"},
+    {TS_RUNNING, "running"},
+    {TS_COMPLETED, "completed"},
+})
+
+TEST_CASE("JSON to enum mapping")
+{
+    SECTION("enum class")
+    {
+        // enum -> json
+        CHECK(json(cards::kreuz) == "kreuz");
+        CHECK(json(cards::pik) == "pik");
+        CHECK(json(cards::herz) == "herz");
+        CHECK(json(cards::karo) == "karo");
+
+        // json -> enum
+        CHECK(cards::kreuz == json("kreuz"));
+        CHECK(cards::pik == json("pik"));
+        CHECK(cards::herz == json("herz"));
+        CHECK(cards::karo == json("karo"));
+
+        // invalid json -> first enum
+        CHECK(cards::kreuz == json("what?").get<cards>());
+    }
+
+    SECTION("traditional enum")
+    {
+        // enum -> json
+        CHECK(json(TS_STOPPED) == "stopped");
+        CHECK(json(TS_RUNNING) == "running");
+        CHECK(json(TS_COMPLETED) == "completed");
+        CHECK(json(TS_INVALID) == json());
+
+        // json -> enum
+        CHECK(TS_STOPPED == json("stopped"));
+        CHECK(TS_RUNNING == json("running"));
+        CHECK(TS_COMPLETED == json("completed"));
+        CHECK(TS_INVALID == json());
+
+        // invalid json -> first enum
+        CHECK(TS_INVALID == json("what?").get<TaskState>());
+    }
+}
+
+enum class strict_cards {kreuz, pik, herz, karo, andere}; // andere not included in mapping
+
+// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_cards,
+{
+    {strict_cards::kreuz, "kreuz"},
+    {strict_cards::pik, "pik"},
+    {strict_cards::pik, "puk"},  // second entry for cards::pik; will not be used
+    {strict_cards::herz, "herz"},
+    {strict_cards::karo, "karo"}
+})
+
+enum StrictTaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
+{
+    STRICT_TS_STOPPED,
+    STRICT_TS_RUNNING,
+    STRICT_TS_COMPLETED,
+    STRICT_TS_OTHER, // STRICT_TS_OTHER not in mapping
+    STRICT_TS_INVALID = -1,
+};
+
+// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(StrictTaskState,
+{
+    {STRICT_TS_INVALID, nullptr},
+    {STRICT_TS_STOPPED, "stopped"},
+    {STRICT_TS_RUNNING, "running"},
+    {STRICT_TS_COMPLETED, "completed"},
+})
+
+// regression test for #5708 item 2: NLOHMANN_JSON_SERIALIZE_ENUM_STRICT must not rely on
+// unqualified lookup of a helper name that a user's own namespace may also declare
+namespace ns_with_colliding_name
+{
+// NOLINTNEXTLINE(misc-use-internal-linkage) - used to shadow the library's internal helper name
+inline void templated_json_throw(int /*unused*/) {}
+
+enum class colliding_enum { a, b };
+
+// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(colliding_enum,
+{
+    {colliding_enum::a, "a"},
+    {colliding_enum::b, "b"}
+})
+} // namespace ns_with_colliding_name
+
+TEST_CASE("NLOHMANN_JSON_SERIALIZE_ENUM_STRICT in a namespace with a colliding name")
+{
+    using ns_with_colliding_name::colliding_enum;
+
+    CHECK(json(colliding_enum::a) == "a");
+    CHECK(colliding_enum::b == json("b"));
+
+    json _;
+    CHECK_THROWS_WITH_AS(_ = json("nope").get<colliding_enum>(), "[json.exception.out_of_range.410] enum value out of range for colliding_enum: \"nope\"", json::out_of_range&);
+}
+
+TEST_CASE("Strict JSON to enum mapping")
+{
+    SECTION("enum class")
+    {
+        // enum -> json
+        CHECK(json(strict_cards::kreuz) == "kreuz");
+        CHECK(json(strict_cards::pik) == "pik");
+        CHECK(json(strict_cards::herz) == "herz");
+        CHECK(json(strict_cards::karo) == "karo");
+
+        // json -> enum
+        CHECK(json("kreuz").get<strict_cards>() == strict_cards::kreuz);
+        CHECK(json("pik").get<strict_cards>() == strict_cards::pik);
+        CHECK(json("herz").get<strict_cards>() == strict_cards::herz);
+        CHECK(json("karo").get<strict_cards>() == strict_cards::karo);
+
+        // comparison of enum and json
+        CHECK(strict_cards::kreuz == json("kreuz"));
+        CHECK(strict_cards::pik == json("pik"));
+        CHECK(strict_cards::herz == json("herz"));
+        CHECK(strict_cards::karo == json("karo"));
+
+        // invalid json -> exception thrown
+        json _;
+        CHECK_THROWS_WITH_AS(_ = json("what?").get<strict_cards>(), "[json.exception.out_of_range.410] enum value out of range for strict_cards: \"what?\"", json::out_of_range&);
+
+        // conversion of unmapped enum -> exception thrown
+        CHECK_THROWS_WITH_AS(json(strict_cards::andere), "[json.exception.out_of_range.410] enum value out of range for strict_cards", json::out_of_range&);
+
+        // comparing an unmapped enum with json throws the same exception
+        // (the scalar comparison operators used to be noexcept, so this
+        // called std::terminate)
+        CHECK_THROWS_WITH_AS(static_cast<void>(strict_cards::andere == json("andere")), "[json.exception.out_of_range.410] enum value out of range for strict_cards", json::out_of_range&);
+        CHECK_THROWS_WITH_AS(static_cast<void>(json("andere") != strict_cards::andere), "[json.exception.out_of_range.410] enum value out of range for strict_cards", json::out_of_range&);
+
+        // invalid UTF-8 -> out_of_range.410, not the type_error.316 thrown while building the
+        // message (regression test for #5667); such strings can reach get<Enum>() unvalidated,
+        // e.g. from from_cbor()/from_msgpack() (#5529)
+        const json j_invalid_utf8 = "\xFF";
+        CHECK_THROWS_WITH_AS(_ = j_invalid_utf8.get<strict_cards>(), "[json.exception.out_of_range.410] enum value out of range for strict_cards: \"\xEF\xBF\xBD\"", json::out_of_range&);
+    }
+
+    SECTION("traditional enum")
+    {
+        // enum -> json
+        CHECK(json(STRICT_TS_STOPPED) == "stopped");
+        CHECK(json(STRICT_TS_RUNNING) == "running");
+        CHECK(json(STRICT_TS_COMPLETED) == "completed");
+        CHECK(json(STRICT_TS_INVALID) == json());
+
+        // json -> enum
+        CHECK(json("stopped").get<StrictTaskState>() == STRICT_TS_STOPPED);
+        CHECK(json("running").get<StrictTaskState>() == STRICT_TS_RUNNING);
+        CHECK(json("completed").get<StrictTaskState>() == STRICT_TS_COMPLETED);
+        CHECK(json().get<StrictTaskState>() == STRICT_TS_INVALID);
+
+        // comparison of enum and json
+        CHECK(STRICT_TS_STOPPED == json("stopped"));
+        CHECK(STRICT_TS_RUNNING == json("running"));
+        CHECK(STRICT_TS_COMPLETED == json("completed"));
+        CHECK(STRICT_TS_INVALID == json());
+
+        // invalid json -> exception thrown
+        json _;
+        CHECK_THROWS_WITH_AS(_ = json("what?").get<StrictTaskState>(), "[json.exception.out_of_range.410] enum value out of range for StrictTaskState: \"what?\"", json::out_of_range&);
+
+        // conversion of unmapped enum -> exception thrown
+        CHECK_THROWS_WITH_AS(json(STRICT_TS_OTHER), "[json.exception.out_of_range.410] enum value out of range for StrictTaskState", json::out_of_range&);
+
+        // comparing an unmapped enum with json throws the same exception
+        CHECK_THROWS_WITH_AS(static_cast<void>(STRICT_TS_OTHER < json("x")), "[json.exception.out_of_range.410] enum value out of range for StrictTaskState", json::out_of_range&);
+    }
+}
+
+
+#ifdef JSON_HAS_CPP_17
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+TEST_CASE("std::filesystem::path")
+{
+    SECTION("ascii")
+    {
+        json const j_string = "Path";
+        auto p = j_string.template get<nlohmann::detail::std_fs::path>();
+        json const j_path = p;
+
+        CHECK(j_path.template get<std::string>() ==
+              j_string.template get<std::string>());
+    }
+
+    SECTION("utf-8")
+    {
+        json const j_string = "P\xc4\x9b\xc5\xa1ina";
+        auto p = j_string.template get<nlohmann::detail::std_fs::path>();
+        json const j_path = p;
+
+        CHECK(j_path.template get<std::string>() ==
+              j_string.template get<std::string>());
+    }
+}
+#endif
+
+// the ADL to_json overload for std::u8string only exists under the same guard
+// as std::filesystem::path support (it is otherwise only reached indirectly,
+// via std::filesystem::path::u8string()) -- mirror both #if conditions from
+// include/nlohmann/detail/conversions/to_json.hpp exactly
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#if defined(__cpp_lib_char8_t)
+TEST_CASE("std::u8string")
+{
+    SECTION("ascii")
+    {
+        const std::u8string s = u8"Path";
+        json const j = s;
+
+        CHECK(j.template get<std::string>() == "Path");
+    }
+
+    SECTION("utf-8")
+    {
+        // use \u universal-character-names (rather than raw \x byte escapes
+        // or literal non-ASCII source bytes) to compose the multi-byte UTF-8
+        // encoding -- MSVC treats \x escapes used that way inside a u8
+        // literal as a nonstandard extension (warning C5321), which some of
+        // our CI configs promote to an error; \u is portable and produces
+        // the exact same encoded bytes without depending on the source
+        // file's encoding
+        const std::u8string s = u8"P\u011B\u0161ina";
+        json const j = s;
+
+        CHECK(j.template get<std::string>() == "P\xc4\x9b\xc5\xa1ina");
+    }
+}
+#endif
+#endif
+
+#if !defined(JSON_NOEXCEPTION)
+namespace
+{
+// a type whose to_json reports an error by throwing, used below to check that
+// converting a std::optional<T> to JSON propagates an exception thrown while
+// converting its contained value instead of calling std::terminate (#5642)
+struct throwing_to_json_type {};
+
+[[noreturn]] void to_json(json& /*unused*/, const throwing_to_json_type& /*unused*/)
+{
+    throw std::runtime_error("cannot serialize throwing_to_json_type");
+}
+}  // namespace
+#endif
+
+TEST_CASE("std::optional")
+{
+    SECTION("null")
+    {
+        const json j_null;
+        const std::optional<std::string> opt_null;
+
+        CHECK(json(opt_null) == j_null);
+        CHECK(j_null.get<std::optional<std::string>>() == std::nullopt);
+
+        // Constructing std::optional<T> directly from JSON null throws because
+        // std::optional's own converting constructor is chosen over basic_json's
+        // operator T(). This is a language-level limitation (std::optional<T> is
+        // constructible from T, and T is constructible from basic_json via the
+        // operator); there is no SFINAE path that distinguishes "call from inside
+        // std::optional's constructor" from "direct call". Use get<std::optional<T>>()
+        // or get_to() instead for correct null handling. See #4864 and #5246.
+        CHECK_THROWS_WITH_AS(std::optional<std::string>(j_null),
+                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
+        CHECK_THROWS_WITH_AS(std::optional<int>(j_null),
+                             "[json.exception.type_error.302] type must be number, but is null", json::type_error&);
+
+        // Assignment goes through the same overload resolution as direct
+        // construction, so it throws for the same reason. This relies on
+        // basic_json's implicit conversion operator, so it only applies
+        // when JSON_USE_IMPLICIT_CONVERSIONS is enabled (the default).
+#if JSON_USE_IMPLICIT_CONVERSIONS
+        std::optional<std::string> opt_assign;
+        CHECK_THROWS_WITH_AS(opt_assign = j_null,
+                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
+#endif
+
+        // get_to() is the correct way to obtain std::nullopt from a JSON null.
+        std::optional<std::string> opt_get_to = "placeholder";
+        j_null.get_to(opt_get_to);
+        CHECK(opt_get_to == std::nullopt);
+    }
+
+    SECTION("string")
+    {
+        json j_string = "string";
+        std::optional<std::string> opt_string = "string";
+
+        CHECK(json(opt_string) == j_string);
+        CHECK(std::optional<std::string>(j_string) == opt_string);
+        // false positive: Infer attributes the destruction of the temporaries above to opt_string
+        // @infer-ignore USE_AFTER_DELETE
+    }
+
+    SECTION("bool")
+    {
+        json j_bool = true;
+        std::optional<bool> opt_bool = true;
+
+        CHECK(json(opt_bool) == j_bool);
+        CHECK(std::optional<bool>(j_bool) == opt_bool);
+    }
+
+    SECTION("number")
+    {
+        json j_number = 1;
+        std::optional<int> opt_int = 1;
+
+        CHECK(json(opt_int) == j_number);
+        CHECK(j_number.get<std::optional<int>>() == opt_int);
+    }
+
+    SECTION("array")
+    {
+        json j_array = {1, 2, nullptr};
+        std::vector<std::optional<int>> opt_array = {{1, 2, std::nullopt}};
+
+        CHECK(json(opt_array) == j_array);
+        CHECK(j_array.get<std::vector<std::optional<int>>>() == opt_array);
+    }
+
+    SECTION("object")
+    {
+        json j_object = {{"one", 1}, {"two", 2}, {"zero", nullptr}};
+        std::map<std::string, std::optional<int>> opt_object {{"one", 1}, {"two", 2}, {"zero", std::nullopt}};
+
+        CHECK(json(opt_object) == j_object);
+        CHECK(std::map<std::string, std::optional<int>>(j_object) == opt_object);
+    }
+
+#if !defined(JSON_NOEXCEPTION)
+    SECTION("exception from contained value's to_json propagates (#5642)")
+    {
+        // to_json(BasicJsonType&, const std::optional<T>&) must not be
+        // noexcept: it calls T's to_json, which may throw (a user-defined
+        // to_json that reports an error, or std::bad_alloc for T =
+        // std::string/vector/json). Before the fix, this called
+        // std::terminate() instead of letting the exception propagate.
+        const std::optional<throwing_to_json_type> opt = throwing_to_json_type{};
+        CHECK_THROWS_WITH_AS(json(opt), "cannot serialize throwing_to_json_type", std::runtime_error&);
+
+        // the conversion is noexcept exactly when converting the contained value is
+        static_assert(!std::is_nothrow_constructible<json, const std::optional<throwing_to_json_type>&>::value);
+        static_assert(std::is_nothrow_constructible<json, const std::optional<int>&>::value);
+    }
+#endif
+}
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #undef JSON_HAS_CPP_17
+#endif
+
+#ifdef JSON_HAS_CPP_14
+    #undef JSON_HAS_CPP_14
+#endif
+DOCTEST_CLANG_SUPPRESS_WARNING_POP

tests/src/unit-custom-base-class.cpp

@@ -505,7 +505,7 @@ static json_with_const_base make_nested_array(std::size_t depth)
 {
     if (depth == 0)
     {
-        return json_with_const_base(1);
+        return json_with_const_base(1); // NOLINT(modernize-return-braced-init-list): {1} would be an array
     }
     return json_with_const_base::array({make_nested_array(depth - 1)});
 }

tests/src/unit-disabled_exceptions.cpp

@@ -14,6 +14,9 @@ DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept")
 
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
+#ifdef JSON_TEST_NO_GLOBAL_UDLS
+    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
+#endif
 
 /////////////////////////////////////////////////////////////////////
 // for #2824

tests/src/unit-element_access2.cpp

@@ -1963,8 +1963,8 @@ TEST_CASE("operator[] with user-defined std::string_view-convertible types")
     };
 
     json j = {{"foo", "from_class"}, {"bar", "from_struct"}};
-    TestClass foo_obj;
+    const TestClass foo_obj;
-    TestStruct bar_obj;
+    const TestStruct bar_obj;
 
     SECTION("read access")
     {
@@ -2005,6 +2005,10 @@ TEST_CASE("keys convertible to std::string_view work with all lookup functions (
     // 3.12.0, such a key worked with at, the const operator[], find, count and
     // contains via the conversion to std::string; #4958 made the KeyType&&
     // templates win overload resolution for it instead, and those then failed
+    // the lookups pick the conversion to std::string_view, which leaves the one
+    // to std::string unused; it has to exist to reproduce the ambiguity
+    DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+    DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-member-function")
     struct DualKey
     {
         operator std::string() const
@@ -2016,6 +2020,7 @@ TEST_CASE("keys convertible to std::string_view work with all lookup functions (
             return "a";
         }
     };
+    DOCTEST_CLANG_SUPPRESS_WARNING_POP
 
     SECTION("nlohmann::json")
     {

tests/src/unit-modifiers.cpp

@@ -1162,6 +1162,7 @@ TEST_CASE("update() on deeply nested values")
 
 TEST_CASE("update() with an argument that aliases *this (#5641)")
 {
+#if !defined(JSON_NOEXCEPTION) // checks which exception is thrown, and that nothing changed
     SECTION("the target is checked before the argument, as before the copy")
     {
         json j = 1;
@@ -1172,6 +1173,7 @@ TEST_CASE("update() with an argument that aliases *this (#5641)")
         CHECK_THROWS_WITH_AS(k.update(json::array()), "[json.exception.type_error.312] cannot use update() with array", json::type_error&);
         CHECK(k == json::object());
     }
+#endif
 
     SECTION("const reference")
     {

tests/src/unit-msgpack.cpp

@@ -1560,7 +1560,7 @@ TEST_CASE("MessagePack")
             // dump() still requires valid UTF-8 and throws for such a value,
             // unless an error handler that replaces or ignores the bytes is
             // passed
-            CHECK_THROWS_AS(j_value.dump(), json::type_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(j_value.dump()), json::type_error&);
 
             // the same bytes as an object key round-trip as well
             const std::vector<uint8_t> ill_formed_key = {0x81, 0xa2, 0xc0, 0xae, 0x01};

tests/src/unit-ordered_map.cpp

@@ -430,8 +430,8 @@ TEST_CASE("ordered_map")
 
         SECTION("with T& (lvalue)")
         {
-            std::string one = "1";
+            std::string one = "1"; // NOLINT(misc-const-correctness): emplace must accept a non-const lvalue
-            std::string four = "four";
+            std::string four = "four"; // NOLINT(misc-const-correctness): see above
 
             auto res1 = om.emplace("eins", one);
             CHECK(res1.first == om.begin());
@@ -467,7 +467,7 @@ TEST_CASE("ordered_map")
         SECTION("with key of key_type (non-template overload)")
         {
             const std::string key_vier{"vier"};
-            std::string four = "four";
+            std::string four = "four"; // NOLINT(misc-const-correctness): emplace must accept a non-const lvalue
 
             auto res4 = om.emplace(key_vier, four);
             CHECK(res4.first == om.begin() + 3);

tests/src/unit-regression2.cpp

@@ -940,581 +940,4 @@ TEST_CASE("regression test - excessive binary container size honors allow_except
     CHECK(json::from_cbor(std::vector<std::uint8_t> {0x9b, 0, 0, 0, 0, 0, 0, 0, 0x02}, true, false).is_discarded());
 }
 
-namespace
-{
-/// builds a value from SAX events, asks the parser to recover from its first
-/// 100 errors, and checks that the events are balanced (see #3989)
-class RecoveringParser
-{
-  public:
-    explicit RecoveringParser(json& j)
-        : dom(j, false)
-    {}
-
-    bool null()
-    {
-        value();
-        return dom.null();
-    }
-
-    bool boolean(bool val)
-    {
-        value();
-        return dom.boolean(val);
-    }
-
-    bool number_integer(json::number_integer_t val)
-    {
-        value();
-        return dom.number_integer(val);
-    }
-
-    bool number_unsigned(json::number_unsigned_t val)
-    {
-        value();
-        return dom.number_unsigned(val);
-    }
-
-    bool number_float(json::number_float_t val, const std::string& s)
-    {
-        value();
-        return dom.number_float(val, s);
-    }
-
-    bool string(std::string& val)
-    {
-        value();
-        return dom.string(val);
-    }
-
-    bool binary(json::binary_t& val)
-    {
-        value();
-        return dom.binary(val);
-    }
-
-    bool start_object(std::size_t elements)
-    {
-        value();
-        stack.push_back('o');
-        return dom.start_object(elements);
-    }
-
-    bool key(std::string& val)
-    {
-        if (stack.empty() || stack.back() != 'o')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.back() = 'v';
-        return dom.key(val);
-    }
-
-    bool end_object()
-    {
-        if (stack.empty() || stack.back() != 'o')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.pop_back();
-        return dom.end_object();
-    }
-
-    bool start_array(std::size_t elements)
-    {
-        value();
-        stack.push_back('a');
-        return dom.start_array(elements);
-    }
-
-    bool end_array()
-    {
-        if (stack.empty() || stack.back() != 'a')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.pop_back();
-        return dom.end_array();
-    }
-
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const json::exception& ex)
-    {
-        messages.emplace_back(ex.what());
-        // a limit, so that a reader that does not stop fails the test
-        // instead of making it hang
-        return ++errors < 100;
-    }
-
-    /// whether the events were balanced and every key was followed by a value
-    bool balanced() const
-    {
-        return well_formed && stack.empty();
-    }
-
-    /// builds the value
-    nlohmann::detail::json_sax_dom_parser<json> dom;
-    std::size_t errors = 0;
-    std::vector<std::string> messages {}; // NOLINT(readability-redundant-member-init)
-    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
-    bool well_formed = true;
-
-  private:
-    void value()
-    {
-        if (!stack.empty())
-        {
-            if (stack.back() == 'v')
-            {
-                stack.back() = 'o';
-            }
-            else if (stack.back() == 'o')
-            {
-                well_formed = false;
-            }
-        }
-    }
-
-};
-
-struct BinaryParseResult
-{
-    json value;
-    std::size_t errors;
-    std::vector<std::string> messages;
-    bool ok;
-    bool balanced;
-};
-
-BinaryParseResult parse_binary_recovering(const std::vector<std::uint8_t>& input, const json::input_format_t format)
-{
-    json j;
-    RecoveringParser sax(j);
-    const bool ok = json::sax_parse(input, &sax, format);
-    return {j, sax.errors, sax.messages, ok, sax.balanced()};
-}
-
-#if !defined(JSON_NOEXCEPTION)
-/// the message of the exception that reading @a input into a JSON value
-/// throws, or an empty string if reading succeeds
-std::string binary_error_message(const std::vector<std::uint8_t>& input, const json::input_format_t format)
-{
-    try
-    {
-        json _;
-        switch (format)
-        {
-            case json::input_format_t::cbor:
-                _ = json::from_cbor(input);
-                break;
-            case json::input_format_t::msgpack:
-                _ = json::from_msgpack(input);
-                break;
-            case json::input_format_t::ubjson:
-                _ = json::from_ubjson(input);
-                break;
-            case json::input_format_t::bjdata:
-                _ = json::from_bjdata(input);
-                break;
-            case json::input_format_t::bson:
-                _ = json::from_bson(input);
-                break;
-            case json::input_format_t::bon8:
-                _ = json::from_bon8(input);
-                break;
-            case json::input_format_t::json:
-            default:
-                break;
-        }
-    }
-    catch (const json::exception& e)
-    {
-        return e.what();
-    }
-    return "";
-}
-#endif
-
-/// a BSON element: its type, its name, and its value
-std::vector<std::uint8_t> bson_element(const std::uint8_t type, const std::string& name, const std::vector<std::uint8_t>& value)
-{
-    std::vector<std::uint8_t> result = {type};
-    result.insert(result.end(), name.begin(), name.end());
-    result.push_back(0x00);
-    result.insert(result.end(), value.begin(), value.end());
-    return result;
-}
-
-/// a BSON document of the given elements; @a size_offset is added to the
-/// size it declares
-std::vector<std::uint8_t> bson_document(const std::vector<std::vector<std::uint8_t>>& elements, const int size_offset = 0)
-{
-    std::vector<std::uint8_t> body;
-    for (const auto& element : elements)
-    {
-        body.insert(body.end(), element.begin(), element.end());
-    }
-    const auto size = static_cast<std::uint32_t>(static_cast<int>(body.size()) + 5 + size_offset);
-    std::vector<std::uint8_t> result = {static_cast<std::uint8_t>(size & 0xFFu), static_cast<std::uint8_t>((size >> 8u) & 0xFFu),
-                                        static_cast<std::uint8_t>((size >> 16u) & 0xFFu), static_cast<std::uint8_t>((size >> 24u) & 0xFFu)
-                                       };
-    result.insert(result.end(), body.begin(), body.end());
-    result.push_back(0x00);
-    return result;
-}
-
-/// a BSON int32 value
-std::vector<std::uint8_t> bson_int32(const std::int32_t value)
-{
-    const auto u = static_cast<std::uint32_t>(value);
-    return {static_cast<std::uint8_t>(u & 0xFFu), static_cast<std::uint8_t>((u >> 8u) & 0xFFu),
-            static_cast<std::uint8_t>((u >> 16u) & 0xFFu), static_cast<std::uint8_t>((u >> 24u) & 0xFFu)};
-}
-
-/// a BSON string value, whose length is @a length_offset off
-std::vector<std::uint8_t> bson_string(const std::string& value, const std::int32_t length_offset = 0)
-{
-    auto result = bson_int32(static_cast<std::int32_t>(value.size() + 1) + length_offset);
-    result.insert(result.end(), value.begin(), value.end());
-    result.push_back(0x00);
-    return result;
-}
-
-/// @a count bytes of value 0xAB
-std::vector<std::uint8_t> bytes(const std::size_t count)
-{
-    return std::vector<std::uint8_t>(count, 0xAB);
-}
-
-template<typename... Parts>
-std::vector<std::uint8_t> concatenated(const std::vector<std::uint8_t>& first, const Parts& ... rest)
-{
-    std::vector<std::uint8_t> result = first;
-    for (const auto& part : std::initializer_list<std::vector<std::uint8_t>> {rest...})
-    {
-        result.insert(result.end(), part.begin(), part.end());
-    }
-    return result;
-}
-
-/// U+FFFD REPLACEMENT CHARACTER
-std::string replacement_character()
-{
-    return "\xEF\xBF\xBD";
-}
-}  // namespace
-
-TEST_CASE("regression test - #3989 SAX parse_error() returning true")
-{
-    SECTION("binary formats complete what was read before the input ends")
-    {
-        const json j = {{"a", {1, -2, {{"b", "c"}}, json::array()}}, {"d", {{"e", nullptr}, {"f", true}}}, {"g", 1.5}, {"h", json::binary({1, 2, 3})}};
-
-        const std::vector<std::pair<json::input_format_t, std::vector<std::uint8_t>>> encodings =
-        {
-            {json::input_format_t::cbor, json::to_cbor(j)},
-            {json::input_format_t::msgpack, json::to_msgpack(j)},
-            {json::input_format_t::ubjson, json::to_ubjson(j)},
-            {json::input_format_t::ubjson, json::to_ubjson(j, true, true)},
-            {json::input_format_t::bjdata, json::to_bjdata(j)},
-            {json::input_format_t::bjdata, json::to_bjdata(j, true, true)},
-            {json::input_format_t::bson, json::to_bson(j)},
-            {json::input_format_t::bon8, json::to_bon8(j)},
-        };
-
-        for (const auto& encoding : encodings)
-        {
-            const auto format = encoding.first;
-            const auto& bytes = encoding.second;
-            CAPTURE(format)
-
-            // every prefix is truncated input
-            for (std::size_t length = 0; length < bytes.size(); ++length)
-            {
-                CAPTURE(length)
-                const auto result = parse_binary_recovering(std::vector<std::uint8_t>(bytes.begin(), bytes.begin() + static_cast<std::ptrdiff_t>(length)), format);
-                CHECK(!result.ok);
-                CHECK(result.errors == 1);
-                CHECK(result.balanced);
-            }
-
-            // the complete input is read as usual (binary values do not
-            // round-trip through every format, so compare with a plain parse)
-            json expected;
-            nlohmann::detail::json_sax_dom_parser<json> dom(expected);
-            CHECK(json::sax_parse(bytes, &dom, format));
-            const auto complete = parse_binary_recovering(bytes, format);
-            CHECK(complete.ok);
-            CHECK(complete.errors == 0);
-            CHECK(complete.value == expected);
-
-            // a byte after the value
-            auto trailing_bytes = bytes;
-            trailing_bytes.push_back(0x01);
-            const auto trailing = parse_binary_recovering(trailing_bytes, format);
-            CHECK(!trailing.ok);
-            CHECK(trailing.errors == 1);
-            CHECK(trailing.value == expected);
-        }
-    }
-
-    SECTION("containers without an end")
-    {
-        // these made the readers loop, or read on, after the error
-        const auto cbor_array = parse_binary_recovering({0x9F}, json::input_format_t::cbor);
-        CHECK(cbor_array.errors == 1);
-        CHECK(cbor_array.value == json::array());
-
-        const auto cbor_map = parse_binary_recovering({0xBF, 0x61, 'a'}, json::input_format_t::cbor);
-        CHECK(cbor_map.errors == 1);
-        CHECK(cbor_map.value == json({{"a", nullptr}}));
-
-        const auto msgpack_array = parse_binary_recovering({0xDD, 0xFF, 0xFF, 0xFF, 0xFF}, json::input_format_t::msgpack);
-        CHECK(msgpack_array.errors == 1);
-        CHECK(msgpack_array.value == json::array());
-
-        const auto msgpack_map = parse_binary_recovering({0x81, 0xA1, 'a', 0x92, 0x01}, json::input_format_t::msgpack);
-        CHECK(msgpack_map.errors == 1);
-        CHECK(msgpack_map.value == json({{"a", {1}}}));
-    }
-
-    SECTION("BJData ndarray")
-    {
-        // a 2x3 int8 array with two of its six elements; the annotated array
-        // format opens an object and two arrays of its own
-        const auto result = parse_binary_recovering({'[', '$', 'i', '#', '[', '$', 'i', '#', 'i', 2, 2, 3, 1, 2}, json::input_format_t::bjdata);
-        CHECK(result.errors == 1);
-        CHECK(result.balanced);
-        CHECK(result.value == json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2}}}));
-    }
-
-    SECTION("binary formats repair items whose end is known")
-    {
-        struct Repair
-        {
-            json::input_format_t format;
-            std::vector<std::uint8_t> input;
-            json expected;
-            std::size_t errors;
-        };
-
-        const std::vector<Repair> repairs =
-        {
-            // CBOR: tags are ignored (here tag 1 and the self-describe tag 55799)
-            {json::input_format_t::cbor, {0x82, 0xC1, 0x05, 0xD9, 0xD9, 0xF7, 0x06}, {5, 6}, 2},
-            // CBOR: undefined and other simple values become null
-            {json::input_format_t::cbor, {0x84, 0xF7, 0xE0, 0xF8, 0x20, 0x01}, {nullptr, nullptr, nullptr, 1}, 3},
-            // CBOR: members whose key is not a string are skipped, whatever their key and value
-            {json::input_format_t::cbor, {0xA4, 0x01, 0x02, 0x82, 0x01, 0x02, 0xA1, 0x61, 'x', 0x9F, 0xFF, 0xC1, 0x01, 0x5F, 0x41, 0x00, 0xFF, 0x61, 'a', 0x03}, {{"a", 3}}, 3},
-            {json::input_format_t::cbor, {0xBF, 0xF5, 0xBF, 0x61, 'x', 0x7F, 0x61, 'y', 0xFF, 0xFF, 0x61, 'a', 0x03, 0xFF}, {{"a", 3}}, 1},
-            // MessagePack: members whose key is not a string are skipped
-            {json::input_format_t::msgpack, {0x84, 0x01, 0x02, 0x81, 0xA1, 'x', 0x01, 0x92, 0x01, 0x02, 0xD4, 0x01, 0x02, 0xC0, 0xA1, 'a', 0x04}, {{"a", 4}}, 3},
-            // UBJSON: a char that is not ASCII becomes U+FFFD
-            {json::input_format_t::ubjson, {'[', 'C', 0x80, 'C', 'A', ']'}, {replacement_character(), "A"}, 1},
-            // UBJSON: the longest beginning of a high-precision number is kept
-            {json::input_format_t::ubjson, {'[', 'H', 'i', 5, '1', '2', 'a', 'b', 'c', 'H', 'i', 2, '1', '.', 'H', 'i', 3, 'a', 'b', 'c', 'H', 'i', 3, '4', '.', '5', ']'}, {12, 1, nullptr, 4.5}, 3},
-            // BJData, too
-            {json::input_format_t::bjdata, {'[', 'C', 0xFF, 'H', 'i', 2, '-', '1', 'H', 'i', 2, '-', 'x', ']'}, {replacement_character(), -1, nullptr}, 2},
-            // BON8: members whose key is not a string are skipped
-            {json::input_format_t::bon8, {0x89, 0x91, 0x92, 0xC9, 0x40, 0x82, 0x91, 0x92, 0x61, 0x93}, {{"a", 3}}, 2},
-            {json::input_format_t::bon8, {0x8B, 0x91, 0x85, 0x91, 0xFE, 0xFA, 0x8B, 'x', 0x91, 0xFE, 0x61, 0x93, 0xFE}, {{"a", 3}}, 2},
-            // BSON: elements of types the library does not read become null
-            {
-                json::input_format_t::bson, bson_document(
-                {
-                    bson_element(0x07, "_id", bytes(12)),                         // ObjectId
-                    bson_element(0x09, "date", bytes(8)),                         // UTC datetime
-                    bson_element(0x13, "decimal", bytes(16)),                     // 128-bit decimal
-                    bson_element(0x0B, "regex", {'a', '+', 0, 'i', 0}),           // regular expression
-                    bson_element(0x0D, "code", bson_string("f()")),               // JavaScript code
-                    bson_element(0x0E, "symbol", bson_string("s")),               // symbol
-                    bson_element(0x0C, "pointer", concatenated(bson_string("c"), bytes(12))), // DBPointer
-                    bson_element(0x0F, "scope", concatenated(bson_int32(15), bson_string("g"), bson_document({}))), // code with scope
-                    bson_element(0x06, "undefined", {}),                          // undefined
-                    bson_element(0xFF, "min", {}),                                // min key
-                    bson_element(0x7F, "max", {}),                                // max key
-                    bson_element(0x10, "z", bson_int32(7)),
-                }),
-                {{"_id", nullptr}, {"date", nullptr}, {"decimal", nullptr}, {"regex", nullptr}, {"code", nullptr}, {"symbol", nullptr}, {"pointer", nullptr}, {"scope", nullptr}, {"undefined", nullptr}, {"min", nullptr}, {"max", nullptr}, {"z", 7}},
-                11
-            },
-            // BSON: an element of an unknown type becomes null, and the rest of its document is skipped
-            {
-                json::input_format_t::bson, bson_document(
-                {
-                    bson_element(0x03, "inner", bson_document({bson_element(0x10, "a", bson_int32(1)), bson_element(0x42, "x", bytes(3)), bson_element(0x10, "b", bson_int32(2))})),
-                    bson_element(0x04, "array", bson_document({bson_element(0x10, "0", bson_int32(1)), bson_element(0x42, "1", bytes(3))})),
-                    bson_element(0x10, "after", bson_int32(3)),
-                }),
-                {{"inner", {{"a", 1}, {"x", nullptr}}}, {"array", {1, nullptr}}, {"after", 3}},
-                2
-            },
-            // BSON: so does a string or byte array whose length cannot be right
-            {
-                json::input_format_t::bson, bson_document(
-                {
-                    bson_element(0x03, "inner", bson_document({bson_element(0x02, "s", bson_string("abc", -10)), bson_element(0x10, "b", bson_int32(2))})),
-                    bson_element(0x03, "bin", bson_document({bson_element(0x05, "b", concatenated(bson_int32(-1), bytes(1))), bson_element(0x10, "b", bson_int32(2))})),
-                    bson_element(0x10, "after", bson_int32(3)),
-                }),
-                {{"inner", {{"s", nullptr}}}, {"bin", {{"b", nullptr}}}, {"after", 3}},
-                2
-            },
-            // BSON: a string without its terminator, and a document whose size does not match, are kept
-            {
-                json::input_format_t::bson, bson_document(
-                {
-                    bson_element(0x02, "s", {2, 0, 0, 0, 'a', 'X'}),
-                    bson_element(0x03, "inner", bson_document({bson_element(0x10, "a", bson_int32(1))}, 1)),
-                }),
-                {{"s", "a"}, {"inner", {{"a", 1}}}},
-                2
-            },
-        };
-
-        for (const auto& repair : repairs)
-        {
-            CAPTURE(repair.format)
-            CAPTURE(repair.input)
-            const auto result = parse_binary_recovering(repair.input, repair.format);
-            CHECK(!result.ok);
-            CHECK(result.balanced);
-            CHECK(result.errors == repair.errors);
-            CHECK(result.value == repair.expected);
-            REQUIRE(!result.messages.empty());
-#if !defined(JSON_NOEXCEPTION)
-            // the first error is the one reported without recovering; under
-            // JSON_NOEXCEPTION, reading without recovering aborts instead of
-            // throwing, so there is no message to compare with
-            CHECK(result.messages.front() == binary_error_message(repair.input, repair.format));
-#endif
-        }
-    }
-
-    SECTION("binary formats repair numbers that are out of range")
-    {
-        // CBOR: a negative integer below the range of number_integer_t
-        const auto cbor = parse_binary_recovering({0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, json::input_format_t::cbor);
-        CHECK(cbor.errors == 1);
-        CHECK(cbor.value.is_number_float());
-        CHECK(cbor.value.get<double>() == -18446744073709551616.0);
-
-        // UBJSON: a high-precision number too large for number_float_t
-        const auto ubjson = parse_binary_recovering({'H', 'i', 5, '1', 'e', '9', '9', '9'}, json::input_format_t::ubjson);
-        CHECK(ubjson.errors == 1);
-        CHECK(ubjson.value.is_number_float());
-        CHECK(std::isinf(ubjson.value.get<double>()));
-    }
-
-    SECTION("binary formats stop where the end of an item is not known")
-    {
-        // a byte that begins no item
-        const auto cbor = parse_binary_recovering({0x82, 0x01, 0x1C, 0x02}, json::input_format_t::cbor);
-        CHECK(cbor.errors == 1);
-        CHECK(cbor.value == json({1}));
-
-        // a key that is no item: the unused MessagePack byte, a CBOR break
-        // in a map of known size, and the end of a BON8 container
-        const auto msgpack = parse_binary_recovering({0x82, 0xA1, 'a', 0x01, 0xC1, 0x02}, json::input_format_t::msgpack);
-        CHECK(msgpack.errors == 1);
-        CHECK(msgpack.value == json({{"a", 1}}));
-        const auto cbor_break = parse_binary_recovering({0xA2, 0x61, 'a', 0x01, 0xFF, 0x02}, json::input_format_t::cbor);
-        CHECK(cbor_break.errors == 1);
-        CHECK(cbor_break.value == json({{"a", 1}}));
-        const auto bon8 = parse_binary_recovering({0x88, 0x61, 0x91, 0xFE}, json::input_format_t::bon8);
-        CHECK(bon8.errors == 1);
-        CHECK(bon8.value == json({{"a", 1}}));
-
-        // a skipped member that the input ends in
-        const auto truncated = parse_binary_recovering({0xA2, 0x01, 0x82, 0x01}, json::input_format_t::cbor);
-        CHECK(truncated.errors == 2);
-        CHECK(truncated.balanced);
-        CHECK(truncated.value == json::object());
-
-        // a BSON element of an unknown type in a document whose size cannot be right
-        const auto bson = parse_binary_recovering(bson_document({bson_element(0x10, "a", bson_int32(1)), bson_element(0x42, "x", bytes(3))}, -10), json::input_format_t::bson);
-        CHECK(bson.errors == 1);
-        CHECK(bson.value == json({{"a", 1}, {"x", nullptr}}));
-    }
-
-    SECTION("changed bytes in binary input")
-    {
-        const json j = {{"a", {1, -2, {{"b", "c"}}, json::array()}}, {"d", {{"e", nullptr}, {"f", true}}}, {"g", 1.5}, {"h", json::binary({1, 2, 3})}, {"i", "\xC3\xA4"}};
-
-        const std::vector<std::pair<json::input_format_t, std::vector<std::uint8_t>>> encodings =
-        {
-            {json::input_format_t::cbor, json::to_cbor(j)},
-            {json::input_format_t::msgpack, json::to_msgpack(j)},
-            {json::input_format_t::ubjson, json::to_ubjson(j)},
-            {json::input_format_t::ubjson, json::to_ubjson(j, true, true)},
-            {json::input_format_t::bjdata, json::to_bjdata(j)},
-            {json::input_format_t::bjdata, json::to_bjdata(j, true, true)},
-            {json::input_format_t::bson, json::to_bson(j)},
-            {json::input_format_t::bon8, json::to_bon8(j)},
-        };
-        const std::vector<std::uint8_t> replacements = {0x00, 0x01, 0x7F, 0x80, 0xC1, 0xD9, 0xE0, 0xF7, 0xFE, 0xFF};
-
-        for (const auto& encoding : encodings)
-        {
-            const auto format = encoding.first;
-            const auto& original = encoding.second;
-            CAPTURE(format)
-
-            std::vector<std::vector<std::uint8_t>> inputs;
-            for (std::size_t position = 0; position < original.size(); ++position)
-            {
-                for (const auto replacement : replacements)
-                {
-                    auto changed = original;
-                    changed[position] = replacement;
-                    inputs.push_back(changed);
-                }
-                auto removed = original;
-                removed.erase(removed.begin() + static_cast<std::ptrdiff_t>(position));
-                inputs.push_back(removed);
-            }
-
-            for (const auto& input : inputs)
-            {
-                CAPTURE(input)
-                const auto result = parse_binary_recovering(input, format);
-                CHECK(result.balanced);
-                CHECK(result.errors <= input.size() + 1);
-#if !defined(JSON_NOEXCEPTION)
-                // an error is reported exactly if reading into a JSON value
-                // fails, and the first one is the same (under JSON_NOEXCEPTION,
-                // that reading aborts instead of throwing)
-                const auto message = binary_error_message(input, format);
-                CHECK(result.ok == message.empty());
-                if (!result.ok && result.errors < 100)
-                {
-                    CHECK(result.messages.front() == message);
-                }
-#endif
-            }
-        }
-    }
-
-    SECTION("JSON text")
-    {
-        // the parser stopped, but reported success
-        json j;
-        RecoveringParser sax(j);
-        CHECK(!json::sax_parse("[1,2,3,]", &sax));
-        CHECK(sax.errors == 1);
-        CHECK(j == json({1, 2, 3}));
-    }
-
-    SECTION("the SAX parsers of the library stop")
-    {
-        json _;
-        CHECK(json::from_cbor(std::vector<std::uint8_t> {0x9F}, true, false).is_discarded());
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<std::uint8_t> {0x9F}), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
-        CHECK(json::parse("[1,2,3,]", nullptr, false).is_discarded());
-        CHECK(!json::accept("[1,2,3,]"));
-    }
-}
-
 DOCTEST_CLANG_SUPPRESS_WARNING_POP

tests/src/unit-ubjson.cpp

@@ -2520,7 +2520,7 @@ TEST_CASE("Universal Binary JSON Specification Examples 1")
             CHECK_NOTHROW(j = json::from_ubjson(v));
             REQUIRE(j.is_string());
             CHECK(j.get_ref<const json::string_t&>() == std::string("\xc0\xae"));
-            CHECK_THROWS_AS(j.dump(), json::type_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
             CHECK(json::from_ubjson(json::to_ubjson(j)) == j);
 
             // the same bytes as an object key round-trip as well

tests/src/unit-wstring.cpp

@@ -37,10 +37,10 @@ TEST_CASE("wide strings")
         // 32-bit wchar_t first encodes it as an ill-formed three-byte
         // sequence (rejected one byte later, at column 3)
         const char* const error_low_surrogate = sizeof(wchar_t) == 2
-                                                ? "[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.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: '\"\xFF'"
                                                 : "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"\xED\xB0'";
         const char* const error_high_surrogate = sizeof(wchar_t) == 2
-            ? "[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.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: '\"\xFF'"
             : "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"\xED\xA0'";
 
         // a lone low surrogate cannot start a pair