Fix to_bjdata() emitting the Draft-3-only 'B' marker in default Draft-2 mode

_ArrayType_ = "byte" mapped unconditionally to the BJData type marker
'B', regardless of the requested bjdata_version. 'B' is defined only by
BJData Draft 3; with the default version (draft2), this produced a
stream that is invalid for Draft 2 and, unlike every other
_ArrayType_, round-tripped back as a binary value instead of the
original annotated object.

Only accept "byte" / emit 'B' when bjdata_version selects Draft 3.
Under Draft 2, fall back to the same plain-object encoding used
elsewhere in this function for other invalid-annotation cases, so the
value round-trips correctly.

Fixes #5404.

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

include/nlohmann/detail/output/binary_writer.hpp

@@ -1647,6 +1647,20 @@ class binary_writer
         return 'D';  // float 64
     }
 
+    /*!
+    @brief checks whether a JSON number fits into @a TargetType
+    @param[in] el a JSON number of either the signed or unsigned integer kind
+    @return whether @a el's value can be represented by @a TargetType without
+            wrapping, regardless of which of the two kinds it is stored as
+    */
+    template<typename TargetType>
+    static bool bjdata_ndarray_value_in_range(const BasicJsonType& el)
+    {
+        return el.is_number_unsigned()
+               ? value_in_range_of<TargetType>(el.template get<std::uint64_t>())
+               : value_in_range_of<TargetType>(el.template get<std::int64_t>());
+    }
+
     /*!
     @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
     */
@@ -1667,6 +1681,16 @@ class binary_writer
         }
         CharType dtype = it->second;
 
+        // the 'B' (byte) marker is only defined by BJData Draft 3; emitting it
+        // under the default Draft 2 mode would produce a stream that Draft 2
+        // readers reject, so such an object falls back to a plain object
+        // encoding instead (see the "Binary values" section of the BJData
+        // documentation)
+        if (dtype == 'B' && bjdata_version != bjdata_version_t::draft3)
+        {
+            return true;
+        }
+
         key = "_ArraySize_";
         // the dimensions are written verbatim as the header length below, so a
         // value that is not an array cannot produce a valid one: null emits 'Z'
@@ -1731,6 +1755,60 @@ class binary_writer
             }
         }
 
+        // every element is cast to the (possibly narrower) C++ type matching
+        // dtype below; a value that does not fit that type would silently
+        // wrap (integers) or overflow to infinity (the "single" precision
+        // float) instead of being reported, so such an object falls back to
+        // a plain object encoding as well
+        for (const auto& el : value.at(key))
+        {
+            bool in_range = true;
+            switch (dtype)
+            {
+                case 'U':
+                case 'C':
+                case 'B':
+                    in_range = bjdata_ndarray_value_in_range<std::uint8_t>(el);
+                    break;
+                case 'i':
+                    in_range = bjdata_ndarray_value_in_range<std::int8_t>(el);
+                    break;
+                case 'u':
+                    in_range = bjdata_ndarray_value_in_range<std::uint16_t>(el);
+                    break;
+                case 'I':
+                    in_range = bjdata_ndarray_value_in_range<std::int16_t>(el);
+                    break;
+                case 'm':
+                    in_range = bjdata_ndarray_value_in_range<std::uint32_t>(el);
+                    break;
+                case 'l':
+                    in_range = bjdata_ndarray_value_in_range<std::int32_t>(el);
+                    break;
+                case 'M':
+                    in_range = bjdata_ndarray_value_in_range<std::uint64_t>(el);
+                    break;
+                case 'L':
+                    in_range = bjdata_ndarray_value_in_range<std::int64_t>(el);
+                    break;
+                case 'd':
+                {
+                    const auto dval = el.template get<double>();
+                    in_range = !std::isfinite(dval) ||
+                               (dval >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                                dval <= static_cast<double>((std::numeric_limits<float>::max)()));
+                    break;
+                }
+                default:
+                    // 'D' (double) already spans the full range of number_float_t
+                    break;
+            }
+            if (!in_range)
+            {
+                return true;
+            }
+        }
+
         oa->write_character('[');
         oa->write_character('$');
         oa->write_character(dtype);

single_include/nlohmann/json.hpp

@@ -18655,6 +18655,20 @@ class binary_writer
         return 'D';  // float 64
     }
 
+    /*!
+    @brief checks whether a JSON number fits into @a TargetType
+    @param[in] el a JSON number of either the signed or unsigned integer kind
+    @return whether @a el's value can be represented by @a TargetType without
+            wrapping, regardless of which of the two kinds it is stored as
+    */
+    template<typename TargetType>
+    static bool bjdata_ndarray_value_in_range(const BasicJsonType& el)
+    {
+        return el.is_number_unsigned()
+               ? value_in_range_of<TargetType>(el.template get<std::uint64_t>())
+               : value_in_range_of<TargetType>(el.template get<std::int64_t>());
+    }
+
     /*!
     @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
     */
@@ -18675,6 +18689,16 @@ class binary_writer
         }
         CharType dtype = it->second;
 
+        // the 'B' (byte) marker is only defined by BJData Draft 3; emitting it
+        // under the default Draft 2 mode would produce a stream that Draft 2
+        // readers reject, so such an object falls back to a plain object
+        // encoding instead (see the "Binary values" section of the BJData
+        // documentation)
+        if (dtype == 'B' && bjdata_version != bjdata_version_t::draft3)
+        {
+            return true;
+        }
+
         key = "_ArraySize_";
         // the dimensions are written verbatim as the header length below, so a
         // value that is not an array cannot produce a valid one: null emits 'Z'
