Make contains(json_pointer) return false instead of throwing on unrepresentable array-index tokens

contains(const json_pointer&) is documented to never throw, but a purely
numeric reference token that is syntactically a valid array index yet
numerically too large to be represented (exceeding size_type's max, or
exceeding ULLONG_MAX and causing strtoull() to set errno to ERANGE) made
it fall through to array_index(), which throws out_of_range.410/404.

Pre-check the token's magnitude the same way array_index() does, but
return false instead of throwing, mirroring how the surrounding code
already rejects other malformed tokens (leading zero, non-digit
characters, "-") without throwing. operator[]/at() are untouched and
keep throwing for these inputs.

Fixes #5395

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

include/nlohmann/detail/input/json_sax.hpp

@@ -301,16 +301,6 @@ class json_sax_dom_parser
             JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
         }
 
-        if (len != detail::unknown_size())
-        {
-            // reserve upfront to avoid repeated reallocations while adding elements,
-            // but cap the reservation so a bogus/hostile length (which is not bounded
-            // by max_size(), unlike e.g. std::vector) cannot trigger an oversized
-            // allocation for a small or truncated input
-            constexpr std::size_t reserve_cap = 16384;
-            ref_stack.back()->m_data.m_value.array->reserve(len < reserve_cap ? len : reserve_cap);
-        }
-
         return true;
     }
 
@@ -671,16 +661,6 @@ class json_sax_dom_callback_parser
             {
                 JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
             }
-
-            if (len != detail::unknown_size())
-            {
-                // reserve upfront to avoid repeated reallocations while adding elements,
-                // but cap the reservation so a bogus/hostile length (which is not bounded
-                // by max_size(), unlike e.g. std::vector) cannot trigger an oversized
-                // allocation for a small or truncated input
-                constexpr std::size_t reserve_cap = 16384;
-                ref_stack.back()->m_data.m_value.array->reserve(len < reserve_cap ? len : reserve_cap);
-            }
         }
 
         return true;

include/nlohmann/detail/json_pointer.hpp

@@ -748,6 +748,20 @@ class json_pointer
                         }
                     }
 
+                    // the reference token consists only of digits at this point (cf. checks
+                    // above); however, its numeric value might not be representable, in which
+                    // case array_index() would throw out_of_range.404/410 -- contains() must
+                    // not throw (see #5395), so such a reference token is treated as "not found"
+                    errno = 0; // strtoull() does not reset errno on success
+                    char* p_end = nullptr; // NOLINT(misc-const-correctness)
+                    const unsigned long long magnitude = std::strtoull(reference_token.c_str(), &p_end, 10); // NOLINT(runtime/int)
+                    if (JSON_HEDLEY_UNLIKELY(errno == ERANGE // the value exceeds ULLONG_MAX
+                                             || magnitude >= static_cast<unsigned long long>((std::numeric_limits<typename BasicJsonType::size_type>::max)()))) // NOLINT(runtime/int)
+                    {
+                        // the array index cannot be represented as size_type
+                        return false;
+                    }
+
                     const auto idx = array_index<BasicJsonType>(reference_token);
                     if (idx >= ptr->size())
                     {

single_include/nlohmann/json.hpp

@@ -9829,16 +9829,6 @@ class json_sax_dom_parser
             JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
         }
 
-        if (len != detail::unknown_size())
-        {
-            // reserve upfront to avoid repeated reallocations while adding elements,
-            // but cap the reservation so a bogus/hostile length (which is not bounded
-            // by max_size(), unlike e.g. std::vector) cannot trigger an oversized
-            // allocation for a small or truncated input
-            constexpr std::size_t reserve_cap = 16384;
-            ref_stack.back()->m_data.m_value.array->reserve(len < reserve_cap ? len : reserve_cap);
-        }
-
         return true;
     }
 
@@ -10199,16 +10189,6 @@ class json_sax_dom_callback_parser
             {
                 JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
             }
-
-            if (len != detail::unknown_size())
-            {
-                // reserve upfront to avoid repeated reallocations while adding elements,
-                // but cap the reservation so a bogus/hostile length (which is not bounded
-                // by max_size(), unlike e.g. std::vector) cannot trigger an oversized
-                // allocation for a small or truncated input
-                constexpr std::size_t reserve_cap = 16384;
-                ref_stack.back()->m_data.m_value.array->reserve(len < reserve_cap ? len : reserve_cap);
-            }
         }
 
         return true;
