Add tests for uncovered code paths (#5581)

* Add tests for uncovered code paths

Cover code the test suite did not reach, found from the Coveralls report
of develop and a local coverage run of HEAD:

- dump() of every kind of value below the bound of the recursive descent
  (pretty-printed objects, binary values, discarded values, scalars), and
  flushes of the escape and write buffers mid-string and mid-binary
- the iterative comparison: objects with different keys, containers that
  are a prefix of each other, and elements that cannot be ordered, each
  both at the top level and below the nesting bound
- SAX handlers that stop at any event, including the end of a nested
  container, in the BSON, CBOR, MessagePack, UBJSON and BJData readers
- from_bson/cbor/msgpack/ubjson/bjdata returning a discarded value
  through the iterator and pointer overloads
- JSON Patch, diff, merge_patch and update(..., true) on ordered_json
- smaller gaps: get_allocator(), to_ubjson/to_bjdata into a string,
  value() with an unresolvable JSON pointer, integer/float comparison
  below the integer range and with negative fractions, conversion to a
  custom binary type, std::formatter::parse on a spec without '}',
  unescape() of a lone '~', and the callback parser's start_array()

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

* Cover more paths that were thought unreachable

- parse_float_fast() declining malformed or inexact input, called
  directly since the lexer only passes well-formed numbers to it
- a UTF-16 high surrogate followed by a unit above the low surrogates
- self-assignment of a const_iterator
- a truncated CBOR string read through non-contiguous iterators
- serializing a long double under the de_DE locale, which undoes the
  locale's decimal point and thousands separator
- values read from a binary format carrying no diagnostic positions,
  with and without a parser callback

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

* Fix the CI failures of the new coverage tests

- declare the self-assignment reference const (misc-const-correctness)
- expect the (/path) prefix that JSON_DIAGNOSTICS adds to the messages
  of the failing ordered_json patch operations

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

* Expect the byte range JSON_DIAGNOSTIC_POSITIONS adds to the patch errors

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

* Build the expected dump of the nested-object test with +=

clang-tidy (performance-inefficient-string-concatenation) reported the
chain of operator+ calls that assembled the expected indented output.

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

* Compare the BJData and UBJSON test outputs byte by byte

Building a std::string from the byte vector converts each byte
implicitly, which -fsanitize=integer reports for bytes of 0x80 and
above (ci_test_clang_sanitizer).

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

---------

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

tests/src/unit-class_lexer.cpp

@@ -12,6 +12,7 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
+#include <cfloat> // FLT_EVAL_METHOD
 #include <cstdlib> // strtod
 #include <sstream> // stringstream
 #include <string> // string
@@ -657,3 +658,45 @@ TEST_CASE("lexer string fast path")
         }
     }
 }
+
+TEST_CASE("parse_float_fast declines what it cannot convert exactly")
+{
+    // The lexer only hands well-formed numbers to parse_float_fast, so the
+    // malformed ones below can only be passed to it directly. Declining is
+    // always safe: the caller then falls back to a slower, exact conversion.
+    const auto fast = [](const std::string & s, double & out)
+    {
+        return nlohmann::detail::parse_float_fast(s.data(), s.data() + s.size(), '.', out);
+    };
+    double out = 0;
+
+#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
+    // without true double precision, the fast path declines everything
+    CHECK_FALSE(fast("1.5", out));
+#else
+    CHECK(fast("1.5", out));
+    CHECK(out == 1.5);
+    CHECK(fast("+2.5e1", out));
+    CHECK(out == 25.0);
+    CHECK(fast("-25E-1", out));
+    CHECK(out == -2.5);
+    CHECK(fast("1e", out));
+    CHECK(out == 1.0);
+#endif
+
+    // not a number
+    CHECK_FALSE(fast("", out));
+    CHECK_FALSE(fast("-", out));
+    CHECK_FALSE(fast(".", out));
+    CHECK_FALSE(fast("1.2.3", out));
+    CHECK_FALSE(fast("1x", out));
+    CHECK_FALSE(fast("1e+", out));
+    CHECK_FALSE(fast("1e1x", out));
+
+    // numbers that are not represented exactly on the fast path
+    CHECK_FALSE(fast("12345678901234567890", out));
+    CHECK_FALSE(fast("1e10000", out));
+    CHECK_FALSE(fast("9007199254740993", out));
+    CHECK_FALSE(fast("1e23", out));
+    CHECK_FALSE(fast("1e-23", out));
+}