@@ -18739,6 +18763,60 @@ class binary_writer
             }
         }
 
+        // every element is cast to the (possibly narrower) C++ type matching
+        // dtype below; a value that does not fit that type would silently
+        // wrap (integers) or overflow to infinity (the "single" precision
+        // float) instead of being reported, so such an object falls back to
+        // a plain object encoding as well
+        for (const auto& el : value.at(key))
+        {
+            bool in_range = true;
+            switch (dtype)
+            {
+                case 'U':
+                case 'C':
+                case 'B':
+                    in_range = bjdata_ndarray_value_in_range<std::uint8_t>(el);
+                    break;
+                case 'i':
+                    in_range = bjdata_ndarray_value_in_range<std::int8_t>(el);
+                    break;
+                case 'u':
+                    in_range = bjdata_ndarray_value_in_range<std::uint16_t>(el);
+                    break;
+                case 'I':
+                    in_range = bjdata_ndarray_value_in_range<std::int16_t>(el);
+                    break;
+                case 'm':
+                    in_range = bjdata_ndarray_value_in_range<std::uint32_t>(el);
+                    break;
+                case 'l':
+                    in_range = bjdata_ndarray_value_in_range<std::int32_t>(el);
+                    break;
+                case 'M':
+                    in_range = bjdata_ndarray_value_in_range<std::uint64_t>(el);
+                    break;
+                case 'L':
+                    in_range = bjdata_ndarray_value_in_range<std::int64_t>(el);
+                    break;
+                case 'd':
+                {
+                    const auto dval = el.template get<double>();
+                    in_range = !std::isfinite(dval) ||
+                               (dval >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                                dval <= static_cast<double>((std::numeric_limits<float>::max)()));
+                    break;
+                }
+                default:
+                    // 'D' (double) already spans the full range of number_float_t
+                    break;
+            }
+            if (!in_range)
+            {
+                return true;
+            }
+        }
+
         oa->write_character('[');
         oa->write_character('$');
         oa->write_character(dtype);

tests/CMakeLists.txt

@@ -177,24 +177,6 @@ json_test_add_test_for(src/unit-comparison.cpp
     MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
 )
 
-# test the parser again with JSON_DIAGNOSTIC_POSITIONS enabled
-json_test_set_test_options(test-class_parser_diagnostic_positions
-    COMPILE_DEFINITIONS JSON_DIAGNOSTIC_POSITIONS=1
-)
-json_test_add_test_for(src/unit-class_parser.cpp
-    NAME test-class_parser_diagnostic_positions
-    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
-)
-
-# test diagnostic positions again without regular diagnostics (JSON pointer paths)
-json_test_set_test_options(test-diagnostic-positions_only
-    COMPILE_DEFINITIONS JSON_DIAGNOSTICS=0
-)
-json_test_add_test_for(src/unit-diagnostic-positions.cpp
-    NAME test-diagnostic-positions_only
-    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
-)
-
 # *DO NOT* use json_test_set_test_options() below this line
 
 #############################################################################

tests/src/unit-bjdata.cpp

@@ -2586,7 +2586,12 @@ TEST_CASE("BJData")
                 CHECK(json::to_bjdata(json::from_bjdata(v_d), true, true) == v_d);
                 CHECK(json::to_bjdata(json::from_bjdata(v_D), true, true) == v_D);
                 CHECK(json::to_bjdata(json::from_bjdata(v_C), true, true) == v_C);
-                CHECK(json::to_bjdata(json::from_bjdata(v_B), true, true) == v_B);
+                // v_B uses the Draft-3-only 'B' marker, so it round-trips only when
+                // Draft 3 is explicitly selected (see GitHub issue #5404); the
+                // default Draft 2 falls back to a plain object instead, covered by
+                // the "ndarray with _ArrayType_ "byte" is gated by the BJData draft
+                // version" section below
+                CHECK(json::to_bjdata(json::from_bjdata(v_B), true, true, json::bjdata_version_t::draft3) == v_B);
             }
 
             SECTION("ndarray with data not matching _ArrayType_ is written as an object")
@@ -2629,8 +2634,10 @@ TEST_CASE("BJData")
                 // the C++ API stores an int literal as number_integer, so _ArrayType_
                 // names the wire type rather than the storage. Both storages have to
                 // produce the same typed array for every type.
+                // "byte" is checked separately below since it additionally requires
+                // BJData Draft 3 to be selected explicitly (see GitHub issue #5404).
                 for (const char* type :
-                        {"uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "char", "byte"
+                        {"uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "char"
                         })
                 {
                     CAPTURE(type);
@@ -2641,6 +2648,14 @@ TEST_CASE("BJData")
                     CHECK(from_text == json::to_bjdata(json({{"_ArrayType_", type}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}})));
                 }
 
