Fix swap(array_t&)/swap(object_t&) to update parent pointers under JSON_DIAGNOSTICS

Both overloads swapped the underlying container storage but never called set_parents(), leaving elements moved into *this with stale m_parent pointers (typically nullptr from the free-standing array_t/object_t). This produced wrong JSON Pointer paths in diagnostic messages and could trip assert_invariant() on subsequent copies. Mirrors the fix already applied in swap(reference other). Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-09-06 16:27:59 +00:00 · 2026-09-05 22:01:39 +02:00
5 changed files with 35 additions and 502 deletions
@@ -3573,6 +3573,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        {
            using std::swap;
            swap(*(m_data.m_value.array), other);
            set_parents();
        }
        else
        {
@@ -3589,6 +3590,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        {
            using std::swap;
            swap(*(m_data.m_value.object), other);
            set_parents();
        }
        else
        {
@@ -25001,6 +25001,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        {
            using std::swap;
            swap(*(m_data.m_value.array), other);
            set_parents();
        }
        else
        {
@@ -25017,6 +25018,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        {
            using std::swap;
            swap(*(m_data.m_value.object), other);
            set_parents();
        }
        else
        {
@@ -273,5 +273,36 @@ TEST_CASE("Regression tests for extended diagnostics")
        CHECK(j1["numbers"]["two"] == 2);
        CHECK(j1["string"] == "t");
    }
    SECTION("Regression test - swap(array_t&)/swap(object_t&) must update JSON_DIAGNOSTICS parent pointers")
    {
        // swap(array_t&)
        {
            json j = json::array();
            json::array_t arr = {json::array({1})};
            j.swap(arr);
            // parent pointers of the moved-in elements must point into j, not
            // into the now-defunct free-standing array_t
            CHECK_THROWS_WITH_AS(j[0][0].get<std::string>(), "[json.exception.type_error.302] (/0/0) type must be string, but is number", json::type_error);
            // must not trigger assert_invariant() in a debug/assert-enabled build
            json const k = j;
            CHECK(k == j);
        }
        // swap(object_t&)
        {
            json o = json::object();
            json::object_t obj = {{"a", json::array({1})}};
            o.swap(obj);
            CHECK_THROWS_WITH_AS(o["a"][0].get<std::string>(), "[json.exception.type_error.302] (/a/0) type must be string, but is number", json::type_error);
            // must not trigger assert_invariant() in a debug/assert-enabled build
            json const p = o;
            CHECK(p == o);
        }
    }
 }
@@ -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(std::string str): str_impl(std::move(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));
 }
@@ -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