Merge develop; fix clang-tidy findings in json_view

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

docs/mkdocs/docs/api/basic_json_document/shrink_to_fit.md

@@ -23,6 +23,10 @@ Linear in [`node_count()`](node_count.md) plus the length of the decoded strings
 
 ## Notes
 
+The node index of a small document (an estimate of up to 1024 nodes, which is up to about 4 KiB of minified text) is
+allocated together with the document's header, so that parsing needs one allocation. That part cannot be released
+separately: `shrink_to_fit()` only trims a node index that has its own allocation, and the decoded strings.
+
 !!! warning "Invalidates views"
 
     Unlike moving the document, `shrink_to_fit()` **invalidates every view taken from this document before the

include/nlohmann/detail/view/builder.hpp

@@ -543,7 +543,15 @@ run_found:
     NLOHMANN_VIEW_NOINLINE void arena_grow(std::size_t n)
     {
         const std::size_t used = arena_used();
-        m_doc.arena.resize((std::max)(m_doc.arena.size() * 2, used + n + 256));
+        std::size_t wanted = used + n + 256;
+        if (m_doc.arena.empty())
+        {
+            // the first growth: a decoded string is never longer than its source,
+            // so a fraction of the input (capped, as the buffer is zero-filled)
+            // covers the escapes of a typical document without regrowing it
+            wanted = (std::max)(wanted, (std::min)((static_cast<std::size_t>(m_end - m_begin) / 4) + 16, std::size_t{4096}));
+        }
+        m_doc.arena.resize((std::max)(m_doc.arena.size() * 2, wanted));
         m_arena_write = m_doc.arena.data() + used;
         m_arena_end = m_doc.arena.data() + m_doc.arena.size();
     }

include/nlohmann/detail/view/document_data.hpp

@@ -82,14 +82,17 @@ struct document_data
     };
     std::unique_ptr<edit_state> edits; ///< created by the first edit
 
+    /// the most nodes that are allocated together with the header (16 KiB)
+    static constexpr std::size_t max_inline_nodes = 1024;
+
     /// One allocation for the header and room for `count` nodes, so that a
     /// small document needs one allocation instead of two. Large documents get
     /// a separate node array instead (so it can be trimmed). When a document
-    /// outgrows the inline array, that array stays unused: at most 256 nodes
+    /// outgrows the inline array, that array stays unused: at most 1024 nodes
-    /// (4 KiB), and only for documents whose estimate was too small.
+    /// (16 KiB), and only for documents whose estimate was too small.
     static document_data* create(std::size_t count)
     {
-        count = count <= 256 ? count : 0;
+        count = count <= max_inline_nodes ? count : 0;
         void* mem = ::operator new (sizeof(document_data) + (count * sizeof(node)));
         auto* d = new (mem) document_data(); // NOLINT(cppcoreguidelines-owning-memory): owned by the returned pointer, freed by deleter
         // (aligned: sizeof is a multiple of the alignment; through void*, as GCC's -Wcast-align wants)

include/nlohmann/detail/view/image.hpp

@@ -255,81 +255,6 @@ struct number_token
     bool is_float; ///< a fraction or an exponent
 };
 