@@ -16414,6 +16394,20 @@ class json_pointer
                         }
                     }
 
+                    // the reference token consists only of digits at this point (cf. checks
+                    // above); however, its numeric value might not be representable, in which
+                    // case array_index() would throw out_of_range.404/410 -- contains() must
+                    // not throw (see #5395), so such a reference token is treated as "not found"
+                    errno = 0; // strtoull() does not reset errno on success
+                    char* p_end = nullptr; // NOLINT(misc-const-correctness)
+                    const unsigned long long magnitude = std::strtoull(reference_token.c_str(), &p_end, 10); // NOLINT(runtime/int)
+                    if (JSON_HEDLEY_UNLIKELY(errno == ERANGE // the value exceeds ULLONG_MAX
+                                             || magnitude >= static_cast<unsigned long long>((std::numeric_limits<typename BasicJsonType::size_type>::max)()))) // NOLINT(runtime/int)
+                    {
+                        // the array index cannot be represented as size_type
+                        return false;
+                    }
+
                     const auto idx = array_index<BasicJsonType>(reference_token);
                     if (idx >= ptr->size())
                     {

tests/src/unit-bjdata.cpp

@@ -3489,111 +3489,6 @@ TEST_CASE("BJData")
     }
 }
 
-TEST_CASE("issue #5405 - array reserve for definite-length BJData arrays")
-{
-#if !defined(JSON_NOEXCEPTION)
-    // this SECTION relies on catching a thrown exception to distinguish
-    // which of two acceptable, bounded rejections a hostile header took;
-    // under JSON_NOEXCEPTION, JSON_THROW never produces a catchable C++
-    // exception (it aborts instead), so this cannot be tested that way here
-    SECTION("a huge claimed length with no element data must not over-allocate")
-    {
-        // optimized form [$type#count: type 'i' (int8), count as a four-byte
-        // little-endian 'l' (int32) of 0x7FFFFFFF (2147483647), but no
-        // element data at all. max_size() for a std::vector is far larger
-        // than this count, so it does not reject the header outright; the
-        // (capped) reservation must not attempt to allocate space for
-        // billions of elements before the missing data is detected.
-        json _;
-        const std::vector<uint8_t> input = {'[', '$', 'i', '#', 'l', 0xFF, 0xFF, 0xFF, 0x7F};
-        // On a platform where std::vector<json>::max_size() is smaller than
-        // the claimed count (e.g. 32-bit, where max_size() is bounded by a
-        // 32-bit SIZE_MAX divided by sizeof(json)), the SAX consumer's own
-        // check rejects the header outright (out_of_range.408, with the
-        // claimed count in the message) instead of accepting it and only
-        // finding it short of data once the (capped) reservation looks for
-        // element bytes that were never provided (parse_error.110). Either
-        // is an acceptable, bounded rejection of the hostile header -- the
-        // property under test is that no path attempts to allocate space
-        // for billions of elements.
-        bool threw = false;
-        try
-        {
-            _ = json::from_bjdata(input);
-        }
-        catch (const json::parse_error& e)
-        {
-            threw = true;
-            CHECK(e.id == 110);
-            CHECK(std::string(e.what()) == "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing BJData number: unexpected end of input");
-        }
-        catch (const json::out_of_range& e)
-        {
-            threw = true;
-            CHECK(e.id == 408);
-            CHECK(std::string(e.what()).find("excessive array size") != std::string::npos);
-        }
-        CHECK(threw);
-
-        // json_sax_dom_parser::start_array()'s max_size() check (unlike the
-        // scanner's own parse_error path) throws unconditionally via
-        // JSON_THROW rather than going through sax->parse_error(), so it is
-        // not gated by allow_exceptions=false on a platform where this
-        // header hits that check (e.g. 32-bit, see above) -- allow either
-        // a discarded result or the same out_of_range it throws with
-        // exceptions enabled.
-        try
-        {
-            CHECK(json::from_bjdata(input, true, false).is_discarded());
-        }
-        catch (const json::out_of_range& e)
-        {
-            CHECK(e.id == 408);
-        }
-    }
-#endif
-
-    SECTION("arrays of various sizes decode to the same value as before the reserve optimization")
-    {
-        for (const auto size :
-                {
-                    std::size_t{0}, std::size_t{1}, std::size_t{5}, // small
-                    std::size_t{16384},                             // exactly at the reserve cap
-                    std::size_t{20000}                              // above the reserve cap
-                })
-        {
-            CAPTURE(size)
-            json j = json::array();
-            for (std::size_t i = 0; i < size; ++i)
-            {
-                j.push_back(static_cast<int>(i % 1000));
-            }
-
-            // exercise both the plain and the optimized [$type#count encoding
-            const auto packed_plain = json::to_bjdata(j);
-            CHECK(json::from_bjdata(packed_plain) == j);
-
-            const auto packed_optimized = json::to_bjdata(j, true, true);
-            CHECK(json::from_bjdata(packed_optimized) == j);
-        }
-    }
-
-    SECTION("a user-defined SAX consumer is unaffected by the internal DOM reserve optimization")
-    {
-        // the reserve() call is local to json_sax_dom_parser / json_sax_dom_callback_parser;
-        // a custom SAX consumer that does not touch a DOM array sees identical events
-        json j = json::array();
-        for (int i = 0; i < 100; ++i)
-        {
-            j.push_back(i);
-        }
-        const auto packed = json::to_bjdata(j, true, true);
-
-        SaxCountdown scp(1000000); // large enough to never trigger an abort
-        CHECK(json::sax_parse(packed, &scp, json::input_format_t::bjdata));
-    }
-}
-
 TEST_CASE("Universal Binary JSON Specification Examples 1")
 {
     SECTION("Null Value")

tests/src/unit-cbor.cpp

@@ -2035,92 +2035,6 @@ TEST_CASE("CBOR definite length equal to the indefinite-length sentinel")
     }
 }
 
