diff --git a/include/nlohmann/detail/input/lexer.hpp b/include/nlohmann/detail/input/lexer.hpp
index 35e4e5d01..0843d749d 100644
--- a/include/nlohmann/detail/input/lexer.hpp
+++ b/include/nlohmann/detail/input/lexer.hpp
@@ -819,21 +819,18 @@ class lexer
     }
 
     JSON_HEDLEY_NON_NULL(2)
-    JSON_HEDLEY_CONST
     static void strtof(float& f, const char* str, char** endptr) noexcept
     {
         f = std::strtof(str, endptr);
     }
 
     JSON_HEDLEY_NON_NULL(2)
-    JSON_HEDLEY_CONST
     static void strtof(double& f, const char* str, char** endptr) noexcept
     {
         f = std::strtod(str, endptr);
     }
 
     JSON_HEDLEY_NON_NULL(2)
-    JSON_HEDLEY_CONST
     static void strtof(long double& f, const char* str, char** endptr) noexcept
     {
         f = std::strtold(str, endptr);
diff --git a/include/nlohmann/detail/output/binary_writer.hpp b/include/nlohmann/detail/output/binary_writer.hpp
index b0ab62d19..306f969be 100644
--- a/include/nlohmann/detail/output/binary_writer.hpp
+++ b/include/nlohmann/detail/output/binary_writer.hpp
@@ -1205,7 +1205,7 @@ class binary_writer
 
             case value_t::number_unsigned:
             {
-                if (j.m_value.number_unsigned <= (std::numeric_limits<std::int8_t>::max)())
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
                 {
                     return 'i';
                 }
@@ -1213,11 +1213,11 @@ class binary_writer
                 {
                     return 'U';
                 }
-                if (j.m_value.number_unsigned <= (std::numeric_limits<std::int16_t>::max)())
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
                 {
                     return 'I';
                 }
-                if (j.m_value.number_unsigned <= (std::numeric_limits<std::int32_t>::max)())
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
                 {
                     return 'l';
                 }
diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp
index 8eab28c2b..6d32ff44c 100644
--- a/single_include/nlohmann/json.hpp
+++ b/single_include/nlohmann/json.hpp
@@ -7842,21 +7842,18 @@ class lexer
     }
 
     JSON_HEDLEY_NON_NULL(2)
-    JSON_HEDLEY_CONST
     static void strtof(float& f, const char* str, char** endptr) noexcept
     {
         f = std::strtof(str, endptr);
     }
 
     JSON_HEDLEY_NON_NULL(2)
-    JSON_HEDLEY_CONST
     static void strtof(double& f, const char* str, char** endptr) noexcept
     {
         f = std::strtod(str, endptr);
     }
 
     JSON_HEDLEY_NON_NULL(2)
-    JSON_HEDLEY_CONST
     static void strtof(long double& f, const char* str, char** endptr) noexcept
     {
         f = std::strtold(str, endptr);
@@ -12316,7 +12313,7 @@ class binary_writer
 
             case value_t::number_unsigned:
             {
-                if (j.m_value.number_unsigned <= (std::numeric_limits<std::int8_t>::max)())
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
                 {
                     return 'i';
                 }
@@ -12324,11 +12321,11 @@ class binary_writer
                 {
                     return 'U';
                 }
-                if (j.m_value.number_unsigned <= (std::numeric_limits<std::int16_t>::max)())
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
                 {
                     return 'I';
                 }
-                if (j.m_value.number_unsigned <= (std::numeric_limits<std::int32_t>::max)())
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
                 {
                     return 'l';
                 }
diff --git a/test/src/unit-bson.cpp b/test/src/unit-bson.cpp
index 2689dcecd..cc4b5a659 100644
--- a/test/src/unit-bson.cpp
+++ b/test/src/unit-bson.cpp
@@ -112,8 +112,9 @@ TEST_CASE("BSON")
             0x00,
             0x00, 0x00, 0x00, 0x80
         };
-        CHECK_THROWS_AS(json::from_bson(v), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_bson(v), "[json.exception.parse_error.112] parse error at byte 10: syntax error while parsing BSON string: string length must be at least 1, is -2147483648");
+        json _;
+        CHECK_THROWS_AS(_ = json::from_bson(v), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_bson(v), "[json.exception.parse_error.112] parse error at byte 10: syntax error while parsing BSON string: string length must be at least 1, is -2147483648");
     }
 
     SECTION("objects")
@@ -692,8 +693,9 @@ TEST_CASE("Incomplete BSON Input")
             'e', 'n', 't'           // unexpected EOF
         };
 
-        CHECK_THROWS_AS(json::from_bson(incomplete_bson), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_bson(incomplete_bson),
+        json _;
+        CHECK_THROWS_AS(_ = json::from_bson(incomplete_bson), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_bson(incomplete_bson),
                           "[json.exception.parse_error.110] parse error at byte 9: syntax error while parsing BSON cstring: unexpected end of input");
 
         CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
@@ -710,8 +712,9 @@ TEST_CASE("Incomplete BSON Input")
             0x08,                   // entry: boolean, unexpected EOF
         };
 
-        CHECK_THROWS_AS(json::from_bson(incomplete_bson), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_bson(incomplete_bson),
+        json _;
+        CHECK_THROWS_AS(_ = json::from_bson(incomplete_bson), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_bson(incomplete_bson),
                           "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing BSON cstring: unexpected end of input");
         CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
 
@@ -733,8 +736,9 @@ TEST_CASE("Incomplete BSON Input")
             // missing input data...
         };
 
-        CHECK_THROWS_AS(json::from_bson(incomplete_bson), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_bson(incomplete_bson),
+        json _;
+        CHECK_THROWS_AS(_ = json::from_bson(incomplete_bson), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_bson(incomplete_bson),
                           "[json.exception.parse_error.110] parse error at byte 28: syntax error while parsing BSON element list: unexpected end of input");
         CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
 
@@ -749,8 +753,9 @@ TEST_CASE("Incomplete BSON Input")
             0x0D, 0x00, // size (incomplete), unexpected EOF
         };
 
-        CHECK_THROWS_AS(json::from_bson(incomplete_bson), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_bson(incomplete_bson),
+        json _;
+        CHECK_THROWS_AS(_ = json::from_bson(incomplete_bson), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_bson(incomplete_bson),
                           "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing BSON number: unexpected end of input");
         CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
 
@@ -791,8 +796,9 @@ TEST_CASE("Unsupported BSON input")
         0x00 // end marker
     };
 
-    CHECK_THROWS_AS(json::from_bson(bson), json::parse_error&);
-    CHECK_THROWS_WITH(json::from_bson(bson),
+    json _;
+    CHECK_THROWS_AS(_ = json::from_bson(bson), json::parse_error&);
+    CHECK_THROWS_WITH(_ = json::from_bson(bson),
                       "[json.exception.parse_error.114] parse error at byte 5: Unsupported BSON record type 0xFF");
     CHECK(json::from_bson(bson, true, false).is_discarded());
 
diff --git a/test/src/unit-cbor.cpp b/test/src/unit-cbor.cpp
index 69368b418..8b4a17078 100644
--- a/test/src/unit-cbor.cpp
+++ b/test/src/unit-cbor.cpp
@@ -836,15 +836,17 @@ TEST_CASE("CBOR")
                 {
                     SECTION("no byte follows")
                     {
-                        CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf9})), json::parse_error&);
-                        CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xf9})),
+                        json _;
+                        CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0xf9})), json::parse_error&);
+                        CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0xf9})),
                                           "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR number: unexpected end of input");
                         CHECK(json::from_cbor(std::vector<uint8_t>({0xf9}), true, false).is_discarded());
                     }
                     SECTION("only one byte follows")
                     {
-                        CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c})), json::parse_error&);
-                        CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c})),
+                        json _;
+                        CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c})), json::parse_error&);
+                        CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c})),
                                           "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR number: unexpected end of input");
                         CHECK(json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c}), true, false).is_discarded());
                     }
