test: Fix comparing of floating point results in spectest runner

Author: gumb0

test/spectests/spectests.cpp

@@ -58,6 +58,22 @@ fizzy::bytes load_wasm_file(const fs::path& json_file_path, std::string_view fil
         std::istreambuf_iterator<char>{wasm_file}, std::istreambuf_iterator<char>{});
 }
 
+bool float_values_equal(fizzy::Value value1, fizzy::Value value2) noexcept
+{
+    if (std::isnan(value1.as<float>()))
+        return value1.as<uint32_t>() == value2.as<uint32_t>();  // compare binary representations
+    else
+        return value1.as<float>() == value2.as<float>();
+}
+
+bool double_values_equal(fizzy::Value value1, fizzy::Value value2) noexcept
+{
+    if (std::isnan(value1.as<double>()))
+        return value1.i64 == value2.i64;  // compare binary representations
+    else
+        return value1.as<double>() == value2.as<double>();
+}
+
 struct test_settings
 {
     bool skip_validation = false;
@@ -402,15 +418,19 @@ class test_runner
         return it_instance->second.get();
     }
 
-    std::optional<fizzy::Value> read_value(const json& v)
+    std::optional<std::string> read_value_type(const json& v)
     {
-        const auto arg_type = v.at("type").get<std::string>();
-        if (arg_type != "i32" && arg_type != "i64" && arg_type != "f32" && arg_type != "f64")
+        const auto type = v.at("type").get<std::string>();
+        if (type != "i32" && type != "i64" && type != "f32" && type != "f64")
         {
-            skip("Unsupported value type '" + arg_type + "'.");
+            skip("Unsupported value type '" + type + "'.");
             return std::nullopt;
         }
+        return type;
+    }
 
+    static fizzy::Value read_value(const json& v)
+    {
         // Values of all types are serialized to JSON as integers.
         // Value type will handle correct conversions.
         return std::stoull(v.at("value").get<std::string>());
@@ -433,11 +453,10 @@ class test_runner
         std::vector<fizzy::Value> args;
         for (const auto& arg : action.at("args"))
         {
-            const auto arg_value = read_value(arg);
-            if (!arg_value.has_value())
+            if (!read_value_type(arg))
                 return std::nullopt;
 
-            args.push_back(*arg_value);
+            args.push_back(read_value(arg));
         }
 
         try
@@ -453,16 +472,29 @@ class test_runner
 
     bool check_result(fizzy::Value actual_value, const json& expected)
     {
-        const auto expected_value = read_value(expected);
-        if (!expected_value.has_value())
+        const auto value_type = read_value_type(expected);
+        if (!value_type.has_value())
             return false;
 
-        if (*expected_value != actual_value)
+        const auto expected_value = read_value(expected);
+
+        bool is_equal = false;
+        if (value_type == "i32" || value_type == "i64")
+            is_equal = expected_value.i64 == actual_value.i64;
+        else if (value_type == "f32")
+            is_equal = float_values_equal(expected_value, actual_value);
+        else if (value_type == "f64")
+            is_equal = double_values_equal(expected_value, actual_value);
+        else
+            assert(false);
+
+        if (!is_equal)
         {
             std::stringstream message;
-            message << "Incorrect returned value. Expected: " << *expected_value << " (0x"
-                    << std::hex << *expected_value << ") Actual: " << std::dec << actual_value
-                    << " (0x" << std::hex << actual_value << std::dec << ")";
+            message << "Incorrect returned value. Expected: " << expected_value.i64 << " (0x"
+                    << std::hex << expected_value.i64 << ") Actual: " << std::dec
+                    << actual_value.i64 << " (0x" << std::hex << actual_value.i64 << std::dec
+                    << ")";
             fail(message.str());
             return false;
         }