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