Fix develop CI: GCC 4.8, Clang 3.4 and clang-tidy errors (#6100)

* Fix develop CI: GCC 4.8, Clang 3.4 and clang-tidy errors

- unit-json_patch.cpp: move multi-line raw strings out of CHECK(), which
  GCC 4.8 cannot parse inside a macro argument
- unit-recursion_depth_limit.cpp: value-initialize the const std::hash
  (Clang 3.4 rejects default initialization of a const object)
- json_view: silence modernize-use-transparent-functors (std::less<> is
  C++14), bugprone-suspicious-stringview-data-usage (the length comes from
  the node) and the deliberate use-after-clear() / owning-memory hits in
  unit-json_view_builder.cpp; use a raw string literal there

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

* Fix clang-tidy errors in the std::u8string tests

Test the lvalue path with the const original instead of a mutable copy
and the rvalue path with a temporary (misc-const-correctness), and mark
the intentional char8_t array with NOLINT (avoid-c-arrays).

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

---------

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

tests/src/unit-conversions2.cpp

@@ -761,9 +761,8 @@ TEST_CASE("std::u8string")
         CHECK(json(with_nul).template get<std::u8string>() == with_nul);
 
         // the lvalue and rvalue paths, and in containers
-        std::u8string lvalue = utf8;
-        CHECK(json(lvalue).template get<std::u8string>() == utf8);
-        CHECK(json(std::move(lvalue)).template get<std::u8string>() == utf8);
+        CHECK(json(utf8).template get<std::u8string>() == utf8);
+        CHECK(json(std::u8string(utf8)).template get<std::u8string>() == utf8);
         const std::vector<std::u8string> vec = {utf8, u8"x"};
         json const j_vec = vec;
         CHECK(j_vec.is_array());
@@ -812,7 +811,7 @@ TEST_CASE("std::u8string")
         CHECK(j_view.is_array());
         CHECK(j_view.size() == 8);
 
-        const char8_t arr[] = u8"ab";
+        const char8_t arr[] = u8"ab"; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
         json const j_arr = arr;
         CHECK(j_arr == json::array({0x61, 0x62, 0}));
     }

tests/src/unit-json_patch.cpp

@@ -2682,25 +2682,27 @@ TEST_CASE("JSON patch - consecutive operations with paths that share a prefix")
         const json doc = json::parse(R"({"a": [{"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 7}}})");
 
         // an element inserted before the elements of an array moves them
-        CHECK(doc.patch(json::parse(R"([
+        const json inserted = json::parse(R"([
             {"op": "test", "path": "/a/0/b/2", "value": 3},
             {"op": "add", "path": "/a/0", "value": {"b": [9]}},
             {"op": "test", "path": "/a/1/b/2", "value": 3},
             {"op": "test", "path": "/a/0/b/0", "value": 9},
             {"op": "test", "path": "/a/2/b/0", "value": 4}
-        ])")) == json::parse(R"({"a": [{"b": [9]}, {"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 7}}})"));
+        ])");
+        CHECK(doc.patch(inserted) == json::parse(R"({"a": [{"b": [9]}, {"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 7}}})"));
 
         // an element removed from the front
-        CHECK(doc.patch(json::parse(R"([
+        const json removed_front = json::parse(R"([
             {"op": "test", "path": "/a/1/b/2", "value": 6},
             {"op": "remove", "path": "/a/0"},
             {"op": "test", "path": "/a/0/b/2", "value": 6},
             {"op": "replace", "path": "/a/0/b/2", "value": 60},
             {"op": "test", "path": "/a/0/b/2", "value": 60}
-        ])")) == json::parse(R"({"a": [{"b": [4, 5, 60]}], "c": {"d": {"e": 7}}})"));
+        ])");
+        CHECK(doc.patch(removed_front) == json::parse(R"({"a": [{"b": [4, 5, 60]}], "c": {"d": {"e": 7}}})"));
 
         // a value replaced above the path that was resolved before
-        CHECK(doc.patch(json::parse(R"([
+        const json replaced_above = json::parse(R"([
             {"op": "test", "path": "/c/d/e", "value": 7},
             {"op": "replace", "path": "/c/d", "value": {"e": 8, "f": {"g": 9}}},
             {"op": "test", "path": "/c/d/e", "value": 8},
@@ -2708,7 +2710,8 @@ TEST_CASE("JSON patch - consecutive operations with paths that share a prefix")
             {"op": "remove", "path": "/c/d/f"},
             {"op": "add", "path": "/c/d/f", "value": [1]},
             {"op": "test", "path": "/c/d/f/0", "value": 1}
-        ])")) == json::parse(R"({"a": [{"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 8, "f": [1]}}})"));
+        ])");
+        CHECK(doc.patch(replaced_above) == json::parse(R"({"a": [{"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 8, "f": [1]}}})"));
 
 #if !defined(JSON_NOEXCEPTION)
         // a value removed above the path that was resolved before is gone

tests/src/unit-json_view_builder.cpp

@@ -916,14 +916,15 @@ TEST_CASE("json_view document_data::holds() (the debug check of read())")
 
     SECTION("owned text")
     {
-        d->owned = "{\"a\":\"some text that does not fit a short string\"}";
+        d->owned = R"({"a":"some text that does not fit a short string"})";
         const char* const b = d->owned.data();
         CHECK(d->holds(b, 1));
         CHECK(d->holds(b + 5, 3));
         CHECK(d->holds(b + d->owned.size() - 1, 1));
         // also after clear(), which keeps the buffer that the next parse writes
         d->owned.clear();
-        CHECK(d->holds(b, 4));
+        // (b is only compared with the buffer, never read)
+        CHECK(d->holds(b, 4)); // NOLINT(clang-analyzer-cplusplus.InnerPointer)
         CHECK(!d->holds(other.data(), other.size()));
         CHECK(!d->holds(b, 0));
     }
@@ -946,7 +947,7 @@ TEST_CASE("json_view document_data::holds() (the debug check of read())")
     {
         d->edits.reset(new document_data::edit_state()); // NOLINT(cppcoreguidelines-owning-memory)
         CHECK(!d->holds(other.data(), other.size()));
-        d->edits->texts.emplace_back(new char[16]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        d->edits->texts.emplace_back(new char[16]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-owning-memory)
         d->edits->text_cap = 16;
         CHECK(d->holds(d->edits->texts.back().get() + 3, 3));
         CHECK(!d->holds(other.data(), other.size()));

tests/src/unit-recursion_depth_limit.cpp

@@ -494,7 +494,7 @@ TEST_CASE("walks over values nested around the recursion depth limit")
         for_each_value([](const std::string & kinds)
         {
             const json a = build(kinds, 1);
-            const std::hash<json> hash;
+            const std::hash<json> hash{};
             CHECK(hash(a) == hash(json(a)));
             CHECK(hash(a) == hash(json::parse(expected_compact(kinds, "1"))));
             CHECK(hash(a) != hash(build(kinds, 2)));