Make serializer's indent_string lazily allocated

The serializer constructor unconditionally allocated a 512-byte indent_string, even though it is only ever read inside the pretty_print branches of dump(). This wasted a heap allocation (and its matching deallocation) on every compact (i.e. default, non-pretty) dump() call. indent_string is now default-constructed empty and lazily grown to 512 bytes, filled with indent_char, the first time a pretty-print branch actually needs it. The existing doubling/growth logic for larger indents is otherwise untouched, so output remains byte-identical to before -- including in the pre-existing edge case where growth beyond the initial buffer fills with ' ' instead of indent_char (tracked separately by open PR #5186, which is left alone here). The second, larger optimization mentioned in #5413 (removing the shared_ptr-based output adapter) is intentionally out of scope, as it overlaps open PR #5285. Fixes #5413 Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-09-06 08:17:59 +00:00 · 2026-09-05 20:59:58 +02:00
5 changed files with 135 additions and 506 deletions
@@ -71,7 +71,7 @@ class serializer
        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
        , indent_char(ichar)
-        , indent_string(512, indent_char)
+        , indent_string()
        , error_handler(error_handler_)
    {}
@@ -126,6 +126,10 @@ class serializer
                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
                    {
                        indent_string.resize(512, indent_char);
                    }
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
@@ -199,6 +203,10 @@ class serializer
                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
                    {
                        indent_string.resize(512, indent_char);
                    }
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
@@ -260,6 +268,10 @@ class serializer
                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
                    {
                        indent_string.resize(512, indent_char);
                    }
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
@@ -1010,7 +1022,7 @@ class serializer
    /// the indentation character
    const char indent_char;
-    /// the indentation string
+    /// the indentation string (lazily allocated on first use by a pretty-print branch)
    string_t indent_string;
    /// error_handler how to react on decoding errors
@@ -20150,7 +20150,7 @@ class serializer
        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
        , indent_char(ichar)
-        , indent_string(512, indent_char)
+        , indent_string()
        , error_handler(error_handler_)
    {}
@@ -20205,6 +20205,10 @@ class serializer
                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
                    {
                        indent_string.resize(512, indent_char);
                    }
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
@@ -20278,6 +20282,10 @@ class serializer
                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
                    {
                        indent_string.resize(512, indent_char);
                    }
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
@@ -20339,6 +20347,10 @@ class serializer
                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
                    {
                        indent_string.resize(512, indent_char);
                    }
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
@@ -21089,7 +21101,7 @@ class serializer
    /// the indentation character
    const char indent_char;
-    /// the indentation string
+    /// the indentation string (lazily allocated on first use by a pretty-print branch)
    string_t indent_string;
    /// error_handler how to react on decoding errors
@@ -1,489 +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-FileCopyrightText: 2018 Vitaliy Manushkin <agri@akamo.info>
 // SPDX-License-Identifier: MIT
 // This file closes a test-coverage gap described in GitHub issue #5421:
 // nlohmann::ordered_json (and other non-default basic_json specializations,
 // such as the alt_string-based one from unit-alt-string.cpp) were never
 // exercised through the binary formats (CBOR/MessagePack/UBJSON/BSON/BJData)
 // or through flatten()/unflatten()/diff()/patch()/merge_patch().
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 #include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>
 using nlohmann::json;
 using nlohmann::ordered_json;
 /////////////////////////////////////////////////////////////////////////////
 // alt_json: a second, independent copy of the custom-string_t basic_json
 // specialization defined in unit-alt-string.cpp.
 //
 // It is duplicated here (rather than shared via a header) because every
 // unit-*.cpp file in this test suite is compiled into its own standalone
 // executable (see tests/CMakeLists.txt), so there is no ODR concern in
 // having the same class name defined in multiple translation units.
 //
 // Two members had to be added relative to the original alt_string
 // (a constructor from std::string, and a find(char, pos) overload) because
 // the original type was never used with the binary writers/readers before
 // this file: BSON's array/document writer converts std::to_string() results
 // and checks for embedded NUL characters via find(char), and the UBJSON/BSON
 // high-precision-number path constructs the SAX string_t argument from a
 // std::string. Neither path is exercised anywhere else in the test suite for
 // this type, which is presumably why the gap was never noticed.
 /////////////////////////////////////////////////////////////////////////////
 class alt_string;
 bool operator<(const char* op1, const alt_string& op2) noexcept; // NOLINT(misc-use-internal-linkage)
 void int_to_string(alt_string& target, std::size_t value); // NOLINT(misc-use-internal-linkage)
 class alt_string
 {
  public:
    using value_type = std::string::value_type;
    static constexpr auto npos = (std::numeric_limits<std::size_t>::max)();
    alt_string(const char* str): str_impl(str) {}
    alt_string(const char* str, std::size_t count): str_impl(str, count) {}
    alt_string(const std::string& str): str_impl(str) {}
    alt_string(size_t count, char chr): str_impl(count, chr) {}
    alt_string() = default;
    alt_string& append(char ch)
    {
        str_impl.push_back(ch);
        return *this;
    }
    alt_string& append(const alt_string& str)
    {
        str_impl.append(str.str_impl);
        return *this;
    }
    alt_string& append(const char* s, std::size_t length)
    {
        str_impl.append(s, length);
        return *this;
    }
    void push_back(char c)
    {
        str_impl.push_back(c);
    }
    template <typename op_type>
    bool operator==(const op_type& op) const
    {
        return str_impl == op;
    }
    bool operator==(const alt_string& op) const
    {
        return str_impl == op.str_impl;
    }
    template <typename op_type>
    bool operator!=(const op_type& op) const
    {
        return str_impl != op;
    }
    bool operator!=(const alt_string& op) const
    {
        return str_impl != op.str_impl;
    }
    std::size_t size() const noexcept
    {
        return str_impl.size();
    }
    void resize(std::size_t n)
    {
        str_impl.resize(n);
    }
    void resize(std::size_t n, char c)
    {
        str_impl.resize(n, c);
    }
    template <typename op_type>
    bool operator<(const op_type& op) const noexcept
    {
        return str_impl < op;
    }
    bool operator<(const alt_string& op) const noexcept
    {
        return str_impl < op.str_impl;
    }
    const char* c_str() const
    {
        return str_impl.c_str();
    }
    char& operator[](std::size_t index)
    {
        return str_impl[index];
    }
    const char& operator[](std::size_t index) const
    {
        return str_impl[index];
    }
    char& back()
    {
        return str_impl.back();
    }
    const char& back() const
    {
        return str_impl.back();
    }
    void clear()
    {
        str_impl.clear();
    }
    const value_type* data() const
    {
        return str_impl.data();
    }
    bool empty() const
    {
        return str_impl.empty();
    }
    std::size_t find(const alt_string& str, std::size_t pos = 0) const
    {
        return str_impl.find(str.str_impl, pos);
    }
    // needed by binary_writer's BSON support, which probes string keys for
    // embedded NUL characters via find(char)
    std::size_t find(char c, std::size_t pos = 0) const
    {
        return str_impl.find(c, pos);
    }
    std::size_t find_first_of(char c, std::size_t pos = 0) const
    {
        return str_impl.find_first_of(c, pos);
    }
    alt_string substr(std::size_t pos = 0, std::size_t count = npos) const
    {
        const std::string s = str_impl.substr(pos, count);
        return {s.data(), s.size()};
    }
    alt_string& replace(std::size_t pos, std::size_t count, const alt_string& str)
    {
        str_impl.replace(pos, count, str.str_impl);
        return *this;
    }
    void reserve(std::size_t new_cap = 0)
    {
        str_impl.reserve(new_cap);
    }
  private:
    std::string str_impl {}; // NOLINT(readability-redundant-member-init)
    friend bool operator<(const char* /*op1*/, const alt_string& /*op2*/) noexcept;
 };
 void int_to_string(alt_string& target, std::size_t value)
 {
    target = std::to_string(value).c_str();
 }
 using alt_json = nlohmann::basic_json <
                 std::map,
                 std::vector,
                 alt_string,
                 bool,
                 std::int64_t,
                 std::uint64_t,
                 double,
                 std::allocator,
                 nlohmann::adl_serializer >;
 bool operator<(const char* op1, const alt_string& op2) noexcept
 {
    return op1 < op2.str_impl;
 }
 namespace
 {
 // collects the object keys of j, in iteration order
 std::vector<std::string> collect_keys(const ordered_json& j)
 {
    std::vector<std::string> result;
    for (auto it = j.cbegin(); it != j.cend(); ++it)
    {
        result.push_back(it.key());
    }
    return result;
 }
 // a nested object/array value with keys inserted in non-alphabetical order,
 // used to check both round-trip equality and (for ordered_json) that
 // insertion order survives a trip through a binary format
 ordered_json make_rich_ordered_json()
 {
    ordered_json j;
    j["zebra"] = 1;
    j["apple"] = ordered_json::array({1, 2, 3});
    j["mango"]["z_nested"] = true;
    j["mango"]["a_nested"] = nullptr;
    j["banana"] = "some text";
    j["cherry"] = 3.14;
    return j;
 }
 alt_json make_rich_alt_json()
 {
    alt_json j;
    j["zebra"] = 1;
    j["apple"] = alt_json::array({1, 2, 3});
    j["mango"]["z_nested"] = true;
    j["mango"]["a_nested"] = nullptr;
    j["banana"] = "some text";
    j["cherry"] = 3.14;
    return j;
 }
 } // namespace
 TEST_CASE("ordered_json across binary formats")
 {
    const ordered_json original = make_rich_ordered_json();
    const std::vector<std::string> original_keys = collect_keys(original);
    const std::vector<std::string> original_mango_keys = collect_keys(original["mango"]);
    SECTION("CBOR")
    {
        const auto bytes = ordered_json::to_cbor(original);
        const auto restored = ordered_json::from_cbor(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
    SECTION("MessagePack")
    {
        const auto bytes = ordered_json::to_msgpack(original);
        const auto restored = ordered_json::from_msgpack(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
    SECTION("UBJSON")
    {
        const auto bytes = ordered_json::to_ubjson(original);
        const auto restored = ordered_json::from_ubjson(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
    SECTION("BSON")
    {
        const auto bytes = ordered_json::to_bson(original);
        const auto restored = ordered_json::from_bson(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
    SECTION("BJData")
    {
        const auto bytes = ordered_json::to_bjdata(original);
        const auto restored = ordered_json::from_bjdata(bytes);
        CHECK(restored == original);
        CHECK(collect_keys(restored) == original_keys);
        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
    }
 }
 TEST_CASE("alt_json (custom string_t) across binary formats")
 {
    const alt_json original = make_rich_alt_json();
    SECTION("CBOR")
    {
        const auto bytes = alt_json::to_cbor(original);
        const auto restored = alt_json::from_cbor(bytes);
        CHECK(restored == original);
    }
    SECTION("MessagePack")
    {
        const auto bytes = alt_json::to_msgpack(original);
        const auto restored = alt_json::from_msgpack(bytes);
        CHECK(restored == original);
    }
    SECTION("UBJSON")
    {
        const auto bytes = alt_json::to_ubjson(original);
        const auto restored = alt_json::from_ubjson(bytes);
        CHECK(restored == original);
    }
    SECTION("BSON")
    {
        const auto bytes = alt_json::to_bson(original);
        const auto restored = alt_json::from_bson(bytes);
        CHECK(restored == original);
    }
    SECTION("BJData")
    {
        const auto bytes = alt_json::to_bjdata(original);
        const auto restored = alt_json::from_bjdata(bytes);
        CHECK(restored == original);
    }
 }
 TEST_CASE("ordered_json operator== is sensitive to key order")
 {
    // Unlike nlohmann::json (whose object_t is a std::map, so equality never
    // depends on insertion order), ordered_json's object_t (ordered_map) is a
    // std::vector<std::pair<Key, T>> under the hood, and does not define its
    // own operator==: it inherits std::vector's element-wise comparison. As a
    // result, two ordered_json objects holding the very same key/value pairs
    // in different insertion order compare *unequal*. This is the property
    // that makes the round-trip `CHECK(restored == original)` checks above a
    // meaningful order-preservation check by themselves (the explicit
    // collect_keys() comparisons make that check explicit/readable, and
    // guard against this operator== behavior ever changing).
    ordered_json a;
    a["x"] = 1;
    a["y"] = 2;
    ordered_json b;
    b["y"] = 2;
    b["x"] = 1;
    CHECK(a.size() == b.size());
    CHECK(a["x"] == b["x"]);
    CHECK(a["y"] == b["y"]);
    CHECK_FALSE(a == b);
 }
 TEST_CASE("duplicate keys in a binary-encoded object")
 {
    // CBOR encoding of a map with two entries under the same key "a": {"a": 1, "a": 2}
    const std::vector<std::uint8_t> cbor_bytes
    {
        0xA2, 0x61, 'a', 0x01, 0x61, 'a', 0x02
    };
    // Both json (std::map, via operator[]) and ordered_json (ordered_map, via
    // operator[]) build binary-decoded objects by looking up/creating the
    // entry for each incoming key and then assigning the value into it. This
    // means a repeated key does *not* produce two entries in either case;
    // instead, the *first* occurrence's position is kept (relevant only for
    // ordered_json) while the *last* occurrence's value wins (for both) --
    // this matches operator[]'s "assign the referenced slot" semantics, and
    // is worth noting because it differs from the initializer-list
    // construction path (`ordered_json{{"a",1},{"a",2}}`), which builds
    // through insert()/emplace() and therefore keeps the *first* value, not
    // the last (see the "There are no dup keys..." case in
    // unit-ordered_json.cpp).
    const auto j = json::from_cbor(cbor_bytes);
    const auto oj = ordered_json::from_cbor(cbor_bytes);
    CHECK(j.size() == 1);
    CHECK(oj.size() == 1);
    CHECK(j["a"] == 2);
    CHECK(oj["a"] == 2);
    CHECK(j == json(oj));
 }
 TEST_CASE("ordered_json through flatten/unflatten")
 {
    const ordered_json original = make_rich_ordered_json();
    const std::vector<std::string> original_keys = collect_keys(original);
    const std::vector<std::string> original_mango_keys = collect_keys(original["mango"]);
    const ordered_json flat = original.flatten();
    const ordered_json unflattened = flat.unflatten();
    CHECK(unflattened == original);
    // flatten() walks the value depth-first in iteration order and
    // unflatten() re-inserts each flattened key via operator[] in the flat
    // object's iteration order, so for ordered_json the original key order
    // (both top-level and nested) is preserved end-to-end.
    CHECK(collect_keys(unflattened) == original_keys);
    CHECK(collect_keys(unflattened["mango"]) == original_mango_keys);
 }
 TEST_CASE("ordered_json through diff/patch/patch_inplace")
 {
    ordered_json original;
    original["one"] = 1;
    original["two"] = 2;
    original["three"] = 3;
    ordered_json target = original;
    target["one"] = 100;      // replace
    target.erase("two");      // remove
    target["four"] = 4;       // add
    const ordered_json patch = ordered_json::diff(original, target);
    SECTION("patch")
    {
        const ordered_json patched = original.patch(patch);
        CHECK(patched == target);
    }
    SECTION("patch_inplace")
    {
        ordered_json copy = original;
        copy.patch_inplace(patch);
        CHECK(copy == target);
    }
 }
 TEST_CASE("ordered_json through merge_patch")
 {
    ordered_json original;
    original["a"] = 1;
    original["b"] = 2;
    const ordered_json patch = {{"b", nullptr}, {"c", 3}};
    original.merge_patch(patch);
    ordered_json expected;
    expected["a"] = 1;
    expected["c"] = 3;
    CHECK(original == expected);
    CHECK(collect_keys(original) == collect_keys(expected));
 }
@@ -14,6 +14,40 @@ using nlohmann::json;
 #include <array>
 #include <sstream>
 #include <iomanip>
 #include <cstdlib>
 #include <new>
 namespace
 {
 // heap allocation counter used by the regression test for issue #5413
 // (https://github.com/nlohmann/json/issues/5413); disabled (and thus a
 // no-op besides the counting) unless explicitly toggled on
 bool count_heap_allocations = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 std::size_t heap_allocations = 0; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 } // namespace
 void* operator new (std::size_t size) // NOLINT(cppcoreguidelines-owning-memory,misc-new-delete-overloads)
 {
    if (count_heap_allocations)
    {
        ++heap_allocations;
    }
    if (void* ptr = std::malloc(size)) // NOLINT(cppcoreguidelines-no-malloc,cppcoreguidelines-owning-memory)
    {
        return ptr;
    }
    throw std::bad_alloc(); // NOLINT(hicpp-exception-baseclass)
 }
 void operator delete (void* ptr) noexcept // NOLINT(cppcoreguidelines-owning-memory,misc-new-delete-overloads)
 {
    std::free(ptr); // NOLINT(cppcoreguidelines-no-malloc,cppcoreguidelines-owning-memory)
 }
 void operator delete (void* ptr, std::size_t /*size*/) noexcept // NOLINT(cppcoreguidelines-owning-memory,misc-new-delete-overloads)
 {
    std::free(ptr); // NOLINT(cppcoreguidelines-no-malloc,cppcoreguidelines-owning-memory)
 }
 TEST_CASE("serialization")
 {
@@ -382,3 +416,76 @@ TEST_CASE("dump for basic_json with long double number_float_t")
        check_same(100.0L,  100.0);
    }
 }
 TEST_CASE("regression test for issue #5413 - lazily allocated indent_string")
 {
    // the serializer used to unconditionally allocate a 512-byte
    // indent_string in its constructor, even though it is only ever read
    // inside the pretty_print branches of dump(). This wasted a heap
    // allocation (and its matching deallocation) on every single compact
    // (i.e. non-pretty, the default) dump() call. indent_string is now
    // allocated lazily, the first time a pretty-print branch actually
    // needs it -- so a compact dump() must perform strictly fewer heap
    // allocations than a pretty dump() of the same value.
    const json j = {{"level", "info"}, {"msg", "hello world"}, {"id", 12345}};
    // warm up anything unrelated to indentation (e.g., one-time locale
    // lookups) that might otherwise allocate on first use regardless of
    // pretty-printing, so it does not skew the counts measured below
    const auto warmup = j.dump();
    const auto warmup_pretty = j.dump(4);
    CHECK(!warmup.empty());
    CHECK(!warmup_pretty.empty());
    SECTION("compact dump() has a stable, minimal allocation count")
    {
        count_heap_allocations = true;
        heap_allocations = 0;
        const auto compact1 = j.dump();
        const auto allocs_compact1 = heap_allocations;
        heap_allocations = 0;
        const auto compact2 = j.dump(-1);
        const auto allocs_compact2 = heap_allocations;
        count_heap_allocations = false;
        CHECK(compact1 == compact2);
        // dump() and dump(-1) both take the compact code path and must
        // never touch indent_string, so they allocate identically often
        CHECK(allocs_compact1 == allocs_compact2);
    }
    SECTION("first pretty dump() allocates more than a compact dump()")
    {
        // use a tiny value whose compact ({"a":1}, 7 bytes) and pretty
        // ({"a": 1} with 1-space indent, 11 bytes) serializations both stay
        // well inside every common std::string small-string-optimization
        // buffer (>= 15 bytes on libstdc++/MSVC STL, >= 22 on libc++), so
        // building the result string itself causes no heap allocation
        // either way -- isolating indent_string as the only thing that can
        // possibly account for a difference in allocation count
        const json tiny = {{"a", 1}};
        count_heap_allocations = true;
        heap_allocations = 0;
        const auto compact = tiny.dump();
        const auto allocs_compact = heap_allocations;
        heap_allocations = 0;
        const auto pretty = tiny.dump(1);
        const auto allocs_pretty = heap_allocations;
        count_heap_allocations = false;
        CHECK(compact == "{\"a\":1}");
        CHECK(pretty == "{\n \"a\": 1\n}");
        // a fresh serializer is created per dump() call; the pretty branch
        // lazily allocates indent_string on its first use, so it must
        // allocate at least once more than the compact branch, which never
        // touches indent_string at all
        CHECK(allocs_pretty > allocs_compact);
    }
 }
@@ -17,7 +17,6 @@
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 using ordered_json = nlohmann::ordered_json;
 // JSON_HAS_CPP_20 (do not remove; see note at top of file)
 #if JSON_HAS_STD_FORMAT
@@ -94,16 +93,4 @@ TEST_CASE("std::formatter<nlohmann::json>")
    }
 }
 TEST_CASE("std::formatter<nlohmann::ordered_json>")
 {
    // spot-check a non-default basic_json instantiation, since the formatter
    // is written against the generic NLOHMANN_BASIC_JSON_TPL_DECLARATION
    // template and must actually instantiate (and behave correctly) for
    // template arguments other than nlohmann::json
    const ordered_json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
    CHECK(std::format("{}", j) == j.dump());
    CHECK(std::format("{:#}", j) == j.dump(4));
    CHECK(std::format("{:2}", j) == j.dump(2));
 }
 #endif