+                {
+                    const std::string text = R"({"_ArrayType_":"byte","_ArraySize_":[2,3],"_ArrayData_":[1,2,3,4,5,6]})";
+                    const auto from_text = json::to_bjdata(json::parse(text), true, true, json::bjdata_version_t::draft3);
+                    CHECK(from_text.at(0) == '[');
+                    CHECK(from_text == json::to_bjdata(json({{"_ArrayType_", "byte"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}}),
+                    true, true, json::bjdata_version_t::draft3));
+                }
+
                 // negative values under a signed type behave the same way
                 const auto from_neg = json::to_bjdata(json::parse(R"({"_ArrayType_":"int32","_ArraySize_":[2],"_ArrayData_":[-5,7]})"));
                 CHECK(from_neg.at(0) == '[');
@@ -2776,6 +2791,83 @@ TEST_CASE("BJData")
                 CHECK(out_num.at(0) == '{');
                 CHECK(json::from_bjdata(out_num) == j_num);
             }
+
+            SECTION("ndarray with out-of-range _ArrayData_ elements stays as object")
+            {
+                // each element is cast to the (possibly narrower) C++ type
+                // named by _ArrayType_ before being written; a value that
+                // does not fit that type would silently wrap instead of
+                // being reported, so such an object falls back to a plain
+                // object encoding that still round-trips (see GitHub issue #5403)
+
+                // an unsigned element that does not fit uint8
+                json const j_uint8 = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 256}}});
+                const auto out_uint8 = json::to_bjdata(j_uint8);
+                CHECK(out_uint8.at(0) == '{');
+                CHECK(json::from_bjdata(out_uint8) == j_uint8);
+
+                // a signed element that does not fit int8
+                json const j_int8 = json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 200}}});
+                const auto out_int8 = json::to_bjdata(j_int8);
+                CHECK(out_int8.at(0) == '{');
+                CHECK(json::from_bjdata(out_int8) == j_int8);
+
+                // a negative element is likewise out of range for an
+                // unsigned _ArrayType_
+                json const j_uint16_neg = json({{"_ArrayType_", "uint16"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, -1}}});
+                const auto out_uint16_neg = json::to_bjdata(j_uint16_neg);
+                CHECK(out_uint16_neg.at(0) == '{');
+                CHECK(json::from_bjdata(out_uint16_neg) == j_uint16_neg);
+
+                // a double element that overflows to infinity when narrowed
+                // to the "single" (float) precision named by _ArrayType_
+                json const j_single = json({{"_ArrayType_", "single"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1.5, 1e40}}});
+                const auto out_single = json::to_bjdata(j_single);
+                CHECK(out_single.at(0) == '{');
+                CHECK(json::from_bjdata(out_single) == j_single);
+
+                // in-range boundary values still use the compact ndarray encoding
+                json const j_uint8_ok = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {0, 255}}});
+                CHECK(json::to_bjdata(j_uint8_ok) == std::vector<uint8_t>({'[', '$', 'U', '#', '[', 'i', 2, ']', 0, 255}));
+
+                json const j_int8_ok = json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {-128, 127}}});
+                CHECK(json::to_bjdata(j_int8_ok) == std::vector<uint8_t>({'[', '$', 'i', '#', '[', 'i', 2, ']', 0x80, 0x7F}));
+
+                json const j_single_ok = json({{"_ArrayType_", "single"}, {"_ArraySize_", {1}}, {"_ArrayData_", {1.5}}});
+                const auto out_single_ok = json::to_bjdata(j_single_ok);
+                CHECK(out_single_ok.at(0) == '[');
+                CHECK(json::from_bjdata(out_single_ok) == json({1.5f}));
+            }
+
+            SECTION("ndarray with _ArrayType_ \"byte\" is gated by the BJData draft version")
+            {
+                // the 'B' (byte) marker used by _ArrayType_ "byte" is only defined
+                // by BJData Draft 3; Draft 2 (the default) has no such marker, so
+                // emitting it unconditionally produced a stream that a Draft 2
+                // reader could not parse as intended (see GitHub issue #5404).
+                // Two dimensions are used so that a successfully written ndarray
+                // round-trips back into the annotated object (a single dimension
+                // is, by the BJData ndarray convention, read back as a plain
+                // binary value rather than the annotated object, same as every
+                // other single-dimension ndarray of a non-"byte" type is read
+                // back as a plain array instead of the annotated object).
+                json const j_byte = json({{"_ArrayType_", "byte"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}});
+
+                // default (Draft 2): falls back to a plain object and round-trips
+                const auto out_draft2 = json::to_bjdata(j_byte);
+                CHECK(out_draft2.at(0) == '{');
+                CHECK(json::from_bjdata(out_draft2) == j_byte);
+
+                // explicit Draft 2: same as the default
+                const auto out_draft2_explicit = json::to_bjdata(j_byte, true, true, json::bjdata_version_t::draft2);
+                CHECK(out_draft2_explicit.at(0) == '{');
+                CHECK(json::from_bjdata(out_draft2_explicit) == j_byte);
+
+                // Draft 3 explicitly selected: still uses the compact 'B' ndarray encoding
+                const auto out_draft3 = json::to_bjdata(j_byte, true, true, json::bjdata_version_t::draft3);
+                CHECK(out_draft3 == std::vector<uint8_t>({'[', '$', 'B', '#', '[', '$', 'i', '#', 'i', 2, 2, 3, 1, 2, 3, 4, 5, 6}));
+                CHECK(json::from_bjdata(out_draft3) == j_byte);
+            }
         }
     }
 

tests/src/unit-class_parser.cpp

@@ -17,8 +17,6 @@ using nlohmann::json;
 
 #include <valarray>
 #include <algorithm>
