Merge branch 'json-view/22-view-dump-fast' into json-view/23-zmij

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

.github/workflows/check_amalgamation.yml

@@ -67,7 +67,9 @@ jobs:
 
           python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s .
           python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s .
-          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_view.json -s .
+          # the configuration of json_view.hpp comes with the pull request until
+          # it is on develop; the tool itself is still develop's
+          python3 $TOOL_DIR/amalgamate.py -c $MAIN_DIR/tools/amalgamate/config_json_view.json -s .
 
           # the header list of the Bazel "json" target must match the files in include/
           cmake -P cmake/scripts/gen_bazel_build_file.cmake

docs/mkdocs/docs/examples/basic_json_view__cbegin.cpp

@@ -15,7 +15,7 @@ int main()
     const auto values = measurements.root();
 
     const int sum = std::accumulate(values.cbegin(), values.cend(), 0,
-                                     [](int total, const json_view & v)
+                                    [](int total, const json_view & v)
     {
         return total + v.materialize().get<int>();
     });

docs/mkdocs/docs/examples/basic_json_view__cend.cpp

@@ -15,7 +15,7 @@ int main()
     const auto records = batch.root();
 
     const bool all_objects = std::all_of(records.cbegin(), records.cend(),
-                                          [](const json_view & v)
+                                         [](const json_view & v)
     {
         return v.is_object();
     });

docs/mkdocs/docs/examples/basic_json_view__dump.cpp

@@ -19,7 +19,7 @@ int main()
     // the source text; a json value's object_t is std::map, so
     // materialize().dump() of the very same view sorts the keys instead
     const json_document config = json_document::parse(
-        R"({"name": "cache", "host": "db1", "port": 6379, "timeout": 30})");
+                                     R"({"name": "cache", "host": "db1", "port": 6379, "timeout": 30})");
     std::cout << config.root().dump(2) << "\n\n";
     std::cout << config.root().materialize().dump(2) << '\n';
 }

docs/mkdocs/docs/examples/basic_json_view__operator_eq.cpp

@@ -10,9 +10,9 @@ int main()
     // directly as views, without ever building a nlohmann::json value for
     // either one
     const json_document previous = json_document::parse(
-                                        R"({"name": "cache", "port": 6379, "timeout": 30})");
+                                       R"({"name": "cache", "port": 6379, "timeout": 30})");
     const json_document current = json_document::parse(
-                                       R"({"port": 6379.0, "timeout": 30, "name": "cache"})");
+                                      R"({"port": 6379.0, "timeout": 30, "name": "cache"})");
 
     // same members, reordered, and 6379 written as a float -- operator==
     // treats them the same way BasicJsonType::operator== would
@@ -20,7 +20,7 @@ int main()
 
     // an actually changed value is detected the same way
     const json_document changed = json_document::parse(
-                                       R"({"name": "cache", "port": 6380, "timeout": 30})");
+                                      R"({"name": "cache", "port": 6380, "timeout": 30})");
     std::cout << (previous.root() == changed.root()) << '\n';
 
     // comparing a view directly against an expected json value -- handy in a

docs/mkdocs/docs/examples/basic_json_view__operator_ne.cpp

@@ -11,7 +11,7 @@ int main()
     // unwanted shape -- without ever materializing it into a json value just
     // to compare
     const json_document received = json_document::parse(
-                                        R"({"status": "ok", "code": 200})");
+                                       R"({"status": "ok", "code": 200})");
     const json unwanted = {{"status", "error"}, {"code", 500}};
     std::cout << std::boolalpha << (received.root() != unwanted) << '\n';
 

docs/mkdocs/docs/examples/basic_json_view__type_name.cpp

@@ -13,7 +13,10 @@ int main()
     json_document bad = json_document::parse("[1, 2, 3]");
     json_document failed = json_document::parse("not json", /* allow_exceptions */ false);
 
