Bump cppcheck from 1.5.2 to 1.5.3 in /cmake/requirements

Bumps [cppcheck](https://github.com/msclock/cppcheck-wheel) from 1.5.2 to 1.5.3.
- [Release notes](https://github.com/msclock/cppcheck-wheel/releases)
- [Commits](https://github.com/msclock/cppcheck-wheel/compare/v1.5.2...v1.5.3)

---
updated-dependencies:
- dependency-name: cppcheck
  dependency-version: 1.5.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

cmake/requirements/requirements-cppcheck.txt

@@ -1 +1 @@
-cppcheck==1.5.2
+cppcheck==1.5.3

include/nlohmann/detail/output/binary_writer.hpp

@@ -23,7 +23,6 @@
     #include <cstdlib> // _byteswap_ushort, _byteswap_ulong, _byteswap_uint64
 #endif
 
-#include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/input/binary_reader.hpp>
 #include <nlohmann/detail/input/string_scan.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
@@ -205,12 +204,24 @@ class binary_writer
             }
 
             case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers
+                    write_cbor_head(0x00, static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                else
+                {
+                    // a negative integer n is encoded as -1 - n
+                    write_cbor_head(0x20, static_cast<std::uint64_t>(-1 - j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
             case value_t::number_unsigned:
             {
-                // one case for both, so that an array mixing negative
-                // (number_integer) and non-negative (number_unsigned) values
-                // does not mispredict the switch
-                write_cbor_integer(j);
+                write_cbor_head(0x00, conditional_static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
 
@@ -245,7 +256,13 @@ class binary_writer
 
             case value_t::array:
             {
-                write_cbor_array(j, depth);
+                // step 1: write control byte and the array size
+                write_cbor_head(0x80, j.m_data.m_value.array->size());
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el, depth + 1);
+                }
                 break;
             }
 
@@ -403,12 +420,54 @@ class binary_writer
             }
 
             case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers.
+                    write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa.write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa.write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa.write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        // int 64
+                        oa.write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
             case value_t::number_unsigned:
             {
-                // one case for both, so that an array mixing negative
-                // (number_integer) and non-negative (number_unsigned) values
-                // does not mispredict the switch
-                write_msgpack_integer(j, std::integral_constant<bool, msgpack_integers_fit_64_bits()>());
+                write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
 
@@ -426,7 +485,13 @@ class binary_writer
 
             case value_t::array:
             {
-                write_msgpack_array(j, depth);
+                // step 1: write control byte and the array size
+                write_msgpack_array_prefix(j.m_data.m_value.array->size(), j);
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el, depth + 1);
+                }
                 break;
             }
 
@@ -1886,316 +1951,6 @@ class binary_writer
         }
     }
 
-    /*!
-    @brief size class of an unsigned integer from its bit length
-
-    1, 2, 3, or 4 if @a x fits 1, 2, 4, or 8 bytes. Looked up from the number
-    of leading zero bits instead of found by branches: the sizes of a stream
-    of numbers are hard to predict, and a mispredicted branch costs more than
-    writing the number. (A table, as comparisons are vectorized by clang into
-    slower code.)
-    */
-    static unsigned integer_size_class(const std::uint64_t x) noexcept
-    {
-        static constexpr std::array<std::uint8_t, 64> size_class_by_leading_zeros =
-        {
-            {
-                4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-                3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-                2, 2, 2, 2, 2, 2, 2, 2,
-                1, 1, 1, 1, 1, 1, 1, 1
-            }
-        };
-        // x | 1 keeps count_leading_zeros() away from 0
-        return size_class_by_leading_zeros[static_cast<std::size_t>(count_leading_zeros(x | 1u))];
-    }
-
-    /*!
-    @brief encode @a first_byte and the low-order bytes of @a value that
-           @a size_class calls for (none, or 1, 2, 4, or 8) in network order
-           to @a out
-    @return the number of characters of the encoding; up to
-            @ref integer_encoding_space characters at @a out are overwritten
-
-    The bytes are written as one byte and one 8-byte word whose bytes after
-    the value are scratch that the caller drops, so that writing them does not
-    depend on the size class. For class 0 the word is all scratch; it is
-    shifted by 60 bits rather than 64, which would be undefined.
-    */
-    std::size_t encode_first_byte_and_tail(CharType* out, const std::uint8_t first_byte, const unsigned size_class, const std::uint64_t value) const noexcept
-    {
-        out[0] = to_char_type(first_byte);
-        const unsigned unused_bits = 64u - ((8u << size_class) >> 1u);
-        const std::uint64_t tail = is_little_endian ? byte_swap(value) >> unused_bits : value << unused_bits;
-        std::memcpy(out + 1, &tail, sizeof(tail));
-        return ((std::size_t{1} << size_class) >> 1u) + 1;
-    }
-
-    /// characters encode_first_byte_and_tail() may overwrite: the first byte
-    /// and one 8-byte word
-    static constexpr std::size_t integer_encoding_space = 9;
-
-    /*!
-    @brief the 64 bits of a number_integer or number_unsigned value, and a mask
-           that is all ones if it is negative, else zero
-
-    Selected through masks rather than branches, as the type and the sign of
-    the values in an array of mixed signs alternate unpredictably (non-negative
-    integers are number_unsigned after parsing). Up to 64 bits, the sign is bit
-    63 of the result (a narrower integer is sign-extended); computing it with
-    masks keeps GCC from branching on the type. A wider integer has to be
-    compared.
-    */
-    static std::uint64_t integer_bits(const BasicJsonType& j, std::uint64_t& sign_mask) noexcept
-    {
-        const bool is_signed = j.m_data.m_type == value_t::number_integer;
-        const std::uint64_t raw = is_signed
-                                  ? static_cast<std::uint64_t>(j.m_data.m_value.number_integer)
-                                  : static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned);
-        sign_mask = sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-                    ? (std::uint64_t{0} - static_cast<std::uint64_t>(is_signed)) & (std::uint64_t{0} - (raw >> 63u))
-                    : std::uint64_t{0} - static_cast<std::uint64_t>(is_signed && j.m_data.m_value.number_integer < 0);
-        return raw;
-    }
-
-    /*!
-    @brief encode the head of a CBOR integer to @a out without branching on its
-           size
-    @return the number of characters of the head
-
-    Same output as @ref write_cbor_head. The lengths of strings and containers
-    are mostly predictable, so their heads keep the branches; the sizes of a
-    run of integers are not, so an integer's head is assembled without them.
-    */
-    std::size_t encode_cbor_integer_head(CharType* out, const std::uint8_t major_type, const std::uint64_t argument) const noexcept
-    {
-        // an argument of at most 23 is in size class 1 (one byte) and is moved
-        // to class 0, the first byte, by subtracting 1
-        const auto is_immediate = static_cast<unsigned>(argument <= 0x17u);
-        const unsigned size_class = integer_size_class(argument) - is_immediate;
-
-        // the first byte: the argument itself if it is immediate, else
-        // 0x17 + size_class, selected through a mask
-        const std::uint64_t immediate_mask = std::uint64_t{0} - is_immediate;
-        const auto first_byte = static_cast<std::uint8_t>(major_type + ((argument & immediate_mask) | ((0x17u + size_class) & ~immediate_mask)));
-        return encode_first_byte_and_tail(out, first_byte, size_class, argument);
-    }
-
-    /*!
-    @brief write an array value (head and elements) as CBOR
-
-    Integer elements, the most common scalar, are written without a call to
-    @ref write_cbor. The loop is kept out of line: inlined into write_cbor, its
-    registers would be saved and restored on every call of write_cbor, which
-    is one call per value nested in an object.
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_cbor_array(const BasicJsonType& j, const std::size_t depth)
-    {
-        write_cbor_head(0x80, j.m_data.m_value.array->size());
-        write_array_elements(j, [this](CharType * out, const BasicJsonType & el)
-        {
-            return encode_cbor_integer(out, el);
-        }, [this, depth](const BasicJsonType & el)
-        {
-            write_cbor(el, depth + 1);
-        });
-    }
-
-    /*!
-    @brief write the elements of the array @a j, runs of integers with
-           @a encode_integer and all other values with @a write_value
-
-    Runs of integers are encoded straight into space reserved from the sink
-    for a whole run: the write pointer stays a local, where it would otherwise
-    be reloaded from the sink for every value, as a store of a character may
-    alias it.
-    */
-    template<typename EncodeInteger, typename WriteValue>
-    void write_array_elements(const BasicJsonType& j, EncodeInteger encode_integer, WriteValue write_value)
-    {
-        constexpr std::size_t max_run = max_reserve_size / integer_encoding_space;
-        auto it = j.m_data.m_value.array->begin();
-        const auto end = j.m_data.m_value.array->end();
-        while (it != end)
-        {
-            if (it->is_number_integer())
-            {
-                CharType* const start = oa.reserve(max_run * integer_encoding_space);
-                CharType* out = start;
-                for (std::size_t n = 0; n < max_run && it != end && it->is_number_integer(); ++n, ++it)
-                {
-                    out += encode_integer(out, *it);
-                }
-                oa.commit(static_cast<std::size_t>(out - start));
-            }
-            else
-            {
-                write_value(*it);
-                ++it;
-            }
-        }
-    }
-
-    /*!
-    @brief write a number_integer or number_unsigned value as a CBOR integer
-
-    A negative integer n has major type 1 and the argument -1 - n, which is ~n.
-    Kept out of line, like the other per-value paths, so that write_cbor stays
-    small (runs of integers in an array are encoded inline instead).
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_cbor_integer(const BasicJsonType& j)
-    {
-        oa.commit(encode_cbor_integer(oa.reserve(integer_encoding_space), j));
-    }
-
-    /// encode a number_integer or number_unsigned value to @a out (see
-    /// @ref write_cbor_integer) and return the number of characters
-    std::size_t encode_cbor_integer(CharType* out, const BasicJsonType& j) const noexcept
-    {
-        std::uint64_t sign_mask = 0;
-        const std::uint64_t raw = integer_bits(j, sign_mask);
-        // ~raw is -1 - n in the 64 bits that are written
-        return encode_cbor_integer_head(out, static_cast<std::uint8_t>(sign_mask & 0x20u), raw ^ sign_mask);
-    }
-
-    /*!
-    @brief whether the MessagePack integers of BasicJsonType are written by
-           @ref encode_msgpack_integer
-
-    It picks the format from the low 64 bits; a wider number type keeps the
-    range checks of @ref write_msgpack on the whole value.
-    */
-    static constexpr bool msgpack_integers_fit_64_bits() noexcept
-    {
-        return sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-               && sizeof(typename BasicJsonType::number_unsigned_t) <= sizeof(std::uint64_t);
-    }
-
-    /*!
-    @brief write a number_integer or number_unsigned value as a MessagePack
-           integer without branching on its sign or size
-
-    Same output as @ref write_msgpack: a non-negative integer as positive fixint
-    (< 128) or uint 8/16/32/64, a negative one as negative fixint (>= -32) or
-    int 8/16/32/64. Kept out of line (see @ref write_cbor_integer).
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_msgpack_integer(const BasicJsonType& j, std::true_type /*fits_64_bits*/)
-    {
-        oa.commit(encode_msgpack_integer(oa.reserve(integer_encoding_space), j));
-    }
-
-    /// encode a number_integer or number_unsigned value to @a out (see
-    /// @ref write_msgpack_integer) and return the number of characters
-    std::size_t encode_msgpack_integer(CharType* out, const BasicJsonType& j) const noexcept
-    {
-        std::uint64_t sign_mask = 0;
-        const std::uint64_t raw = integer_bits(j, sign_mask);
-
-        // A negative n fits int 8/16/32 exactly if 2 * (-1 - n) + 1 fits
-        // uint 8/16/32, so x gives the size class of either sign.
-        const std::uint64_t is_negative = sign_mask & 1u;
-        const std::uint64_t x = ((raw ^ sign_mask) << is_negative) | is_negative;
-
-        // A fixint is at most 127, or at least -32 (x at most 63). It is in
-        // size class 1 and is moved to class 0, the first byte, by subtracting 1.
-        const auto is_fixint = static_cast<unsigned>(x <= (127u ^ (sign_mask & 64u)));
-        const unsigned size_class = integer_size_class(x) - is_fixint;
-
-        // the first byte: the low byte of the integer for a fixint, else the
-        // marker 0xCC..0xCF (uint) or 0xD0..0xD3 (int), selected through a mask
-        const std::uint64_t fixint_mask = std::uint64_t{0} - is_fixint;
-        const std::uint64_t marker = 0xCBu + size_class + (sign_mask & 4u);
-        const auto first_byte = static_cast<std::uint8_t>((raw & fixint_mask) | (marker & ~fixint_mask));
-        return encode_first_byte_and_tail(out, first_byte, size_class, raw);
-    }
-
-    /// write a number_integer or number_unsigned value of a number type wider
-    /// than 64 bits as a MessagePack integer, with range checks on the whole value
-    void write_msgpack_integer(const BasicJsonType& j, std::false_type /*fits_64_bits*/)
-    {
-        if (j.m_data.m_type == value_t::number_unsigned)
-        {
-            write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
-            return;
-        }
-
-        if (j.m_data.m_value.number_integer >= 0)
-        {
-            // MessagePack does not differentiate between positive
-            // signed integers and unsigned integers.
-            write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
-        }
-        else
-        {
-            if (j.m_data.m_value.number_integer >= -32)
-            {
-                // negative fixnum
-                write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
-            {
-                // int 8
-                oa.write_character(to_char_type(0xD0));
-                write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
-            {
-                // int 16
-                oa.write_character(to_char_type(0xD1));
-                write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
-            {
-                // int 32
-                oa.write_character(to_char_type(0xD2));
-                write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
-            }
-            else
-            {
-                // int 64
-                oa.write_character(to_char_type(0xD3));
-                write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
-            }
-        }
-    }
-
-    /*!
-    @brief write an array value (head and elements) as MessagePack
-
-    See @ref write_cbor_array.
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_msgpack_array(const BasicJsonType& j, const std::size_t depth)
-    {
-        write_msgpack_array_prefix(j.m_data.m_value.array->size(), j);
-        write_msgpack_array_elements(j, depth, std::integral_constant<bool, msgpack_integers_fit_64_bits()>());
-    }
-
-    void write_msgpack_array_elements(const BasicJsonType& j, const std::size_t depth, std::true_type /*fits_64_bits*/)
-    {
-        write_array_elements(j, [this](CharType * out, const BasicJsonType & el)
-        {
-            return encode_msgpack_integer(out, el);
-        }, [this, depth](const BasicJsonType & el)
-        {
-            write_msgpack(el, depth + 1);
-        });
-    }
-
-    void write_msgpack_array_elements(const BasicJsonType& j, const std::size_t depth, std::false_type /*fits_64_bits*/)
-    {
-        for (const auto& el : *j.m_data.m_value.array)
-        {
-            write_msgpack(el, depth + 1);
-        }
-    }
-
     /*!
     @brief write an object key as a CBOR text string
 

include/nlohmann/detail/output/output_adapters.hpp

@@ -8,10 +8,7 @@
 
 #pragma once
 
-#include <algorithm> // max
-#include <array> // array
 #include <cstddef> // size_t
-#include <cstring> // memcpy
 #include <memory> // shared_ptr, make_shared
 #include <string> // basic_string
 #include <type_traits> // conditional, integral_constant, is_same
@@ -51,170 +48,32 @@ template<typename CharType> struct output_adapter_protocol
 template<typename CharType>
 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
 
-/// the largest number of characters a writer may reserve() from a sink at once;
-/// output_vector_sink also appends writes of at least this size with insert()
-constexpr std::size_t max_reserve_size = 256;
-
 /// @brief non-virtual output sink writing into a std::vector
 ///
 /// This sink is not part of the virtual output_adapter_protocol hierarchy: it is
 /// passed to binary_writer by value as a template parameter, so
 /// write_character()/write_characters() are ordinary (inlinable) calls with no
 /// vtable lookup and no shared_ptr. It is used for the common
-/// `to_cbor`/`to_msgpack`/... into a std::vector.
-///
-/// Most writes are a few bytes - a type marker, or a number of 1, 2, 4, or 8
-/// bytes - and appending those with push_back() or insert() cost more than
-/// encoding them: insert() is an out-of-line call into a routine that can insert
-/// anywhere, and resize() is one as well with libstdc++. The sink therefore keeps
-/// its own write position: it grows the vector geometrically ahead of the
-/// position and copies each write to it, so a write is a capacity check and a
-/// short copy. The destructor shrinks the vector to the bytes actually written,
-/// also when a write throws; shrinking a vector never allocates. The sink owns
-/// that trim, so it can be moved but not copied, and the vector must not be used
-/// while the sink is alive.
+/// `to_cbor`/`to_msgpack`/... into a std::vector. output_vector_adapter below
+/// wraps this same sink to provide the virtual interface.
 template<typename CharType, typename AllocatorType = std::allocator<CharType>>
 class output_vector_sink
 {
   public:
     explicit output_vector_sink(std::vector<CharType, AllocatorType>& vec) noexcept
-        : v(&vec), position(vec.size())
-    {}
-
-    output_vector_sink(const output_vector_sink&) = delete;
-    output_vector_sink& operator=(const output_vector_sink&) = delete;
-    output_vector_sink& operator=(output_vector_sink&&) = delete;
-
-    output_vector_sink(output_vector_sink&& other) noexcept
-        : v(other.v), position(other.position)
-    {
-        other.v = nullptr;
-    }
-
-    ~output_vector_sink()
-    {
-        if (v != nullptr)
-        {
-            v->resize(position);
-        }
-    }
-
-    // always inlined: GCC otherwise keeps these out of line in a large
-    // translation unit, and a call per byte or number costs more than the write
-    JSON_HEDLEY_ALWAYS_INLINE
-    void write_character(CharType c)
-    {
-        if (JSON_HEDLEY_UNLIKELY(position == v->size()))
-        {
-            grow(1);
-        }
-        (*v)[position++] = c;
-    }
-
-    // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values; memcpy must not
-    // see it.
-    JSON_HEDLEY_ALWAYS_INLINE
-    void write_characters(const CharType* s, std::size_t length)
-    {
-        if (JSON_HEDLEY_UNLIKELY(v->size() - position < length))
-        {
-            if (length >= max_reserve_size)
-            {
-                append(s, length);
-                return;
-            }
-            grow(length);
-        }
-        if (length != 0)
-        {
-            std::memcpy(v->data() + position, s, length * sizeof(CharType));
-            position += length;
-        }
-    }
-
-    /// @brief space for writing up to @a length characters directly
-    ///
-    /// Returns a pointer to at least @a length (at most @ref max_reserve_size)
-    /// writable characters at the write position; @ref commit then keeps the
-    /// first ones of them. A writer can store whole words there and keep only
-    /// the bytes it needs, and keep its write pointer in a register across many
-    /// values instead of updating the sink after each.
-    JSON_HEDLEY_ALWAYS_INLINE
-    CharType* reserve(const std::size_t length)
-    {
-        JSON_ASSERT(length <= max_reserve_size);
-        if (JSON_HEDLEY_UNLIKELY(v->size() - position < length))
-        {
-            grow(length);
-        }
-        return v->data() + position;
-    }
-
-    /// keep the first @a length characters written to the space from reserve()
-    JSON_HEDLEY_ALWAYS_INLINE
-    void commit(const std::size_t length) noexcept
-    {
-        position += length;
-    }
-
-  private:
-    /// make room for at least @a length more characters after the position;
-    /// kept out of line so that the write functions stay small enough for
-    /// GCC to inline them into the writer
-    JSON_HEDLEY_NEVER_INLINE
-    void grow(const std::size_t length)
-    {
-        // use the capacity the vector already has, else at least double it;
-        // never less than 64 characters, so that a small value does not
-        // reallocate for every few bytes
-        const std::size_t needed = position + length;
-        v->resize((std::max)(std::size_t{64}, needed <= v->capacity()
-                             ? v->capacity()
-                             : (std::max)(needed, v->capacity() * 2)));
-    }
-
-    /// append @a length (at least max_reserve_size) characters that do not fit
-    /// the space ahead of the position: insert() copies them once into the
-    /// grown vector, where grow() would first zero the new space and then copy
-    /// over it - noticeable for a large string or binary value
-    JSON_HEDLEY_NEVER_INLINE
-    void append(const CharType* s, const std::size_t length)
-    {
-        v->resize(position);
-        if (v->capacity() - position < length)
-        {
-            // grow geometrically, with room for the writes that follow, so
-            // that the next grow() need not reallocate right away
-            v->reserve((std::max)(v->capacity() * 2, position + length + max_reserve_size));
-        }
-        v->insert(v->end(), s, s + length);
-        position = v->size();
-    }
-
-    std::vector<CharType, AllocatorType>* v;
-    /// number of characters of *v written so far
-    std::size_t position;
-};
-
-/// output adapter for byte vectors
-template<typename CharType, typename AllocatorType = std::allocator<CharType>>
-class output_vector_adapter : public output_adapter_protocol<CharType>
-{
-  public:
-    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
         : v(vec)
     {}
 
-    void write_character(CharType c) override
+    void write_character(CharType c)
     {
         v.push_back(c);
     }
 
     // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values; appending an empty
-    // range is a no-op
-    void write_characters(const CharType* s, std::size_t length) override
+    // pointer with length 0 for empty strings/binary values. Appending an empty
+    // range is a no-op; the type-erased path tolerates this via the (unattributed)
+    // virtual base, and the concrete sink must do the same.
+    void write_characters(const CharType* s, std::size_t length)
     {
         v.insert(v.end(), s, s + length);
     }
@@ -223,6 +82,33 @@ class output_vector_adapter : public output_adapter_protocol<CharType>
     std::vector<CharType, AllocatorType>& v;
 };
 
+/// output adapter for byte vectors
+///
+/// The appending itself lives in output_vector_sink; this class only adds the
+/// virtual output_adapter_protocol interface on top of it, so both the
+/// type-erased and the templated path share one implementation.
+template<typename CharType, typename AllocatorType = std::allocator<CharType>>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+        : sink(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        sink.write_character(c);
+    }
+
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        sink.write_characters(s, length);
+    }
+
+  private:
+    output_vector_sink<CharType, AllocatorType> sink;
+};
+
 #ifndef JSON_NO_IO
 /// output adapter for output streams
 template<typename CharType>
@@ -302,24 +188,8 @@ class output_adapter_sink
         oa->write_characters(s, length);
     }
 
-    /// space for writing up to @a length characters (see
-    /// output_vector_sink::reserve)
-    CharType* reserve(const std::size_t length) noexcept
-    {
-        JSON_ASSERT(length <= max_reserve_size);
-        static_cast<void>(length);
-        return reserved.data();
-    }
-
-    /// write the first @a length characters written to the space from reserve()
-    void commit(const std::size_t length)
-    {
-        oa->write_characters(reserved.data(), length);
-    }
-
   private:
     output_adapter_t<CharType> oa;
-    std::array<CharType, max_reserve_size> reserved{};
 };
 
 /// @brief whether std::basic_string<CharType> has a non-deprecated std::char_traits

single_include/nlohmann/json.hpp

@@ -22664,8 +22664,6 @@ NLOHMANN_JSON_NAMESPACE_END
     #include <cstdlib> // _byteswap_ushort, _byteswap_ulong, _byteswap_uint64
 #endif
 
-// #include <nlohmann/detail/bit_ops.hpp>
-
 // #include <nlohmann/detail/input/binary_reader.hpp>
 
 // #include <nlohmann/detail/input/string_scan.hpp>
@@ -22685,10 +22683,7 @@ NLOHMANN_JSON_NAMESPACE_END
 
 
 
-#include <algorithm> // max
-#include <array> // array
 #include <cstddef> // size_t
-#include <cstring> // memcpy
 #include <memory> // shared_ptr, make_shared
 #include <string> // basic_string
 #include <type_traits> // conditional, integral_constant, is_same
@@ -22729,170 +22724,32 @@ template<typename CharType> struct output_adapter_protocol
 template<typename CharType>
 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
 
-/// the largest number of characters a writer may reserve() from a sink at once;
-/// output_vector_sink also appends writes of at least this size with insert()
-constexpr std::size_t max_reserve_size = 256;
-
 /// @brief non-virtual output sink writing into a std::vector
 ///
 /// This sink is not part of the virtual output_adapter_protocol hierarchy: it is
 /// passed to binary_writer by value as a template parameter, so
 /// write_character()/write_characters() are ordinary (inlinable) calls with no
 /// vtable lookup and no shared_ptr. It is used for the common
-/// `to_cbor`/`to_msgpack`/... into a std::vector.
-///
-/// Most writes are a few bytes - a type marker, or a number of 1, 2, 4, or 8
-/// bytes - and appending those with push_back() or insert() cost more than
-/// encoding them: insert() is an out-of-line call into a routine that can insert
-/// anywhere, and resize() is one as well with libstdc++. The sink therefore keeps
-/// its own write position: it grows the vector geometrically ahead of the
-/// position and copies each write to it, so a write is a capacity check and a
-/// short copy. The destructor shrinks the vector to the bytes actually written,
-/// also when a write throws; shrinking a vector never allocates. The sink owns
-/// that trim, so it can be moved but not copied, and the vector must not be used
-/// while the sink is alive.
+/// `to_cbor`/`to_msgpack`/... into a std::vector. output_vector_adapter below
+/// wraps this same sink to provide the virtual interface.
 template<typename CharType, typename AllocatorType = std::allocator<CharType>>
 class output_vector_sink
 {
   public:
     explicit output_vector_sink(std::vector<CharType, AllocatorType>& vec) noexcept
-        : v(&vec), position(vec.size())
-    {}
-
-    output_vector_sink(const output_vector_sink&) = delete;
-    output_vector_sink& operator=(const output_vector_sink&) = delete;
-    output_vector_sink& operator=(output_vector_sink&&) = delete;
-
-    output_vector_sink(output_vector_sink&& other) noexcept
-        : v(other.v), position(other.position)
-    {
-        other.v = nullptr;
-    }
-
-    ~output_vector_sink()
-    {
-        if (v != nullptr)
-        {
-            v->resize(position);
-        }
-    }
-
-    // always inlined: GCC otherwise keeps these out of line in a large
-    // translation unit, and a call per byte or number costs more than the write
-    JSON_HEDLEY_ALWAYS_INLINE
-    void write_character(CharType c)
-    {
-        if (JSON_HEDLEY_UNLIKELY(position == v->size()))
-        {
-            grow(1);
-        }
-        (*v)[position++] = c;
-    }
-
-    // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values; memcpy must not
-    // see it.
-    JSON_HEDLEY_ALWAYS_INLINE
-    void write_characters(const CharType* s, std::size_t length)
-    {
-        if (JSON_HEDLEY_UNLIKELY(v->size() - position < length))
-        {
-            if (length >= max_reserve_size)
-            {
-                append(s, length);
-                return;
-            }
-            grow(length);
-        }
-        if (length != 0)
-        {
-            std::memcpy(v->data() + position, s, length * sizeof(CharType));
-            position += length;
-        }
-    }
-
-    /// @brief space for writing up to @a length characters directly
-    ///
-    /// Returns a pointer to at least @a length (at most @ref max_reserve_size)
-    /// writable characters at the write position; @ref commit then keeps the
-    /// first ones of them. A writer can store whole words there and keep only
-    /// the bytes it needs, and keep its write pointer in a register across many
-    /// values instead of updating the sink after each.
-    JSON_HEDLEY_ALWAYS_INLINE
-    CharType* reserve(const std::size_t length)
-    {
-        JSON_ASSERT(length <= max_reserve_size);
-        if (JSON_HEDLEY_UNLIKELY(v->size() - position < length))
-        {
-            grow(length);
-        }
-        return v->data() + position;
-    }
-
-    /// keep the first @a length characters written to the space from reserve()
-    JSON_HEDLEY_ALWAYS_INLINE
-    void commit(const std::size_t length) noexcept
-    {
-        position += length;
-    }
-
-  private:
-    /// make room for at least @a length more characters after the position;
-    /// kept out of line so that the write functions stay small enough for
-    /// GCC to inline them into the writer
-    JSON_HEDLEY_NEVER_INLINE
-    void grow(const std::size_t length)
-    {
-        // use the capacity the vector already has, else at least double it;
-        // never less than 64 characters, so that a small value does not
-        // reallocate for every few bytes
-        const std::size_t needed = position + length;
-        v->resize((std::max)(std::size_t{64}, needed <= v->capacity()
-                             ? v->capacity()
-                             : (std::max)(needed, v->capacity() * 2)));
-    }
-
-    /// append @a length (at least max_reserve_size) characters that do not fit
-    /// the space ahead of the position: insert() copies them once into the
-    /// grown vector, where grow() would first zero the new space and then copy
-    /// over it - noticeable for a large string or binary value
-    JSON_HEDLEY_NEVER_INLINE
-    void append(const CharType* s, const std::size_t length)
-    {
-        v->resize(position);
-        if (v->capacity() - position < length)
-        {
-            // grow geometrically, with room for the writes that follow, so
-            // that the next grow() need not reallocate right away
-            v->reserve((std::max)(v->capacity() * 2, position + length + max_reserve_size));
-        }
-        v->insert(v->end(), s, s + length);
-        position = v->size();
-    }
-
-    std::vector<CharType, AllocatorType>* v;
-    /// number of characters of *v written so far
-    std::size_t position;
-};
-
-/// output adapter for byte vectors
-template<typename CharType, typename AllocatorType = std::allocator<CharType>>
-class output_vector_adapter : public output_adapter_protocol<CharType>
-{
-  public:
-    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
         : v(vec)
     {}
 
-    void write_character(CharType c) override
+    void write_character(CharType c)
     {
         v.push_back(c);
     }
 
     // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values; appending an empty
-    // range is a no-op
-    void write_characters(const CharType* s, std::size_t length) override
+    // pointer with length 0 for empty strings/binary values. Appending an empty
+    // range is a no-op; the type-erased path tolerates this via the (unattributed)
+    // virtual base, and the concrete sink must do the same.
+    void write_characters(const CharType* s, std::size_t length)
     {
         v.insert(v.end(), s, s + length);
     }
@@ -22901,6 +22758,33 @@ class output_vector_adapter : public output_adapter_protocol<CharType>
     std::vector<CharType, AllocatorType>& v;
 };
 
+/// output adapter for byte vectors
+///
+/// The appending itself lives in output_vector_sink; this class only adds the
+/// virtual output_adapter_protocol interface on top of it, so both the
+/// type-erased and the templated path share one implementation.
+template<typename CharType, typename AllocatorType = std::allocator<CharType>>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+        : sink(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        sink.write_character(c);
+    }
+
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        sink.write_characters(s, length);
+    }
+
+  private:
+    output_vector_sink<CharType, AllocatorType> sink;
+};
+
 #ifndef JSON_NO_IO
 /// output adapter for output streams
 template<typename CharType>
@@ -22980,24 +22864,8 @@ class output_adapter_sink
         oa->write_characters(s, length);
     }
 
-    /// space for writing up to @a length characters (see
-    /// output_vector_sink::reserve)
-    CharType* reserve(const std::size_t length) noexcept
-    {
-        JSON_ASSERT(length <= max_reserve_size);
-        static_cast<void>(length);
-        return reserved.data();
-    }
-
-    /// write the first @a length characters written to the space from reserve()
-    void commit(const std::size_t length)
-    {
-        oa->write_characters(reserved.data(), length);
-    }
-
   private:
     output_adapter_t<CharType> oa;
-    std::array<CharType, max_reserve_size> reserved{};
 };
 
 /// @brief whether std::basic_string<CharType> has a non-deprecated std::char_traits
@@ -23282,12 +23150,24 @@ class binary_writer
             }
 
             case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers
+                    write_cbor_head(0x00, static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                else
+                {
+                    // a negative integer n is encoded as -1 - n
+                    write_cbor_head(0x20, static_cast<std::uint64_t>(-1 - j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
             case value_t::number_unsigned:
             {
-                // one case for both, so that an array mixing negative
-                // (number_integer) and non-negative (number_unsigned) values
-                // does not mispredict the switch
-                write_cbor_integer(j);
+                write_cbor_head(0x00, conditional_static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
 
@@ -23322,7 +23202,13 @@ class binary_writer
 
             case value_t::array:
             {
-                write_cbor_array(j, depth);
+                // step 1: write control byte and the array size
+                write_cbor_head(0x80, j.m_data.m_value.array->size());
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el, depth + 1);
+                }
                 break;
             }
 
@@ -23480,12 +23366,54 @@ class binary_writer
             }
 
             case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers.
+                    write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa.write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa.write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa.write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        // int 64
+                        oa.write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
             case value_t::number_unsigned:
             {
-                // one case for both, so that an array mixing negative
-                // (number_integer) and non-negative (number_unsigned) values
-                // does not mispredict the switch
-                write_msgpack_integer(j, std::integral_constant<bool, msgpack_integers_fit_64_bits()>());
+                write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
 
@@ -23503,7 +23431,13 @@ class binary_writer
 
             case value_t::array:
             {
-                write_msgpack_array(j, depth);
+                // step 1: write control byte and the array size
+                write_msgpack_array_prefix(j.m_data.m_value.array->size(), j);
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el, depth + 1);
+                }
                 break;
             }
 
@@ -24963,316 +24897,6 @@ class binary_writer
         }
     }
 
-    /*!
-    @brief size class of an unsigned integer from its bit length
-
-    1, 2, 3, or 4 if @a x fits 1, 2, 4, or 8 bytes. Looked up from the number
-    of leading zero bits instead of found by branches: the sizes of a stream
-    of numbers are hard to predict, and a mispredicted branch costs more than
-    writing the number. (A table, as comparisons are vectorized by clang into
-    slower code.)
-    */
-    static unsigned integer_size_class(const std::uint64_t x) noexcept
-    {
-        static constexpr std::array<std::uint8_t, 64> size_class_by_leading_zeros =
-        {
-            {
-                4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-                3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-                2, 2, 2, 2, 2, 2, 2, 2,
-                1, 1, 1, 1, 1, 1, 1, 1
-            }
-        };
-        // x | 1 keeps count_leading_zeros() away from 0
-        return size_class_by_leading_zeros[static_cast<std::size_t>(count_leading_zeros(x | 1u))];
-    }
-
-    /*!
-    @brief encode @a first_byte and the low-order bytes of @a value that
-           @a size_class calls for (none, or 1, 2, 4, or 8) in network order
-           to @a out
-    @return the number of characters of the encoding; up to
-            @ref integer_encoding_space characters at @a out are overwritten
-
-    The bytes are written as one byte and one 8-byte word whose bytes after
-    the value are scratch that the caller drops, so that writing them does not
-    depend on the size class. For class 0 the word is all scratch; it is
-    shifted by 60 bits rather than 64, which would be undefined.
-    */
-    std::size_t encode_first_byte_and_tail(CharType* out, const std::uint8_t first_byte, const unsigned size_class, const std::uint64_t value) const noexcept
-    {
-        out[0] = to_char_type(first_byte);
-        const unsigned unused_bits = 64u - ((8u << size_class) >> 1u);
-        const std::uint64_t tail = is_little_endian ? byte_swap(value) >> unused_bits : value << unused_bits;
-        std::memcpy(out + 1, &tail, sizeof(tail));
-        return ((std::size_t{1} << size_class) >> 1u) + 1;
-    }
-
-    /// characters encode_first_byte_and_tail() may overwrite: the first byte
-    /// and one 8-byte word
-    static constexpr std::size_t integer_encoding_space = 9;
-
-    /*!
-    @brief the 64 bits of a number_integer or number_unsigned value, and a mask
-           that is all ones if it is negative, else zero
-
-    Selected through masks rather than branches, as the type and the sign of
-    the values in an array of mixed signs alternate unpredictably (non-negative
-    integers are number_unsigned after parsing). Up to 64 bits, the sign is bit
-    63 of the result (a narrower integer is sign-extended); computing it with
-    masks keeps GCC from branching on the type. A wider integer has to be
-    compared.
-    */
-    static std::uint64_t integer_bits(const BasicJsonType& j, std::uint64_t& sign_mask) noexcept
-    {
-        const bool is_signed = j.m_data.m_type == value_t::number_integer;
-        const std::uint64_t raw = is_signed
-                                  ? static_cast<std::uint64_t>(j.m_data.m_value.number_integer)
-                                  : static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned);
-        sign_mask = sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-                    ? (std::uint64_t{0} - static_cast<std::uint64_t>(is_signed)) & (std::uint64_t{0} - (raw >> 63u))
-                    : std::uint64_t{0} - static_cast<std::uint64_t>(is_signed && j.m_data.m_value.number_integer < 0);
-        return raw;
-    }
-
-    /*!
-    @brief encode the head of a CBOR integer to @a out without branching on its
-           size
-    @return the number of characters of the head
-
-    Same output as @ref write_cbor_head. The lengths of strings and containers
-    are mostly predictable, so their heads keep the branches; the sizes of a
-    run of integers are not, so an integer's head is assembled without them.
-    */
-    std::size_t encode_cbor_integer_head(CharType* out, const std::uint8_t major_type, const std::uint64_t argument) const noexcept
-    {
-        // an argument of at most 23 is in size class 1 (one byte) and is moved
-        // to class 0, the first byte, by subtracting 1
-        const auto is_immediate = static_cast<unsigned>(argument <= 0x17u);
-        const unsigned size_class = integer_size_class(argument) - is_immediate;
-
-        // the first byte: the argument itself if it is immediate, else
-        // 0x17 + size_class, selected through a mask
-        const std::uint64_t immediate_mask = std::uint64_t{0} - is_immediate;
-        const auto first_byte = static_cast<std::uint8_t>(major_type + ((argument & immediate_mask) | ((0x17u + size_class) & ~immediate_mask)));
-        return encode_first_byte_and_tail(out, first_byte, size_class, argument);
-    }
-
-    /*!
-    @brief write an array value (head and elements) as CBOR
-
-    Integer elements, the most common scalar, are written without a call to
-    @ref write_cbor. The loop is kept out of line: inlined into write_cbor, its
-    registers would be saved and restored on every call of write_cbor, which
-    is one call per value nested in an object.
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_cbor_array(const BasicJsonType& j, const std::size_t depth)
-    {
-        write_cbor_head(0x80, j.m_data.m_value.array->size());
-        write_array_elements(j, [this](CharType * out, const BasicJsonType & el)
-        {
-            return encode_cbor_integer(out, el);
-        }, [this, depth](const BasicJsonType & el)
-        {
-            write_cbor(el, depth + 1);
-        });
-    }
-
-    /*!
-    @brief write the elements of the array @a j, runs of integers with
-           @a encode_integer and all other values with @a write_value
-
-    Runs of integers are encoded straight into space reserved from the sink
-    for a whole run: the write pointer stays a local, where it would otherwise
-    be reloaded from the sink for every value, as a store of a character may
-    alias it.
-    */
-    template<typename EncodeInteger, typename WriteValue>
-    void write_array_elements(const BasicJsonType& j, EncodeInteger encode_integer, WriteValue write_value)
-    {
-        constexpr std::size_t max_run = max_reserve_size / integer_encoding_space;
-        auto it = j.m_data.m_value.array->begin();
-        const auto end = j.m_data.m_value.array->end();
-        while (it != end)
-        {
-            if (it->is_number_integer())
-            {
-                CharType* const start = oa.reserve(max_run * integer_encoding_space);
-                CharType* out = start;
-                for (std::size_t n = 0; n < max_run && it != end && it->is_number_integer(); ++n, ++it)
-                {
-                    out += encode_integer(out, *it);
-                }
-                oa.commit(static_cast<std::size_t>(out - start));
-            }
-            else
-            {
-                write_value(*it);
-                ++it;
-            }
-        }
-    }
-
-    /*!
-    @brief write a number_integer or number_unsigned value as a CBOR integer
-
-    A negative integer n has major type 1 and the argument -1 - n, which is ~n.
-    Kept out of line, like the other per-value paths, so that write_cbor stays
-    small (runs of integers in an array are encoded inline instead).
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_cbor_integer(const BasicJsonType& j)
-    {
-        oa.commit(encode_cbor_integer(oa.reserve(integer_encoding_space), j));
-    }
-
-    /// encode a number_integer or number_unsigned value to @a out (see
-    /// @ref write_cbor_integer) and return the number of characters
-    std::size_t encode_cbor_integer(CharType* out, const BasicJsonType& j) const noexcept
-    {
-        std::uint64_t sign_mask = 0;
-        const std::uint64_t raw = integer_bits(j, sign_mask);
-        // ~raw is -1 - n in the 64 bits that are written
-        return encode_cbor_integer_head(out, static_cast<std::uint8_t>(sign_mask & 0x20u), raw ^ sign_mask);
-    }
-
-    /*!
-    @brief whether the MessagePack integers of BasicJsonType are written by
-           @ref encode_msgpack_integer
-
-    It picks the format from the low 64 bits; a wider number type keeps the
-    range checks of @ref write_msgpack on the whole value.
-    */
-    static constexpr bool msgpack_integers_fit_64_bits() noexcept
-    {
-        return sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-               && sizeof(typename BasicJsonType::number_unsigned_t) <= sizeof(std::uint64_t);
-    }
-
-    /*!
-    @brief write a number_integer or number_unsigned value as a MessagePack
-           integer without branching on its sign or size
-
-    Same output as @ref write_msgpack: a non-negative integer as positive fixint
-    (< 128) or uint 8/16/32/64, a negative one as negative fixint (>= -32) or
-    int 8/16/32/64. Kept out of line (see @ref write_cbor_integer).
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_msgpack_integer(const BasicJsonType& j, std::true_type /*fits_64_bits*/)
-    {
-        oa.commit(encode_msgpack_integer(oa.reserve(integer_encoding_space), j));
-    }
-
-    /// encode a number_integer or number_unsigned value to @a out (see
-    /// @ref write_msgpack_integer) and return the number of characters
-    std::size_t encode_msgpack_integer(CharType* out, const BasicJsonType& j) const noexcept
-    {
-        std::uint64_t sign_mask = 0;
-        const std::uint64_t raw = integer_bits(j, sign_mask);
-
-        // A negative n fits int 8/16/32 exactly if 2 * (-1 - n) + 1 fits
-        // uint 8/16/32, so x gives the size class of either sign.
-        const std::uint64_t is_negative = sign_mask & 1u;
-        const std::uint64_t x = ((raw ^ sign_mask) << is_negative) | is_negative;
-
-        // A fixint is at most 127, or at least -32 (x at most 63). It is in
-        // size class 1 and is moved to class 0, the first byte, by subtracting 1.
-        const auto is_fixint = static_cast<unsigned>(x <= (127u ^ (sign_mask & 64u)));
-        const unsigned size_class = integer_size_class(x) - is_fixint;
-
-        // the first byte: the low byte of the integer for a fixint, else the
-        // marker 0xCC..0xCF (uint) or 0xD0..0xD3 (int), selected through a mask
-        const std::uint64_t fixint_mask = std::uint64_t{0} - is_fixint;
-        const std::uint64_t marker = 0xCBu + size_class + (sign_mask & 4u);
-        const auto first_byte = static_cast<std::uint8_t>((raw & fixint_mask) | (marker & ~fixint_mask));
-        return encode_first_byte_and_tail(out, first_byte, size_class, raw);
-    }
-
-    /// write a number_integer or number_unsigned value of a number type wider
-    /// than 64 bits as a MessagePack integer, with range checks on the whole value
-    void write_msgpack_integer(const BasicJsonType& j, std::false_type /*fits_64_bits*/)
-    {
-        if (j.m_data.m_type == value_t::number_unsigned)
-        {
-            write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
-            return;
-        }
-
-        if (j.m_data.m_value.number_integer >= 0)
-        {
-            // MessagePack does not differentiate between positive
-            // signed integers and unsigned integers.
-            write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
-        }
-        else
-        {
-            if (j.m_data.m_value.number_integer >= -32)
-            {
-                // negative fixnum
-                write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
-            {
-                // int 8
-                oa.write_character(to_char_type(0xD0));
-                write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
-            {
-                // int 16
-                oa.write_character(to_char_type(0xD1));
-                write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
-            {
-                // int 32
-                oa.write_character(to_char_type(0xD2));
-                write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
-            }
-            else
-            {
-                // int 64
-                oa.write_character(to_char_type(0xD3));
-                write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
-            }
-        }
-    }
-
-    /*!
-    @brief write an array value (head and elements) as MessagePack
-
-    See @ref write_cbor_array.
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_msgpack_array(const BasicJsonType& j, const std::size_t depth)
-    {
-        write_msgpack_array_prefix(j.m_data.m_value.array->size(), j);
-        write_msgpack_array_elements(j, depth, std::integral_constant<bool, msgpack_integers_fit_64_bits()>());
-    }
-
-    void write_msgpack_array_elements(const BasicJsonType& j, const std::size_t depth, std::true_type /*fits_64_bits*/)
-    {
-        write_array_elements(j, [this](CharType * out, const BasicJsonType & el)
-        {
-            return encode_msgpack_integer(out, el);
-        }, [this, depth](const BasicJsonType & el)
-        {
-            write_msgpack(el, depth + 1);
-        });
-    }
-
-    void write_msgpack_array_elements(const BasicJsonType& j, const std::size_t depth, std::false_type /*fits_64_bits*/)
-    {
-        for (const auto& el : *j.m_data.m_value.array)
-        {
-            write_msgpack(el, depth + 1);
-        }
-    }
-
     /*!
     @brief write an object key as a CBOR text string
 

tests/CMakeLists.txt

@@ -118,7 +118,7 @@ endif()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     # avoid stack overflow, see https://github.com/nlohmann/json/issues/2955
-    json_test_set_test_options("test-bon8;test-cbor;test-msgpack;test-ubjson;test-bjdata;test-bjdata_round_trip_draft2;test-bjdata_round_trip_draft3;test-binary_formats" LINK_OPTIONS /STACK:4000000)
+    json_test_set_test_options("test-bon8;test-cbor;test-msgpack;test-ubjson;test-bjdata;test-binary_formats" LINK_OPTIONS /STACK:4000000)
 endif()
 
 # disable exceptions for test-disabled_exceptions

tests/src/bjdata_round_trip.hpp

@@ -1,103 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <cstdint> // uint8_t
-#include <vector> // vector
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#include "round_trip_corpus.hpp"
-
-// The BJData round-trip invariants, split by the BJData version that turns a
-// corpus value into j1 (unit-bjdata_round_trip_draft2.cpp and
-// unit-bjdata_round_trip_draft3.cpp). They were part of unit-bjdata.cpp, but
-// took 80 % of its time; as separate tests, both halves run in parallel and
-// stay below the ctest timeout under Valgrind.
-namespace utils
-{
-
-// This checks what the parse_bjdata_fuzzer driver checks (see
-// tests/src/fuzzer-parse_bjdata.cpp), so that a regression shows up in CI
-// rather than as an OSS-Fuzz report: every value from_bjdata() returns
-// (j1) can be serialized with any combination of options, the result can
-// be parsed back (j2), and serializing j2 again with the same options
-// yields a value-equal result.
-//
-// Beyond the driver, this also checks that j2 equals j1 and that
-// serializing j2 reproduces the exact bytes, both except for values that
-// contain a binary value: a binary value is only written as a binary
-// value with Draft 3's optimized binary array, and otherwise read back as
-// an array of integers, for which the writer may choose different (but
-// equally valid) type markers when it is serialized again (see #5494).
-//
-// Values are compared with dump() rather than operator==, because a NaN
-// never compares equal to itself.
-//
-// Only the corpus values written with @a initial_version become j1; each j1
-// is then serialized with every combination of options, both versions
-// included.
-inline void check_bjdata_round_trip(const nlohmann::json::bjdata_version_t initial_version)
-{
-    using nlohmann::json;
-
-    struct options
-    {
-        bool use_size;
-        bool use_type;
-        json::bjdata_version_t version;
-    };
-    const std::vector<options> all_options =
-    {
-        {false, false, json::bjdata_version_t::draft2},
-        {true, false, json::bjdata_version_t::draft2},
-        {true, true, json::bjdata_version_t::draft2},
-        {false, false, json::bjdata_version_t::draft3},
-        {true, false, json::bjdata_version_t::draft3},
-        {true, true, json::bjdata_version_t::draft3},
-    };
-
-    for (const auto& j0 : utils::round_trip_corpus::values())
-    {
-        // turn the corpus value into a value as from_bjdata() returns it
-        for (const auto& initial : all_options)
-        {
-            if (initial.version != initial_version)
-            {
-                continue;
-            }
-
-            const json j1 = json::from_bjdata(json::to_bjdata(j0, initial.use_size, initial.use_type, initial.version));
-            const bool has_binary = utils::round_trip_corpus::contains_binary(j1);
-
-            for (const auto& o : all_options)
-            {
-                INFO("j1 = " << j1.dump() << ", use_size = " << o.use_size << ", use_type = " << o.use_type
-                     << ", draft3 = " << (o.version == json::bjdata_version_t::draft3));
-
-                const std::vector<std::uint8_t> vec = json::to_bjdata(j1, o.use_size, o.use_type, o.version);
-                json j2;
-                // anything the library writes must be parsable by the library
-                REQUIRE_NOTHROW(j2 = json::from_bjdata(vec));
-                const std::vector<std::uint8_t> vec2 = json::to_bjdata(j2, o.use_size, o.use_type, o.version);
-                CHECK(json::from_bjdata(vec2).dump() == j2.dump());
-
-                if (!has_binary)
-                {
-                    CHECK(j2.dump() == j1.dump());
-                    CHECK(vec2 == vec);
-                }
-            }
-        }
-    }
-}
-
-} // namespace utils

tests/src/unit-binary_writer_sinks.cpp

@@ -11,10 +11,8 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
-#include <array>
 #include <cstdint>
 #include <limits>
-#include <sstream>
 #include <string>
 #include <vector>
 
@@ -37,17 +35,6 @@ std::vector<json> test_values()
         big_object[std::to_string(i)] = i;
     }
 
-    // large strings and binary values between small ones: a write too large
-    // for the space the vector sink has ahead takes a different path than a
-    // small one, and the small writes after it must still land behind it
-    json large_payloads = json::array();
-    for (int i = 0; i < 50; ++i)
-    {
-        large_payloads.push_back(std::string(300, static_cast<char>('a' + (i % 26))));
-        large_payloads.push_back(i);
-        large_payloads.push_back(json::binary(std::vector<std::uint8_t>(static_cast<std::size_t>(100 * i), static_cast<std::uint8_t>(i))));
-    }
-
     return
     {
         json(nullptr), json(true), json(false),
@@ -59,23 +46,10 @@ std::vector<json> test_values()
         json::array(), json::object(),
         json::array({1, 2, 3}), json({{"a", 1}, {"b", nullptr}}),
         json({{"nested", {{"deep", json::array({1, "two", 3.0, nullptr})}}}}),
-        big_array, big_object, large_payloads,
-        json::binary(std::vector<std::uint8_t>(5000, 0x42))
+        big_array, big_object
     };
 }
 
-// explicit char -> uint8_t conversion (the iterator-range constructor converts implicitly, which -fsanitize=integer flags)
-std::vector<std::uint8_t> to_bytes(const std::string& str)
-{
-    std::vector<std::uint8_t> result;
-    result.reserve(str.size());
-    for (const char c : str)
-    {
-        result.push_back(static_cast<std::uint8_t>(c));
-    }
-    return result;
-}
-
 // BON8 has no integers above the int64 range, so to_bon8() rejects them
 bool bon8_representable(const json& j)
 {
@@ -196,258 +170,6 @@ TEST_CASE("binary writer output sinks")
     }
 }
 
-namespace
-{
-
-// the CBOR head of an integer, encoded independently of binary_writer
-void reference_cbor_head(std::vector<std::uint8_t>& out, const std::uint8_t major_type, const std::uint64_t argument)
-{
-    if (argument <= 23)
-    {
-        out.push_back(static_cast<std::uint8_t>(major_type + argument));
-        return;
-    }
-
-    int length = 8;
-    std::uint8_t additional = 27;
-    if (argument <= 0xFF)
-    {
-        length = 1;
-        additional = 24;
-    }
-    else if (argument <= 0xFFFF)
-    {
-        length = 2;
-        additional = 25;
-    }
-    else if (argument <= 0xFFFFFFFF)
-    {
-        length = 4;
-        additional = 26;
-    }
-
-    out.push_back(static_cast<std::uint8_t>(major_type + additional));
-    for (int i = length - 1; i >= 0; --i)
-    {
-        out.push_back(static_cast<std::uint8_t>(argument >> (8 * i)));
-    }
-}
-
-// the CBOR encoding of an integer value
-void reference_cbor_integer(std::vector<std::uint8_t>& out, const json& j)
-{
-    if (j.is_number_unsigned())
-    {
-        reference_cbor_head(out, 0x00, j.get<std::uint64_t>());
-        return;
-    }
-
-    const auto n = j.get<std::int64_t>();
-    if (n >= 0)
-    {
-        reference_cbor_head(out, 0x00, static_cast<std::uint64_t>(n));
-    }
-    else
-    {
-        reference_cbor_head(out, 0x20, static_cast<std::uint64_t>(-1 - n));
-    }
-}
-
-// the MessagePack encoding of an integer value, encoded independently of
-// binary_writer
-void reference_msgpack_integer(std::vector<std::uint8_t>& out, const json& j)
-{
-    const auto put = [&out](const std::uint8_t marker, const std::uint64_t bits, const int length)
-    {
-        out.push_back(marker);
-        for (int i = length - 1; i >= 0; --i)
-        {
-            out.push_back(static_cast<std::uint8_t>(bits >> (8 * i)));
-        }
-    };
-
-    if (j.is_number_unsigned() || j.get<std::int64_t>() >= 0)
-    {
-        const auto u = j.get<std::uint64_t>();
-        if (u < 128)
-        {
-            out.push_back(static_cast<std::uint8_t>(u));
-        }
-        else if (u <= 0xFF)
-        {
-            put(0xCC, u, 1);
-        }
-        else if (u <= 0xFFFF)
-        {
-            put(0xCD, u, 2);
-        }
-        else if (u <= 0xFFFFFFFF)
-        {
-            put(0xCE, u, 4);
-        }
-        else
-        {
-            put(0xCF, u, 8);
-        }
-        return;
-    }
-
-    const auto n = j.get<std::int64_t>();
-    const auto bits = static_cast<std::uint64_t>(n);
-    if (n >= -32)
-    {
-        out.push_back(static_cast<std::uint8_t>(bits));
-    }
-    else if (n >= -128)
-    {
-        put(0xD0, bits, 1);
-    }
-    else if (n >= -32768)
-    {
-        put(0xD1, bits, 2);
-    }
-    else if (n >= -2147483648LL)
-    {
-        put(0xD2, bits, 4);
-    }
-    else
-    {
-        put(0xD3, bits, 8);
-    }
-}
-
-// integers at every boundary of the CBOR and MessagePack sizes, signed and
-// unsigned
-std::vector<json> boundary_integers()
-{
-    std::vector<json> result;
-    const std::array<std::uint64_t, 38> boundaries =
-    {
-        {
-            0, 1, 22, 23, 24, 25, 31, 32, 33, 126, 127, 128, 129, 254, 255, 256, 257,
-            32766, 32767, 32768, 32769, 65534, 65535, 65536, 65537,
-            2147483646ULL, 2147483647ULL, 2147483648ULL, 2147483649ULL,
-            4294967294ULL, 4294967295ULL, 4294967296ULL, 4294967297ULL,
-            9223372036854775806ULL, 9223372036854775807ULL, 9223372036854775808ULL,
-            18446744073709551614ULL, 18446744073709551615ULL
-        }
-    };
-    for (const std::uint64_t u : boundaries)
-    {
-        result.emplace_back(u);
-        if (u <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
-        {
-            const auto n = static_cast<std::int64_t>(u);
-            result.emplace_back(n);
-            result.emplace_back(-n);
-            result.emplace_back(-n - 1);
-        }
-    }
-    return result;
-}
-
-} // namespace
-
-// Arrays of integers are written in runs straight into space reserved from the
-// sink, with branch-free encodings; check them against independent encoders for
-// runs shorter and longer than one reservation, broken up by other values, and
-// through each sink.
-TEST_CASE("CBOR and MessagePack integer arrays")
-{
-    const std::vector<json> integers = boundary_integers();
-
-    for (const std::size_t length :
-            {
-                std::size_t{1}, std::size_t{27}, std::size_t{28}, std::size_t{29}, std::size_t{57}, std::size_t{1000}
-            })
-    {
-        for (const std::size_t break_every :
-                {
-                    std::size_t{0}, std::size_t{1}, std::size_t{7}, std::size_t{28}
-                })
-        {
-            CAPTURE(length)
-            CAPTURE(break_every)
-
-            json array = json::array();
-            std::vector<std::uint8_t> expected_cbor;
-            std::vector<std::uint8_t> expected_msgpack;
-            for (std::size_t i = 0; i < length; ++i)
-            {
-                if (break_every != 0 && i % (break_every + 1) == break_every)
-                {
-                    array.push_back("x");
-                    expected_cbor.push_back(0x61);
-                    expected_cbor.push_back('x');
-                    expected_msgpack.push_back(0xA1);
-                    expected_msgpack.push_back('x');
-                }
-                else
-                {
-                    const json& value = integers[(i * 7) % integers.size()];
-                    array.push_back(value);
-                    reference_cbor_integer(expected_cbor, value);
-                    reference_msgpack_integer(expected_msgpack, value);
-                }
-            }
-
-            std::vector<std::uint8_t> head;
-            reference_cbor_head(head, 0x80, length);
-            expected_cbor.insert(expected_cbor.begin(), head.begin(), head.end());
-
-            head.clear();
-            if (length <= 15)
-            {
-                head.push_back(static_cast<std::uint8_t>(0x90 + length));
-            }
-            else
-            {
-                head = {0xDC, static_cast<std::uint8_t>(length >> 8), static_cast<std::uint8_t>(length)};
-            }
-            expected_msgpack.insert(expected_msgpack.begin(), head.begin(), head.end());
-
-            CHECK(json::to_cbor(array) == expected_cbor);
-            CHECK(json::to_msgpack(array) == expected_msgpack);
-
-            std::vector<std::uint8_t> through_adapter = {0xAA};
-            json::to_cbor(array, through_adapter);
-            CHECK(std::vector<std::uint8_t>(through_adapter.begin() + 1, through_adapter.end()) == expected_cbor);
-            through_adapter = {0xAA};
-            json::to_msgpack(array, through_adapter);
-            CHECK(std::vector<std::uint8_t>(through_adapter.begin() + 1, through_adapter.end()) == expected_msgpack);
-
-            std::ostringstream stream;
-            json::to_cbor(array, stream);
-            std::string streamed = stream.str();
-            CHECK(to_bytes(streamed) == expected_cbor);
-            stream.str("");
-            json::to_msgpack(array, stream);
-            streamed = stream.str();
-            CHECK(to_bytes(streamed) == expected_msgpack);
-
-            CHECK(json::from_cbor(expected_cbor) == array);
-            CHECK(json::from_msgpack(expected_msgpack) == array);
-
-            // the same array as object members
-            const json object = {{"a", array}, {"b", array}};
-            CHECK(json::from_cbor(json::to_cbor(object)) == object);
-            CHECK(json::from_msgpack(json::to_msgpack(object)) == object);
-        }
-    }
-
-    // single values, outside an array
-    for (const auto& value : integers)
-    {
-        CAPTURE(value)
-        std::vector<std::uint8_t> expected;
-        reference_cbor_integer(expected, value);
-        CHECK(json::to_cbor(value) == expected);
-        expected.clear();
-        reference_msgpack_integer(expected, value);
-        CHECK(json::to_msgpack(value) == expected);
-    }
-}
-
 // binary_reserve_hint() is documented as a *lower* bound on the serialized size,
 // so that reserving it up front can never leave the returned vector holding
 // capacity beyond what the value actually needs.

tests/src/unit-bjdata.cpp

@@ -28,6 +28,7 @@ using ordered_json = nlohmann::ordered_json;
 #include <fstream>
 #include <set>
 #include "make_test_data_available.hpp"
+#include "round_trip_corpus.hpp"
 #include "test_utils.hpp"
 #include "sax_countdown.hpp"
 using utils::SaxCountdown;
@@ -4440,6 +4441,70 @@ TEST_CASE("BJData use_type requires use_size")
     }
 }
 
+TEST_CASE("BJData round-trip invariants")
+{
+    // This checks what the parse_bjdata_fuzzer driver checks (see
+    // tests/src/fuzzer-parse_bjdata.cpp), so that a regression shows up in CI
+    // rather than as an OSS-Fuzz report: every value from_bjdata() returns
+    // (j1) can be serialized with any combination of options, the result can
+    // be parsed back (j2), and serializing j2 again with the same options
+    // yields a value-equal result.
+    //
+    // Beyond the driver, this also checks that j2 equals j1 and that
+    // serializing j2 reproduces the exact bytes, both except for values that
+    // contain a binary value: a binary value is only written as a binary
+    // value with Draft 3's optimized binary array, and otherwise read back as
+    // an array of integers, for which the writer may choose different (but
+    // equally valid) type markers when it is serialized again (see #5494).
+    //
+    // Values are compared with dump() rather than operator==, because a NaN
+    // never compares equal to itself.
+    struct options
+    {
+        bool use_size;
+        bool use_type;
+        json::bjdata_version_t version;
+    };
+    const std::vector<options> all_options =
+    {
+        {false, false, json::bjdata_version_t::draft2},
+        {true, false, json::bjdata_version_t::draft2},
+        {true, true, json::bjdata_version_t::draft2},
+        {false, false, json::bjdata_version_t::draft3},
+        {true, false, json::bjdata_version_t::draft3},
+        {true, true, json::bjdata_version_t::draft3},
+    };
+
+    for (const auto& j0 : utils::round_trip_corpus::values())
+    {
+        // turn the corpus value into a value as from_bjdata() returns it
+        for (const auto& initial : all_options)
+        {
+            const json j1 = json::from_bjdata(json::to_bjdata(j0, initial.use_size, initial.use_type, initial.version));
+            const bool has_binary = utils::round_trip_corpus::contains_binary(j1);
+
+            for (const auto& o : all_options)
+            {
+                INFO("j1 = " << j1.dump() << ", use_size = " << o.use_size << ", use_type = " << o.use_type
+                     << ", draft3 = " << (o.version == json::bjdata_version_t::draft3));
+
+                const std::vector<std::uint8_t> vec = json::to_bjdata(j1, o.use_size, o.use_type, o.version);
+                json j2;
+                // anything the library writes must be parsable by the library
+                REQUIRE_NOTHROW(j2 = json::from_bjdata(vec));
+                const std::vector<std::uint8_t> vec2 = json::to_bjdata(j2, o.use_size, o.use_type, o.version);
+                CHECK(json::from_bjdata(vec2).dump() == j2.dump());
+
+                if (!has_binary)
+                {
+                    CHECK(j2.dump() == j1.dump());
+                    CHECK(vec2 == vec);
+                }
+            }
+        }
+    }
+}
+
 TEST_CASE("BJData round trip of a binary value is value-stable, not byte-stable")
 {
     // OSS-Fuzz issue 474480402: a Draft 3 optimized binary array is read as a

tests/src/unit-bjdata_round_trip_draft2.cpp

@@ -1,22 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include "bjdata_round_trip.hpp"
-
-// split from unit-bjdata.cpp, see bjdata_round_trip.hpp; the other half is in
-// unit-bjdata_round_trip_draft3.cpp
-
-TEST_CASE("BJData round-trip invariants (j1 written with Draft 2)")
-{
-    utils::check_bjdata_round_trip(json::bjdata_version_t::draft2);
-}

tests/src/unit-bjdata_round_trip_draft3.cpp

@@ -1,22 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include "bjdata_round_trip.hpp"
-
-// split from unit-bjdata.cpp, see bjdata_round_trip.hpp; the other half is in
-// unit-bjdata_round_trip_draft2.cpp
-
-TEST_CASE("BJData round-trip invariants (j1 written with Draft 3)")
-{
-    utils::check_bjdata_round_trip(json::bjdata_version_t::draft3);
-}

tests/src/unit-large_json.cpp

@@ -13,6 +13,8 @@ using nlohmann::json;
 
 #include <algorithm>
 #include <string>
+#include <utility>
+#include <vector>
 
 TEST_CASE("tests on very large JSONs")
 {
@@ -53,6 +55,24 @@ const json* innermost_value(const json& j, std::size_t& depth)
     return current;
 }
 
+// The text of a value nested depth levels deep around the number 0. Level i is
+// an array if pattern[i % pattern.size()] is '[', and otherwise an object with
+// the single member "a", which every object type enumerates in the same order.
+std::string nested_text(std::size_t depth, const std::string& pattern)
+{
+    std::string text;
+    std::string closing;
+    for (std::size_t i = 0; i < depth; ++i)
+    {
+        const bool array = pattern[i % pattern.size()] == '[';
+        text += array ? "[" : "{\"a\":";
+        closing += array ? ']' : '}';
+    }
+    text += '0';
+    text.append(closing.rbegin(), closing.rend());
+    return text;
+}
+
 } // namespace
 
 TEST_CASE("tests on deeply nested JSONs")
@@ -224,4 +244,385 @@ TEST_CASE("tests on deeply nested JSONs")
             CHECK(*innermost_value(j, unused) == 0);
         }
     }
+
+    SECTION("issue #5650 - stack overflow converting between specializations")
+    {
+        const std::vector<std::string> patterns = {"[", "{", "[{"};
+
+        SECTION("json to ordered_json")
+        {
+            for (const auto& pattern : patterns)
+            {
+                CAPTURE(pattern)
+                const std::string text = nested_text(depth, pattern);
+                const json j = json::parse(text);
+
+                const nlohmann::ordered_json converted = j;
+                CHECK(converted.dump() == text);
+            }
+        }
+
+        SECTION("ordered_json to json")
+        {
+            for (const auto& pattern : patterns)
+            {
+                CAPTURE(pattern)
+                const std::string text = nested_text(depth, pattern);
+                const nlohmann::ordered_json o = nlohmann::ordered_json::parse(text);
+
+                const json converted = o;
+                CHECK(converted.dump() == text);
+            }
+        }
+
+        SECTION("get<ordered_json>()")
+        {
+            for (const auto& pattern : patterns)
+            {
+                CAPTURE(pattern)
+                const std::string text = nested_text(depth, pattern);
+                const json j = json::parse(text);
+
+                CHECK(j.get<nlohmann::ordered_json>().dump() == text);
+            }
+        }
+
+        SECTION("depths around the bound of the recursive descent")
+        {
+            for (std::size_t d = 1; d <= 300; ++d)
+            {
+                CAPTURE(d)
+                for (const auto& pattern : patterns)
+                {
+                    CAPTURE(pattern)
+                    const std::string text = nested_text(d, pattern);
+                    const json j = json::parse(text);
+
+                    const nlohmann::ordered_json converted = j;
+                    CHECK(converted.dump() == text);
+                    const json back = converted;
+                    CHECK(back.dump() == text);
+                }
+            }
+        }
+
+        SECTION("values below the bound are converted as values above it")
+        {
+            // Bury a value below the bound, where it is converted without the
+            // call stack, and compare it with the same value converted on its
+            // own by the containers' range constructors. Its objects have
+            // members that the two object types enumerate in different orders.
+            const auto bury = [](nlohmann::ordered_json value)
+            {
+                for (std::size_t i = 0; i < 200; ++i)
+                {
+                    value = nlohmann::ordered_json::array({std::move(value)});
+                }
+                return value;
+            };
+            const auto dig = [](const json & value)
+            {
+                const json* current = &value;
+                for (std::size_t i = 0; i < 200; ++i)
+                {
+                    current = &current->at(0);
+                }
+                return current;
+            };
+
+            nlohmann::ordered_json value = nlohmann::ordered_json::object();
+            value["z"] = {1, -2, 3U, 4.5, true, nullptr, "six", nlohmann::ordered_json::binary({7, 8}, 9),
+                          nlohmann::ordered_json::binary({10}), nlohmann::ordered_json::array(), nlohmann::ordered_json::object()
+                         };
+            value["y"] = {{"x", {{"w", 1}, {"v", 2}}}, {"u", {3, {{"t", 4}, {"s", 5}}}}};
+            value["r"] = nlohmann::ordered_json::array({nlohmann::ordered_json(nlohmann::ordered_json::value_t::discarded)});
+
+            const json converted_above = value;
+            const json buried = bury(value);
+            const json& converted_below = *dig(buried);
+
+            CHECK(converted_below.dump() == converted_above.dump());
+            CHECK(converted_below.at("z").at(7).get_binary().subtype() == 9);
+            CHECK_FALSE(converted_below.at("z").at(8).get_binary().has_subtype());
+            CHECK(converted_below.at("r").at(0).is_discarded());
+
+            // a discarded value is never equal to anything, so compare the rest
+            value.erase("r");
+            const json without_discarded_above = value;
+            const json without_discarded_buried = bury(value);
+            CHECK(*dig(without_discarded_buried) == without_discarded_above);
+        }
+    }
 }
+
+namespace
+{
+json nested_array(const std::size_t depth, json leaf)
+{
+    json j = std::move(leaf);
+    for (std::size_t i = 0; i < depth; ++i)
+    {
+        json a = json::array();
+        a.push_back(std::move(j));
+        j = std::move(a);
+    }
+    return j;
+}
+
+json nested_object(const std::size_t depth, json leaf)
+{
+    json j = std::move(leaf);
+    for (std::size_t i = 0; i < depth; ++i)
+    {
+        json o = json::object();
+        o["k"] = std::move(j);
+        j = std::move(o);
+    }
+    return j;
+}
+} // namespace
+
+TEST_CASE("issue #5392 - binary writers on deeply nested values")
+{
+    // 200 is past the point where the writers stop recursing, and still
+    // shallow enough that from_* and operator== (which still recurse) are fine.
+    const json deep_array = nested_array(200, json(0));
+    const json deep_object = nested_object(200, json("x"));
+    const json empty_array = nested_array(200, json::array());
+    const json empty_object = nested_object(200, json::object());
+    const json mixed = nested_object(80, nested_array(80, json(true)));
+
+    SECTION("roundtrip past the recursion bound")
+    {
+        CHECK(json::from_cbor(json::to_cbor(deep_array)) == deep_array);
+        CHECK(json::from_msgpack(json::to_msgpack(deep_array)) == deep_array);
+        CHECK(json::from_ubjson(json::to_ubjson(deep_array)) == deep_array);
+        CHECK(json::from_ubjson(json::to_ubjson(deep_array, true, false)) == deep_array);
+        CHECK(json::from_ubjson(json::to_ubjson(deep_array, true, true)) == deep_array);
+        CHECK(json::from_bjdata(json::to_bjdata(deep_array)) == deep_array);
+        CHECK(json::from_bon8(json::to_bon8(deep_array)) == deep_array);
+
+        CHECK(json::from_cbor(json::to_cbor(deep_object)) == deep_object);
+        CHECK(json::from_msgpack(json::to_msgpack(deep_object)) == deep_object);
+        CHECK(json::from_ubjson(json::to_ubjson(deep_object)) == deep_object);
+        CHECK(json::from_ubjson(json::to_ubjson(deep_object, true, true)) == deep_object);
+        CHECK(json::from_bjdata(json::to_bjdata(deep_object)) == deep_object);
+        CHECK(json::from_bon8(json::to_bon8(deep_object)) == deep_object);
+
+        CHECK(json::from_cbor(json::to_cbor(empty_array)) == empty_array);
+        CHECK(json::from_msgpack(json::to_msgpack(empty_array)) == empty_array);
+        CHECK(json::from_ubjson(json::to_ubjson(empty_array)) == empty_array);
+        CHECK(json::from_ubjson(json::to_ubjson(empty_array, true, true)) == empty_array);
+        CHECK(json::from_bon8(json::to_bon8(empty_array)) == empty_array);
+
+        CHECK(json::from_cbor(json::to_cbor(empty_object)) == empty_object);
+        CHECK(json::from_msgpack(json::to_msgpack(empty_object)) == empty_object);
+        CHECK(json::from_ubjson(json::to_ubjson(empty_object)) == empty_object);
+        CHECK(json::from_bon8(json::to_bon8(empty_object)) == empty_object);
+
+        CHECK(json::from_cbor(json::to_cbor(mixed)) == mixed);
+        CHECK(json::from_msgpack(json::to_msgpack(mixed)) == mixed);
+        CHECK(json::from_ubjson(json::to_ubjson(mixed)) == mixed);
+        CHECK(json::from_bjdata(json::to_bjdata(mixed)) == mixed);
+        CHECK(json::from_bon8(json::to_bon8(mixed)) == mixed);
+    }
+
+    SECTION("the two ways of writing a value meet at the bound")
+    {
+        for (std::size_t depth = 120; depth <= 140; ++depth)
+        {
+            CAPTURE(depth)
+
+            const json array = nested_array(depth, json(7));
+            CHECK(json::from_cbor(json::to_cbor(array)) == array);
+            CHECK(json::from_msgpack(json::to_msgpack(array)) == array);
+            CHECK(json::from_ubjson(json::to_ubjson(array, true, true)) == array);
+            CHECK(json::from_bon8(json::to_bon8(array)) == array);
+
+            const json object = nested_object(depth, json(7));
+            CHECK(json::from_cbor(json::to_cbor(object)) == object);
+            CHECK(json::from_msgpack(json::to_msgpack(object)) == object);
+            CHECK(json::from_bjdata(json::to_bjdata(object)) == object);
+            CHECK(json::from_bon8(json::to_bon8(object)) == object);
+        }
+    }
+
+    SECTION("a BJData ndarray below the bound is still an ndarray")
+    {
+        const json ndarray = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}});
+        const json invalid = json({{"_ArrayType_", "nope"}, {"_ArraySize_", {1}}, {"_ArrayData_", {1}}});
+
+        const json deep_ndarray = nested_array(140, ndarray);
+        const json deep_invalid = nested_array(140, invalid);
+
+        CHECK(json::from_bjdata(json::to_bjdata(deep_ndarray)) == deep_ndarray);
+        CHECK(json::from_bjdata(json::to_bjdata(deep_invalid)) == deep_invalid);
+        CHECK(json::from_bjdata(json::to_bjdata(ndarray)) == ndarray);
+    }
+
+    SECTION("byte-exact across the switch-over")
+    {
+        // nested one-element arrays around the recursion bound: the exact
+        // bytes a writer produces do not depend on whether it stayed on the
+        // call stack or moved to the heap one partway through
+        for (const std::size_t depth :
+                {
+                    nlohmann::detail::recursion_depth_limit() - 1, nlohmann::detail::recursion_depth_limit(),
+                    nlohmann::detail::recursion_depth_limit() + 1, nlohmann::detail::recursion_depth_limit() + 2
+                })
+        {
+            CAPTURE(depth)
+            const json array = nested_array(depth, json(0));
+
+            std::vector<std::uint8_t> expected_cbor(depth, 0x81);
+            expected_cbor.push_back(0x00);
+            CHECK(json::to_cbor(array) == expected_cbor);
+
+            std::vector<std::uint8_t> expected_msgpack(depth, 0x91);
+            expected_msgpack.push_back(0x00);
+            CHECK(json::to_msgpack(array) == expected_msgpack);
+
+            std::string expected_ubjson(depth, '[');
+            expected_ubjson += "i";
+            expected_ubjson += '\0';
+            expected_ubjson.append(depth, ']');
+            const auto packed_ubjson = json::to_ubjson(array);
+            CHECK(std::string(packed_ubjson.begin(), packed_ubjson.end()) == expected_ubjson);
+
+            std::vector<std::uint8_t> expected_bon8(depth, 0x81);
+            expected_bon8.push_back(0x90);
+            CHECK(json::to_bon8(array) == expected_bon8);
+        }
+    }
+
+    SECTION("a deep object, and a BJData ndarray, past the recursion bound")
+    {
+        const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 50;
+
+        const json object = nested_object(depth, json(42));
+        CHECK(json::from_cbor(json::to_cbor(object)) == object);
+        CHECK(json::from_msgpack(json::to_msgpack(object)) == object);
+        CHECK(json::from_ubjson(json::to_ubjson(object, true, true)) == object);
+        CHECK(json::from_bjdata(json::to_bjdata(object)) == object);
+        CHECK(json::from_bon8(json::to_bon8(object)) == object);
+
+        const json ndarray = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}});
+        const json deep_ndarray = nested_array(depth, ndarray);
+        CHECK(json::from_bjdata(json::to_bjdata(deep_ndarray)) == deep_ndarray);
+    }
+
+    SECTION("a discarded value past the recursion bound still throws type_error.321")
+    {
+        const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 50;
+        const json discarded_leaf(json::value_t::discarded);
+        const json deep_discarded = nested_array(depth, discarded_leaf);
+
+        // with diagnostics, the message names the path to the discarded leaf
+#if JSON_DIAGNOSTICS
+        std::string path;
+        for (std::size_t i = 0; i < depth; ++i)
+        {
+            path += "/0";
+        }
+        const std::string prefix = "[json.exception.type_error.321] (" + path + ") ";
+#else
+        const std::string prefix = "[json.exception.type_error.321] ";
+#endif
+
+        CHECK_THROWS_WITH_AS(json::to_cbor(deep_discarded), (prefix + "cannot serialize discarded value to CBOR").c_str(), json::type_error);
+        CHECK_THROWS_WITH_AS(json::to_msgpack(deep_discarded), (prefix + "cannot serialize discarded value to MessagePack").c_str(), json::type_error);
+        CHECK_THROWS_WITH_AS(json::to_ubjson(deep_discarded), (prefix + "cannot serialize discarded value to UBJSON").c_str(), json::type_error);
+        CHECK_THROWS_WITH_AS(json::to_bjdata(deep_discarded), (prefix + "cannot serialize discarded value to BJData").c_str(), json::type_error);
+    }
+
+    SECTION("BON8 past the recursion bound: discarded values and errors")
+    {
+        const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 50;
+
+        // BON8 rejects a discarded value (type_error.321), deep or not
+        const json deep_discarded = nested_array(depth, json(json::value_t::discarded));
+        CHECK_THROWS_AS(json::to_bon8(deep_discarded), json::type_error);
+
+        // errors are thrown from below the bound as from above it
+        const json deep_invalid_string = nested_array(depth, json(std::string("\x80")));
+        CHECK_THROWS_AS(json::to_bon8(deep_invalid_string), json::type_error);
+
+        json deep_invalid_key = json::object();
+        deep_invalid_key[std::string("\x80")] = 1;
+        deep_invalid_key = nested_object(depth, deep_invalid_key);
+        CHECK_THROWS_AS(json::to_bon8(deep_invalid_key), json::type_error);
+
+        const json deep_too_large = nested_array(depth, json(9223372036854775808u));
+        CHECK_THROWS_AS(json::to_bon8(deep_too_large), json::out_of_range);
+    }
+
+    SECTION("does not overflow the C++ stack")
+    {
+        const std::size_t depth = 100000;
+        const json j = json::parse(std::string(depth, '[') + "0" + std::string(depth, ']'));
+
+        std::vector<std::uint8_t> packed;
+        CHECK_NOTHROW(packed = json::to_cbor(j));
+        CHECK(json::from_cbor(packed) == j);
+
+        CHECK_NOTHROW(packed = json::to_msgpack(j));
+        CHECK(json::from_msgpack(packed) == j);
+
+        CHECK_NOTHROW(packed = json::to_ubjson(j));
+        CHECK(json::from_ubjson(packed) == j);
+
+        CHECK_NOTHROW(packed = json::to_ubjson(j, true, false));
+        CHECK(json::from_ubjson(packed) == j);
+
+        CHECK_NOTHROW(packed = json::to_bjdata(j));
+        CHECK(json::from_bjdata(packed) == j);
+
+        CHECK_NOTHROW(packed = json::to_bon8(j));
+        CHECK(json::from_bon8(packed) == j);
+    }
+
+    SECTION("BON8 containers with more than four elements past the recursion bound")
+    {
+        // such containers are closed with 0xFE, which the iterative writer
+        // must emit when it leaves them; strings next to each other must
+        // still be separated with 0xFF
+        const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 50;
+        json wide_array = json::array({1, "a", "b", json::array(), 5});
+        json wide_object = json({{"k1", "v"}, {"k2", 2}, {"k3", ""}, {"k4", json::object()}, {"k5", nullptr}});
+        for (std::size_t i = 0; i < depth; ++i)
+        {
+            wide_array = json::array({"s", wide_array, "t", wide_object, true});
+            wide_object = json({{"a", wide_object}, {"b", "x"}, {"c", "y"}, {"d", wide_array.size()}, {"e", "z"}});
+        }
+
+        CHECK(json::from_bon8(json::to_bon8(wide_array)) == wide_array);
+        CHECK(json::from_bon8(json::to_bon8(wide_object)) == wide_object);
+    }
+
+    SECTION("regression test for https://issues.oss-fuzz.com/issues/566583014")
+    {
+        // 200000 nested one-element CBOR arrays, the innermost holding null;
+        // round-tripping this used to recurse once per level on the way back
+        // out through to_cbor(), deep enough to overflow the stack
+        std::vector<std::uint8_t> v(200000, 0x81);
+        v.push_back(0xf6);
+        const json j = json::from_cbor(v);
+        CHECK(json::to_cbor(j) == v);
+
+        // the MessagePack analogue: fixarray of 1 nesting down to nil
+        std::vector<std::uint8_t> v_msgpack(200000, 0x91);
+        v_msgpack.push_back(0xc0);
+        const json j_msgpack = json::from_msgpack(v_msgpack);
+        CHECK(json::to_msgpack(j_msgpack) == v_msgpack);
+    }
+
+    SECTION("regression test for https://issues.oss-fuzz.com/issues/572238015")
+    {
+        // the BON8 analogue: 200000 nested one-element arrays down to null
+        std::vector<std::uint8_t> v(200000, 0x81);
+        v.push_back(0xFA);
+        const json j = json::from_bon8(v);
+        CHECK(json::to_bon8(j) == v);
+    }
+}
+

tests/src/unit-large_json_binary_writers.cpp

@@ -1,294 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <utility>
-#include <vector>
-
-// split from unit-large_json.cpp so that both run in parallel and stay below
-// the ctest timeout under Valgrind
-
-namespace
-{
-json nested_array(const std::size_t depth, json leaf)
-{
-    json j = std::move(leaf);
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        json a = json::array();
-        a.push_back(std::move(j));
-        j = std::move(a);
-    }
-    return j;
-}
-
-json nested_object(const std::size_t depth, json leaf)
-{
-    json j = std::move(leaf);
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        json o = json::object();
-        o["k"] = std::move(j);
-        j = std::move(o);
-    }
-    return j;
-}
-} // namespace
-
-TEST_CASE("issue #5392 - binary writers on deeply nested values")
-{
-    // 200 is past the point where the writers stop recursing, and still
-    // shallow enough that from_* and operator== (which still recurse) are fine.
-    const json deep_array = nested_array(200, json(0));
-    const json deep_object = nested_object(200, json("x"));
-    const json empty_array = nested_array(200, json::array());
-    const json empty_object = nested_object(200, json::object());
-    const json mixed = nested_object(80, nested_array(80, json(true)));
-
-    SECTION("roundtrip past the recursion bound")
-    {
-        CHECK(json::from_cbor(json::to_cbor(deep_array)) == deep_array);
-        CHECK(json::from_msgpack(json::to_msgpack(deep_array)) == deep_array);
-        CHECK(json::from_ubjson(json::to_ubjson(deep_array)) == deep_array);
-        CHECK(json::from_ubjson(json::to_ubjson(deep_array, true, false)) == deep_array);
-        CHECK(json::from_ubjson(json::to_ubjson(deep_array, true, true)) == deep_array);
-        CHECK(json::from_bjdata(json::to_bjdata(deep_array)) == deep_array);
-        CHECK(json::from_bon8(json::to_bon8(deep_array)) == deep_array);
-
-        CHECK(json::from_cbor(json::to_cbor(deep_object)) == deep_object);
-        CHECK(json::from_msgpack(json::to_msgpack(deep_object)) == deep_object);
-        CHECK(json::from_ubjson(json::to_ubjson(deep_object)) == deep_object);
-        CHECK(json::from_ubjson(json::to_ubjson(deep_object, true, true)) == deep_object);
-        CHECK(json::from_bjdata(json::to_bjdata(deep_object)) == deep_object);
-        CHECK(json::from_bon8(json::to_bon8(deep_object)) == deep_object);
-
-        CHECK(json::from_cbor(json::to_cbor(empty_array)) == empty_array);
-        CHECK(json::from_msgpack(json::to_msgpack(empty_array)) == empty_array);
-        CHECK(json::from_ubjson(json::to_ubjson(empty_array)) == empty_array);
-        CHECK(json::from_ubjson(json::to_ubjson(empty_array, true, true)) == empty_array);
-        CHECK(json::from_bon8(json::to_bon8(empty_array)) == empty_array);
-
-        CHECK(json::from_cbor(json::to_cbor(empty_object)) == empty_object);
-        CHECK(json::from_msgpack(json::to_msgpack(empty_object)) == empty_object);
-        CHECK(json::from_ubjson(json::to_ubjson(empty_object)) == empty_object);
-        CHECK(json::from_bon8(json::to_bon8(empty_object)) == empty_object);
-
-        CHECK(json::from_cbor(json::to_cbor(mixed)) == mixed);
-        CHECK(json::from_msgpack(json::to_msgpack(mixed)) == mixed);
-        CHECK(json::from_ubjson(json::to_ubjson(mixed)) == mixed);
-        CHECK(json::from_bjdata(json::to_bjdata(mixed)) == mixed);
-        CHECK(json::from_bon8(json::to_bon8(mixed)) == mixed);
-    }
-
-    SECTION("the two ways of writing a value meet at the bound")
-    {
-        for (std::size_t depth = 120; depth <= 140; ++depth)
-        {
-            CAPTURE(depth)
-
-            const json array = nested_array(depth, json(7));
-            CHECK(json::from_cbor(json::to_cbor(array)) == array);
-            CHECK(json::from_msgpack(json::to_msgpack(array)) == array);
-            CHECK(json::from_ubjson(json::to_ubjson(array, true, true)) == array);
-            CHECK(json::from_bon8(json::to_bon8(array)) == array);
-
-            const json object = nested_object(depth, json(7));
-            CHECK(json::from_cbor(json::to_cbor(object)) == object);
-            CHECK(json::from_msgpack(json::to_msgpack(object)) == object);
-            CHECK(json::from_bjdata(json::to_bjdata(object)) == object);
-            CHECK(json::from_bon8(json::to_bon8(object)) == object);
-        }
-    }
-
-    SECTION("a BJData ndarray below the bound is still an ndarray")
-    {
-        const json ndarray = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}});
-        const json invalid = json({{"_ArrayType_", "nope"}, {"_ArraySize_", {1}}, {"_ArrayData_", {1}}});
-
-        const json deep_ndarray = nested_array(140, ndarray);
-        const json deep_invalid = nested_array(140, invalid);
-
-        CHECK(json::from_bjdata(json::to_bjdata(deep_ndarray)) == deep_ndarray);
-        CHECK(json::from_bjdata(json::to_bjdata(deep_invalid)) == deep_invalid);
-        CHECK(json::from_bjdata(json::to_bjdata(ndarray)) == ndarray);
-    }
-
-    SECTION("byte-exact across the switch-over")
-    {
-        // nested one-element arrays around the recursion bound: the exact
-        // bytes a writer produces do not depend on whether it stayed on the
-        // call stack or moved to the heap one partway through
-        for (const std::size_t depth :
-                {
-                    nlohmann::detail::recursion_depth_limit() - 1, nlohmann::detail::recursion_depth_limit(),
-                    nlohmann::detail::recursion_depth_limit() + 1, nlohmann::detail::recursion_depth_limit() + 2
-                })
-        {
-            CAPTURE(depth)
-            const json array = nested_array(depth, json(0));
-
-            std::vector<std::uint8_t> expected_cbor(depth, 0x81);
-            expected_cbor.push_back(0x00);
-            CHECK(json::to_cbor(array) == expected_cbor);
-
-            std::vector<std::uint8_t> expected_msgpack(depth, 0x91);
-            expected_msgpack.push_back(0x00);
-            CHECK(json::to_msgpack(array) == expected_msgpack);
-
-            std::string expected_ubjson(depth, '[');
-            expected_ubjson += "i";
-            expected_ubjson += '\0';
-            expected_ubjson.append(depth, ']');
-            const auto packed_ubjson = json::to_ubjson(array);
-            CHECK(std::string(packed_ubjson.begin(), packed_ubjson.end()) == expected_ubjson);
-
-            std::vector<std::uint8_t> expected_bon8(depth, 0x81);
-            expected_bon8.push_back(0x90);
-            CHECK(json::to_bon8(array) == expected_bon8);
-        }
-    }
-
-    SECTION("a deep object, and a BJData ndarray, past the recursion bound")
-    {
-        const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 50;
-
-        const json object = nested_object(depth, json(42));
-        CHECK(json::from_cbor(json::to_cbor(object)) == object);
-        CHECK(json::from_msgpack(json::to_msgpack(object)) == object);
-        CHECK(json::from_ubjson(json::to_ubjson(object, true, true)) == object);
-        CHECK(json::from_bjdata(json::to_bjdata(object)) == object);
-        CHECK(json::from_bon8(json::to_bon8(object)) == object);
-
-        const json ndarray = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}});
-        const json deep_ndarray = nested_array(depth, ndarray);
-        CHECK(json::from_bjdata(json::to_bjdata(deep_ndarray)) == deep_ndarray);
-    }
-
-    SECTION("a discarded value past the recursion bound still throws type_error.321")
-    {
-        const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 50;
-        const json discarded_leaf(json::value_t::discarded);
-        const json deep_discarded = nested_array(depth, discarded_leaf);
-
-        // with diagnostics, the message names the path to the discarded leaf
-#if JSON_DIAGNOSTICS
-        std::string path;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            path += "/0";
-        }
-        const std::string prefix = "[json.exception.type_error.321] (" + path + ") ";
-#else
-        const std::string prefix = "[json.exception.type_error.321] ";
-#endif
-
-        CHECK_THROWS_WITH_AS(json::to_cbor(deep_discarded), (prefix + "cannot serialize discarded value to CBOR").c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(json::to_msgpack(deep_discarded), (prefix + "cannot serialize discarded value to MessagePack").c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(json::to_ubjson(deep_discarded), (prefix + "cannot serialize discarded value to UBJSON").c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(json::to_bjdata(deep_discarded), (prefix + "cannot serialize discarded value to BJData").c_str(), json::type_error);
-    }
-
-    SECTION("BON8 past the recursion bound: discarded values and errors")
-    {
-        const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 50;
-
-        // BON8 rejects a discarded value (type_error.321), deep or not
-        const json deep_discarded = nested_array(depth, json(json::value_t::discarded));
-        CHECK_THROWS_AS(json::to_bon8(deep_discarded), json::type_error);
-
-        // errors are thrown from below the bound as from above it
-        const json deep_invalid_string = nested_array(depth, json(std::string("\x80")));
-        CHECK_THROWS_AS(json::to_bon8(deep_invalid_string), json::type_error);
-
-        json deep_invalid_key = json::object();
-        deep_invalid_key[std::string("\x80")] = 1;
-        deep_invalid_key = nested_object(depth, deep_invalid_key);
-        CHECK_THROWS_AS(json::to_bon8(deep_invalid_key), json::type_error);
-
-        const json deep_too_large = nested_array(depth, json(9223372036854775808u));
-        CHECK_THROWS_AS(json::to_bon8(deep_too_large), json::out_of_range);
-    }
-
-    SECTION("does not overflow the C++ stack")
-    {
-        const std::size_t depth = 100000;
-        const json j = json::parse(std::string(depth, '[') + "0" + std::string(depth, ']'));
-
-        std::vector<std::uint8_t> packed;
-        CHECK_NOTHROW(packed = json::to_cbor(j));
-        CHECK(json::from_cbor(packed) == j);
-
-        CHECK_NOTHROW(packed = json::to_msgpack(j));
-        CHECK(json::from_msgpack(packed) == j);
-
-        CHECK_NOTHROW(packed = json::to_ubjson(j));
-        CHECK(json::from_ubjson(packed) == j);
-
-        CHECK_NOTHROW(packed = json::to_ubjson(j, true, false));
-        CHECK(json::from_ubjson(packed) == j);
-
-        CHECK_NOTHROW(packed = json::to_bjdata(j));
-        CHECK(json::from_bjdata(packed) == j);
-
-        CHECK_NOTHROW(packed = json::to_bon8(j));
-        CHECK(json::from_bon8(packed) == j);
-    }
-
-    SECTION("BON8 containers with more than four elements past the recursion bound")
-    {
-        // such containers are closed with 0xFE, which the iterative writer
-        // must emit when it leaves them; strings next to each other must
-        // still be separated with 0xFF
-        const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 50;
-        json wide_array = json::array({1, "a", "b", json::array(), 5});
-        json wide_object = json({{"k1", "v"}, {"k2", 2}, {"k3", ""}, {"k4", json::object()}, {"k5", nullptr}});
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            wide_array = json::array({"s", wide_array, "t", wide_object, true});
-            wide_object = json({{"a", wide_object}, {"b", "x"}, {"c", "y"}, {"d", wide_array.size()}, {"e", "z"}});
-        }
-
-        CHECK(json::from_bon8(json::to_bon8(wide_array)) == wide_array);
-        CHECK(json::from_bon8(json::to_bon8(wide_object)) == wide_object);
-    }
-
-    SECTION("regression test for https://issues.oss-fuzz.com/issues/566583014")
-    {
-        // 200000 nested one-element CBOR arrays, the innermost holding null;
-        // round-tripping this used to recurse once per level on the way back
-        // out through to_cbor(), deep enough to overflow the stack
-        std::vector<std::uint8_t> v(200000, 0x81);
-        v.push_back(0xf6);
-        const json j = json::from_cbor(v);
-        CHECK(json::to_cbor(j) == v);
-
-        // the MessagePack analogue: fixarray of 1 nesting down to nil
-        std::vector<std::uint8_t> v_msgpack(200000, 0x91);
-        v_msgpack.push_back(0xc0);
-        const json j_msgpack = json::from_msgpack(v_msgpack);
-        CHECK(json::to_msgpack(j_msgpack) == v_msgpack);
-    }
-
-    SECTION("regression test for https://issues.oss-fuzz.com/issues/572238015")
-    {
-        // the BON8 analogue: 200000 nested one-element arrays down to null
-        std::vector<std::uint8_t> v(200000, 0x81);
-        v.push_back(0xFA);
-        const json j = json::from_bon8(v);
-        CHECK(json::to_bon8(j) == v);
-    }
-}
-

tests/src/unit-large_json_conversions.cpp

@@ -1,156 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstddef>
-#include <string>
-#include <utility>
-#include <vector>
-
-// split from unit-large_json.cpp so that both run in parallel and stay below
-// the ctest timeout under Valgrind
-
-namespace
-{
-
-// The text of a value nested depth levels deep around the number 0. Level i is
-// an array if pattern[i % pattern.size()] is '[', and otherwise an object with
-// the single member "a", which every object type enumerates in the same order.
-std::string nested_text(std::size_t depth, const std::string& pattern)
-{
-    std::string text;
-    std::string closing;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        const bool array = pattern[i % pattern.size()] == '[';
-        text += array ? "[" : "{\"a\":";
-        closing += array ? ']' : '}';
-    }
-    text += '0';
-    text.append(closing.rbegin(), closing.rend());
-    return text;
-}
-
-} // namespace
-
-TEST_CASE("issue #5650 - stack overflow converting between specializations")
-{
-    // deep enough to exhaust the call stack, but small enough to stay cheap:
-    // parsing is iterative, so building the values below costs little
-    const std::size_t depth = 100000;
-
-    const std::vector<std::string> patterns = {"[", "{", "[{"};
-
-    SECTION("json to ordered_json")
-    {
-        for (const auto& pattern : patterns)
-        {
-            CAPTURE(pattern)
-            const std::string text = nested_text(depth, pattern);
-            const json j = json::parse(text);
-
-            const nlohmann::ordered_json converted = j;
-            CHECK(converted.dump() == text);
-        }
-    }
-
-    SECTION("ordered_json to json")
-    {
-        for (const auto& pattern : patterns)
-        {
-            CAPTURE(pattern)
-            const std::string text = nested_text(depth, pattern);
-            const nlohmann::ordered_json o = nlohmann::ordered_json::parse(text);
-
-            const json converted = o;
-            CHECK(converted.dump() == text);
-        }
-    }
-
-    SECTION("get<ordered_json>()")
-    {
-        for (const auto& pattern : patterns)
-        {
-            CAPTURE(pattern)
-            const std::string text = nested_text(depth, pattern);
-            const json j = json::parse(text);
-
-            CHECK(j.get<nlohmann::ordered_json>().dump() == text);
-        }
-    }
-
-    SECTION("depths around the bound of the recursive descent")
-    {
-        for (std::size_t d = 1; d <= 300; ++d)
-        {
-            CAPTURE(d)
-            for (const auto& pattern : patterns)
-            {
-                CAPTURE(pattern)
-                const std::string text = nested_text(d, pattern);
-                const json j = json::parse(text);
-
-                const nlohmann::ordered_json converted = j;
-                CHECK(converted.dump() == text);
-                const json back = converted;
-                CHECK(back.dump() == text);
-            }
-        }
-    }
-
-    SECTION("values below the bound are converted as values above it")
-    {
-        // Bury a value below the bound, where it is converted without the
-        // call stack, and compare it with the same value converted on its
-        // own by the containers' range constructors. Its objects have
-        // members that the two object types enumerate in different orders.
-        const auto bury = [](nlohmann::ordered_json value)
-        {
-            for (std::size_t i = 0; i < 200; ++i)
-            {
-                value = nlohmann::ordered_json::array({std::move(value)});
-            }
-            return value;
-        };
-        const auto dig = [](const json & value)
-        {
-            const json* current = &value;
-            for (std::size_t i = 0; i < 200; ++i)
-            {
-                current = &current->at(0);
-            }
-            return current;
-        };
-
-        nlohmann::ordered_json value = nlohmann::ordered_json::object();
-        value["z"] = {1, -2, 3U, 4.5, true, nullptr, "six", nlohmann::ordered_json::binary({7, 8}, 9),
-                      nlohmann::ordered_json::binary({10}), nlohmann::ordered_json::array(), nlohmann::ordered_json::object()
-                     };
-        value["y"] = {{"x", {{"w", 1}, {"v", 2}}}, {"u", {3, {{"t", 4}, {"s", 5}}}}};
-        value["r"] = nlohmann::ordered_json::array({nlohmann::ordered_json(nlohmann::ordered_json::value_t::discarded)});
-
-        const json converted_above = value;
-        const json buried = bury(value);
-        const json& converted_below = *dig(buried);
-
-        CHECK(converted_below.dump() == converted_above.dump());
-        CHECK(converted_below.at("z").at(7).get_binary().subtype() == 9);
-        CHECK_FALSE(converted_below.at("z").at(8).get_binary().has_subtype());
-        CHECK(converted_below.at("r").at(0).is_discarded());
-
-        // a discarded value is never equal to anything, so compare the rest
-        value.erase("r");
-        const json without_discarded_above = value;
-        const json without_discarded_buried = bury(value);
-        CHECK(*dig(without_discarded_buried) == without_discarded_above);
-    }
-}