-#include <cstdio>
-#include <fstream>
 #include <list>
 #include <sstream>
 #include <string>
@@ -346,50 +344,6 @@ void trailing_comma_helper(const std::string& s)
     }
 }
 
-#if JSON_DIAGNOSTIC_POSITIONS
-/**
- * Validates that the generated JSON object is the same as expected
- * Validates that the start position and end position match the start and end of the string
- *
- * This check assumes that there is no whitespace around the json object in the original string.
- */
-void validate_generated_json_and_start_end_pos_helper(const std::string& original_string, const json& j, const json& check)
-{
-    CHECK(j == check);
-    CHECK(j.start_pos() == 0);
-    CHECK(j.end_pos() == original_string.size());
-}
-
-/**
- * Parses the root object from the given root string and validates that the start and end positions for the nested object are correct.
- *
- * This checks that whitespace around the nested object is included in the start and end positions of the root object.
- */
-void validate_start_end_pos_for_nested_obj_helper(const std::string& nested_type_json_str, const std::string& root_type_json_str, const json& expected_json, const json::parser_callback_t& cb = nullptr)
-{
-    json j;
-
-    // 1. If callback is provided, use callback version of parse()
-    if (cb)
-    {
-        j = json::parse(root_type_json_str, cb);
-    }
-    else
-    {
-        j = json::parse(root_type_json_str);
-    }
-
-    // 2. Check if the generated JSON is as expected
-    // Assumptions: The root_type_json_str does not have any whitespace around the json object
-    validate_generated_json_and_start_end_pos_helper(root_type_json_str, j, expected_json);
-
-    // 3. Get the nested object
-    const auto& nested = j["nested"];
-    // 4. Check if the start and end positions are generated correctly for nested objects and arrays
-    CHECK(nested_type_json_str == root_type_json_str.substr(nested.start_pos(), nested.end_pos() - nested.start_pos()));
-}
-#endif
-
 } // namespace
 
 TEST_CASE("parser class")