-TEST_CASE("issue #5405 - array reserve for definite-length CBOR arrays")
-{
-#if !defined(JSON_NOEXCEPTION)
-    // this SECTION relies on catching a thrown exception to distinguish
-    // which of two acceptable, bounded rejections a hostile header took;
-    // under JSON_NOEXCEPTION, JSON_THROW never produces a catchable C++
-    // exception (it aborts instead), so this cannot be tested that way here
-    SECTION("a huge claimed length with no element data must not over-allocate")
-    {
-        // 0x9A: array with a four-byte length; claims 0xFFFFFFFF (4294967295)
-        // elements but provides none. max_size() for a std::vector is far
-        // larger than this count, so it does not reject the header outright;
-        // the (capped) reservation must not attempt to allocate space for
-        // billions of elements before the missing data is detected.
-        json _;
-        const std::vector<uint8_t> input = {0x9A, 0xFF, 0xFF, 0xFF, 0xFF};
-        // On a platform where std::size_t is narrower than 64 bits (e.g.
-        // 32-bit), the claimed count 0xFFFFFFFF coincides with that
-        // platform's detail::unknown_size() sentinel (SIZE_MAX), so the
-        // format-level size check rejects it outright (out_of_range.408,
-        // "excessive ... size") before the SAX consumer's own max_size()
-        // check would even run; on a 64-bit platform it passes both of
-        // those checks and is only found short of data once the (capped)
-        // reservation looks for element bytes that were never provided
-        // (parse_error.110). Either is an acceptable, bounded rejection of
-        // the hostile header -- the property under test is that no path
-        // attempts to allocate space for billions of elements.
-        bool threw = false;
-        try
-        {
-            _ = json::from_cbor(input);
-        }
-        catch (const json::parse_error& e)
-        {
-            threw = true;
-            CHECK(e.id == 110);
-            CHECK(std::string(e.what()) == "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing CBOR value: unexpected end of input");
-        }
-        catch (const json::out_of_range& e)
-        {
-            threw = true;
-            CHECK(e.id == 408);
-            CHECK(std::string(e.what()).find("excessive") != std::string::npos);
-        }
-        CHECK(threw);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-#endif
-
-    SECTION("arrays of various sizes decode to the same value as before the reserve optimization")
-    {
-        for (const auto size :
-                {
-                    std::size_t{0}, std::size_t{1}, std::size_t{5}, // small
-                    std::size_t{16384},                             // exactly at the reserve cap
-                    std::size_t{20000}                              // above the reserve cap
-                })
-        {
-            CAPTURE(size)
-            json j = json::array();
-            for (std::size_t i = 0; i < size; ++i)
-            {
-                j.push_back(static_cast<int>(i % 1000));
-            }
-
-            const auto packed = json::to_cbor(j);
-            CHECK(json::from_cbor(packed) == j);
-        }
-    }
-
-    SECTION("a user-defined SAX consumer is unaffected by the internal DOM reserve optimization")
-    {
-        // the reserve() call is local to json_sax_dom_parser / json_sax_dom_callback_parser;
-        // a custom SAX consumer that does not touch a DOM array sees identical events
-        json j = json::array();
-        for (int i = 0; i < 100; ++i)
-        {
-            j.push_back(i);
-        }
-        const auto packed = json::to_cbor(j);
-
-        SaxCountdown scp(1000000); // large enough to never trigger an abort
-        CHECK(json::sax_parse(packed, &scp, json::input_format_t::cbor));
-    }
-}
-
 TEST_CASE("CBOR roundtrips" * doctest::skip())
 {
     SECTION("input from flynn")

tests/src/unit-json_pointer.cpp

@@ -319,6 +319,44 @@ TEST_CASE("JSON pointers")
 
                 CHECK_THROWS_WITH_AS(j[jp] = 1, throw_msg.c_str(), json::out_of_range&);
                 CHECK_THROWS_WITH_AS(j_const[jp] == 1, throw_msg.c_str(), json::out_of_range&);
+
+                // #5395: contains() must not throw for a reference token that is a
+                // syntactically valid array index but numerically exceeds ULLONG_MAX
+                // (causing strtoull() to set errno to ERANGE) -- it should just report
+                // that the pointer does not resolve to an element
+                CHECK(!j.contains(jp));
+                CHECK(!j_const.contains(jp));
+            }
+
+            {
+                // #5395: same as above, but using the exact reproduction from the issue
+                json::json_pointer const jp("/99999999999999999999");
+                std::string const throw_msg = "[json.exception.out_of_range.404] unresolved reference token '99999999999999999999'";
+
+                CHECK_THROWS_WITH_AS(j[jp] = 1, throw_msg.c_str(), json::out_of_range&);
+                CHECK_THROWS_WITH_AS(j_const[jp] == 1, throw_msg.c_str(), json::out_of_range&);
+                CHECK_THROWS_WITH_AS(j.at(jp) = 1, throw_msg.c_str(), json::out_of_range&);
+                CHECK_THROWS_WITH_AS(j_const.at(jp) == 1, throw_msg.c_str(), json::out_of_range&);
+
+                CHECK(!j.contains(jp));
+                CHECK(!j_const.contains(jp));
+            }
+
+            {
+                // #5395: a reference token that is numerically representable in
+                // unsigned long long but exceeds size_type's max (e.g. ULLONG_MAX
+                // itself on typical 64-bit platforms, where size_type's max equals
+                // ULLONG_MAX) must not make contains() throw either
+                json::json_pointer const jp("/18446744073709551615");
+                std::string const throw_msg = "[json.exception.out_of_range.410] array index 18446744073709551615 exceeds size_type";
+
+                CHECK_THROWS_WITH_AS(j[jp] = 1, throw_msg.c_str(), json::out_of_range&);
+                CHECK_THROWS_WITH_AS(j_const[jp] == 1, throw_msg.c_str(), json::out_of_range&);
+                CHECK_THROWS_WITH_AS(j.at(jp) = 1, throw_msg.c_str(), json::out_of_range&);
+                CHECK_THROWS_WITH_AS(j_const.at(jp) == 1, throw_msg.c_str(), json::out_of_range&);
+
+                CHECK(!j.contains(jp));
+                CHECK(!j_const.contains(jp));
             }
 
             // on some machines, the check below is not constant
@@ -334,6 +372,10 @@ TEST_CASE("JSON pointers")
 
                 CHECK_THROWS_WITH_AS(j[jp] = 1, throw_msg.c_str(), json::out_of_range&);
                 CHECK_THROWS_WITH_AS(j_const[jp] == 1, throw_msg.c_str(), json::out_of_range&);
+
+                // #5395: contains() must not throw for a reference token exceeding size_type's max
+                CHECK(!j.contains(jp));
+                CHECK(!j_const.contains(jp));
             }
 
             DOCTEST_MSVC_SUPPRESS_WARNING_POP