@@ -1319,86 +1321,88 @@ TEST_CASE("CBOR")
     {
         SECTION("empty byte vector")
         {
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>()), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>()),
+            json _;
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>()), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>()),
                               "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing CBOR value: unexpected end of input");
             CHECK(json::from_cbor(std::vector<uint8_t>(), true, false).is_discarded());
         }
 
         SECTION("too short byte vector")
         {
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x18})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x19})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x19, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x62})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x62, 0x60})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x7F})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x7F, 0x60})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x82, 0x01})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x9F, 0x01})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0x61, 0xF5})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xA1, 0x61, 0X61})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0X61})), json::parse_error&);
+            json _;
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x18})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x19})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x19, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1a})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1a, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1b})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x62})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x62, 0x60})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x7F})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x7F, 0x60})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x82, 0x01})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x9F, 0x01})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0x61, 0xF5})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0xA1, 0x61, 0X61})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0X61})), json::parse_error&);
 
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x18})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x18})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x19})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x19})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x19, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x19, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1a})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1a})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1a, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1b})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1b})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 7: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 9: syntax error while parsing CBOR number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x62})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x62})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR string: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x62, 0x60})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x62, 0x60})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR string: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x7F})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x7F})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR string: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x7F, 0x60})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x7F, 0x60})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR string: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x82, 0x01})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x82, 0x01})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR value: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x9F, 0x01})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x9F, 0x01})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR value: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0x61, 0xF5})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0x61, 0xF5})),
                               "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing CBOR string: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xA1, 0x61, 0x61})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0xA1, 0x61, 0x61})),
                               "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR value: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0x61})),
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0x61})),
                               "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR value: unexpected end of input");
 
             CHECK(json::from_cbor(std::vector<uint8_t>({0x18}), true, false).is_discarded());
@@ -1431,13 +1435,14 @@ TEST_CASE("CBOR")
         {
             SECTION("concrete examples")
             {
-                CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1c})), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1c})),
+                json _;
+                CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0x1c})), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0x1c})),
                                   "[json.exception.parse_error.112] parse error at byte 1: syntax error while parsing CBOR value: invalid byte: 0x1C");
                 CHECK(json::from_cbor(std::vector<uint8_t>({0x1c}), true, false).is_discarded());
 
-                CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf8})), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xf8})),
+                CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0xf8})), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0xf8})),
                                   "[json.exception.parse_error.112] parse error at byte 1: syntax error while parsing CBOR value: invalid byte: 0xF8");
                 CHECK(json::from_cbor(std::vector<uint8_t>({0xf8}), true, false).is_discarded());
             }
@@ -1488,7 +1493,8 @@ TEST_CASE("CBOR")
                             0xf8
                         })
                 {
-                    CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error&);
+                    json _;
+                    CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error&);
                     CHECK(json::from_cbor(std::vector<uint8_t>({static_cast<uint8_t>(byte)}), true, false).is_discarded());
                 }
             }
@@ -1496,8 +1502,9 @@ TEST_CASE("CBOR")
 
         SECTION("invalid string in map")
         {
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01})), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01})),
+            json _;
+            CHECK_THROWS_AS(_ = json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01})), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01})),
                               "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0xFF");
             CHECK(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01}), true, false).is_discarded());
         }
@@ -1514,8 +1521,9 @@ TEST_CASE("CBOR")
 
             SECTION("strict mode")
             {
-                CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_cbor(vec),
+                json _;
+                CHECK_THROWS_AS(_ = json::from_cbor(vec), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_cbor(vec),
                                   "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR value: expected end of input; last byte: 0xF6");
                 CHECK(json::from_cbor(vec, true, false).is_discarded());
             }
diff --git a/test/src/unit-class_parser.cpp b/test/src/unit-class_parser.cpp
index edbef4991..fa09c5658 100644
--- a/test/src/unit-class_parser.cpp
+++ b/test/src/unit-class_parser.cpp
@@ -406,8 +406,9 @@ TEST_CASE("parser class")
                     // uses an iterator range.
                     std::string s = "\"1\"";
                     s[1] = '\0';
-                    CHECK_THROWS_AS(json::parse(s.begin(), s.end()), json::parse_error&);
-                    CHECK_THROWS_WITH(json::parse(s.begin(), s.end()), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid string: control character U+0000 (NUL) must be escaped to \\u0000; last read: '\"<U+0000>'");
+                    json _;
+                    CHECK_THROWS_AS(_ = json::parse(s.begin(), s.end()), json::parse_error&);
+                    CHECK_THROWS_WITH(_ = json::parse(s.begin(), s.end()), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid string: control character U+0000 (NUL) must be escaped to \\u0000; last read: '\"<U+0000>'");
                 }
             }
 
@@ -1219,19 +1220,21 @@ TEST_CASE("parser class")
             }
         }
 
+        json _;
+
         // missing part of a surrogate pair