@@ -1825,228 +1779,6 @@ TEST_CASE("parser class")
         CHECK_THROWS_WITH_AS(_ = json::parse("/a", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid comment; expecting '/' or '*' after '/'; last read: '/a'", json::parse_error);
         CHECK_THROWS_WITH_AS(_ = json::parse("/*", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid comment; missing closing '*/'; last read: '/*<U+0000>'", json::parse_error);
     }
-
-#if JSON_DIAGNOSTIC_POSITIONS
-    // Macro for all test cases for start_pos and end_pos
-#define SETUP_TESTCASES() \
-    SECTION("with callback") \
-    { \
-        SECTION("filter nothing") \
-        { \
-            json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t /*unused*/, json& /*unused*/) noexcept \
-            { \
-                return true; \
-            }; \
-            validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, expected, cb); \
-        } \
-        SECTION("filter element") \
-        { \
-            json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t event, json& j) noexcept \
-            { \
-                return (event != json::parse_event_t::key && event != json::parse_event_t::value) || j != json("a"); \
-            }; \
-            validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, filteredExpected, cb); \
-        } \
-    } \
-    SECTION("without callback") \
-    { \
-        validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, expected); \
-    }
-
-    SECTION("retrieve start position and end position")
-    {
-        SECTION("for object")
-        {
-            // Create an object with spaces to test the start and end positions. Spaces will not be included in the
-            // JSON object, however, the start and end positions should include the spaces from the input JSON string.
-            const std::string nested_type_json_str =  R"({    "a":       1,"b"      : "test1"})";
-            const std::string root_type_json_str =  R"({    "nested": )" + nested_type_json_str + R"(, "anotherValue": "test2"})";
-            auto expected = json({{"nested", {{"a", 1}, {"b", "test1"}}}, {"anotherValue", "test2"}});
-            auto filteredExpected = expected;
-            filteredExpected["nested"].erase("a");
-
-            SETUP_TESTCASES()
-        }
-
-        SECTION("for array")
-        {
-            const std::string nested_type_json_str =  R"(["a", "test", 45])";
-            const std::string root_type_json_str =  R"({   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-            auto expected = json({{"nested", {"a", "test", 45}}, {"anotherValue", "test"}});
-            auto filteredExpected = expected;
-            filteredExpected["nested"] = json({"test", 45});
-            SETUP_TESTCASES()
-        }
-
-        SECTION("for array with objects")
-        {
-            const std::string nested_type_json_str =  R"([{"a": 1, "b": "test"}, {"c": 2, "d": "test2"}])";
-            const std::string root_type_json_str =  R"({   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-            auto expected = json({{"nested", {{{"a", 1}, {"b", "test"}}, {{"c", 2}, {"d", "test2"}}}}, {"anotherValue", "test"}});
-            auto filteredExpected = expected;
-            filteredExpected["nested"][0].erase("a");
-            SETUP_TESTCASES()
-
-            auto j = json::parse(root_type_json_str);
-            auto nested_array = j["nested"];
-            const auto& nested_obj = nested_array[0];
-            CHECK(nested_type_json_str.substr(1, 21) == root_type_json_str.substr(nested_obj.start_pos(), nested_obj.end_pos() - nested_obj.start_pos()));
-            CHECK(nested_type_json_str.substr(24, 22) == root_type_json_str.substr(nested_array[1].start_pos(), nested_array[1].end_pos() - nested_array[1].start_pos()));
-        }
-
-        SECTION("for two levels of nesting objects")
-        {
-            const std::string nested_type_json_str =  R"({"nested2": {"b": "test"}})";
-            const std::string root_type_json_str =  R"({   "a": 2, "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-            auto expected = json({{"a", 2}, {"nested", {{"nested2", {{"b", "test"}}}}}, {"anotherValue", "test"}});
-            auto filteredExpected = expected;
-            filteredExpected.erase("a");
-            SETUP_TESTCASES()
-
-            auto j = json::parse(root_type_json_str);
-            auto nested_obj = j["nested"]["nested2"];
-            CHECK(nested_type_json_str.substr(12, 13) == root_type_json_str.substr(nested_obj.start_pos(), nested_obj.end_pos() - nested_obj.start_pos()));
-        }
-
-        SECTION("for simple types")
-        {
-            SECTION("no nested")
-            {
-                SECTION("with callback")
-                {
-                    json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t /*unused*/, json& /*unused*/) noexcept
-                    {
-                        return true;
-                    };
-
-                    // 1. string type
-                    std::string json_str =  R"("test")";
-                    auto j = json::parse(json_str, cb);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, "test");
-
-                    // 2. number type
-                    json_str =  R"(1)";
-                    j = json::parse(json_str, cb);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, 1);
-
-                    // 3. boolean type
-                    json_str =  R"(true)";
-                    j = json::parse(json_str, cb);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, true);
-
-                    // 4. null type
-                    json_str =  R"(null)";
-                    j = json::parse(json_str, cb);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, nullptr);
-                }
-
-                SECTION("without callback")
-                {
-                    // 1. string type
-                    std::string json_str =  R"("test")";
-                    auto j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, "test");
-
-                    // 2. number type
-                    json_str =  R"(1)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, 1);
-
-                    json_str = R"(1.001239923)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, 1.001239923);
-
-                    json_str = R"(1.123812389000000)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, 1.123812389);
-
-                    // 3. boolean type
-                    json_str =  R"(true)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, true);
-
-                    json_str =  R"(false)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, false);
-
-                    // 4. null type
-                    json_str =  R"(null)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, nullptr);
-                }
-            }
-
-            SECTION("string type")
-            {
-                const std::string nested_type_json_str =  R"("test")";
-                const std::string root_type_json_str =  R"({ "a": 1,   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-                auto expected = json({{"nested", "test"}, {"anotherValue", "test"}, {"a", 1}});
-                auto filteredExpected = expected;
-                filteredExpected.erase("a");
-                SETUP_TESTCASES()
-            }
-
-            SECTION("number type")
-            {
-                const std::string nested_type_json_str =  R"(2)";
-                const std::string root_type_json_str =  R"({ "a": 1,   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-                auto expected = json({{"nested", 2}, {"anotherValue", "test"}, {"a", 1}});
-                auto filteredExpected = expected;
-                filteredExpected.erase("a");
-                SETUP_TESTCASES()
-            }
-
-            SECTION("boolean type")
-            {
-                const std::string nested_type_json_str =  R"(true)";
-                const std::string root_type_json_str =  R"({ "a": 1,   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-                auto expected = json({{"nested", true}, {"anotherValue", "test"}, {"a", 1}});
-                auto filteredExpected = expected;
-                filteredExpected.erase("a");
-                SETUP_TESTCASES()
-            }
-
-            SECTION("null type")
-            {
-                const std::string nested_type_json_str =  R"(null)";
-                const std::string root_type_json_str =  R"({ "a": 1,   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-                auto expected = json({{"nested", nullptr}, {"anotherValue", "test"}, {"a", 1}});
-                auto filteredExpected = expected;
-                filteredExpected.erase("a");
-                SETUP_TESTCASES()
-            }
-        }
-        SECTION("with leading whitespace and newlines around root JSON")
-        {
-            const std::string initial_whitespace = R"(
-                
-            )";
-            const std::string nested_type_json_str = R"({
-                "a": 1,
-                "nested": {
-                    "b": "test"
-                },
-                "anotherValue": "test"
-            })";
-            const std::string end_whitespace = R"(
-                
-            )";
-            const std::string root_type_json_str = initial_whitespace + nested_type_json_str + end_whitespace;
-
-            auto expected = json({{"a", 1}, {"nested", {{"b", "test"}}}, {"anotherValue", "test"}});
-
-            auto j = json::parse(root_type_json_str);
-
-            // 2. Check if the generated JSON is as expected
-            CHECK(j == expected);
-
-            // 3. Check if the start and end positions do not include the surrounding whitespace
-            CHECK(j.start_pos() == initial_whitespace.size());
-            CHECK(j.end_pos() == root_type_json_str.size() - end_whitespace.size());
-        }
-    }
-#undef SETUP_TESTCASES
-#endif
 }
 
 // this test relies on parse errors being thrown, so it is skipped when
@@ -2155,315 +1887,3 @@ TEST_CASE("last-read diagnostics are identical across input adapters")
     }
 }
 #endif // !defined(JSON_NOEXCEPTION)