tests/src/unit-msgpack.cpp

@@ -1597,91 +1597,6 @@ TEST_CASE("MessagePack")
     }
 }
 
-TEST_CASE("issue #5405 - array reserve for definite-length MessagePack arrays")
-{
-#if !defined(JSON_NOEXCEPTION)
-    // this SECTION relies on catching a thrown exception to distinguish
-    // which of two acceptable, bounded rejections a hostile header took;
-    // under JSON_NOEXCEPTION, JSON_THROW never produces a catchable C++
-    // exception (it aborts instead), so this cannot be tested that way here
-    SECTION("a huge claimed length with no element data must not over-allocate")
-    {
-        // 0xdd: array 32 (four-byte length); claims 0xFFFFFFFF (4294967295)
-        // elements but provides none. max_size() for a std::vector is far
-        // larger than this count, so it does not reject the header outright;
-        // the (capped) reservation must not attempt to allocate space for
-        // billions of elements before the missing data is detected.
-        json _;
-        const std::vector<uint8_t> input = {0xdd, 0xFF, 0xFF, 0xFF, 0xFF};
-        // On a platform where std::size_t is narrower than 64 bits (e.g.
-        // 32-bit), the claimed count 0xFFFFFFFF coincides with that
-        // platform's SIZE_MAX, which some size-narrowing checks treat the
-        // same as detail::unknown_size(); it may then be rejected before
-        // the SAX consumer's own max_size() check (out_of_range.408) rather
-        // than being accepted and only found short of data once the
-        // (capped) reservation looks for element bytes that were never
-        // provided (parse_error.110). Either is an acceptable, bounded
-        // rejection of the hostile header -- the property under test is
-        // that no path attempts to allocate space for billions of elements.
-        bool threw = false;
-        try
-        {
-            _ = json::from_msgpack(input);
-        }
-        catch (const json::parse_error& e)
-        {
-            threw = true;
-            CHECK(e.id == 110);
-            CHECK(std::string(e.what()) == "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing MessagePack value: unexpected end of input");
-        }
-        catch (const json::out_of_range& e)
-        {
-            threw = true;
-            CHECK(e.id == 408);
-            CHECK(std::string(e.what()).find("excessive") != std::string::npos);
-        }
-        CHECK(threw);
-        CHECK(json::from_msgpack(input, true, false).is_discarded());
-    }
-#endif
-
-    SECTION("arrays of various sizes decode to the same value as before the reserve optimization")
-    {
-        for (const auto size :
-                {
-                    std::size_t{0}, std::size_t{1}, std::size_t{5}, // small
-                    std::size_t{16384},                             // exactly at the reserve cap
-                    std::size_t{20000}                              // above the reserve cap
-                })
-        {
-            CAPTURE(size)
-            json j = json::array();
-            for (std::size_t i = 0; i < size; ++i)
-            {
-                j.push_back(static_cast<int>(i % 1000));
-            }
-
-            const auto packed = json::to_msgpack(j);
-            CHECK(json::from_msgpack(packed) == j);
-        }
-    }
-
-    SECTION("a user-defined SAX consumer is unaffected by the internal DOM reserve optimization")
-    {
-        // the reserve() call is local to json_sax_dom_parser / json_sax_dom_callback_parser;
-        // a custom SAX consumer that does not touch a DOM array sees identical events
-        json j = json::array();
-        for (int i = 0; i < 100; ++i)
-        {
-            j.push_back(i);
-        }
-        const auto packed = json::to_msgpack(j);
-
-        SaxCountdown scp(1000000); // large enough to never trigger an abort
-        CHECK(json::sax_parse(packed, &scp, json::input_format_t::msgpack));
-    }
-}
-
 // use this testcase outside [hide] to run it with Valgrind
 TEST_CASE("single MessagePack roundtrip")
 {

tests/src/unit-ubjson.cpp

@@ -2149,111 +2149,6 @@ TEST_CASE("UBJSON")
     }
 }
 