-        CHECK_THROWS_AS(json::parse("\"\\uD80C\""), json::parse_error&);
-        CHECK_THROWS_WITH(json::parse("\"\\uD80C\""),
+        CHECK_THROWS_AS(_ = json::parse("\"\\uD80C\""), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::parse("\"\\uD80C\""),
                           "[json.exception.parse_error.101] parse error at line 1, column 8: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD80C\"'");
         // invalid surrogate pair
-        CHECK_THROWS_AS(json::parse("\"\\uD80C\\uD80C\""), json::parse_error&);
-        CHECK_THROWS_AS(json::parse("\"\\uD80C\\u0000\""), json::parse_error&);
-        CHECK_THROWS_AS(json::parse("\"\\uD80C\\uFFFF\""), json::parse_error&);
-        CHECK_THROWS_WITH(json::parse("\"\\uD80C\\uD80C\""),
+        CHECK_THROWS_AS(_ = json::parse("\"\\uD80C\\uD80C\""), json::parse_error&);
+        CHECK_THROWS_AS(_ = json::parse("\"\\uD80C\\u0000\""), json::parse_error&);
+        CHECK_THROWS_AS(_ = json::parse("\"\\uD80C\\uFFFF\""), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::parse("\"\\uD80C\\uD80C\""),
                           "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD80C\\uD80C'");
-        CHECK_THROWS_WITH(json::parse("\"\\uD80C\\u0000\""),
+        CHECK_THROWS_WITH(_ = json::parse("\"\\uD80C\\u0000\""),
                           "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD80C\\u0000'");
-        CHECK_THROWS_WITH(json::parse("\"\\uD80C\\uFFFF\""),
+        CHECK_THROWS_WITH(_ = json::parse("\"\\uD80C\\uFFFF\""),
                           "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD80C\\uFFFF'");
     }
 
@@ -1679,12 +1682,13 @@ TEST_CASE("parser class")
 
             CHECK(json::parse("{\"foo\": true:", cb, false).is_discarded());
 
-            CHECK_THROWS_AS(json::parse("{\"foo\": true:", cb), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse("{\"foo\": true:", cb),
+            json _;
+            CHECK_THROWS_AS(_ = json::parse("{\"foo\": true:", cb), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse("{\"foo\": true:", cb),
                               "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing object - unexpected ':'; expected '}'");
 
-            CHECK_THROWS_AS(json::parse("1.18973e+4932", cb), json::out_of_range&);
-            CHECK_THROWS_WITH(json::parse("1.18973e+4932", cb),
+            CHECK_THROWS_AS(_ = json::parse("1.18973e+4932", cb), json::out_of_range&);
+            CHECK_THROWS_WITH(_ = json::parse("1.18973e+4932", cb),
                               "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'");
         }
 
diff --git a/test/src/unit-constructor1.cpp b/test/src/unit-constructor1.cpp
index f7b6c7757..93528d375 100644
--- a/test/src/unit-constructor1.cpp
+++ b/test/src/unit-constructor1.cpp
@@ -1052,9 +1052,10 @@ TEST_CASE("constructors")
 
             SECTION("object with error")
             {
-                CHECK_THROWS_AS(json::object({ {"one", 1}, {"two", 1u}, {"three", 2.2}, {"four", false}, 13 }),
+                json _;
+                CHECK_THROWS_AS(_ = json::object({ {"one", 1}, {"two", 1u}, {"three", 2.2}, {"four", false}, 13 }),
                 json::type_error&);
-                CHECK_THROWS_WITH(json::object({ {"one", 1}, {"two", 1u}, {"three", 2.2}, {"four", false}, 13 }),
+                CHECK_THROWS_WITH(_ = json::object({ {"one", 1}, {"two", 1u}, {"three", 2.2}, {"four", false}, 13 }),
                 "[json.exception.type_error.301] cannot create object from initializer list");
             }
 
diff --git a/test/src/unit-deserialization.cpp b/test/src/unit-deserialization.cpp
index 10bece66d..f49f1025d 100644
--- a/test/src/unit-deserialization.cpp
+++ b/test/src/unit-deserialization.cpp
@@ -269,8 +269,10 @@ TEST_CASE("deserialization")
             ss3 << "[\"foo\",1,2,3,false,{\"one\":1}";
             ss4 << "[\"foo\",1,2,3,false,{\"one\":1}";
             ss5 << "[\"foo\",1,2,3,false,{\"one\":1}";
-            CHECK_THROWS_AS(json::parse(ss1), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse(ss2),
+
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(ss1), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse(ss2),
                               "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'");
             CHECK(not json::accept(ss3));
 
@@ -293,8 +295,9 @@ TEST_CASE("deserialization")
         SECTION("string")
         {
             json::string_t s = "[\"foo\",1,2,3,false,{\"one\":1}";
-            CHECK_THROWS_AS(json::parse(s), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse(s),
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(s), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse(s),
                               "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'");
             CHECK(not json::accept(s));
 
@@ -430,7 +433,8 @@ TEST_CASE("deserialization")
             SECTION("empty container")
             {
                 std::vector<uint8_t> v;
-                CHECK_THROWS_AS(json::parse(v), json::parse_error&);
+                json _;
+                CHECK_THROWS_AS(_ = json::parse(v), json::parse_error&);
                 CHECK(not json::accept(v));
 
                 SaxEventLogger l;
@@ -614,8 +618,9 @@ TEST_CASE("deserialization")
             SECTION("case 6")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xDF, 0x7F};
-                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK_THROWS_WITH(json::parse(std::begin(v), std::end(v)),
+                json _;
+                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::parse(std::begin(v), std::end(v)),
                                   "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"\x7f\xdf\x7f'");
                 CHECK(not json::accept(std::begin(v), std::end(v)));
 
@@ -801,12 +806,13 @@ TEST_CASE("deserialization")
 
         SECTION("BOM only")
         {
-            CHECK_THROWS_AS(json::parse(bom), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse(bom),
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(bom), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse(bom),
                               "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal");
 
-            CHECK_THROWS_AS(json::parse(std::istringstream(bom)), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse(std::istringstream(bom)),
+            CHECK_THROWS_AS(_ = json::parse(std::istringstream(bom)), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse(std::istringstream(bom)),
                               "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal");
 
             SaxEventLogger l;
@@ -840,12 +846,13 @@ TEST_CASE("deserialization")
 
         SECTION("2 byte of BOM")
         {
-            CHECK_THROWS_AS(json::parse(bom.substr(0, 2)), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse(bom.substr(0, 2)),
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(bom.substr(0, 2)), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse(bom.substr(0, 2)),
                               "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF\xBB'");
 
-            CHECK_THROWS_AS(json::parse(std::istringstream(bom.substr(0, 2))), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse(std::istringstream(bom.substr(0, 2))),
+            CHECK_THROWS_AS(_ = json::parse(std::istringstream(bom.substr(0, 2))), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse(std::istringstream(bom.substr(0, 2))),
                               "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF\xBB'");
 
             SaxEventLogger l1, l2;
@@ -865,12 +872,13 @@ TEST_CASE("deserialization")
 
         SECTION("1 byte of BOM")
         {
-            CHECK_THROWS_AS(json::parse(bom.substr(0, 1)), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse(bom.substr(0, 1)),
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(bom.substr(0, 1)), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse(bom.substr(0, 1)),
                               "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF'");
 
-            CHECK_THROWS_AS(json::parse(std::istringstream(bom.substr(0, 1))), json::parse_error&);
-            CHECK_THROWS_WITH(json::parse(std::istringstream(bom.substr(0, 1))),
+            CHECK_THROWS_AS(_ = json::parse(std::istringstream(bom.substr(0, 1))), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::parse(std::istringstream(bom.substr(0, 1))),
                               "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF'");
 
             SaxEventLogger l1, l2;
@@ -925,8 +933,9 @@ TEST_CASE("deserialization")
                         else
                         {
                             // any variation is an error
-                            CHECK_THROWS_AS(json::parse(s + "null"), json::parse_error&);
-                            CHECK_THROWS_AS(json::parse(std::istringstream(s + "null")), json::parse_error&);
+                            json _;
+                            CHECK_THROWS_AS(_ = json::parse(s + "null"), json::parse_error&);
+                            CHECK_THROWS_AS(_ = json::parse(std::istringstream(s + "null")), json::parse_error&);
 
                             SaxEventLogger l;
                             CHECK(not json::sax_parse(s + "null", &l));
diff --git a/test/src/unit-msgpack.cpp b/test/src/unit-msgpack.cpp
index cc1b8ae31..7a095544f 100644
--- a/test/src/unit-msgpack.cpp
+++ b/test/src/unit-msgpack.cpp
@@ -1128,71 +1128,73 @@ TEST_CASE("MessagePack")
     {
         SECTION("empty byte vector")
         {
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>()), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>()),
+            json _;
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>()), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>()),
                               "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing MessagePack value: unexpected end of input");
             CHECK(json::from_msgpack(std::vector<uint8_t>(), true, false).is_discarded());
         }
 
         SECTION("too short byte vector")
         {
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0x87})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcc})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcd})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcd, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xa5, 0x68, 0x65})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0x92, 0x01})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0x81, 0xa1, 0x61})), json::parse_error&);
+            json _;
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0x87})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcc})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcd})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcd, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xce})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xce, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcf})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xa5, 0x68, 0x65})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0x92, 0x01})), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0x81, 0xa1, 0x61})), json::parse_error&);
 
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0x87})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0x87})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing MessagePack string: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcc})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcc})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcd})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcd})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcd, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcd, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xce})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xce})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xce, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcf})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcf})),
                               "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 7: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})),
                               "[json.exception.parse_error.110] parse error at byte 9: syntax error while parsing MessagePack number: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xa5, 0x68, 0x65})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xa5, 0x68, 0x65})),
                               "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing MessagePack string: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0x92, 0x01})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0x92, 0x01})),
                               "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing MessagePack value: unexpected end of input");
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0x81, 0xa1, 0x61})),
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0x81, 0xa1, 0x61})),
                               "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing MessagePack value: unexpected end of input");
 
             CHECK(json::from_msgpack(std::vector<uint8_t>({0x87}), true, false).is_discarded());
@@ -1220,13 +1222,14 @@ TEST_CASE("MessagePack")
         {
             SECTION("concrete examples")
             {
-                CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xc1})), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xc1})),
+                json _;
+                CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xc1})), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xc1})),
                                   "[json.exception.parse_error.112] parse error at byte 1: syntax error while parsing MessagePack value: invalid byte: 0xC1");
                 CHECK(json::from_msgpack(std::vector<uint8_t>({0xc6}), true, false).is_discarded());
 
-                CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xc6})), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xc6})),
+                CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xc6})), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0xc6})),
                                   "[json.exception.parse_error.112] parse error at byte 1: syntax error while parsing MessagePack value: invalid byte: 0xC6");
                 CHECK(json::from_msgpack(std::vector<uint8_t>({0xc6}), true, false).is_discarded());
             }