-
-// this test characterizes the current (documented-by-example, not otherwise
-// specified) behavior of JSON_DIAGNOSTIC_POSITIONS positions with respect to
-// value lifetime (copy/move/swap/mutation), the various input adapters, and
-// user-driven SAX usage. It is regression protection, not a behavior
-// specification: if any of these checks fail after a change to json.hpp,
-// that change deliberately altered observable behavior and the test (and
-// this comment) should be updated accordingly, rather than "fixed" blindly.
-#if JSON_DIAGNOSTIC_POSITIONS
-TEST_CASE("diagnostic positions: value lifetime, input adapters, and SAX")
-{
-    SECTION("value lifetime")
-    {
-        SECTION("copy constructor copies positions, recursively")
-        {
-            // basic_json(const basic_json&) (json.hpp, around line 1192) copies
-            // start_position/end_position for the value itself; nested values
-            // are copied via their own copy constructor (through the copied
-            // object/array container), so positions are preserved throughout
-            // the whole tree.
-            const std::string s = R"({"a":1,"b":[1,2,3]})";
-            const json a = json::parse(s);
-            const json b = a; // NOLINT(performance-unnecessary-copy-initialization)
-
-            CHECK(b.start_pos() == a.start_pos());
-            CHECK(b.end_pos() == a.end_pos());
-            CHECK(b["b"].start_pos() == a["b"].start_pos());
-            CHECK(b["b"].end_pos() == a["b"].end_pos());
-            CHECK(b["b"][0].start_pos() == a["b"][0].start_pos());
-            CHECK(b["b"][0].end_pos() == a["b"][0].end_pos());
-
-            // sanity: the positions are meaningful (not all npos)
-            CHECK(b.start_pos() == 0);
-            CHECK(b.end_pos() == s.size());
-        }
-
-        SECTION("move constructor resets the moved-from value to npos")
-        {
-            // basic_json(basic_json&&) (json.hpp, around line 1265) copies
-            // other's start_position/end_position into *this and then resets
-            // other's to npos (see the "// cppcheck-suppress[accessForwarded]
-            // TODO check" comments there). Only the top-level moved-from value
-            // is affected; its (moved-away) children are gone along with it.
-            const std::string s = R"({"a":1,"b":[1,2,3]})";
-            json a = json::parse(s);
-            const auto a_start = a.start_pos();
-            const auto a_end = a.end_pos();
-            const auto nested_start = a["b"].start_pos();
-            const auto nested_end = a["b"].end_pos();
-
-            const json b(std::move(a));
-
-            // the destination retains the original positions, recursively
-            CHECK(b.start_pos() == a_start);
-            CHECK(b.end_pos() == a_end);
-            CHECK(b["b"].start_pos() == nested_start);
-            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.start_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,clang-analyzer-cplusplus.Move)
-        }
-
-        SECTION("swap() does NOT exchange positions (likely a real bug, see below)")
-        {
-            // NOTE (characterizing, not fixing, for #5420): basic_json::swap()
-            // (json.hpp, around line 3540, and the friend swap() that forwards
-            // to it) swaps m_data.m_type and m_data.m_value but -- unlike
-            // copy-assignment's operator=(basic_json) (json.hpp, around line
-            // 1291), which swaps start_position/end_position as part of its
-            // copy-and-swap implementation -- it never touches
-            // start_position/end_position. So after swap(a, b), the *values*
-            // of a and b are exchanged, but their *positions* are not: each
-            // ends up with its own original position describing the other's
-            // new content. This looks like an oversight/inconsistency rather
-            // than intended behavior, and is flagged to the maintainer; this
-            // test only pins the current (surprising) behavior so a fix (or a
-            // deliberate decision to keep it) shows up here as an intentional
-            // change rather than a silent regression.
-            json a = json::parse(R"({"a":1})");
-            json b = json::parse(R"([1,2,3,4,5])");
-            const auto a_start = a.start_pos();
-            const auto a_end = a.end_pos();
-            const auto b_start = b.start_pos();
-            const auto b_end = b.end_pos();
-            // both start at 0 (root values start right away), but their
-            // lengths (and thus end positions) differ, which is enough to
-            // tell after the swap whether positions actually moved with
-            // the values
-            CHECK(a_end != b_end);
-
-            using std::swap;
-            swap(a, b);
-
-            // values were exchanged as expected ...
-            CHECK(a == json::parse(R"([1,2,3,4,5])"));
-            CHECK(b == json::parse(R"({"a":1})"));
-
-            // ... but positions were NOT: each variable kept its own
-            // original position, now describing the other's content
-            CHECK(a.start_pos() == a_start);
-            CHECK(a.end_pos() == a_end);
-            CHECK(b.start_pos() == b_start);
-            CHECK(b.end_pos() == b_end);
-        }
-
-        SECTION("mutating a parsed document leaves positions of unrelated values untouched")
-        {
-            // Positions are recorded once, during parsing, and are not
-            // recomputed on mutation. As a consequence, after a mutation the
-            // parent's own recorded span may no longer describe its current
-            // (serialized) content -- it still describes what was originally
-            // parsed. This is characterized here as current behavior, not
-            // asserted to be desirable or specified.
-            SECTION("operator[] adding a new object key")
-            {
-                const std::string s = R"({"a":1})";
-                json j = json::parse(s);
-                const auto root_start = j.start_pos();
-                const auto root_end = j.end_pos();
-                const auto a_start = j["a"].start_pos();
-                const auto a_end = j["a"].end_pos();
-
-                j["c"] = 42;
-
-                // the newly-added value was never parsed, so it has no position
-                CHECK(j["c"].start_pos() == std::string::npos);
-                CHECK(j["c"].end_pos() == std::string::npos);
-
-                // the existing sibling's position is unaffected
-                CHECK(j["a"].start_pos() == a_start);
-                CHECK(j["a"].end_pos() == a_end);
-
-                // the parent's own recorded span is left as-is (now stale:
-                // it still reflects the original, shorter `{"a":1}` string)
-                CHECK(j.start_pos() == root_start);
-                CHECK(j.end_pos() == root_end);
-            }
-
-            SECTION("push_back on a parsed array")
-            {
-                const std::string s = R"([1,2,3])";
-                json j = json::parse(s);
-                const auto root_start = j.start_pos();
-                const auto root_end = j.end_pos();
-                const auto first_start = j[0].start_pos();
-
-                j.push_back(4);
-
-                CHECK(j.back().start_pos() == std::string::npos);
-                CHECK(j.back().end_pos() == std::string::npos);
-                CHECK(j[0].start_pos() == first_start);
-                CHECK(j.start_pos() == root_start);
-                CHECK(j.end_pos() == root_end);
-            }
-
-            SECTION("erase on a parsed array shifts elements but keeps their own positions")
-            {
-                const std::string s = R"([1,2,3])";
-                json j = json::parse(s);
-                const auto second_start = j[1].start_pos();
-                const auto third_start = j[2].start_pos();
-                const auto root_start = j.start_pos();
-                const auto root_end = j.end_pos();
-
-                j.erase(0);
-
-                // remaining elements moved down an index, but each one still
-                // reports the position it had *before* the erase (i.e. its
-                // position in the original source string, not a
-                // recalculated one)
-                CHECK(j[0].start_pos() == second_start);
-                CHECK(j[1].start_pos() == third_start);
-
-                // the parent's own recorded span is again left as-is
-                CHECK(j.start_pos() == root_start);
-                CHECK(j.end_pos() == root_end);
-            }
-        }
-    }
-
-    SECTION("input adapters")
-    {
-        SECTION("wide string input: positions count transcoded UTF-8 bytes, not wide characters")
-        {
-            // 'é' (U+00E9) is a single code unit in a wchar_t/UTF-16 string, but
-            // transcodes to 2 bytes in UTF-8; the lexer only ever sees the
-            // transcoded UTF-8 byte stream, so reported positions are byte
-            // offsets into that UTF-8 stream, not indices into the original
-            // std::wstring.
-            const std::wstring ws = L"{\"a\":\"éé\"}";
-            CHECK(ws.size() == 10); // 10 wide characters
-
-            const json j = json::parse(ws);
-            CHECK(j.start_pos() == 0);
-            // the transcoded UTF-8 form is 2 bytes longer than the wide string,
-            // because each of the two 'é' characters becomes 2 UTF-8 bytes
-            CHECK(j.end_pos() == 12);
-            CHECK(j.end_pos() != ws.size());
-
-            const json& a = j["a"];
-            CHECK(a.start_pos() == 5);
-            CHECK(a.end_pos() == 11);
-        }
-
-        SECTION("BOM-prefixed input: start_pos() reflects the skipped 3-byte BOM")
-        {
-            const std::string s = "\xEF\xBB\xBF{\"a\":1}";
-            const json j = json::parse(s);
-
-            // the lexer silently skips the BOM before parsing the value, so
-            // the root value's recorded span starts right after it
-            CHECK(j.start_pos() == 3);
-            CHECK(j.end_pos() == s.size());
-        }
-
-        SECTION("std::istringstream: positions are consistent, not npos")
-        {
-            const std::string s = R"({"a":1,"b":2})";
-            std::istringstream ss(s);
-            const json j = json::parse(ss);
-
-            CHECK(j.start_pos() == 0);
-            CHECK(j.end_pos() == s.size());
-            CHECK(j["a"].start_pos() == 5);
-        }
-
-        SECTION("std::ifstream: positions are consistent, not npos")
-        {
-            const std::string s = R"({"a":1,"b":2})";
-            {
-                std::ofstream file("unit-class_parser_diagnostic_positions.tmp");
-                file << s;
-            }
-
-            {
-                std::ifstream f("unit-class_parser_diagnostic_positions.tmp");
-                const json j = json::parse(f);
-
-                CHECK(j.start_pos() == 0);
-                CHECK(j.end_pos() == s.size());
-                CHECK(j["a"].start_pos() == 5);
-            }
-
-            static_cast<void>(std::remove("unit-class_parser_diagnostic_positions.tmp"));
-        }
-
-        SECTION("iterator-pair input: positions are consistent, not npos")
-        {
-            const std::string s = R"({"a":1,"b":2})";
-            const json j = json::parse(s.begin(), s.end());
-
-            CHECK(j.start_pos() == 0);
-            CHECK(j.end_pos() == s.size());
-            CHECK(j["a"].start_pos() == 5);
-        }
-
-        SECTION("binary formats have no text positions")
-        {
-            // binary formats (CBOR, MessagePack, UBJSON, BSON, BJData) are
-            // parsed via detail::binary_reader, which never sets
-            // start_position/end_position on the values it produces (they
-            // have no notion of a text offset), so every value's position
-            // stays at its default of npos.
-            const json src = json::parse(R"({"a":1,"b":[1,2]})");
-
-            const json from_cbor = json::from_cbor(json::to_cbor(src));
-            CHECK(from_cbor.start_pos() == std::string::npos);
-            CHECK(from_cbor.end_pos() == std::string::npos);
-            CHECK(from_cbor["a"].start_pos() == std::string::npos);
-            CHECK(from_cbor["b"][0].start_pos() == std::string::npos);
-
-            const json from_msgpack = json::from_msgpack(json::to_msgpack(src));
-            CHECK(from_msgpack.start_pos() == std::string::npos);
-            CHECK(from_msgpack.end_pos() == std::string::npos);
-
-            const json from_ubjson = json::from_ubjson(json::to_ubjson(src));
-            CHECK(from_ubjson.start_pos() == std::string::npos);
-            CHECK(from_ubjson.end_pos() == std::string::npos);
-
-            const json from_bson_val = json::from_bson(json::to_bson(src));
-            CHECK(from_bson_val.start_pos() == std::string::npos);
-            CHECK(from_bson_val.end_pos() == std::string::npos);
-        }
-    }
-
-    SECTION("user-driven SAX consumers with no lexer report npos")
-    {
-        // json::parse() internally wires up its json_sax_dom_parser with a
-        // pointer to its own lexer (see parser.hpp), which is how positions
-        // get set at all. A user who constructs a json_sax_dom_parser
-        // directly (e.g. to drive it via json::sax_parse()) and does not
-        // supply a lexer pointer gets a consumer with m_lexer_ref == nullptr;
-        // every "if (m_lexer_ref)" guard in json_sax.hpp is then skipped, so
-        // every value it produces keeps its default, unset position (npos).
-        // This was previously true but silently unasserted (operator==
-        // ignores positions), see #5420.
-        json result;
-        nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::string_input_adapter_type> sdp(result);
-        const std::string s = R"({"a":1,"b":[1,2,3]})";
-        CHECK(json::sax_parse(s, &sdp));
-
-        CHECK(result.start_pos() == std::string::npos);
-        CHECK(result.end_pos() == std::string::npos);
-        CHECK(result["a"].start_pos() == std::string::npos);
-        CHECK(result["a"].end_pos() == std::string::npos);
-        CHECK(result["b"][0].start_pos() == std::string::npos);
-        CHECK(result["b"][0].end_pos() == std::string::npos);
-    }
-}
-#endif

