Fix discarded nodiscard results across the test suite for GCC's warn_unused_result

A plain (void) cast on a call expression suppresses the C++17 [[nodiscard]]
warning but not GCC's warning for functions annotated via the GNU
__attribute__((warn_unused_result)) form -- which is what
JSON_HEDLEY_WARN_UNUSED_RESULT expands to on GCC. Several existing tests
that call a newly-annotated function (dump(), empty()) purely to check
that it throws/does not throw, discarding the result via (void), newly
warned (and failed -Werror builds) once the annotation was broadened.
Route those discards through a small ignore_return_value() helper
instead, which actually consumes the value and suppresses the warning
on both attribute forms.

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/json.hpp

@@ -1335,6 +1335,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief serialization
     /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     string_t dump(const int indent = -1,
                   const char indent_char = ' ',
                   const bool ensure_ascii = false,
@@ -1357,6 +1358,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return the type of the JSON value (explicit)
     /// @sa https://json.nlohmann.me/api/basic_json/type/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr value_t type() const noexcept
     {
         return m_data.m_type;
@@ -1364,6 +1366,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether type is primitive
     /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_primitive() const noexcept
     {
         return is_null() || is_string() || is_boolean() || is_number() || is_binary();
@@ -1371,6 +1374,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether type is structured
     /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_structured() const noexcept
     {
         return is_array() || is_object();
@@ -1378,6 +1382,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is null
     /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_null() const noexcept
     {
         return m_data.m_type == value_t::null;
@@ -1385,6 +1390,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a boolean
     /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_boolean() const noexcept
     {
         return m_data.m_type == value_t::boolean;
@@ -1392,6 +1398,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number() const noexcept
     {
         return is_number_integer() || is_number_float();
@@ -1399,6 +1406,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an integer number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_integer() const noexcept
     {
         return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
@@ -1406,6 +1414,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an unsigned integer number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_unsigned() const noexcept
     {
         return m_data.m_type == value_t::number_unsigned;
@@ -1413,6 +1422,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a floating-point number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_float() const noexcept
     {
         return m_data.m_type == value_t::number_float;
@@ -1420,6 +1430,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an object
     /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_object() const noexcept
     {
         return m_data.m_type == value_t::object;
@@ -1427,6 +1438,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an array
     /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_array() const noexcept
     {
         return m_data.m_type == value_t::array;
@@ -1434,6 +1446,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a string
     /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_string() const noexcept
     {
         return m_data.m_type == value_t::string;
@@ -1441,6 +1454,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a binary array
     /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_binary() const noexcept
     {
         return m_data.m_type == value_t::binary;
@@ -1448,6 +1462,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is discarded
     /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_discarded() const noexcept
     {
         return m_data.m_type == value_t::discarded;
@@ -2779,6 +2794,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the number of occurrences of a key in a JSON object
     /// @sa https://json.nlohmann.me/api/basic_json/count/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type count(const typename object_t::key_type& key) const
     {
         // return 0 for all nonobject types
@@ -2789,6 +2805,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/count/
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type count(KeyType && key) const
     {
         // return 0 for all nonobject types
@@ -2797,6 +2814,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief check the existence of an element in a JSON object
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(const typename object_t::key_type& key) const
     {
         return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
@@ -2806,6 +2824,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(KeyType && key) const
     {
         return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
@@ -2813,12 +2832,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief check the existence of an element in a JSON object given a JSON pointer
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(const json_pointer& ptr) const
     {
         return ptr.contains(this);
     }
 
     template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
     {
@@ -2974,6 +2995,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief checks whether the container is empty.
     /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool empty() const noexcept
     {
         switch (m_data.m_type)
@@ -3013,6 +3035,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the number of elements
     /// @sa https://json.nlohmann.me/api/basic_json/size/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type size() const noexcept
     {
         switch (m_data.m_type)
@@ -3052,6 +3075,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the maximum possible number of elements
     /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type max_size() const noexcept
     {
         switch (m_data.m_type)
@@ -4129,6 +4153,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief check if the input is valid JSON
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
     template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     static bool accept(InputType&& i,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
@@ -4140,6 +4165,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
     template<typename IteratorType, typename SentinelType = IteratorType,
              detail::enable_if_t<detail::can_compare_ne<IteratorType, SentinelType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     static bool accept(IteratorType first, SentinelType last,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
@@ -4239,6 +4265,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return the type as string
     /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_RETURNS_NON_NULL
     const char* type_name() const noexcept
     {

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;
@@ -22783,6 +22763,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief serialization
     /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     string_t dump(const int indent = -1,
                   const char indent_char = ' ',
                   const bool ensure_ascii = false,
@@ -22805,6 +22786,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return the type of the JSON value (explicit)
     /// @sa https://json.nlohmann.me/api/basic_json/type/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr value_t type() const noexcept
     {
         return m_data.m_type;
@@ -22812,6 +22794,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether type is primitive
     /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_primitive() const noexcept
     {
         return is_null() || is_string() || is_boolean() || is_number() || is_binary();
@@ -22819,6 +22802,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether type is structured
     /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_structured() const noexcept
     {
         return is_array() || is_object();
@@ -22826,6 +22810,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is null
     /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_null() const noexcept
     {
         return m_data.m_type == value_t::null;
@@ -22833,6 +22818,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a boolean
     /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_boolean() const noexcept
     {
         return m_data.m_type == value_t::boolean;
@@ -22840,6 +22826,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number() const noexcept
     {
         return is_number_integer() || is_number_float();
@@ -22847,6 +22834,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an integer number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_integer() const noexcept
     {
         return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
@@ -22854,6 +22842,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an unsigned integer number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_unsigned() const noexcept
     {
         return m_data.m_type == value_t::number_unsigned;
@@ -22861,6 +22850,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a floating-point number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_float() const noexcept
     {
         return m_data.m_type == value_t::number_float;
@@ -22868,6 +22858,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an object
     /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_object() const noexcept
     {
         return m_data.m_type == value_t::object;
@@ -22875,6 +22866,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an array
     /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_array() const noexcept
     {
         return m_data.m_type == value_t::array;
@@ -22882,6 +22874,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a string
     /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_string() const noexcept
     {
         return m_data.m_type == value_t::string;
@@ -22889,6 +22882,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a binary array
     /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_binary() const noexcept
     {
         return m_data.m_type == value_t::binary;
@@ -22896,6 +22890,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is discarded
     /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_discarded() const noexcept
     {
         return m_data.m_type == value_t::discarded;
@@ -24227,6 +24222,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the number of occurrences of a key in a JSON object
     /// @sa https://json.nlohmann.me/api/basic_json/count/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type count(const typename object_t::key_type& key) const
     {
         // return 0 for all nonobject types
@@ -24237,6 +24233,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/count/
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type count(KeyType && key) const
     {
         // return 0 for all nonobject types
@@ -24245,6 +24242,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief check the existence of an element in a JSON object
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(const typename object_t::key_type& key) const
     {
         return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
@@ -24254,6 +24252,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(KeyType && key) const
     {
         return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
@@ -24261,12 +24260,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief check the existence of an element in a JSON object given a JSON pointer
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(const json_pointer& ptr) const
     {
         return ptr.contains(this);
     }
 
     template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
     {
@@ -24422,6 +24423,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief checks whether the container is empty.
     /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool empty() const noexcept
     {
         switch (m_data.m_type)
@@ -24461,6 +24463,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the number of elements
     /// @sa https://json.nlohmann.me/api/basic_json/size/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type size() const noexcept
     {
         switch (m_data.m_type)
@@ -24500,6 +24503,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the maximum possible number of elements
     /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type max_size() const noexcept
     {
         switch (m_data.m_type)
@@ -25577,6 +25581,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief check if the input is valid JSON
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
     template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     static bool accept(InputType&& i,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
@@ -25588,6 +25593,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
     template<typename IteratorType, typename SentinelType = IteratorType,
              detail::enable_if_t<detail::can_compare_ne<IteratorType, SentinelType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     static bool accept(IteratorType first, SentinelType last,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
@@ -25687,6 +25693,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return the type as string
     /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_RETURNS_NON_NULL
     const char* type_name() const noexcept
     {

tests/src/test_utils.hpp

@@ -15,6 +15,15 @@
 namespace utils
 {
 
+// Some tests intentionally discard the [[nodiscard]]/JSON_HEDLEY_WARN_UNUSED_RESULT
+// return value of a call they only make to exercise its side effects (e.g. checking
+// that it does not throw). A plain (void) cast on the call expression does not
+// suppress GCC's warning for functions using the GNU __attribute__((warn_unused_result))
+// form (as opposed to the C++17 [[nodiscard]] attribute) -- passing the value into an
+// ordinary function call does.
+template<typename T>
+inline void ignore_return_value(T&& /*unused*/) noexcept {}
+
 inline std::vector<std::uint8_t> read_binary_file(const std::string& filename)
 {
     std::ifstream file(filename, std::ios::binary);

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-class_parser.cpp

@@ -23,6 +23,8 @@ using nlohmann::json;
 #include <utility>
 #include <vector>
 
+#include "test_utils.hpp"
+
 namespace
 {
 class SaxEventLogger
@@ -624,7 +626,8 @@ TEST_CASE("parser class")
             SECTION("overflow")
             {
                 // overflows during parsing yield an exception
-                CHECK_THROWS_WITH_AS(parser_helper("1.18973e+4932").empty(), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
+                // empty() is nodiscard; the exception is thrown by parser_helper() itself, before empty() would run
+                CHECK_THROWS_WITH_AS(utils::ignore_return_value(parser_helper("1.18973e+4932").empty()), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
             }
 
             SECTION("invalid numbers")

tests/src/unit-class_parser_diagnostic_positions.cpp

@@ -22,6 +22,8 @@ using nlohmann::json;
 
 #include <valarray>
 
+#include "test_utils.hpp"
+
 namespace
 {
 class SaxEventLogger
@@ -629,7 +631,8 @@ TEST_CASE("parser class")
             SECTION("overflow")
             {
                 // overflows during parsing yield an exception
-                CHECK_THROWS_WITH_AS(parser_helper("1.18973e+4932").empty(), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
+                // empty() is nodiscard; the exception is thrown by parser_helper() itself, before empty() would run
+                CHECK_THROWS_WITH_AS(utils::ignore_return_value(parser_helper("1.18973e+4932").empty()), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
             }
 
             SECTION("invalid numbers")

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-regression1.cpp

@@ -29,6 +29,7 @@ using nlohmann::json;
 #include <limits>
 #include <cstdio>
 #include "make_test_data_available.hpp"
+#include "test_utils.hpp"
 
 #ifdef JSON_HAS_CPP_17
     #include <variant>
@@ -1373,7 +1374,8 @@ TEST_CASE("regression tests 1")
         std::array<uint8_t, 28> key1 = {{ 103, 92, 117, 48, 48, 48, 55, 92, 114, 215, 126, 214, 95, 92, 34, 174, 40, 71, 38, 174, 40, 71, 38, 223, 134, 247, 127, 0 }};
         std::string const key1_str(reinterpret_cast<char*>(key1.data()));
         json const j = key1_str;
-        CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 10: 0x7E", json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
+        CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 10: 0x7E", json::type_error&);
     }
 
 #if JSON_USE_IMPLICIT_CONVERSIONS

tests/src/unit-regression2.cpp

@@ -31,6 +31,8 @@ using ordered_json = nlohmann::ordered_json;
 #include <type_traits>
 #include <utility>
 
+#include "test_utils.hpp"
+
 #ifdef JSON_HAS_CPP_17
     #include <any>
     #include <variant>
@@ -639,7 +641,12 @@ TEST_CASE("regression tests 2")
                 s += static_cast<char>(i);
             }
             dump_test["1"] = s;
-            dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
+            // dump() is nodiscard; this only checks that dumping does not throw/crash.
+            // A (void) cast on the call itself does not suppress GCC's warning for the
+            // GNU warn_unused_result attribute (unlike a real C++17 [[nodiscard]]), so
+            // capture the result in a variable and discard that instead.
+            auto dump_result = dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
+            (void)dump_result;
         }
     }
 
@@ -731,12 +738,14 @@ TEST_CASE("regression tests 2")
     {
         const std::array<unsigned char, 23> data = {{0x81, 0xA4, 0x64, 0x61, 0x74, 0x61, 0xC4, 0x0F, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x31, 0x30, 0x37, 0x30, 0x35, 0x30, 0x31, 0x30}};
         const json j = json::from_msgpack(data.data(), data.size());
+        // dump() is nodiscard; this only checks that dumping does not throw
         CHECK_NOTHROW(
-            j.dump(4,                             // Indent
+            utils::ignore_return_value(
-                   ' ',                           // Indent char
+                j.dump(4,                             // Indent
-                   false,                         // Ensure ascii
+                       ' ',                           // Indent char
-                   json::error_handler_t::strict  // Error
+                       false,                         // Ensure ascii
-                  ));
+                       json::error_handler_t::strict  // Error
+                      )));
     }
 
     SECTION("PR #2181 - regression bug with lvalue")

tests/src/unit-serialization.cpp

@@ -15,6 +15,8 @@ using nlohmann::json;
 #include <sstream>
 #include <iomanip>
 
+#include "test_utils.hpp"
+
 TEST_CASE("serialization")
 {
     SECTION("operator<<")
@@ -84,8 +86,9 @@ TEST_CASE("serialization")
         {
             const json j = "ä\xA9ü";
 
-            CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&);
+            // dump() is nodiscard; the exception is thrown by dump() itself before it would return
-            CHECK_THROWS_WITH_AS(j.dump(1, ' ', false, json::error_handler_t::strict), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&);
+            CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&);
+            CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&);
             CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"äü\"");
             CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"ä\xEF\xBF\xBDü\"");
             CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"\\u00e4\\ufffd\\u00fc\"");
@@ -95,8 +98,9 @@ TEST_CASE("serialization")
         {
             const json j = "123\xC2";
 
-            CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0xC2", json::type_error&);
+            // dump() is nodiscard; the exception is thrown by dump() itself before it would return
-            CHECK_THROWS_AS(j.dump(1, ' ', false, json::error_handler_t::strict), json::type_error&);
+            CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0xC2", json::type_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), json::type_error&);
             CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"123\"");
             CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"123\xEF\xBF\xBD\"");
             CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"123\\ufffd\"");
@@ -106,8 +110,9 @@ TEST_CASE("serialization")
         {
             const json j = "123\xF1\xB0\x34\x35\x36";
 
-            CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0x34", json::type_error&);
+            // dump() is nodiscard; the exception is thrown by dump() itself before it would return
-            CHECK_THROWS_AS(j.dump(1, ' ', false, json::error_handler_t::strict), json::type_error&);
+            CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0x34", json::type_error&);
+            CHECK_THROWS_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), json::type_error&);
             CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"123456\"");
             CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"123\xEF\xBF\xBD\x34\x35\x36\"");
             CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"123\\ufffd456\"");

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")

tests/src/unit-unicode1.cpp

@@ -17,6 +17,7 @@ using nlohmann::json;
 #include <sstream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
+#include "test_utils.hpp"
 
 TEST_CASE("Unicode (1/5)" * doctest::skip())
 {
@@ -240,7 +241,8 @@ void roundtrip(bool success_expected, const std::string& s)
     if (success_expected)
     {
         // serialization succeeds
-        CHECK_NOTHROW(j.dump());
+        // dump() is nodiscard; this only checks that dumping does not throw
+        CHECK_NOTHROW(utils::ignore_return_value(j.dump()));
 
         // exclude parse test for U+0000
         if (s[0] != '\0')
@@ -259,7 +261,8 @@ void roundtrip(bool success_expected, const std::string& s)
     else
     {
         // serialization fails
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
+        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
 
         // parsing JSON text fails
         CHECK_THROWS_AS(_ = json::parse(ps), json::parse_error&);

tests/src/unit-unicode2.cpp

@@ -19,6 +19,7 @@ using nlohmann::json;
 #include <iostream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
+#include "test_utils.hpp"
 
 // this test suite uses static variables with non-trivial destructors
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
@@ -97,7 +98,8 @@ void check_utf8dump(bool success_expected, int byte1, int byte2 = -1, int byte3
     else
     {
         // strict mode must throw if success is not expected
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
+        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
         // ignore and replace must create different dumps
         CHECK(s_ignored != s_replaced);
 

tests/src/unit-unicode3.cpp

@@ -19,6 +19,7 @@ using nlohmann::json;
 #include <iostream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
+#include "test_utils.hpp"
 
 // this test suite uses static variables with non-trivial destructors
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
@@ -97,7 +98,8 @@ void check_utf8dump(bool success_expected, int byte1, int byte2 = -1, int byte3
     else
     {
         // strict mode must throw if success is not expected
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
+        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
         // ignore and replace must create different dumps
         CHECK(s_ignored != s_replaced);
 

tests/src/unit-unicode4.cpp

@@ -19,6 +19,7 @@ using nlohmann::json;
 #include <iostream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
+#include "test_utils.hpp"
 
 // this test suite uses static variables with non-trivial destructors
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
@@ -97,7 +98,8 @@ void check_utf8dump(bool success_expected, int byte1, int byte2 = -1, int byte3
     else
     {
         // strict mode must throw if success is not expected
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
+        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
         // ignore and replace must create different dumps
         CHECK(s_ignored != s_replaced);
 

tests/src/unit-unicode5.cpp

@@ -19,6 +19,7 @@ using nlohmann::json;
 #include <iostream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
+#include "test_utils.hpp"
 
 // this test suite uses static variables with non-trivial destructors
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
@@ -97,7 +98,8 @@ void check_utf8dump(bool success_expected, int byte1, int byte2 = -1, int byte3
     else
     {
         // strict mode must throw if success is not expected
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
+        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
         // ignore and replace must create different dumps
         CHECK(s_ignored != s_replaced);