@@ -1245,7 +1248,8 @@ TEST_CASE("MessagePack")
                             0xd4, 0xd5, 0xd6, 0xd7, 0xd8
                         })
                 {
-                    CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error&);
+                    json _;
+                    CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error&);
                     CHECK(json::from_msgpack(std::vector<uint8_t>({static_cast<uint8_t>(byte)}), true, false).is_discarded());
                 }
             }
@@ -1253,8 +1257,9 @@ TEST_CASE("MessagePack")
 
         SECTION("invalid string in map")
         {
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01})), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01})),
+            json _;
+            CHECK_THROWS_AS(_ = json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01})), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01})),
                               "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing MessagePack string: expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0xFF");
             CHECK(json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01}), true, false).is_discarded());
         }
@@ -1270,8 +1275,9 @@ TEST_CASE("MessagePack")
 
             SECTION("strict mode")
             {
-                CHECK_THROWS_AS(json::from_msgpack(vec), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_msgpack(vec),
+                json _;
+                CHECK_THROWS_AS(_ = json::from_msgpack(vec), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_msgpack(vec),
                                   "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing MessagePack value: expected end of input; last byte: 0xC0");
                 CHECK(json::from_msgpack(vec, true, false).is_discarded());
             }
diff --git a/test/src/unit-regression.cpp b/test/src/unit-regression.cpp
index 88b12114d..2bac06b8e 100644
--- a/test/src/unit-regression.cpp
+++ b/test/src/unit-regression.cpp
@@ -696,8 +696,9 @@ TEST_CASE("regression tests")
 
     SECTION("issue #329 - serialized value not always can be parsed")
     {
-        CHECK_THROWS_AS(json::parse("22e2222"), json::out_of_range&);
-        CHECK_THROWS_WITH(json::parse("22e2222"),
+        json _;
+        CHECK_THROWS_AS(_ = json::parse("22e2222"), json::out_of_range&);
+        CHECK_THROWS_WITH(_ = json::parse("22e2222"),
                           "[json.exception.out_of_range.406] number overflow parsing '22e2222'");
     }
 
@@ -762,8 +763,9 @@ TEST_CASE("regression tests")
     SECTION("issue #366 - json::parse on failed stream gets stuck")
     {
         std::ifstream f("file_not_found.json");
-        CHECK_THROWS_AS(json::parse(f), json::parse_error&);
-        CHECK_THROWS_WITH(json::parse(f), "[json.exception.parse_error.101] parse error at line 1, column 1: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal");
+        json _;
+        CHECK_THROWS_AS(_ = json::parse(f), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::parse(f), "[json.exception.parse_error.101] parse error at line 1, column 1: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal");
     }
 
     SECTION("issue #367 - calling stream at EOF")
@@ -958,50 +960,55 @@ TEST_CASE("regression tests")
     {
         // original test case
         std::vector<uint8_t> vec {0x65, 0xf5, 0x0a, 0x48, 0x21};
-        CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec),
+        json _;
+        CHECK_THROWS_AS(_ = json::from_cbor(vec), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec),
                           "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing CBOR string: unexpected end of input");
     }
 
     SECTION("issue #407 - Heap-buffer-overflow (OSS-Fuzz issue 343)")
     {
+        json _;
+
         // original test case: incomplete float64
         std::vector<uint8_t> vec1 {0xcb, 0x8f, 0x0a};
-        CHECK_THROWS_AS(json::from_msgpack(vec1), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_msgpack(vec1),
+        CHECK_THROWS_AS(_ = json::from_msgpack(vec1), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_msgpack(vec1),
                           "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing MessagePack number: unexpected end of input");
 
         // related test case: incomplete float32
         std::vector<uint8_t> vec2 {0xca, 0x8f, 0x0a};
-        CHECK_THROWS_AS(json::from_msgpack(vec2), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_msgpack(vec2),
+        CHECK_THROWS_AS(_ = json::from_msgpack(vec2), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_msgpack(vec2),
                           "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing MessagePack number: unexpected end of input");
 
         // related test case: incomplete Half-Precision Float (CBOR)
         std::vector<uint8_t> vec3 {0xf9, 0x8f};
-        CHECK_THROWS_AS(json::from_cbor(vec3), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec3),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec3), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec3),
                           "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR number: unexpected end of input");
 
         // related test case: incomplete Single-Precision Float (CBOR)
         std::vector<uint8_t> vec4 {0xfa, 0x8f, 0x0a};
-        CHECK_THROWS_AS(json::from_cbor(vec4), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec4),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec4), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec4),
                           "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR number: unexpected end of input");
 
         // related test case: incomplete Double-Precision Float (CBOR)
         std::vector<uint8_t> vec5 {0xfb, 0x8f, 0x0a};
-        CHECK_THROWS_AS(json::from_cbor(vec5), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec5),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec5), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec5),
                           "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR number: unexpected end of input");
     }
 
     SECTION("issue #408 - Heap-buffer-overflow (OSS-Fuzz issue 344)")
     {
+        json _;
+
         // original test case
         std::vector<uint8_t> vec1 {0x87};
-        CHECK_THROWS_AS(json::from_msgpack(vec1), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_msgpack(vec1),
+        CHECK_THROWS_AS(_ = json::from_msgpack(vec1), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_msgpack(vec1),
                           "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing MessagePack string: unexpected end of input");
 
         // more test cases for MessagePack
@@ -1014,7 +1021,7 @@ TEST_CASE("regression tests")
                 })
         {
             std::vector<uint8_t> vec(1, static_cast<uint8_t>(b));
-            CHECK_THROWS_AS(json::from_msgpack(vec), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_msgpack(vec), json::parse_error&);
         }
 
         // more test cases for CBOR
@@ -1029,37 +1036,39 @@ TEST_CASE("regression tests")
                 })
         {
             std::vector<uint8_t> vec(1, static_cast<uint8_t>(b));
-            CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error&);
+            CHECK_THROWS_AS(_ = json::from_cbor(vec), json::parse_error&);
         }
 
         // special case: empty input
         std::vector<uint8_t> vec2;
-        CHECK_THROWS_AS(json::from_cbor(vec2), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec2),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec2), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec2),
                           "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing CBOR value: unexpected end of input");
-        CHECK_THROWS_AS(json::from_msgpack(vec2), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_msgpack(vec2),
+        CHECK_THROWS_AS(_ = json::from_msgpack(vec2), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_msgpack(vec2),
                           "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing MessagePack value: unexpected end of input");
     }
 
     SECTION("issue #411 - Heap-buffer-overflow (OSS-Fuzz issue 366)")
     {
+        json _;
+
         // original test case: empty UTF-8 string (indefinite length)
         std::vector<uint8_t> vec1 {0x7f};
-        CHECK_THROWS_AS(json::from_cbor(vec1), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec1),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec1), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec1),
                           "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR string: unexpected end of input");
 
         // related test case: empty array (indefinite length)
         std::vector<uint8_t> vec2 {0x9f};
-        CHECK_THROWS_AS(json::from_cbor(vec2), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec2),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec2), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec2),
                           "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR value: unexpected end of input");
 
         // related test case: empty map (indefinite length)
         std::vector<uint8_t> vec3 {0xbf};
-        CHECK_THROWS_AS(json::from_cbor(vec3), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec3),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec3), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec3),
                           "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR string: unexpected end of input");
     }
 
@@ -1086,26 +1095,28 @@ TEST_CASE("regression tests")
             0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60,
             0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60
         };
-        CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec),
+
+        json _;
+        CHECK_THROWS_AS(_ = json::from_cbor(vec), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec),
                           "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x98");
 
         // related test case: nonempty UTF-8 string (indefinite length)
         std::vector<uint8_t> vec1 {0x7f, 0x61, 0x61};
