Raise line coverage to 99.9 %: fix the measurement, remove unreachable code, add tests (#5997)

* CI: measure line coverage without lcov's unexecuted-block adjustment

Drop geninfo_unexecuted_blocks=1 from the lcov capture of ci_test_coverage:
it reset every line of an inlined or templated function to 0 as soon as one
copy had an unexecuted block, which understated the line coverage by about
three points.

Add -fvar-tracking-assignments to both coverage builds. At -O0, GCC inlines
always_inline functions before it places the coverage counters, so the call
sites of such helpers (put_literal() and others) got no line record and
showed as 0 in an -O3 translation unit that never reaches them. With the
flag, the call sites carry counts in every translation unit. The generated
code is identical.

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

* Remove unreachable code found by the coverage analysis

Remove code that no input can reach, and mark the lines that cannot be
covered with LCOV_EXCL_LINE:

- BJData writer: the dry_run parameter of the ND-array element writers was
  always true; replace them by range checks.
- BON8 writer: call throw_integer_out_of_range() directly instead of
  write_bon8_value() for values that always throw.
- binary_writer: integer_bits() is only called for integers of up to 64 bits.
- serializer, view serializer, lexer: replace guards that the callers make
  unreachable by assertions or by the simpler code (surrogate pairs under
  ensure_ascii, next_unget, '-' at the end of the buffer).
- json_view: drop unreachable branches in scalar(), set(), check_utf8_scan(),
  append_input_impl() and unescape().
- Mark exception-cleanup braces, 2 GiB limits, big-endian and 32-bit code, and
  fall-through case labels with LCOV_EXCL_LINE.

No behavior changes for any input that reaches these functions.

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

* Tests: cover the remaining lines of the library headers

Add tests for the lines of include/nlohmann that were not covered: the
binary readers and writers, the lexer and locale paths, the json_view
modules, the custom number, key and array types, json_pointer, json_patch,
diff and the iterators.

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

* Fix test failures in the coverage tests

- unit-custom-object-key-type: remove the unused make_strict_key(strict_key)
  overload, the unused range constructor and default constructor, and guard
  data() with JSON_DIAGNOSTICS (unused-function/-member-function errors with
  GCC and clang -Weverything).
- unit-json_view_compare: move the two new sections to the new
  unit-json_view_compare_values.cpp, as the object file got too large for the
  MinGW assembler again, and use a std::map with std::greater instead of
  std::unordered_map, which does not accept the incomplete basic_json
  (clang 3.9, icpc).
- unit-json_view_dump: rename the variables that hid outer ones (MSVC C4456).
- unit-stream-bulk-scan: restore the real size of the oversized get area
  before the adapter is destroyed (JSON_PRECISE_STREAM_POSITION reads the
  character at the read position), and skip the test where the streambuf
  cannot hold a get area larger than an int (MSVC).
- unit-regression1: with JSON_NO_THREAD_LOCAL, copies are built member by
  member and keep correct timestamps, so check the corresponding outcome.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01N5NasAgbDGG28MqXjQvLqp
Signed-off-by: Claude <noreply@anthropic.com>

* Return std::size_t from the hash helper in the ordered_json test

MSVC (Win32) rejected the implicit conversion of the unsigned long long
product to the 32-bit std::size_t (C4244 as an error). Also note when
JSON_NO_THREAD_LOCAL is set in the regression test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01N5NasAgbDGG28MqXjQvLqp
Signed-off-by: Claude <noreply@anthropic.com>

---------

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Signed-off-by: Claude <noreply@anthropic.com>
Co-authored-by: Claude <noreply@anthropic.com>

tests/src/unit-regression1.cpp

@@ -23,11 +23,13 @@ using nlohmann::json;
     using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif
 
+#include <array>
 #include <fstream>
 #include <sstream>
 #include <list>
 #include <limits>
 #include <cstdio>
+#include <utility>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
 
@@ -1519,6 +1521,76 @@ TEST_CASE("regression tests 1")
         }
     }
 
+    SECTION("operator[](json_pointer) continues with the member that emplace() found")
+    {
+        // see the section above: the lookup does not find "k", but emplace()
+        // finds "x" and the pointer continues with the member of "x". Here
+        // the member is a container, so the pointer can go on below it. Only
+        // the outermost object may be a copy (with restarted timestamps): the
+        // value of "x" is moved in, so that its own lookups work.
+        const my_json orig = my_json::parse(R"({"x":null})");
+        const auto make = [&orig]()
+        {
+            my_json::object_t top = orig.get_ref<const my_json::object_t&>();
+            top.at("x") = my_json::parse(R"({"a":{"b":1},"n":null,"arr":[10,20],"objs":[{"m":5},{"m":6}]})");
+            return my_json(std::move(top));
+        };
+
+        SECTION("existing members")
+        {
+            // emplace() registers the key "k" in the object, so that every
+            // pointer needs a new object to reach the member of "x" again
+            const std::array<std::pair<const char*, const char*>, 4> pointers = {{{"/k/a/b", "1"}, {"/k/arr/1", "20"}, {"/k/n", "null"}, {"/k/objs/1/m", "6"}}};
+            for (const auto& pointer : pointers)
+            {
+                CAPTURE(pointer.first)
+                my_json j = make();
+                CHECK(j[my_json::json_pointer(pointer.first)].dump() == pointer.second);
+                CHECK(j.size() == 1);
+                CHECK(j["x"].size() == 4);
+            }
+        }
+
+        SECTION("a missing member of an object")
+        {
+            my_json j = make();
+#ifdef JSON_NO_THREAD_LOCAL
+            // (set by the user, or by the library for clang with MinGW)
+            // the objects below the outermost one are not copied by their
+            // object_t here, but member by member, which keeps their
+            // timestamps correct: "c" is not mistaken for "b" and is inserted
+            CHECK(j[my_json::json_pointer("/k/a/c/d")].is_null());
+            CHECK(j["x"]["a"].dump() == R"({"b":1,"c":{"d":null}})");
+#else
+            // the timestamp of "c" is that of "b" again, so that emplace()
+            // finds the member "b", a number, which has no member "d"
+            CHECK_THROWS_AS(j[my_json::json_pointer("/k/a/c/d")], my_json::out_of_range&);
+            CHECK(j["x"]["a"].dump() == R"({"b":1})");
+#endif
+        }
+
+        SECTION("a null value is converted to an object")
+        {
+            my_json j = make();
+            j[my_json::json_pointer("/k/n/c")] = 3;
+            CHECK(j["x"]["n"].dump() == R"({"c":3})");
+        }
+
+        SECTION("the end of an array")
+        {
+            my_json j = make();
+            j[my_json::json_pointer("/k/arr/-")] = 30;
+            CHECK(j["x"]["arr"].dump() == "[10,20,30]");
+        }
+
+        SECTION("an index past the end of an array")
+        {
+            my_json j = make();
+            j[my_json::json_pointer("/k/arr/3")] = 40;
+            CHECK(j["x"]["arr"].dump() == "[10,20,null,40]");
+        }
+    }
+
     SECTION("issue #977 - Assigning between different json types")
     {
         foo_json lj = ns::foo{3};