test: Rework Result() matcher

Author: chfast

Diff for: test/utils/asserts.hpp

@@ -30,8 +30,6 @@ MATCHER_P(Result, value, "")  // NOLINT(readability-redundant-string-init)
 {
     using namespace fizzy;
 
-    static_assert(is_any_of<value_type, uint32_t, int32_t, uint64_t, int64_t, float, double>);
-
     // Require the arg to be TypedExecutionResult.
     // This can be a static_assert, but just returning false and failing a test provides better
     // location of the error.
@@ -44,24 +42,37 @@ MATCHER_P(Result, value, "")  // NOLINT(readability-redundant-string-init)
 
     if constexpr (std::is_same_v<result_type, test::TypedExecutionResult>)
     {
-        // Type safe checks.
-        if constexpr (is_any_of<value_type, uint32_t, int32_t>)
+        if constexpr (std::is_same_v<value_type, float>)
         {
-            return arg.type == ValType::i32 && arg.value.i64 == static_cast<uint32_t>(value);
+            return arg.type == ValType::f32 && arg.value.f32 == test::FP{value};
         }
-        else if constexpr (is_any_of<value_type, uint64_t, int64_t>)
+
+        if constexpr (std::is_same_v<value_type, double>)
         {
-            return arg.type == ValType::i64 && arg.value.i64 == static_cast<uint64_t>(value);
+            return arg.type == ValType::f64 && arg.value.f64 == test::FP{value};
         }
-        else if constexpr (std::is_same_v<value_type, float>)
+
+        if constexpr (std::is_integral_v<value_type> && sizeof(value_type) == sizeof(uint64_t))
         {
-            return arg.type == ValType::f32 && arg.value.f32 == test::FP{value};
+            return arg.type == ValType::i64 && arg.value.i64 == static_cast<uint64_t>(value);
         }
-        else
+
+        if constexpr (std::is_integral_v<value_type> && sizeof(value_type) == sizeof(uint32_t))
         {
-            return arg.type == ValType::f64 && arg.value.f64 == test::FP{value};
+            if (arg.type == ValType::i32)
+            {
+                return arg.value.i64 == static_cast<uint32_t>(value);
+            }
+            else if (arg.type == ValType::i64 && value >= 0)
+            {
+                // Here allow convenient zero-extension of the expected value u32 -> u64.
+                return arg.value.i64 == static_cast<uint32_t>(value);
+            }
+            return false;
         }
     }
+
+    return false;
 }
 
 MATCHER(CTraps, "")  // NOLINT(readability-redundant-string-init)