-        CHECK_THROWS_AS(json::from_cbor(vec1), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec1),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec1), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec1),
                           "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing CBOR string: unexpected end of input");
 
         // related test case: nonempty array (indefinite length)
         std::vector<uint8_t> vec2 {0x9f, 0x01};
-        CHECK_THROWS_AS(json::from_cbor(vec2), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec2),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec2), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec2),
                           "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR value: unexpected end of input");
 
         // related test case: nonempty map (indefinite length)
         std::vector<uint8_t> vec3 {0xbf, 0x61, 0x61, 0x01};
-        CHECK_THROWS_AS(json::from_cbor(vec3), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec3),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec3), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec3),
                           "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing CBOR string: unexpected end of input");
     }
 
@@ -1139,8 +1150,10 @@ TEST_CASE("regression tests")
             0x96, 0x96, 0xb4, 0xb4, 0xfa, 0x94, 0x94, 0x61,
             0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0xfa
         };
-        CHECK_THROWS_AS(json::from_cbor(vec1), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec1),
+
+        json _;
+        CHECK_THROWS_AS(_ = json::from_cbor(vec1), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec1),
                           "[json.exception.parse_error.113] parse error at byte 13: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0xB4");
 
         // related test case: double-precision
@@ -1153,15 +1166,16 @@ TEST_CASE("regression tests")
             0x96, 0x96, 0xb4, 0xb4, 0xfa, 0x94, 0x94, 0x61,
             0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0xfb
         };
-        CHECK_THROWS_AS(json::from_cbor(vec2), json::parse_error&);
-        CHECK_THROWS_WITH(json::from_cbor(vec2),
+        CHECK_THROWS_AS(_ = json::from_cbor(vec2), json::parse_error&);
+        CHECK_THROWS_WITH(_ = json::from_cbor(vec2),
                           "[json.exception.parse_error.113] parse error at byte 13: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0xB4");
     }
 
     SECTION("issue #452 - Heap-buffer-overflow (OSS-Fuzz issue 585)")
     {
         std::vector<uint8_t> vec = {'-', '0', '1', '2', '2', '7', '4'};
-        CHECK_THROWS_AS(json::parse(vec), json::parse_error&);
+        json _;
+        CHECK_THROWS_AS(_ = json::parse(vec), json::parse_error&);
     }
 
     SECTION("issue #454 - doubles are printed as integers")
@@ -1309,8 +1323,9 @@ TEST_CASE("regression tests")
 
     SECTION("issue #575 - heap-buffer-overflow (OSS-Fuzz 1400)")
     {
+        json _;
         std::vector<uint8_t> vec = {'"', '\\', '"', 'X', '"', '"'};
-        CHECK_THROWS_AS(json::parse(vec), json::parse_error&);
+        CHECK_THROWS_AS(_ = json::parse(vec), json::parse_error&);
     }
 
     SECTION("issue #600 - how does one convert a map in Json back to std::map?")
@@ -1349,7 +1364,8 @@ TEST_CASE("regression tests")
     SECTION("issue #602 - BOM not skipped when using json:parse(iterator)")
     {
         std::string i = "\xef\xbb\xbf{\n   \"foo\": true\n}";
-        CHECK_NOTHROW(json::parse(i.begin(), i.end()));
+        json _;
+        CHECK_NOTHROW(_ = json::parse(i.begin(), i.end()));
     }
 
     SECTION("issue #702 - conversion from valarray<double> to json fails to build")
@@ -1412,7 +1428,8 @@ TEST_CASE("regression tests")
             ); // handle different exceptions as 'file not found', 'permission denied'
 
             is.open("test/data/regression/working_file.json");
-            CHECK_NOTHROW(nlohmann::json::parse(is));
+            json _;
+            CHECK_NOTHROW(_ = nlohmann::json::parse(is));
         }
 
         {
@@ -1425,7 +1442,8 @@ TEST_CASE("regression tests")
 
             is.open("test/data/json_nlohmann_tests/all_unicode.json.cbor",
                     std::ios_base::in | std::ios_base::binary);
-            CHECK_NOTHROW(nlohmann::json::from_cbor(is));
+            json _;
+            CHECK_NOTHROW(_ = nlohmann::json::from_cbor(is));
         }
     }
 
@@ -1505,13 +1523,14 @@ TEST_CASE("regression tests")
 
     SECTION("issue #962 - Timeout (OSS-Fuzz 6034)")
     {
+        json _;
         std::vector<uint8_t> v_ubjson = {'[', '$', 'Z', '#', 'L', 0x78, 0x28, 0x00, 0x68, 0x28, 0x69, 0x69, 0x17};
-        CHECK_THROWS_AS(json::from_ubjson(v_ubjson), json::out_of_range&);
+        CHECK_THROWS_AS(_ = json::from_ubjson(v_ubjson), json::out_of_range&);
         //CHECK_THROWS_WITH(json::from_ubjson(v_ubjson),
         //                  "[json.exception.out_of_range.408] excessive array size: 8658170730974374167");
 
         v_ubjson[0] = '{';
-        CHECK_THROWS_AS(json::from_ubjson(v_ubjson), json::out_of_range&);
+        CHECK_THROWS_AS(_ = json::from_ubjson(v_ubjson), json::out_of_range&);
         //CHECK_THROWS_WITH(json::from_ubjson(v_ubjson),
         //                  "[json.exception.out_of_range.408] excessive object size: 8658170730974374167");
     }
diff --git a/test/src/unit-testsuites.cpp b/test/src/unit-testsuites.cpp
index 6496be105..e65fb88e3 100644
--- a/test/src/unit-testsuites.cpp
+++ b/test/src/unit-testsuites.cpp
@@ -79,7 +79,8 @@ TEST_CASE("compliance tests from json.org")
         {
             CAPTURE(filename)
             std::ifstream f(filename);
-            CHECK_THROWS_AS(json::parse(f), json::parse_error&);
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(f), json::parse_error&);
         }
     }
 
@@ -387,36 +388,36 @@ TEST_CASE("json.org examples")
     SECTION("FILE 1.json")
     {
         std::unique_ptr<std::FILE, decltype(&std::fclose)> f(std::fopen("test/data/json.org/1.json", "r"), &std::fclose);
-        json j;
-        CHECK_NOTHROW(j.parse(f.get()));
+        json _;
+        CHECK_NOTHROW(_ = json::parse(f.get()));
     }
 
     SECTION("FILE 2.json")
     {
         std::unique_ptr<std::FILE, decltype(&std::fclose)> f(std::fopen("test/data/json.org/2.json", "r"), &std::fclose);
-        json j;
-        CHECK_NOTHROW(j.parse(f.get()));
+        json _;
+        CHECK_NOTHROW(_ = json::parse(f.get()));
     }
 
     SECTION("FILE 3.json")
     {
         std::unique_ptr<std::FILE, decltype(&std::fclose)> f(std::fopen("test/data/json.org/3.json", "r"), &std::fclose);
-        json j;
-        CHECK_NOTHROW(j.parse(f.get()));
+        json _;
+        CHECK_NOTHROW(_ = json::parse(f.get()));
     }
 
     SECTION("FILE 4.json")
     {
         std::unique_ptr<std::FILE, decltype(&std::fclose)> f(std::fopen("test/data/json.org/4.json", "r"), &std::fclose);
-        json j;
-        CHECK_NOTHROW(j.parse(f.get()));
+        json _;
+        CHECK_NOTHROW(_ = json::parse(f.get()));
     }
 
     SECTION("FILE 5.json")
     {
         std::unique_ptr<std::FILE, decltype(&std::fclose)> f(std::fopen("test/data/json.org/5.json", "r"), &std::fclose);
-        json j;
-        CHECK_NOTHROW(j.parse(f.get()));
+        json _;
+        CHECK_NOTHROW(_ = json::parse(f.get()));
     }
 }
 