tests/src/unit-diagnostic-positions-only.cpp

@@ -0,0 +1,44 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#include "doctest_compatibility.h"
+
+#ifdef JSON_DIAGNOSTICS
+    #undef JSON_DIAGNOSTICS
+#endif
+
+#define JSON_DIAGNOSTICS 0
+#define JSON_DIAGNOSTIC_POSITIONS 1
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+TEST_CASE("Better diagnostics with positions only")
+{
+    SECTION("invalid type")
+    {
+        const std::string json_invalid_string = R"(
+        {
+            "address": {
+                "street": "Fake Street",
+                "housenumber": "1"
+            }
+        }
+        )";
+        json j = json::parse(json_invalid_string);
+        CHECK_THROWS_WITH_AS(j.at("address").at("housenumber").get<int>(),
+                             "[json.exception.type_error.302] (bytes 108-111) type must be number, but is string", json::type_error);
+    }
+
+    SECTION("invalid type without positions")
+    {
+        const json j = "foo";
+        CHECK_THROWS_WITH_AS(j.get<int>(),
+                             "[json.exception.type_error.302] type must be number, but is string", json::type_error);
+    }
+}

tests/src/unit-diagnostic-positions.cpp

@@ -8,9 +8,7 @@
 
 #include "doctest_compatibility.h"
 