-    for (const json_view v : { good.root(), bad.root(), failed.root() })
+    for (const json_view v :
+            {
+                good.root(), bad.root(), failed.root()
+            })
     {
         if (v.is_object())
         {

include/nlohmann/detail/conversions/to_chars.hpp

@@ -983,7 +983,8 @@ inline void shortest_digits(char* buf, int& len, int& decimal_exponent, double v
     std::size_t n = digits.size();
     while (d.significand >= 100)
     {
-        const auto i = static_cast<std::size_t>(d.significand % 100) * 2;
+        const std::uint64_t two_digits = d.significand % 100; // a variable: GCC calls a cast of the remainder useless where std::uint64_t is std::size_t
+        const auto i = static_cast<std::size_t>(two_digits) * 2;
         d.significand /= 100;
         n -= 2;
         digits[n] = pairs[i];

include/nlohmann/detail/view/builder.hpp

@@ -202,8 +202,9 @@ class builder
     {
         const std::uint64_t done = static_cast<std::uint64_t>(at - b) + 1;
         const std::uint64_t guess = static_cast<std::uint64_t>(n) * static_cast<std::uint64_t>(e - b + 1) / done;
+        const std::uint64_t grown = guess + (guess / 4) + 64; // a variable: GCC calls a cast of the sum useless where std::uint64_t is std::size_t
         doc.tape_size = n;
-        doc.reserve((std::max)(static_cast<std::size_t>(guess + (guess / 4) + 64), n + (n / 2) + 64));
+        doc.reserve((std::max)(static_cast<std::size_t>(grown), n + (n / 2) + 64));
         return doc.tape;
     }
 
@@ -425,6 +426,14 @@ class builder
         return w;
     }
 
+    /// a compile-time option as a runtime condition: testing the template
+    /// argument directly makes a condition like `TrailingCommas && c == ']'`
+    /// constant when the option is off, which MSVC reports as C4127
+    static NLOHMANN_VIEW_ALWAYS_INLINE bool enabled(bool option) noexcept
+    {
+        return option;
+    }
+
     /// The parse state and the parser proper. The cursor is a local object of
     /// run() whose address never escapes (everything it calls out of line is a
     /// member of the builder and gets the positions it needs), so that the
@@ -554,7 +563,7 @@ arr_next:
                 {
                     return false;
                 }
-                if (TrailingCommas && cur() == ']')
+                if (enabled(TrailingCommas) && cur() == ']')
                 {
                     ++p;
                     goto close_container;
@@ -621,7 +630,7 @@ obj_next:
                 {
                     return false;
                 }
-                if (TrailingCommas && cur() == '}')
+                if (enabled(TrailingCommas) && cur() == '}')
                 {
                     ++p;
                     goto close_object;
@@ -771,7 +780,7 @@ indent_done:
                 {
                     ++p;
                 }
-                if (Comments && cur() == '/')
+                if (enabled(Comments) && cur() == '/')
                 {
                     const unsigned char* const q = cold.comment(p);
                     if (q == nullptr)

include/nlohmann/detail/view/document_data.hpp

@@ -103,7 +103,7 @@ struct document_data
         }
     };
 
-    document_data() noexcept = default;
+    document_data() = default;
     document_data(const document_data&) = delete;
     document_data(document_data&&) = delete;
     document_data& operator=(const document_data&) = delete;

include/nlohmann/detail/view/object_index.hpp

@@ -71,7 +71,8 @@ inline void build_object_index(document_data& d, node* obj)
     for (const node* k = document_data::first_child(obj), *end = document_data::child_end(obj); k != end; k = document_data::after(k + 1))
     {
         const char* const key = d.str(*k);
-        std::size_t i = static_cast<std::size_t>(key_hash(key, k->len)) & mask;
+        const std::uint64_t hash = key_hash(key, k->len); // (a cast of the call would be useless where std::uint64_t is std::size_t)
+        std::size_t i = static_cast<std::size_t>(hash) & mask;
         bool duplicate = false;
         while (slots[i] != 0)
         {
@@ -107,7 +108,8 @@ inline const node* find_indexed(const document_data& d, const node* obj, const c
 {
     const document_data::object_index& ix = d.indexes[obj->extra - 1u];
     const std::uint32_t* const slots = d.index_slots.data() + ix.start;
-    std::size_t i = static_cast<std::size_t>(key_hash(key, n)) & ix.mask;
+    const std::uint64_t hash = key_hash(key, n); // (a cast of the call would be useless where std::uint64_t is std::size_t)
+    std::size_t i = static_cast<std::size_t>(hash) & ix.mask;
     for (;;)
     {
         const std::uint32_t s = slots[i];

include/nlohmann/detail/view/pointer.hpp

@@ -69,7 +69,7 @@ index_status array_index(const StringType& s, std::size_t& idx) noexcept
         }
         v = (v * 10) + d;
     }
-    if (v >= static_cast<std::uint64_t>((std::numeric_limits<std::size_t>::max)()))
+    if (v >= (std::numeric_limits<std::size_t>::max)()) // (std::size_t converts to std::uint64_t implicitly)
     {
         return index_status::too_large;
     }

single_include/nlohmann/json.hpp

@@ -25114,7 +25114,8 @@ inline void shortest_digits(char* buf, int& len, int& decimal_exponent, double v
     std::size_t n = digits.size();
     while (d.significand >= 100)
     {
-        const auto i = static_cast<std::size_t>(d.significand % 100) * 2;
+        const std::uint64_t two_digits = d.significand % 100; // a variable: GCC calls a cast of the remainder useless where std::uint64_t is std::size_t
+        const auto i = static_cast<std::size_t>(two_digits) * 2;
         d.significand /= 100;
         n -= 2;
         digits[n] = pairs[i];

single_include/nlohmann/json_view.hpp

@@ -368,7 +368,7 @@ struct document_data
         }
     };
 
-    document_data() noexcept = default;
+    document_data() = default;
     document_data(const document_data&) = delete;
     document_data(document_data&&) = delete;
     document_data& operator=(const document_data&) = delete;
@@ -1187,8 +1187,9 @@ class builder
     {
         const std::uint64_t done = static_cast<std::uint64_t>(at - b) + 1;
         const std::uint64_t guess = static_cast<std::uint64_t>(n) * static_cast<std::uint64_t>(e - b + 1) / done;
+        const std::uint64_t grown = guess + (guess / 4) + 64; // a variable: GCC calls a cast of the sum useless where std::uint64_t is std::size_t
         doc.tape_size = n;
-        doc.reserve((std::max)(static_cast<std::size_t>(guess + (guess / 4) + 64), n + (n / 2) + 64));
+        doc.reserve((std::max)(static_cast<std::size_t>(grown), n + (n / 2) + 64));
         return doc.tape;
     }
 
@@ -1410,6 +1411,14 @@ class builder
         return w;
     }
 
+    /// a compile-time option as a runtime condition: testing the template
+    /// argument directly makes a condition like `TrailingCommas && c == ']'`
+    /// constant when the option is off, which MSVC reports as C4127
+    static NLOHMANN_VIEW_ALWAYS_INLINE bool enabled(bool option) noexcept
+    {
+        return option;
+    }
+
     /// The parse state and the parser proper. The cursor is a local object of
     /// run() whose address never escapes (everything it calls out of line is a
     /// member of the builder and gets the positions it needs), so that the
@@ -1539,7 +1548,7 @@ arr_next:
                 {
                     return false;
                 }
-                if (TrailingCommas && cur() == ']')
+                if (enabled(TrailingCommas) && cur() == ']')
                 {
                     ++p;
                     goto close_container;
@@ -1606,7 +1615,7 @@ obj_next:
                 {
                     return false;
                 }
-                if (TrailingCommas && cur() == '}')
+                if (enabled(TrailingCommas) && cur() == '}')
                 {
                     ++p;
                     goto close_object;
@@ -1756,7 +1765,7 @@ indent_done:
                 {
                     ++p;
                 }
-                if (Comments && cur() == '/')
+                if (enabled(Comments) && cur() == '/')
                 {
                     const unsigned char* const q = cold.comment(p);
                     if (q == nullptr)
@@ -2817,7 +2826,8 @@ inline void build_object_index(document_data& d, node* obj)
     for (const node* k = document_data::first_child(obj), *end = document_data::child_end(obj); k != end; k = document_data::after(k + 1))
     {
         const char* const key = d.str(*k);
-        std::size_t i = static_cast<std::size_t>(key_hash(key, k->len)) & mask;
+        const std::uint64_t hash = key_hash(key, k->len); // (a cast of the call would be useless where std::uint64_t is std::size_t)
+        std::size_t i = static_cast<std::size_t>(hash) & mask;
         bool duplicate = false;
         while (slots[i] != 0)
         {
@@ -2853,7 +2863,8 @@ inline const node* find_indexed(const document_data& d, const node* obj, const c
 {
     const document_data::object_index& ix = d.indexes[obj->extra - 1u];
     const std::uint32_t* const slots = d.index_slots.data() + ix.start;
-    std::size_t i = static_cast<std::size_t>(key_hash(key, n)) & ix.mask;
+    const std::uint64_t hash = key_hash(key, n); // (a cast of the call would be useless where std::uint64_t is std::size_t)
+    std::size_t i = static_cast<std::size_t>(hash) & ix.mask;
     for (;;)
     {
         const std::uint32_t s = slots[i];
@@ -5186,7 +5197,7 @@ index_status array_index(const StringType& s, std::size_t& idx) noexcept
         }
         v = (v * 10) + d;
     }
-    if (v >= static_cast<std::uint64_t>((std::numeric_limits<std::size_t>::max)()))
+    if (v >= (std::numeric_limits<std::size_t>::max)()) // (std::size_t converts to std::uint64_t implicitly)
     {
         return index_status::too_large;
     }

tests/src/fuzzer-json_view_image.cpp

@@ -41,7 +41,10 @@ using image_check = json_document::image_check;
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
     // the input as an image
-    for (const image_check check : {image_check::full, image_check::bounds})
+    for (const image_check check :
+            {
+                image_check::full, image_check::bounds
+            })
     {
         json_document d;
         try
@@ -79,7 +82,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     if (!parsed.is_discarded())
     {
         const std::vector<std::uint8_t> image = parsed.save();
-        for (const image_check check : {image_check::full, image_check::bounds, image_check::none})
+        for (const image_check check :
+                {
+                    image_check::full, image_check::bounds, image_check::none
+                })
         {
             const json_document loaded = json_document::load(image, check);
             assert(loaded.root().dump() == parsed.root().dump());

tests/src/unit-class_lexer.cpp

@@ -1465,7 +1465,8 @@ TEST_CASE("Eisel-Lemire float conversion")
             // than the distance to the rounding boundary, so it must not change
             std::string longer = token;
             const std::size_t e = longer.find('e');
-            const std::string extra = longer.find('.') == std::string::npos ? ".000000000000000000001" : "000000000000000000001";
+            const std::size_t dot = longer.find('.');
+            const std::string extra = dot == std::string::npos ? ".000000000000000000001" : "000000000000000000001";
             longer.insert(e == std::string::npos ? longer.size() : e, extra);
             CAPTURE(longer);
             if (eisel_lemire(longer, out))
@@ -1488,7 +1489,8 @@ TEST_CASE("Eisel-Lemire float conversion")
         CHECK(bits_of(json::parse("-65.613616999999977").get<double>()) == bits_of(-65.613616999999977));
         CHECK(bits_of(json::parse("2.2250738585072011e-308").get<double>()) == 0x000FFFFFFFFFFFFFu);
         CHECK(bits_of(json::parse("4.9406564584124654e-324").get<double>()) == 1u);
-        CHECK_THROWS_WITH_AS(json::parse("1.7976931348623159e308"),
+        json _;
+        CHECK_THROWS_WITH_AS(_ = json::parse("1.7976931348623159e308"),
                              "[json.exception.out_of_range.406] number overflow parsing '1.7976931348623159e308'", json::out_of_range&);
     }
 }
@@ -1555,16 +1557,23 @@ TEST_CASE("string scanning kernels")
         state ^= state << 17u;
         return state;
     };
+    // the upper half as a 32-bit value: converts to std::size_t implicitly on
+    // every platform (a cast of std::uint64_t is useless where both are the
+    // same type, and required where std::size_t is 32 bits wide)
+    const auto next_small = [&next]()
+    {
+        return static_cast<std::uint32_t>(next() >> 32u);
+    };
     for (int round = 0; round < 100000; ++round)
     {
         // mostly ordinary text, so that runs span several words
-        std::string text(static_cast<std::size_t>(next() % 8), '.');
-        const auto count = static_cast<std::size_t>(next() % 12);
+        std::string text(next_small() % 8u, '.');
+        const std::size_t count = next_small() % 12u;
         for (std::size_t k = 0; k < count; ++k)
         {
-            const std::size_t p = (next() % 4 == 0) ? static_cast<std::size_t>(next() % pieces.size()) : 0;
+            const std::size_t p = (next() % 4 == 0) ? next_small() % pieces.size() : 0;
             text += pieces[p];
-            text += std::string(static_cast<std::size_t>(next() % 10), 'x');
+            text += std::string(next_small() % 10u, 'x');
         }
         const auto* data = reinterpret_cast<const unsigned char*>(text.data()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
         for (std::size_t offset = 0; offset < 3 && offset <= text.size(); ++offset)

tests/src/unit-json_view.cpp

@@ -39,6 +39,7 @@ using nlohmann::ordered_json_view;
 
 namespace
 {
+#if !defined(JSON_NOEXCEPTION)
 // the exception parse() throws for a text, or "" if it accepts it
 std::string parse_exception(const std::string& text, bool comments = false, bool trailing_commas = false)
 {
@@ -67,6 +68,7 @@ std::string view_exception(const std::string& text, bool comments = false, bool
     }
     return "";
 }
+#endif
 
 // a small deterministic generator of documents
 struct generator
@@ -156,7 +158,7 @@ TEST_CASE("json_view")
             CHECK(v.materialize() == j);
         }
 
-        const json_view invalid;
+        const json_view invalid{};
         CHECK(invalid.is_discarded());
         CHECK(!static_cast<bool>(invalid));
         CHECK(invalid.type() == json::value_t::discarded);
@@ -201,9 +203,11 @@ TEST_CASE("json_view")
                 })
         {
             CAPTURE(text);
+#if !defined(JSON_NOEXCEPTION)
             const std::string expected = parse_exception(text);
             REQUIRE(!expected.empty());
             CHECK(view_exception(text) == expected);
+#endif
             CHECK(!json_document::accept(text));
             const json_document d = json_document::parse(text, false);
             CHECK(d.is_discarded());
@@ -211,8 +215,9 @@ TEST_CASE("json_view")
             CHECK(d.node_count() == 0);
         }
         // the exception types
-        CHECK_THROWS_AS(json_document::parse("[1,"), json::parse_error&);
-        CHECK_THROWS_AS(json_document::parse("1e400"), json::out_of_range&);
+        json_document _;
+        CHECK_THROWS_AS(_ = json_document::parse("[1,"), json::parse_error&);
+        CHECK_THROWS_AS(_ = json_document::parse("1e400"), json::out_of_range&);
     }
 
     SECTION("parse options")
@@ -227,7 +232,9 @@ TEST_CASE("json_view")
                 const bool comments = (options & 1) != 0;
                 const bool trailing_commas = (options & 2) != 0;
                 CHECK(json_document::accept(text, comments, trailing_commas) == json::accept(text, comments, trailing_commas));
+#if !defined(JSON_NOEXCEPTION)
                 CHECK(view_exception(text, comments, trailing_commas) == parse_exception(text, comments, trailing_commas));
+#endif
             }
         }
     }
@@ -239,7 +246,9 @@ TEST_CASE("json_view")
         const std::string nul_in_comment("[1, // c\0\n2]", 12);
         CHECK(json_document::accept(nul_in_comment, true) == json::accept(nul_in_comment, true));
         CHECK(json_document::parse("\xEF\xBB\xBF[1]").root().materialize() == json::parse("\xEF\xBB\xBF[1]"));
+#if !defined(JSON_NOEXCEPTION)
         CHECK(view_exception("\xEF\xBB") == parse_exception("\xEF\xBB"));
+#endif
     }
 
     SECTION("inputs")
@@ -385,6 +394,7 @@ TEST_CASE("json_view")
 
 namespace
 {
+#if !defined(JSON_NOEXCEPTION)
 // the exception a call throws, or "" if it throws none
 template<typename F>
 std::string exception_of(F f)
@@ -399,6 +409,7 @@ std::string exception_of(F f)
     }
     return "";
 }
+#endif
 
 // compares a view with the ordered_json value materialize() gives for it:
 // types, sizes, elements and members (by index, key, and iteration), in
@@ -567,6 +578,7 @@ TEST_CASE("json_view element access and iteration")
             const json_document d = json_document::parse(text);
             const json_view v = d.root();
             const json j = v.materialize();
+#if !defined(JSON_NOEXCEPTION)
             if (!j.is_object())
             {
                 CHECK(exception_of([&] { static_cast<void>(v["a"]); }) == exception_of([&] { static_cast<void>(j["a"]); }));
@@ -588,6 +600,7 @@ TEST_CASE("json_view element access and iteration")
                 CHECK(exception_of([&] { static_cast<void>(v.front()); }) == exception_of([&] { static_cast<void>(j.front()); }));
                 CHECK(exception_of([&] { static_cast<void>(v.back()); }) == exception_of([&] { static_cast<void>(j.back()); }));
             }
+#endif
             CHECK(v.contains("a") == j.contains("a"));
             CHECK(v.count("a") == j.count("a"));
             CHECK((v.find("a") == v.end()) == (j.find("a") == j.end())); // NOLINT(readability-container-contains): find() is what is tested
@@ -599,7 +612,7 @@ TEST_CASE("json_view element access and iteration")
         CHECK(!d.root()["a"][0]);
         CHECK_THROWS_WITH_AS(d.root()["a"].front(), "[json.exception.invalid_iterator.214] cannot get value", json::invalid_iterator&);
         CHECK_THROWS_WITH_AS(d.root()["a"].back(), "[json.exception.invalid_iterator.214] cannot get value", json::invalid_iterator&);
-        const json_view invalid;
+        const json_view invalid{};
         CHECK(invalid.begin() == invalid.end());
         CHECK(std::string(invalid.type_name()) == "discarded");
         CHECK_THROWS_WITH_AS(invalid["a"], "[json.exception.type_error.305] cannot use operator[] with a string argument with discarded", json::type_error&);
@@ -659,6 +672,7 @@ TEST_CASE("json_view element access and iteration")
 
 namespace
 {
+#if !defined(JSON_NOEXCEPTION)
 // an exception message without the context that basic_json adds with
 // JSON_DIAGNOSTICS ("(/path) ") and JSON_DIAGNOSTIC_POSITIONS ("(bytes 1-2) ");
 // the view's exceptions have no such context
@@ -676,6 +690,7 @@ std::string without_path(std::string msg)
     }
     return msg;
 }
+#endif
 
 // the bits of a float, to compare values bit for bit
 std::uint64_t bits(double x)
@@ -755,6 +770,7 @@ void check_values(const ordered_json_view& v, const ordered_json& j, const std::
             break;
     }
 
+#if !defined(JSON_NOEXCEPTION)
     // conversions to the wrong type throw what basic_json throws
     if (!j.is_number())
     {
@@ -771,6 +787,7 @@ void check_values(const ordered_json_view& v, const ordered_json& j, const std::
     {
         CHECK(exception_of([&] { static_cast<void>(v.get<std::map<std::string, int>>()); }) == without_path(exception_of([&] { static_cast<void>(j.get<std::map<std::string, int>>()); })));
     }
+#endif
 
     if (v.is_array())
     {
@@ -931,7 +948,7 @@ TEST_CASE("json_view values")
         // a duplicate key: the last value, as parse()
         CHECK((json_document::parse(R"({"a":1,"a":2})").root().get<std::map<std::string, int>>() == std::map<std::string, int> {{"a", 2}}));
 
-        const json_view invalid;
+        const json_view invalid{};
         CHECK_THROWS_WITH_AS(invalid.get<int>(), "[json.exception.type_error.302] type must be number, but is discarded", json::type_error&);
         CHECK(invalid.get<json>().is_discarded());
     }
@@ -952,10 +969,12 @@ TEST_CASE("json_view values")
         // with a JSON pointer, arrays can be asked as well
         CHECK(v["o"]["x"].value(json::json_pointer("/1"), 0) == j["o"]["x"].value(json::json_pointer("/1"), 0));
         CHECK(v["o"]["x"].value(json::json_pointer("/7"), 3) == j["o"]["x"].value(json::json_pointer("/7"), 3));
+#if !defined(JSON_NOEXCEPTION)
         CHECK(exception_of([&] { static_cast<void>(v["o"]["x"].value("k", 0)); }) == without_path(exception_of([&] { static_cast<void>(j["o"]["x"].value("k", 0)); })));
         CHECK(exception_of([&] { static_cast<void>(v.value("s", 0)); }) == without_path(exception_of([&] { static_cast<void>(j.value("s", 0)); })));
         CHECK(exception_of([&] { static_cast<void>(v["n"].value("x", 0)); }) == without_path(exception_of([&] { static_cast<void>(j["n"].value("x", 0)); })));
         CHECK(exception_of([&] { static_cast<void>(v["n"].value(json::json_pointer("/x"), 0)); }) == without_path(exception_of([&] { static_cast<void>(j["n"].value(json::json_pointer("/x"), 0)); })));
+#endif
     }
 }
 
@@ -994,6 +1013,7 @@ TEST_CASE("json_view JSON pointers")
         }
     }
 
+#if !defined(JSON_NOEXCEPTION)
     SECTION("errors are those of basic_json")
     {
         const std::string text = R"({"a": [1, {"b": null}], "c": "s", "": {"": 0}, "a~b": 1, "c/d": 2})";
@@ -1026,11 +1046,16 @@ TEST_CASE("json_view JSON pointers")
             // (basic_json::contains() throws out_of_range.404 for an empty
             // array index token, although it is not meant to throw; the view
             // answers false)
-            const std::string contains_error = exception_of([&] { static_cast<void>(j.contains(p)); });
+            const std::string contains_error = exception_of([&]
+            {
+                const bool found = j.contains(p);
+                static_cast<void>(found);
+            });
             CHECK(v.contains(p) == (contains_error.empty() && j.contains(p)));
             CHECK(exception_of([&] { static_cast<void>(v.value(p, 5)); }) == without_path(exception_of([&] { static_cast<void>(j.value(p, 5)); })));
         }
     }
+#endif
 }
 
 TEST_CASE("json_view dump")

tests/src/unit-json_view_builder.cpp

@@ -9,8 +9,12 @@
 #include "doctest_compatibility.h"
 
 #include <nlohmann/json.hpp>
-#include <nlohmann/detail/view/builder.hpp>
-#include <nlohmann/detail/view/string_ref.hpp>
+#if JSON_TEST_USING_MULTIPLE_HEADERS
+    #include <nlohmann/detail/view/builder.hpp>
+    #include <nlohmann/detail/view/string_ref.hpp>
+#else
+    #include <nlohmann/json_view.hpp> // the single header contains the internal headers
+#endif
 using nlohmann::json;
 
 #include <array>

tests/src/unit-json_view_edit.cpp

@@ -35,7 +35,9 @@ namespace
 std::uint32_t rng()
 {
     static std::mt19937 generator(5295); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible
-    return generator();
+    // result_type is std::uint_fast32_t, which may be wider than 32 bits
+    const std::mt19937::result_type value = generator();
+    return static_cast<std::uint32_t>(value);
 }
 
 int r(int n)
@@ -344,6 +346,8 @@ TEST_CASE("json_view edits: differential")
 
 namespace
 {
+#if !defined(JSON_NOEXCEPTION)
+// the exception a call throws, or "" if it throws none
 std::string exception_of_call(const std::function<void()>& f)
 {
     try
@@ -356,6 +360,7 @@ std::string exception_of_call(const std::function<void()>& f)
     }
     return "";
 }
+#endif
 } // namespace
 
 TEST_CASE("json_view edits: errors")
@@ -389,6 +394,7 @@ TEST_CASE("json_view edits: errors")
     CHECK_THROWS_WITH_AS(d.set(root, json_editable_view()), "[json.exception.type_error.302] type must be a value, but is discarded", json::type_error&);
     CHECK_THROWS_WITH_AS(d.set(root, json::binary({1, 2})), "[json.exception.type_error.319] cannot store a binary value in a json_document", json::type_error&);
 
+#if !defined(JSON_NOEXCEPTION)
     // invalid UTF-8 is rejected when it enters the document, with the error
     // basic_json::dump() reports for the same string
     for (const std::string bad :
@@ -406,6 +412,7 @@ TEST_CASE("json_view edits: errors")
         CHECK(exception_of_call([&] { d.set(root["o"], bad, 1); }) == expected);
         CHECK(exception_of_call([&] { d.set(root["z"], json{{"k", bad}}); }) == expected);
     }
+#endif
     // nothing of the failed edits is visible
     CHECK(root.dump() == R"({"o":{"a":1},"a":[1,2],"n":1,"z":null})");
     static_cast<void>(other);
@@ -462,8 +469,8 @@ TEST_CASE("json_view edits: views and values")
         d.set(d.root(), 2, 0.1);
         d.push_back(d.root(), std::numeric_limits<double>::quiet_NaN());
         d.push_back(d.root(), -std::numeric_limits<double>::infinity());
-        d.push_back(d.root(), static_cast<std::uint64_t>(18446744073709551615u));
-        d.push_back(d.root(), static_cast<std::int64_t>(-9223372036854775807 - 1));
+        d.push_back(d.root(), (std::numeric_limits<std::uint64_t>::max)());
+        d.push_back(d.root(), (std::numeric_limits<std::int64_t>::min)());
         CHECK(d.root().dump() == "[1.5,100.0,0.1,null,null,18446744073709551615,-9223372036854775808]");
         CHECK(d.root().dump(-1, ' ', false, json_editable_view::number_format::source) == "[1.50,1E2,0.1,null,null,18446744073709551615,-9223372036854775808]");
         CHECK(std::isnan(d.root()[3].get<double>()));

tests/src/unit-json_view_image.cpp

@@ -36,6 +36,7 @@ using nlohmann::detail::view::node;
 
 namespace
 {
+#if !defined(JSON_NOEXCEPTION)
 std::string exception_of(const std::function<void()>& f)
 {
     try
@@ -50,6 +51,7 @@ std::string exception_of(const std::function<void()>& f)
 }
 
 const char* const check_failed = "[json.exception.parse_error.116] parse error: invalid json_document image: the check failed";
+#endif
 
 std::string read_file(const std::string& name)
 {
@@ -76,7 +78,8 @@ void set_header_field(std::vector<std::uint8_t>& image, std::size_t offset, std:
 
 std::size_t node_count(const std::vector<std::uint8_t>& image)
 {
-    return static_cast<std::size_t>(header_field(image, 8));
+    const std::uint64_t count = header_field(image, 8);
+    return static_cast<std::size_t>(count);
 }
 
 std::size_t text_at(const std::vector<std::uint8_t>& image)
@@ -96,6 +99,7 @@ void set_node(std::vector<std::uint8_t>& image, std::size_t i, const node& n)
     std::memcpy(image.data() + header_size + (i * sizeof(node)), &n, sizeof(node));
 }
 
+#if !defined(JSON_NOEXCEPTION)
 /// the result of loading an image with a check: "" or the exception message
 std::string load_result(const std::vector<std::uint8_t>& image, image_check check)
 {
@@ -116,6 +120,7 @@ std::vector<std::uint8_t> corrupted(const std::vector<std::uint8_t>& image, std:
     set_node(b, i, n);
     return b;
 }
+#endif
 
 /// a document and the documents loaded from its image must be equal
 template<typename Document>
@@ -142,7 +147,9 @@ void check_round_trip(const Document& d)
 std::uint32_t rng()
 {
     static std::mt19937 generator(5295); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible
-    return generator();
+    // result_type is std::uint_fast32_t, which may be wider than 32 bits
+    const std::mt19937::result_type value = generator();
+    return static_cast<std::uint32_t>(value);
 }
 } // namespace
 
@@ -353,6 +360,8 @@ TEST_CASE("json_view images: ownership")
     }
 }
 
+// the remaining tests are about the exceptions of load() and save()
+#if !defined(JSON_NOEXCEPTION)
 TEST_CASE("json_view images: errors")
 {
     SECTION("a literal as the root: dump() after loading")
@@ -373,7 +382,7 @@ TEST_CASE("json_view images: errors")
 
     SECTION("saving a discarded document")
     {
-        const json_document empty;
+        const json_document empty{};
         CHECK(exception_of([&] { static_cast<void>(empty.save()); }) == "[json.exception.type_error.320] cannot save a discarded json_document");
         const json_document failed = json_document::parse("[1,", false);
         CHECK(exception_of([&] { static_cast<void>(failed.save()); }) == "[json.exception.type_error.320] cannot save a discarded json_document");
@@ -779,6 +788,7 @@ TEST_CASE("json_view images: damaged images")
         }
     }
 }
+#endif
 
 #else
 

tests/src/unit-to_chars.cpp

@@ -20,8 +20,11 @@ using nlohmann::detail::dtoa_impl::reinterpret_bits;
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
+#include <iomanip>
 #include <limits>
+#include <locale>
 #include <random>
+#include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
@@ -664,9 +667,11 @@ void check_shortest(double v)
     if (digits.size() > 1)
     {
         // the decimals of one digit fewer next to the value
-        std::array<char, 64> shorter{};
-        const int n = std::snprintf(shorter.data(), shorter.size(), "%.*e", static_cast<int>(digits.size()) - 2, v); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-        const auto near = digits_and_exponent(std::string(shorter.data(), static_cast<std::size_t>(n)));
+        // (a stream rather than snprintf("%.*e"), whose output GCC cannot bound)
+        std::ostringstream shorter;
+        shorter.imbue(std::locale::classic());
+        shorter << std::scientific << std::setprecision(static_cast<int>(digits.size()) - 2) << v;
+        const auto near = digits_and_exponent(shorter.str());
         // as an integer with digits.size() - 1 digits
         std::string m = near.first;
         int e = near.second;