@@ -810,7 +811,8 @@ TEST_CASE("nst's JSONTestSuite")
             {
                 CAPTURE(filename)
                 std::ifstream f(filename);
-                CHECK_THROWS_AS(json::parse(f), json::parse_error&);
+                json _;
+                CHECK_THROWS_AS(_ = json::parse(f), json::parse_error&);
             }
         }
 
@@ -1027,7 +1029,8 @@ TEST_CASE("nst's JSONTestSuite (2)")
             {
                 CAPTURE(filename)
                 std::ifstream f(filename);
-                CHECK_NOTHROW(json::parse(f));
+                json _;
+                CHECK_NOTHROW(_ = json::parse(f));
                 std::ifstream f2(filename);
                 CHECK(json::accept(f2));
             }
@@ -1228,7 +1231,8 @@ TEST_CASE("nst's JSONTestSuite (2)")
             {
                 CAPTURE(filename)
                 std::ifstream f(filename);
-                CHECK_THROWS_AS(json::parse(f), json::parse_error&);
+                json _;
+                CHECK_THROWS_AS(_ = json::parse(f), json::parse_error&);
                 std::ifstream f2(filename);
                 CHECK(not json::accept(f2));
             }
@@ -1293,7 +1297,8 @@ TEST_CASE("nst's JSONTestSuite (2)")
             {
                 CAPTURE(filename)
                 std::ifstream f(filename);
-                CHECK_NOTHROW(json::parse(f));
+                json _;
+                CHECK_NOTHROW(_ = json::parse(f));
                 std::ifstream f2(filename);
                 CHECK(json::accept(f2));
             }
@@ -1343,7 +1348,8 @@ TEST_CASE("nst's JSONTestSuite (2)")
             {
                 CAPTURE(filename)
                 std::ifstream f(filename);
-                CHECK_THROWS_AS(json::parse(f), json::exception&); // could be parse_error or out_of_range
+                json _;
+                CHECK_THROWS_AS(_ = json::parse(f), json::exception&); // could be parse_error or out_of_range
                 std::ifstream f2(filename);
                 CHECK(not json::accept(f2));
             }
diff --git a/test/src/unit-ubjson.cpp b/test/src/unit-ubjson.cpp
index ca6b70fdc..46539dd63 100644
--- a/test/src/unit-ubjson.cpp
+++ b/test/src/unit-ubjson.cpp
@@ -1301,8 +1301,9 @@ TEST_CASE("UBJSON")
 
             SECTION("strict mode")
             {
-                CHECK_THROWS_AS(json::from_ubjson(vec), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_ubjson(vec),
+                json _;
+                CHECK_THROWS_AS(_ = json::from_ubjson(vec), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_ubjson(vec),
                                   "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON value: expected end of input; last byte: 0x5A");
             }
         }
@@ -1311,8 +1312,9 @@ TEST_CASE("UBJSON")
         {
             // larger than max int64
             json j = 9223372036854775808llu;
-            CHECK_THROWS_AS(json::to_ubjson(j), json::out_of_range&);
-            CHECK_THROWS_WITH(json::to_ubjson(j), "[json.exception.out_of_range.407] integer number 9223372036854775808 cannot be represented by UBJSON as it does not fit int64");
+            json _;
+            CHECK_THROWS_AS(_ = json::to_ubjson(j), json::out_of_range&);
+            CHECK_THROWS_WITH(_ = json::to_ubjson(j), "[json.exception.out_of_range.407] integer number 9223372036854775808 cannot be represented by UBJSON as it does not fit int64");
         }
 
         SECTION("excessive size")
@@ -1320,27 +1322,29 @@ TEST_CASE("UBJSON")
             SECTION("array")
             {
                 std::vector<uint8_t> v_ubjson = {'[', '$', 'Z', '#', 'L', 0x78, 0x28, 0x00, 0x68, 0x28, 0x69, 0x69, 0x17};
-                CHECK_THROWS_AS(json::from_ubjson(v_ubjson), json::out_of_range&);
+                json _;
+                CHECK_THROWS_AS(_ = json::from_ubjson(v_ubjson), json::out_of_range&);
 
                 json j;
                 nlohmann::detail::json_sax_dom_callback_parser<json> scp(j, [](int, json::parse_event_t, const json&)
                 {
                     return true;
                 });
-                CHECK_THROWS_AS(json::sax_parse(v_ubjson, &scp, json::input_format_t::ubjson), json::out_of_range&);
+                CHECK_THROWS_AS(_ = json::sax_parse(v_ubjson, &scp, json::input_format_t::ubjson), json::out_of_range&);
             }
 
             SECTION("object")
             {
                 std::vector<uint8_t> v_ubjson = {'{', '$', 'Z', '#', 'L', 0x78, 0x28, 0x00, 0x68, 0x28, 0x69, 0x69, 0x17};
-                CHECK_THROWS_AS(json::from_ubjson(v_ubjson), json::out_of_range&);
+                json _;
+                CHECK_THROWS_AS(_ = json::from_ubjson(v_ubjson), json::out_of_range&);
 
                 json j;
                 nlohmann::detail::json_sax_dom_callback_parser<json> scp(j, [](int, json::parse_event_t, const json&)
                 {
                     return true;
                 });
-                CHECK_THROWS_AS(json::sax_parse(v_ubjson, &scp, json::input_format_t::ubjson), json::out_of_range&);
+                CHECK_THROWS_AS(_ = json::sax_parse(v_ubjson, &scp, json::input_format_t::ubjson), json::out_of_range&);
             }
         }
     }