-TEST_CASE("issue #5405 - array reserve for definite-length UBJSON arrays")
-{
-#if !defined(JSON_NOEXCEPTION)
-    // this SECTION relies on catching a thrown exception to distinguish
-    // which of two acceptable, bounded rejections a hostile header took;
-    // under JSON_NOEXCEPTION, JSON_THROW never produces a catchable C++
-    // exception (it aborts instead), so this cannot be tested that way here
-    SECTION("a huge claimed length with no element data must not over-allocate")
-    {
-        // optimized form [$type#count: type 'i' (int8), count as a four-byte
-        // 'l' (int32) of 0x7FFFFFFF (2147483647), but no element data at all.
-        // max_size() for a std::vector is far larger than this count, so it
-        // does not reject the header outright; the (capped) reservation must
-        // not attempt to allocate space for billions of elements before the
-        // missing data is detected.
-        json _;
-        const std::vector<uint8_t> input = {'[', '$', 'i', '#', 'l', 0x7F, 0xFF, 0xFF, 0xFF};
-        // On a platform where std::vector<json>::max_size() is smaller than
-        // the claimed count (e.g. 32-bit, where max_size() is bounded by a
-        // 32-bit SIZE_MAX divided by sizeof(json)), the SAX consumer's own
-        // check rejects the header outright (out_of_range.408, with the
-        // claimed count in the message) instead of accepting it and only
-        // finding it short of data once the (capped) reservation looks for
-        // element bytes that were never provided (parse_error.110). Either
-        // is an acceptable, bounded rejection of the hostile header -- the
-        // property under test is that no path attempts to allocate space
-        // for billions of elements.
-        bool threw = false;
-        try
-        {
-            _ = json::from_ubjson(input);
-        }
-        catch (const json::parse_error& e)
-        {
-            threw = true;
-            CHECK(e.id == 110);
-            CHECK(std::string(e.what()) == "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing UBJSON number: unexpected end of input");
-        }
-        catch (const json::out_of_range& e)
-        {
-            threw = true;
-            CHECK(e.id == 408);
-            CHECK(std::string(e.what()).find("excessive array size") != std::string::npos);
-        }
-        CHECK(threw);
-
-        // json_sax_dom_parser::start_array()'s max_size() check (unlike the
-        // scanner's own parse_error path) throws unconditionally via
-        // JSON_THROW rather than going through sax->parse_error(), so it is
-        // not gated by allow_exceptions=false on a platform where this
-        // header hits that check (e.g. 32-bit, see above) -- allow either
-        // a discarded result or the same out_of_range it throws with
-        // exceptions enabled.
-        try
-        {
-            CHECK(json::from_ubjson(input, true, false).is_discarded());
-        }
-        catch (const json::out_of_range& e)
-        {
-            CHECK(e.id == 408);
-        }
-    }
-#endif
-
-    SECTION("arrays of various sizes decode to the same value as before the reserve optimization")
-    {
-        for (const auto size :
-                {
-                    std::size_t{0}, std::size_t{1}, std::size_t{5}, // small
-                    std::size_t{16384},                             // exactly at the reserve cap
-                    std::size_t{20000}                              // above the reserve cap
-                })
-        {
-            CAPTURE(size)
-            json j = json::array();
-            for (std::size_t i = 0; i < size; ++i)
-            {
-                j.push_back(static_cast<int>(i % 1000));
-            }
-
-            // exercise both the plain and the optimized [$type#count encoding
-            const auto packed_plain = json::to_ubjson(j);
-            CHECK(json::from_ubjson(packed_plain) == j);
-
-            const auto packed_optimized = json::to_ubjson(j, true, true);
-            CHECK(json::from_ubjson(packed_optimized) == j);
-        }
-    }
-
-    SECTION("a user-defined SAX consumer is unaffected by the internal DOM reserve optimization")
-    {
-        // the reserve() call is local to json_sax_dom_parser / json_sax_dom_callback_parser;
-        // a custom SAX consumer that does not touch a DOM array sees identical events
-        json j = json::array();
-        for (int i = 0; i < 100; ++i)
-        {
-            j.push_back(i);
-        }
-        const auto packed = json::to_ubjson(j, true, true);
-
-        SaxCountdown scp(1000000); // large enough to never trigger an abort
-        CHECK(json::sax_parse(packed, &scp, json::input_format_t::ubjson));
-    }
-}
-
 TEST_CASE("Universal Binary JSON Specification Examples 1")
 {
     SECTION("Null Value")