-#ifndef JSON_DIAGNOSTICS
-    #define JSON_DIAGNOSTICS 1
-#endif
+#define JSON_DIAGNOSTICS 1
 #define JSON_DIAGNOSTIC_POSITIONS 1
 #include <nlohmann/json.hpp>
 
@@ -29,13 +27,8 @@ TEST_CASE("Better diagnostics with positions")
         }
         )";
         json j = json::parse(json_invalid_string);
-#if JSON_DIAGNOSTICS
         CHECK_THROWS_WITH_AS(j.at("address").at("housenumber").get<int>(),
                              "[json.exception.type_error.302] (/address/housenumber) (bytes 108-111) type must be number, but is string", json::type_error);
-#else
-        CHECK_THROWS_WITH_AS(j.at("address").at("housenumber").get<int>(),
-                             "[json.exception.type_error.302] (bytes 108-111) type must be number, but is string", json::type_error);
-#endif
     }
 
     SECTION("invalid type without positions")
@@ -81,12 +74,7 @@ TEST_CASE("Better diagnostics with positions")
         // (/foo/bar); the position of that parent is reported in the message
         const json doc = json::parse(R"({"foo":{"bar":"a string"}})");
         const json patch = json::parse(R"([{"op":"add","path":"/foo/bar/baz","value":1}])");
-#if JSON_DIAGNOSTICS
         CHECK_THROWS_WITH_AS(doc.patch(patch),
                              "[json.exception.out_of_range.411] (/foo/bar) (bytes 14-24) cannot add value: the JSON Patch 'add' target's parent is of type string, but must be an object or array", json::out_of_range);
-#else
-        CHECK_THROWS_WITH_AS(doc.patch(patch),
-                             "[json.exception.out_of_range.411] (bytes 14-24) cannot add value: the JSON Patch 'add' target's parent is of type string, but must be an object or array", json::out_of_range);
-#endif
     }
 }