@@ -1531,8 +1535,9 @@ TEST_CASE("UBJSON")
     {
         SECTION("empty byte vector")
         {
-            CHECK_THROWS_AS(json::from_ubjson(std::vector<uint8_t>()), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(std::vector<uint8_t>()),
+            json _;
+            CHECK_THROWS_AS(_ = json::from_ubjson(std::vector<uint8_t>()), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(std::vector<uint8_t>()),
                               "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing UBJSON value: unexpected end of input");
         }
 
@@ -1541,15 +1546,17 @@ TEST_CASE("UBJSON")
             SECTION("eof after C byte")
             {
                 std::vector<uint8_t> v = {'C'};
-                CHECK_THROWS_AS(json::from_ubjson(v), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON char: unexpected end of input");
+                json _;
+                CHECK_THROWS_AS(_ = json::from_ubjson(v), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON char: unexpected end of input");
             }
 
             SECTION("byte out of range")
             {
                 std::vector<uint8_t> v = {'C', 130};
-                CHECK_THROWS_AS(json::from_ubjson(v), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_ubjson(v), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON char: byte after 'C' must be in range 0x00..0x7F; last byte: 0x82");
+                json _;
+                CHECK_THROWS_AS(_ = json::from_ubjson(v), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_ubjson(v), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON char: byte after 'C' must be in range 0x00..0x7F; last byte: 0x82");
             }
         }
 
@@ -1558,15 +1565,17 @@ TEST_CASE("UBJSON")
             SECTION("eof after S byte")
             {
                 std::vector<uint8_t> v = {'S'};
-                CHECK_THROWS_AS(json::from_ubjson(v), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON value: unexpected end of input");
+                json _;
+                CHECK_THROWS_AS(_ = json::from_ubjson(v), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON value: unexpected end of input");
             }
 
             SECTION("invalid byte")
             {
                 std::vector<uint8_t> v = {'S', '1', 'a'};
-                CHECK_THROWS_AS(json::from_ubjson(v), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_ubjson(v), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON string: expected length type specification (U, i, I, l, L); last byte: 0x31");
+                json _;
+                CHECK_THROWS_AS(_ = json::from_ubjson(v), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_ubjson(v), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON string: expected length type specification (U, i, I, l, L); last byte: 0x31");
             }
         }
 
@@ -1575,138 +1584,144 @@ TEST_CASE("UBJSON")
             SECTION("optimized array: no size following type")
             {
                 std::vector<uint8_t> v = {'[', '$', 'i', 2};
-                CHECK_THROWS_AS(json::from_ubjson(v), json::parse_error&);
-                CHECK_THROWS_WITH(json::from_ubjson(v), "[json.exception.parse_error.112] parse error at byte 4: syntax error while parsing UBJSON size: expected '#' after type information; last byte: 0x02");
+                json _;
+                CHECK_THROWS_AS(_ = json::from_ubjson(v), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::from_ubjson(v), "[json.exception.parse_error.112] parse error at byte 4: syntax error while parsing UBJSON size: expected '#' after type information; last byte: 0x02");
             }
         }
 
         SECTION("strings")
         {
             std::vector<uint8_t> vS = {'S'};
-            CHECK_THROWS_AS(json::from_ubjson(vS), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vS), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON value: unexpected end of input");
+            json _;
+            CHECK_THROWS_AS(_ = json::from_ubjson(vS), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vS), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(vS, true, false).is_discarded());
 
             std::vector<uint8_t> v = {'S', 'i', '2', 'a'};
-            CHECK_THROWS_AS(json::from_ubjson(v), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing UBJSON string: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(v), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing UBJSON string: unexpected end of input");
             CHECK(json::from_ubjson(v, true, false).is_discarded());
 
             std::vector<uint8_t> vC = {'C'};
-            CHECK_THROWS_AS(json::from_ubjson(vC), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vC), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON char: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vC), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vC), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON char: unexpected end of input");
             CHECK(json::from_ubjson(vC, true, false).is_discarded());
         }
 
         SECTION("sizes")
         {
             std::vector<uint8_t> vU = {'[', '#', 'U'};
-            CHECK_THROWS_AS(json::from_ubjson(vU), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vU), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
+            json _;
+            CHECK_THROWS_AS(_ = json::from_ubjson(vU), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vU), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
             CHECK(json::from_ubjson(vU, true, false).is_discarded());
 
             std::vector<uint8_t> vi = {'[', '#', 'i'};
-            CHECK_THROWS_AS(json::from_ubjson(vi), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vi), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vi), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vi), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
             CHECK(json::from_ubjson(vi, true, false).is_discarded());
 
             std::vector<uint8_t> vI = {'[', '#', 'I'};
-            CHECK_THROWS_AS(json::from_ubjson(vI), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vI), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vI), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vI), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
             CHECK(json::from_ubjson(vI, true, false).is_discarded());
 
             std::vector<uint8_t> vl = {'[', '#', 'l'};
-            CHECK_THROWS_AS(json::from_ubjson(vl), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vl), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vl), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vl), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
             CHECK(json::from_ubjson(vl, true, false).is_discarded());
 
             std::vector<uint8_t> vL = {'[', '#', 'L'};
-            CHECK_THROWS_AS(json::from_ubjson(vL), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vL), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vL), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vL), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON number: unexpected end of input");
             CHECK(json::from_ubjson(vL, true, false).is_discarded());
 
             std::vector<uint8_t> v0 = {'[', '#', 'T', ']'};
-            CHECK_THROWS_AS(json::from_ubjson(v0), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(v0), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing UBJSON size: expected length type specification (U, i, I, l, L) after '#'; last byte: 0x54");
+            CHECK_THROWS_AS(_ = json::from_ubjson(v0), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(v0), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing UBJSON size: expected length type specification (U, i, I, l, L) after '#'; last byte: 0x54");
             CHECK(json::from_ubjson(v0, true, false).is_discarded());
         }
 
         SECTION("types")
         {
             std::vector<uint8_t> v0 = {'[', '$'};
-            CHECK_THROWS_AS(json::from_ubjson(v0), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(v0), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing UBJSON type: unexpected end of input");
+            json _;
+            CHECK_THROWS_AS(_ = json::from_ubjson(v0), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(v0), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing UBJSON type: unexpected end of input");
             CHECK(json::from_ubjson(v0, true, false).is_discarded());
 
             std::vector<uint8_t> vi = {'[', '$', '#'};
-            CHECK_THROWS_AS(json::from_ubjson(vi), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vi), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON value: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vi), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vi), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(vi, true, false).is_discarded());
 
             std::vector<uint8_t> vT = {'[', '$', 'T'};
-            CHECK_THROWS_AS(json::from_ubjson(vT), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vT), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON value: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vT), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vT), "[json.exception.parse_error.110] parse error at byte 4: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(vT, true, false).is_discarded());
         }
 
         SECTION("arrays")
         {
             std::vector<uint8_t> vST = {'[', '$', 'i', '#', 'i', 2, 1};
-            CHECK_THROWS_AS(json::from_ubjson(vST), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vST), "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing UBJSON number: unexpected end of input");
+            json _;
+            CHECK_THROWS_AS(_ = json::from_ubjson(vST), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vST), "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing UBJSON number: unexpected end of input");
             CHECK(json::from_ubjson(vST, true, false).is_discarded());
 
             std::vector<uint8_t> vS = {'[', '#', 'i', 2, 'i', 1};
-            CHECK_THROWS_AS(json::from_ubjson(vS), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vS), "[json.exception.parse_error.110] parse error at byte 7: syntax error while parsing UBJSON value: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vS), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vS), "[json.exception.parse_error.110] parse error at byte 7: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(vS, true, false).is_discarded());
 
             std::vector<uint8_t> v = {'[', 'i', 2, 'i', 1};
-            CHECK_THROWS_AS(json::from_ubjson(v), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing UBJSON value: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(v), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(v, true, false).is_discarded());
         }
 
         SECTION("objects")
         {
             std::vector<uint8_t> vST = {'{', '$', 'i', '#', 'i', 2, 'i', 1, 'a', 1};
-            CHECK_THROWS_AS(json::from_ubjson(vST), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vST), "[json.exception.parse_error.110] parse error at byte 11: syntax error while parsing UBJSON value: unexpected end of input");
+            json _;
+            CHECK_THROWS_AS(_ = json::from_ubjson(vST), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vST), "[json.exception.parse_error.110] parse error at byte 11: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(vST, true, false).is_discarded());
 
             std::vector<uint8_t> vT = {'{', '$', 'i', 'i', 1, 'a', 1};
-            CHECK_THROWS_AS(json::from_ubjson(vT), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vT), "[json.exception.parse_error.112] parse error at byte 4: syntax error while parsing UBJSON size: expected '#' after type information; last byte: 0x69");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vT), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vT), "[json.exception.parse_error.112] parse error at byte 4: syntax error while parsing UBJSON size: expected '#' after type information; last byte: 0x69");
             CHECK(json::from_ubjson(vT, true, false).is_discarded());
 
             std::vector<uint8_t> vS = {'{', '#', 'i', 2, 'i', 1, 'a', 'i', 1};
-            CHECK_THROWS_AS(json::from_ubjson(vS), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vS), "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing UBJSON value: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vS), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vS), "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(vS, true, false).is_discarded());
 
             std::vector<uint8_t> v = {'{', 'i', 1, 'a', 'i', 1};