-/// advance over ASCII digits, eight bytes at a time
-inline const unsigned char* digit_run(const unsigned char* p, const unsigned char* e) noexcept
-{
-    constexpr std::uint64_t ones = 0x0101010101010101ull;
-    while (e - p >= 8)
-    {
-        // (the digits become 0..9; a byte above 9, or with bit 7 set, is no digit. A carry
-        // out of a byte with bit 7 set only affects the bytes above, after the first one
-        // that count_trailing_zeros finds.)
-        const std::uint64_t x = read_eight_bytes(p) ^ (ones * 0x30u);
-        const std::uint64_t not_digit = ((x + (ones * 0x76u)) | x) & (ones * 0x80u);
-        if (not_digit != 0)
-        {
-            return p + (static_cast<std::size_t>(count_trailing_zeros(not_digit)) / 8);
-        }
-        p += 8;
-    }
-    while (p != e && is_digit(*p))
-    {
-        ++p;
-    }
-    return p;
-}
-
-/// whether the n bytes at p are ASCII digits (n > 0)
-inline bool all_digits(const unsigned char* p, std::size_t n) noexcept
-{
-    const auto digits = [](const unsigned char* q)
-    {
-        constexpr std::uint64_t ones = 0x0101010101010101ull;
-        const std::uint64_t x = read_eight_bytes(q) ^ (ones * 0x30u);
-        return (((x + (ones * 0x76u)) | x) & (ones * 0x80u)) == 0;
-    };
-    if (n >= 8)
-    {
-        for (std::size_t i = 0; i + 8 < n; i += 8)
-        {
-            if (!digits(p + i))
-            {
-                return false;
-            }
-        }
-        return digits(p + n - 8); // (overlapping the bytes before: they are digits)
-    }
-    for (std::size_t i = 0; i < n; ++i)
-    {
-        if (!is_digit(p[i]))
-        {
-            return false;
-        }
-    }
-    return true;
-}
-
-/// Whether a float token has the shape that the parser records for most of
-/// them: [-]digits.digits, with the numbers of digits of the node's layout
-/// (extra). Then the token is a number of that layout, and the general scan
-/// that follows is not needed.
-inline bool plain_float_token(const unsigned char* s, std::size_t len, std::uint16_t extra) noexcept
-{
-    const std::size_t int_digits = extra & 0xFFu;
-    const std::size_t frac_digits = extra >> 8u;
-    if (int_digits == 0 || int_digits >= 255 || frac_digits == 0 || frac_digits >= 255 || len == 0)
-    {
-        return false;
-    }
-    const std::size_t negative = *s == '-' ? 1 : 0;
-    if (len != negative + int_digits + 1 + frac_digits)
-    {
-        return false;
-    }
-    const unsigned char* const p = s + negative;
-    return !(int_digits > 1 && *p == '0') && p[int_digits] == '.' && all_digits(p, int_digits) && all_digits(p + int_digits + 1, frac_digits);
-}
-
 /// whether [s, s + len) is a JSON number (the grammar the parser accepts)
 inline bool scan_number_token(const unsigned char* s, std::size_t len, number_token& t)
 {
@@ -348,7 +273,11 @@ inline bool scan_number_token(const unsigned char* s, std::size_t len, number_to
     }
     else if (*p >= '1' && *p <= '9')
     {
-        p = digit_run(p + 1, e);
+        do
+        {
+            ++p;
+        }
+        while (p != e && is_digit(*p));
     }
     else
     {
@@ -360,7 +289,10 @@ inline bool scan_number_token(const unsigned char* s, std::size_t len, number_to
     if (p != e && *p == '.')
     {
         const unsigned char* const f0 = ++p;
-        p = digit_run(p, e);
+        while (p != e && is_digit(*p))
+        {
+            ++p;
+        }
         if (p == f0)
         {
             return false;
@@ -471,15 +403,10 @@ struct float_range
 template<typename Check>
 bool check_distinct_ranges(std::vector<byte_range>& ranges, Check check)
 {
-    // (save() writes the ranges in the order of the nodes, which is sorted already)
+    std::sort(ranges.begin(), ranges.end(), [](const byte_range & a, const byte_range & b)
-    const auto before = [](const byte_range & a, const byte_range & b)
     {
         return a.off != b.off ? a.off < b.off : a.len < b.len;
-    };
+    });
-    if (!std::is_sorted(ranges.begin(), ranges.end(), before))
-    {
-        std::sort(ranges.begin(), ranges.end(), before);
-    }
     std::size_t end = 0;
     for (std::size_t i = 0; i < ranges.size(); ++i)
     {
@@ -501,8 +428,7 @@ bool check_distinct_ranges(std::vector<byte_range>& ranges, Check check)
 /// record layouts that match it), tokens must not overlap.
 inline bool check_float_ranges(std::vector<float_range>& ranges, const unsigned char* text)
 {
-    // (save() writes the tokens in the order of the nodes, which is sorted already)
+    std::sort(ranges.begin(), ranges.end(), [](const float_range & a, const float_range & b)
-    const auto before = [](const float_range & a, const float_range & b)
     {
         if (a.off != b.off)
         {
@@ -513,11 +439,7 @@ inline bool check_float_ranges(std::vector<float_range>& ranges, const unsigned
             return a.len < b.len;
         }
         return a.extra < b.extra;
-    };
+    });
-    if (!std::is_sorted(ranges.begin(), ranges.end(), before))
-    {
-        std::sort(ranges.begin(), ranges.end(), before);
-    }
     std::size_t end = 0;
     std::size_t i = 0;
     while (i < ranges.size())
@@ -527,18 +449,14 @@ inline bool check_float_ranges(std::vector<float_range>& ranges, const unsigned
         {
             return false;
         }
-        const unsigned char* const s = text + r.off;
-        std::uint16_t layout = r.extra;
-        if (!plain_float_token(s, r.len, r.extra))
-        {
         number_token t{};
+        const unsigned char* const s = text + r.off;
         if (!scan_number_token(s, r.len, t) || !float_token_finite(s, r.len, t))
         {
             return false;
         }
         // the digit layout the parser records (or "many", as compaction writes it)
-            layout = float_layout(t);
+        const std::uint16_t layout = float_layout(t);
-        }
         for (; i < ranges.size() && ranges[i].off == r.off && ranges[i].len == r.len; ++i)
         {
             if (ranges[i].extra != layout && ranges[i].extra != 0xFFFFu)

include/nlohmann/json_view.hpp

@@ -743,12 +743,8 @@ class basic_json_view
     template<typename, bool> friend class basic_json_document;
     template<typename, bool> friend class basic_json_view;
     template<typename, typename> friend class detail::view::editor;
-    template<typename, typename> friend class detail::view::view_side;
     friend iterator;
 
-    /// whether the view is one of an editable document
-    static constexpr bool is_editable = Editable;
-
     basic_json_view(const document_data* d, const node* n) noexcept
         : m_doc(d), m_node(n)
     {}

tests/src/unit-json_view.cpp

@@ -666,6 +666,61 @@ TEST_CASE("json_view")
         CHECK(small.root().materialize() == json::parse("[1,[2,3],{\"a\":\"b\\n\"}]"));
     }
 
+    SECTION("block sizes")
+    {
+        // documents whose node estimate lies around the size that is allocated
+        // with the header, and whose decoded strings need the first growth of
+        // the buffer, in all sizes around the points where the policies change
+        for (const int count :
+                {
+                    1, 2, 10, 50, 100, 255, 256, 257, 500, 1000, 1023, 1024, 1025, 2000, 5000
+                })
+        {
+            // strings with escapes (decoded text, minified)
+            std::string escaped = "[";
+            for (int i = 0; i < count; ++i)
+            {
+                escaped += (i != 0 ? ",\"a\\n" : "\"a\\n") + std::to_string(i) + "\\u00e4\"";
+            }
+            escaped += ']';
+            json_document e = json_document::parse(escaped);
+            CHECK(e.root().materialize() == json::parse(escaped));
+            e.shrink_to_fit();
+            CHECK(e.root().materialize() == json::parse(escaped));
+
+            // dense numbers (more nodes per byte than the estimate expects)
+            std::string dense = "[";
+            for (int i = 0; i < count; ++i)
+            {
+                dense += (i != 0 ? ",1" : "1");
+            }
+            dense += ']';
+            json_document n = json_document::parse(dense);
+            CHECK(n.node_count() == static_cast<std::size_t>(count) + 1);
+            CHECK(n.root().materialize() == json::parse(dense));
+            n.shrink_to_fit();
+            CHECK(n.root().size() == static_cast<std::size_t>(count));
+
+            // the same documents, pretty-printed
+            const std::string pretty = json::parse(escaped).dump(2);
+            json_document p = json_document::parse(pretty);
+            CHECK(p.root().materialize() == json::parse(escaped));
+        }
+
+        // a large document with a single escape does not need a buffer of the
+        // size of its input
+        std::string large = R"(["a\n")";
+        for (int i = 0; i < 100000; ++i)
+        {
+            large += ",1";
+        }
+        large += ']';
+        const json_document l = json_document::parse(large);
+        CHECK(l.root().size() == 100001);
+        CHECK(l.root()[0].get_string() == "a\n");
+        CHECK(l.root()[100000].get<int>() == 1);
+    }
+
     SECTION("source offsets")
     {
         const std::string text = R"(  {"key": "value", "escaped": "a\nb", "n": 42})";

tests/src/unit-json_view_compare.cpp

@@ -1,364 +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_view.hpp>
-using nlohmann::json;
-using nlohmann::ordered_json;
-using nlohmann::json_document;
-using nlohmann::ordered_json_editable_document;
-using nlohmann::json_view;
-using nlohmann::ordered_json_document;
-
-#include "json_view_test_helpers.hpp"
-using json_view_test::generator;
-
-#include <array>
-#include <cstddef>
-#include <string>
-#include <vector>
-
-// These tests were split off unit-json_view_dump.cpp, whose object file got too
-// large for the MinGW assembler ("file too big"). Like that file, this one is
-// also built with C++17, as it mentions JSON_HAS_CPP_17.
-
-TEST_CASE("json_view comparison")
-{
-    SECTION("equality of the values parse() produces")
-    {
-        generator g;
-        std::vector<std::string> texts;
-        for (int i = 0; i < 600; ++i)
-        {
-            std::string text;
-            g.value(text, 0);
-            texts.push_back(text);
-            // the same value written differently: sorted keys, canonical numbers
-            texts.push_back(json::parse(text).dump(1));
-        }
-        for (std::size_t i = 0; i + 2 < texts.size(); ++i)
-        {
-            for (std::size_t k = i; k < i + 3; ++k)
-            {
-                CAPTURE(texts[i])
-                CAPTURE(texts[k])
-                const json_document a = json_document::parse(texts[i]);
-                const json_document b = json_document::parse(texts[k]);
-                const json ja = json::parse(texts[i]);
-                const json jb = json::parse(texts[k]);
-                CHECK((a.root() == b.root()) == (ja == jb));
-                CHECK((a.root() != b.root()) == (ja != jb));
-                CHECK((a.root() == jb) == (ja == jb));
-                CHECK((jb == a.root()) == (ja == jb));
-                CHECK((a.root() != jb) == (ja != jb));
-                CHECK((jb != a.root()) == (ja != jb));
-
-                // ordered_json compares members in order
-                const ordered_json_document oa = ordered_json_document::parse(texts[i]);
-                const ordered_json_document ob = ordered_json_document::parse(texts[k]);
-                const ordered_json oja = ordered_json::parse(texts[i]);
-                const ordered_json ojb = ordered_json::parse(texts[k]);
-                CHECK((oa.root() == ob.root()) == (oja == ojb));
-                CHECK((oa.root() == ojb) == (oja == ojb));
-            }
-        }
-    }
-
-    SECTION("objects whose first keys differ or repeat")
-    {
-        const std::array<const char*, 17> texts =
-        {
-            {
-                R"({"a":1,"b":2})", R"({"a":1,"c":2})", R"({"b":1,"a":2})", R"({"a":1,"a":2,"b":3})", R"({"a":2,"b":3})",
-                R"({"a":1,"b":1,"a":2})", R"({"a":2,"b":1})", R"({"a":1,"a":2})", R"({"b":1})", R"({"a":1,"b":2,"c":3,"d":4,"e":5})",
-                R"({"a":1,"b":2,"c":3,"d":4,"f":5})", R"({"a":1,"b":2,"c":3,"a":4,"e":5})", R"({"a":4,"b":2,"c":3,"e":5})",
-                R"({"\u0061":1,"b":2})", R"({})", R"([{"a":1,"b":2}])", R"([{"a":1,"c":2}])"
-            }
-        };
-        for (const char* const x : texts)
-        {
-            for (const char* const y : texts)
-            {
-                CAPTURE(x)
-                CAPTURE(y)
-                const ordered_json_document dx = ordered_json_document::parse(x);
-                const ordered_json_document dy = ordered_json_document::parse(y);
-                const ordered_json_editable_document ex = ordered_json_editable_document::parse(x);
-                const ordered_json jx = ordered_json::parse(x);
-                const ordered_json jy = ordered_json::parse(y);
-                CHECK((dx.root() == dy.root()) == (jx == jy));
-                CHECK((dx.root() == jy) == (jx == jy));
-                CHECK((ex.root() == dy.root()) == (jx == jy));
-            }
-        }
-    }
-
-    SECTION("objects with duplicate keys, small and large")
-    {
-        // n members with keys in descending order; with duplicates, some keys
-        // repeat later (the first after unique ones in key order); in reverse,
-        // the members are in ascending key order
-        const auto object = [](int n, bool duplicates, bool reverse, int value)
-        {
-            std::string s = "{";
-            for (int i = 0; i < n; ++i)
-            {
-                const int k = reverse ? i : n - 1 - i;
-                s += (i != 0 ? ",\"k" : "\"k") + std::to_string(100 + k) + "\":" + std::to_string(value + k);
-            }
-            if (duplicates)
-            {
-                for (int k = n / 2; k < n; k += 3)
-                {
-                    s += ",\"k" + std::to_string(100 + k) + "\":" + std::to_string(value + k);
-                }
-            }
-            return s + "}";
-        };
-        std::vector<std::string> texts;
-        for (const int n :
-                {
-                    3, 16, 17, 40
-                })
-        {
-            for (const int flags :
-                    {
-                        0, 1, 2, 3
-                    })
-            {
-                texts.push_back(object(n, (flags & 1) != 0, (flags & 2) != 0, 0));
-            }
-            texts.push_back(object(n, true, false, 1)); // other values
-        }
-        // many objects in one comparison (working memory reused across objects)
-        std::string array = "[";
-        std::string array_other = "[";
-        for (std::size_t i = 0; i < texts.size(); ++i)
-        {
-            array += (i != 0 ? "," : "") + texts[i];
-            array_other += (i != 0 ? "," : "") + texts[texts.size() - 1 - i];
-        }
-        texts.push_back(array + "]");
-        texts.push_back(array_other + "]");
-        for (const std::string& x : texts)
-        {
-            for (const std::string& y : texts)
-            {
-                CAPTURE(x)
-                CAPTURE(y)
-                const ordered_json_document dx = ordered_json_document::parse(x);
-                const ordered_json_document dy = ordered_json_document::parse(y);
-                const ordered_json jx = ordered_json::parse(x);
-                const ordered_json jy = ordered_json::parse(y);
-                CHECK((dx.root() == dy.root()) == (jx == jy));
-                CHECK((dx.root() == jy) == (jx == jy));
-                const json_document ux = json_document::parse(x);
-                const json uy = json::parse(y);
-                CHECK((ux.root() == uy) == (json::parse(x) == uy));
-            }
-        }
-    }
-
-    SECTION("numbers, duplicate keys, member order")
-    {
-        const auto same = [](const char* x, const char* y)
-        {
-            const json_document dx = json_document::parse(x);
-            const json_document dy = json_document::parse(y);
-            return dx.root() == dy.root();
-        };
-        CHECK(same("1", "1.0"));
-        CHECK(same("[1, -1, 2.5]", "[1.0, -1.0, 25e-1]"));
-        CHECK(!same("1", "1.5"));
-        CHECK(same("18446744073709551615", "18446744073709551615"));
-        CHECK(same(R"({"a": 1, "a": 2})", R"({"a": 2})"));
-        CHECK(!same(R"({"a": 1, "a": 2})", R"({"a": 1})"));
-        CHECK(same(R"({"a": 1, "b": 2})", R"({"b": 2, "a": 1})"));
-        CHECK(!same(R"({"a": 1})", R"({"a": 1, "b": 2})"));
-        CHECK(!same("[1, 2]", "[2, 1]"));
-        CHECK(!same("\"a\"", "\"b\""));
-        CHECK(same("\"\\u00e9\"", "\"\xc3\xa9\""));
-        CHECK(!same("null", "false"));
-        CHECK(!same("[]", "{}"));
-        const ordered_json_document dup = ordered_json_document::parse(R"({"a": 1, "b": 2, "a": 3})");
-        const ordered_json_document last = ordered_json_document::parse(R"({"a": 3, "b": 2})");
-        CHECK(dup.root() == last.root());
-        // (== compares as parse() resolves duplicates, a lookup finds the first)
-        CHECK(dup.root()["a"].materialize() == 1);
-        CHECK(dup.root()["a"] != last.root()["a"]);
-        const ordered_json_document ab = ordered_json_document::parse(R"({"a": 1, "b": 2})");
-        const ordered_json_document ba = ordered_json_document::parse(R"({"b": 2, "a": 1})");
-        CHECK(ab.root() != ba.root());
-
-        // discarded values compare as basic_json's do
-        const json discarded(json::value_t::discarded);
-        CHECK((json_view() == json_view()) == (discarded == discarded)); // NOLINT(readability-container-size-empty): operator== is tested
-        CHECK((json_view() == discarded) == (discarded == discarded)); // NOLINT(readability-container-size-empty)
-        const json_document null_document = json_document::parse("null");
-        CHECK(!(json_view() == null_document.root())); // NOLINT(readability-container-size-empty)
-        CHECK(!(null_document.root() == discarded));
-    }
-
-    SECTION("values that are the same text, or the same value written differently, at any depth")
-    {
-        // nested arrays and objects around depths where the walk over equal text gives up
-        for (const int depth :
-                {
-                    1, 5, 47, 48, 49, 50, 60, 300
-                })
-        {
-            CAPTURE(depth)
-            std::string head;
-            std::string tail;
-            for (int i = 0; i < depth; ++i)
-            {
-                head += i % 2 == 0 ? R"({"k":[1,"s",{"x":true},)" : R"([null,2.5,{"y":)";
-                tail.insert(0, i % 2 == 0 ? "]}" : "}]");
-            }
-            // the same text, one number changed, and one number written differently
-            const auto with_number = [&](const char* number)
-            {
-                std::string result = head;
-                result += number;
-                result += tail;
-                return result;
-            };
-            const std::string text = with_number("7");
-            const std::string changed = with_number("8");
-            const std::string spelled = with_number("7.0");
-            const json_document a = json_document::parse(text);
-            const json_document b = json_document::parse(text);
-            const json_document c = json_document::parse(changed);
-            const json_document d = json_document::parse(spelled);
-            CHECK(a.root() == b.root());
-            CHECK(a.root() != c.root());
-            CHECK(c.root() != a.root());
-            CHECK(a.root() == d.root());
-            CHECK(d.root() == a.root());
-            CHECK(a.root() == json::parse(text));
-            CHECK(a.root() != json::parse(changed));
-            CHECK(json::parse(spelled) == a.root());
-            const nlohmann::json_editable_document e = nlohmann::json_editable_document::parse(text);
-            CHECK(a.root() == e.root());
-            CHECK(e.root() == a.root());
-            CHECK(c.root() != e.root());
-            CHECK(e.root() == e.root());
-            const ordered_json_document oa = ordered_json_document::parse(text);
-            const ordered_json_document oc = ordered_json_document::parse(changed);
-            CHECK(oa.root() != oc.root());
-            CHECK(oa.root() == ordered_json::parse(text));
-            CHECK(oc.root() != ordered_json::parse(text));
-        }
-
-        // not the same text, but the same value
-        const auto same = [](const char* x, const char* y)
-        {
-            const json_document dx = json_document::parse(x);
-            const json_document dy = json_document::parse(y);
-            const bool equal = dx.root() == dy.root();
-            CHECK(equal == (json::parse(x) == json::parse(y)));
-            CHECK(equal == (dx.root() == json::parse(y)));
-            return equal;
-        };
-        CHECK(same(R"({"a":1,"a":2})", R"({"a":3,"a":2})"));
-        CHECK(same(R"({"a":1,"b":[1,{"c":2,"c":3}]})", R"({"b":[1,{"c":9,"c":3}],"a":1})"));
-        CHECK(!same(R"({"a":1,"a":2})", R"({"a":2,"a":3})"));
-        CHECK(same("[1.0,-0,0,1e2]", "[1.00,0,-0,100.0]"));
-        CHECK(same(R"(["\u00e9","\n"])", "[\"\xc3\xa9\",\"\\n\"]"));
-        CHECK(!same(R"({"a":[1,2,{"b":null}]})", R"({"a":[1,2,{"b":false}]})"));
-        CHECK(!same(R"({"a":[1,2,{"b":null}]})", R"({"a":[1,2,{"c":null}]})"));
-        CHECK(!same(R"({"a":[1,2,{"b":null}]})", R"({"a":[1,2,{"b":null,"c":1}]})"));
-
-        // edited documents: moved sequences, links, and values of new nodes
-        nlohmann::json_editable_document edited = nlohmann::json_editable_document::parse(R"({"a":[1,2,3],"b":{"c":"d"},"e":0.5})");
-        const json_document plain = json_document::parse(R"({"a":[1,2,3,4],"b":{"c":"x","y":null},"e":0.5,"z":[]})");
-        edited.push_back(edited.root()["a"], 4);
-        edited.set(edited.root()["b"], "c", "x");
-        edited.set(edited.root()["b"], "y", nullptr);
-        edited.set(edited.root(), "z", json::array());
-        CHECK(edited.root() == plain.root());
-        CHECK(plain.root() == edited.root());
-        edited.erase(edited.root()["a"], 0);
-        CHECK(edited.root() != plain.root());
-        CHECK(edited.root()["a"] == json::parse("[2,3,4]"));
-        const json_document tail = json_document::parse("[2,3,4]");
-        CHECK(edited.root()["a"] == tail.root());
-    }
-
-    SECTION("large documents, with a difference at any place")
-    {
-        const auto make = [](std::size_t count, std::size_t changed, bool swap_members)
-        {
-            std::string text = R"({"b":1,"list":[)";
-            for (std::size_t i = 0; i < count; ++i)
-            {
-                text += (i != 0 ? "," : "");
-                const std::string id = std::to_string(i == changed ? i + 1 : i);
-                if (swap_members && i % 3 == 0)
-                {
-                    text += R"({"v":[1.5,"s",{"k":)";
-                    text += id;
-                    text += R"(}],"id":)";
-                    text += id;
-                    text += "}";
-                }
-                else
-                {
-                    text += R"({"id":)";
-                    text += id;
-                    text += R"(,"v":[1.5,"s",{"k":)";
-                    text += id;
-                    text += "}]}";
-                }
-            }
-            return text + R"(],"a":{"y":2,"x":3}})";
-        };
-        const std::size_t count = 3000;
-        for (const std::size_t changed :
-                {
-                    count, std::size_t{0}, std::size_t{1}, count / 2, count - 1
-                })
-        {
-            for (const bool swap :
-                    {
-                        false, true
-                    })
-            {
-                CAPTURE(changed)
-                CAPTURE(swap)
-                const std::string text_a = make(count, count, false);
-                const std::string text_b = make(count, changed, swap);
-                const json_document a = json_document::parse(text_a);
-                const json_document b = json_document::parse(text_b);
-                const bool equal = changed == count;
-                CHECK((a.root() == b.root()) == equal);
-                CHECK((b.root() == a.root()) == equal);
-                CHECK((a.root() == json::parse(text_b)) == equal);
-                CHECK((json::parse(text_b) == a.root()) == equal);
-                CHECK((a.root()["list"] == b.root()["list"]) == equal);
-                const ordered_json_document oa = ordered_json_document::parse(text_a);
-                const ordered_json_document ob = ordered_json_document::parse(text_b);
-                CHECK((oa.root() == ob.root()) == (equal && !swap));
-                CHECK((oa.root() == ordered_json::parse(text_b)) == (equal && !swap));
-            }
-        }
-    }
-
-    SECTION("deep nesting")
-    {
-        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
-        const json_document a = json_document::parse(deep);
-        const json_document b = json_document::parse(deep);
-        CHECK(a.root() == b.root());
-        CHECK(a.root() == json::parse(deep));
-        const std::string other = std::string(100000, '[') + "1" + std::string(100000, ']');
-        const json_document c = json_document::parse(other);
-        CHECK(a.root() != c.root());
-    }
-}

tests/src/unit-json_view_dump.cpp

@@ -432,6 +432,101 @@ TEST_CASE("json_view dump")
     }
 }
 
+TEST_CASE("json_view comparison")
+{
+    SECTION("equality of the values parse() produces")
+    {
+        generator g;
+        std::vector<std::string> texts;
+        for (int i = 0; i < 600; ++i)
+        {
+            std::string text;
+            g.value(text, 0);
+            texts.push_back(text);
+            // the same value written differently: sorted keys, canonical numbers
+            texts.push_back(json::parse(text).dump(1));
+        }
+        for (std::size_t i = 0; i + 2 < texts.size(); ++i)
+        {
+            for (std::size_t k = i; k < i + 3; ++k)
+            {
+                CAPTURE(texts[i])
+                CAPTURE(texts[k])
+                const json_document a = json_document::parse(texts[i]);
+                const json_document b = json_document::parse(texts[k]);
+                const json ja = json::parse(texts[i]);
+                const json jb = json::parse(texts[k]);
+                CHECK((a.root() == b.root()) == (ja == jb));
+                CHECK((a.root() != b.root()) == (ja != jb));
+                CHECK((a.root() == jb) == (ja == jb));
+                CHECK((jb == a.root()) == (ja == jb));
+                CHECK((a.root() != jb) == (ja != jb));
+                CHECK((jb != a.root()) == (ja != jb));
+
+                // ordered_json compares members in order
+                const ordered_json_document oa = ordered_json_document::parse(texts[i]);
+                const ordered_json_document ob = ordered_json_document::parse(texts[k]);
+                const ordered_json oja = ordered_json::parse(texts[i]);
+                const ordered_json ojb = ordered_json::parse(texts[k]);
+                CHECK((oa.root() == ob.root()) == (oja == ojb));
+                CHECK((oa.root() == ojb) == (oja == ojb));
+            }
+        }
+    }
+
+    SECTION("numbers, duplicate keys, member order")
+    {
+        const auto same = [](const char* x, const char* y)
+        {
+            const json_document dx = json_document::parse(x);
+            const json_document dy = json_document::parse(y);
+            return dx.root() == dy.root();
+        };
+        CHECK(same("1", "1.0"));
+        CHECK(same("[1, -1, 2.5]", "[1.0, -1.0, 25e-1]"));
+        CHECK(!same("1", "1.5"));
+        CHECK(same("18446744073709551615", "18446744073709551615"));
+        CHECK(same(R"({"a": 1, "a": 2})", R"({"a": 2})"));
+        CHECK(!same(R"({"a": 1, "a": 2})", R"({"a": 1})"));
+        CHECK(same(R"({"a": 1, "b": 2})", R"({"b": 2, "a": 1})"));
+        CHECK(!same(R"({"a": 1})", R"({"a": 1, "b": 2})"));
+        CHECK(!same("[1, 2]", "[2, 1]"));
+        CHECK(!same("\"a\"", "\"b\""));
+        CHECK(same("\"\\u00e9\"", "\"\xc3\xa9\""));
+        CHECK(!same("null", "false"));
+        CHECK(!same("[]", "{}"));
+        const ordered_json_document dup = ordered_json_document::parse(R"({"a": 1, "b": 2, "a": 3})");
+        const ordered_json_document last = ordered_json_document::parse(R"({"a": 3, "b": 2})");
+        CHECK(dup.root() == last.root());
+        // (== compares as parse() resolves duplicates, a lookup finds the first)
+        CHECK(dup.root()["a"].materialize() == 1);
+        CHECK(dup.root()["a"] != last.root()["a"]);
+        const ordered_json_document ab = ordered_json_document::parse(R"({"a": 1, "b": 2})");
+        const ordered_json_document ba = ordered_json_document::parse(R"({"b": 2, "a": 1})");
+        CHECK(ab.root() != ba.root());
+
+        // discarded values compare as basic_json's do
+        const json discarded(json::value_t::discarded);
+        CHECK((json_view() == json_view()) == (discarded == discarded)); // NOLINT(readability-container-size-empty): operator== is tested
+        CHECK((json_view() == discarded) == (discarded == discarded)); // NOLINT(readability-container-size-empty)
+        const json_document null_document = json_document::parse("null");
+        CHECK(!(json_view() == null_document.root())); // NOLINT(readability-container-size-empty)
+        CHECK(!(null_document.root() == discarded));
+    }
+
+    SECTION("deep nesting")
+    {
+        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
+        const json_document a = json_document::parse(deep);
+        const json_document b = json_document::parse(deep);
+        CHECK(a.root() == b.root());
+        CHECK(a.root() == json::parse(deep));
+        const std::string other = std::string(100000, '[') + "1" + std::string(100000, ']');
+        const json_document c = json_document::parse(other);
+        CHECK(a.root() != c.root());
+    }
+}
+
 TEST_CASE("json_view large objects")
 {
     // objects with 128 members or more are looked up with a hash index

tests/src/unit-json_view_image.cpp

@@ -682,64 +682,6 @@ TEST_CASE("json_view images: ownership")
 #if !defined(JSON_NOEXCEPTION)
 TEST_CASE("json_view images: errors")
 {
-    SECTION("float tokens: a changed byte is accepted if the text is still a number with the digits the node records")
-    {
-        for (const char* const token :
-                {
-                    "-12.375", "0.5", "123456.0", "-0.0", "9999999999999999999.5", "0.000000000000000000000001", "1.25e10", "5E-3"
-                })
-        {
-            CAPTURE(token)
-            const std::string text = std::string("[") + token + "]";
-            const json_document d = json_document::parse(text);
-            const std::vector<std::uint8_t> image = d.save();
-            const std::size_t at = text_at(image) + 1; // the first byte of the token
-            const std::uint16_t recorded = node_at(image, 1).extra;
-            CHECK(loaded_dump(image) == json::parse(text).dump());
-            for (std::size_t pos = 0; token[pos] != '\0'; ++pos)
-            {
-                for (unsigned int byte = 0; byte < 256; ++byte)
-                {
-                    std::vector<std::uint8_t> changed = image;
-                    changed[at + pos] = static_cast<std::uint8_t>(byte);
-                    std::string t = token;
-                    t[pos] = static_cast<char>(byte);
-                    // the digits of the integer part and of the fraction of the changed token
-                    std::size_t integer = 0;
-                    std::size_t fraction = 0;
-                    std::size_t k = (t[0] == '-') ? 1 : 0;
-                    for (; k < t.size() && t[k] >= '0' && t[k] <= '9'; ++k)
-                    {
-                        ++integer;
-                    }
-                    if (k < t.size() && t[k] == '.')
-                    {
-                        for (++k; k < t.size() && t[k] >= '0' && t[k] <= '9'; ++k)
-                        {
-                            ++fraction;
-                        }
-                    }
-                    // (as a JSON text, the token may have white space around it)
-                    const bool float_token = json::accept(t) && t.find_first_of(std::string(" \t\r\n\0", 5)) == std::string::npos && (t.find('.') != std::string::npos || t.find_first_of("eE") != std::string::npos) // NOLINT(abseil-string-find-str-contains)
-                                             && ((integer | (fraction << 8U)) == recorded);
-                    CAPTURE(pos)
-                    CAPTURE(byte)
-                    std::string result;
-                    try
-                    {
-                        result = loaded_dump(changed);
-                    }
-                    catch (const json::parse_error& e)
-                    {
-                        CHECK(std::string(e.what()) == check_failed);
-                        result = "rejected";
-                    }
-                    CHECK((result != "rejected") == float_token);
-                }
-            }
-        }
-    }
-
     SECTION("invalid UTF-8 of a decoded string: the compact dump writes it, the others throw")
     {
         const json_document d = json_document::parse(R"({"k\n":"\u00e9x"})");