-            CHECK_THROWS_AS(json::from_ubjson(v), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 7: syntax error while parsing UBJSON value: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(v), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(v), "[json.exception.parse_error.110] parse error at byte 7: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(v, true, false).is_discarded());
 
             std::vector<uint8_t> v2 = {'{', 'i', 1, 'a', 'i', 1, 'i'};
-            CHECK_THROWS_AS(json::from_ubjson(v2), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(v2), "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing UBJSON number: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(v2), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(v2), "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing UBJSON number: unexpected end of input");
             CHECK(json::from_ubjson(v2, true, false).is_discarded());
 
             std::vector<uint8_t> v3 = {'{', 'i', 1, 'a'};
-            CHECK_THROWS_AS(json::from_ubjson(v3), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(v3), "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing UBJSON value: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(v3), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(v3), "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(v3, true, false).is_discarded());
 
             std::vector<uint8_t> vST1 = {'{', '$', 'd', '#', 'i', 2, 'i', 1, 'a'};
-            CHECK_THROWS_AS(json::from_ubjson(vST1), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vST1), "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing UBJSON number: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vST1), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vST1), "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing UBJSON number: unexpected end of input");
             CHECK(json::from_ubjson(vST1, true, false).is_discarded());
 
             std::vector<uint8_t> vST2 = {'{', '#', 'i', 2, 'i', 1, 'a'};
-            CHECK_THROWS_AS(json::from_ubjson(vST2), json::parse_error&);
-            CHECK_THROWS_WITH(json::from_ubjson(vST2), "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing UBJSON value: unexpected end of input");
+            CHECK_THROWS_AS(_ = json::from_ubjson(vST2), json::parse_error&);
+            CHECK_THROWS_WITH(_ = json::from_ubjson(vST2), "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing UBJSON value: unexpected end of input");
             CHECK(json::from_ubjson(vST2, true, false).is_discarded());
         }
     }
diff --git a/test/src/unit-unicode.cpp b/test/src/unit-unicode.cpp
index e69639f49..0f499c703 100644
--- a/test/src/unit-unicode.cpp
+++ b/test/src/unit-unicode.cpp
@@ -158,13 +158,14 @@ void check_utf8string(bool success_expected, int byte1, int byte2 = -1, int byte
 
     CAPTURE(json_string)
 
+    json _;
     if (success_expected)
     {
-        CHECK_NOTHROW(json::parse(json_string));
+        CHECK_NOTHROW(_ = json::parse(json_string));
     }
     else
     {
-        CHECK_THROWS_AS(json::parse(json_string), json::parse_error&);
+        CHECK_THROWS_AS(_ = json::parse(json_string), json::parse_error&);
     }
 }
 }
@@ -1051,7 +1052,8 @@ TEST_CASE("Unicode" * doctest::skip())
 
                 json_text += "\"";
                 CAPTURE(json_text)
-                CHECK_NOTHROW(json::parse(json_text));
+                json _;
+                CHECK_NOTHROW(_ = json::parse(json_text));
             }
         }
 
@@ -1059,32 +1061,34 @@ TEST_CASE("Unicode" * doctest::skip())
         {
             SECTION("incorrect surrogate values")
             {
-                CHECK_THROWS_AS(json::parse("\"\\uDC00\\uDC00\""), json::parse_error&);
-                CHECK_THROWS_WITH(json::parse("\"\\uDC00\\uDC00\""),
+                json _;
+
+                CHECK_THROWS_AS(_ = json::parse("\"\\uDC00\\uDC00\""), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::parse("\"\\uDC00\\uDC00\""),
                                   "[json.exception.parse_error.101] parse error at line 1, column 7: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF; last read: '\"\\uDC00'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD7FF\\uDC00\""), json::parse_error&);
-                CHECK_THROWS_WITH(json::parse("\"\\uD7FF\\uDC00\""),
+                CHECK_THROWS_AS(_ = json::parse("\"\\uD7FF\\uDC00\""), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::parse("\"\\uD7FF\\uDC00\""),
                                   "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF; last read: '\"\\uD7FF\\uDC00'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800]\""), json::parse_error&);
-                CHECK_THROWS_WITH(json::parse("\"\\uD800]\""),
+                CHECK_THROWS_AS(_ = json::parse("\"\\uD800]\""), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::parse("\"\\uD800]\""),
                                   "[json.exception.parse_error.101] parse error at line 1, column 8: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800]'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800\\v\""), json::parse_error&);
-                CHECK_THROWS_WITH(json::parse("\"\\uD800\\v\""),
+                CHECK_THROWS_AS(_ = json::parse("\"\\uD800\\v\""), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::parse("\"\\uD800\\v\""),
                                   "[json.exception.parse_error.101] parse error at line 1, column 9: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800\\v'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800\\u123\""), json::parse_error&);
-                CHECK_THROWS_WITH(json::parse("\"\\uD800\\u123\""),
+                CHECK_THROWS_AS(_ = json::parse("\"\\uD800\\u123\""), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::parse("\"\\uD800\\u123\""),
                                   "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\uD800\\u123\"'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800\\uDBFF\""), json::parse_error&);
-                CHECK_THROWS_WITH(json::parse("\"\\uD800\\uDBFF\""),
+                CHECK_THROWS_AS(_ = json::parse("\"\\uD800\\uDBFF\""), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::parse("\"\\uD800\\uDBFF\""),
                                   "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800\\uDBFF'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800\\uE000\""), json::parse_error&);
-                CHECK_THROWS_WITH(json::parse("\"\\uD800\\uE000\""),
+                CHECK_THROWS_AS(_ = json::parse("\"\\uD800\\uE000\""), json::parse_error&);
+                CHECK_THROWS_WITH(_ = json::parse("\"\\uD800\\uE000\""),
                                   "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800\\uE000'");
             }
         }
@@ -1203,8 +1207,9 @@ TEST_CASE("Unicode" * doctest::skip())
 
     SECTION("error for incomplete/wrong BOM")
     {
-        CHECK_THROWS_AS(json::parse("\xef\xbb"), json::parse_error&);
-        CHECK_THROWS_AS(json::parse("\xef\xbb\xbb"), json::parse_error&);
+        json _;
+        CHECK_THROWS_AS(_ = json::parse("\xef\xbb"), json::parse_error&);
+        CHECK_THROWS_AS(_ = json::parse("\xef\xbb\xbb"), json::parse_error&);
     }
 }
 
@@ -1215,6 +1220,7 @@ void roundtrip(bool success_expected, const std::string& s);
 void roundtrip(bool success_expected, const std::string& s)
 {
     CAPTURE(s)
+    json _;
 
     // create JSON string value
     json j = s;
@@ -1230,11 +1236,11 @@ void roundtrip(bool success_expected, const std::string& s)
         if (s[0] != '\0')
         {
             // parsing JSON text succeeds
-            CHECK_NOTHROW(json::parse(ps));
+            CHECK_NOTHROW(_ = json::parse(ps));
         }
 
         // roundtrip succeeds
-        CHECK_NOTHROW(json::parse(j.dump()));
+        CHECK_NOTHROW(_ = json::parse(j.dump()));
 
         // after roundtrip, the same string is stored
         json jr = json::parse(j.dump());
@@ -1246,7 +1252,7 @@ void roundtrip(bool success_expected, const std::string& s)
         CHECK_THROWS_AS(j.dump(), json::type_error&);
 
         // parsing JSON text fails
-        CHECK_THROWS_AS(json::parse(ps), json::parse_error&);
+        CHECK_THROWS_AS(_ = json::parse(ps), json::parse_error&);
     }
 }
 }
diff --git a/test/src/unit-wstring.cpp b/test/src/unit-wstring.cpp
index 85aa04db2..598265338 100644
--- a/test/src/unit-wstring.cpp
+++ b/test/src/unit-wstring.cpp
@@ -70,7 +70,8 @@ TEST_CASE("wide strings")
         if (wstring_is_utf16())
         {
             std::wstring w = L"\"\xDBFF";
-            CHECK_THROWS_AS(json::parse(w), json::parse_error&);
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(w), json::parse_error&);
         }
     }
 
@@ -89,7 +90,8 @@ TEST_CASE("wide strings")
         if (wstring_is_utf16())
         {
             std::u16string w = u"\"\xDBFF";
-            CHECK_THROWS_AS(json::parse(w), json::parse_error&);
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(w), json::parse_error&);
         }
     }
 
@@ -108,7 +110,8 @@ TEST_CASE("wide strings")
         if (u32string_is_utf32())
         {
             std::u32string w = U"\"\x110000";
-            CHECK_THROWS_AS(json::parse(w), json::parse_error&);
+            json _;
+            CHECK_THROWS_AS(_ = json::parse(w), json::parse_error&);
         }
     }
 }