Fix the issue with float32 and float64 comparison

Author: ccoVeille

assert/assertions.go

@@ -176,40 +176,57 @@ func ObjectsAreEqualValues(expected, actual interface{}) bool {
 	if !expectedType.ConvertibleTo(actualType) {
 		return false
 	}
+	expectedValueCmp := expectedValue.Convert(actualType).Interface()
+	actualValueCmp := actual
 
 	if !isNumericType(expectedType) || !isNumericType(actualType) {
 		// Attempt comparison after type conversion
 		return reflect.DeepEqual(
-			expectedValue.Convert(actualType).Interface(), actual,
+			expectedValueCmp, actualValueCmp,
 		)
 	}
 
-	// If BOTH values are numeric, there are chances of false positives due
-	// to overflow or underflow. So, we need to make sure to always convert
-	// the smaller type to a larger type before comparing.
-	fromType := actualType
-	toType := expectedType
-	fromValue := actualValue
-	toValue := expectedValue
-	if expectedType.Size() < actualType.Size() {
-		fromType = expectedType
-		toType = actualType
-		fromValue = expectedValue
-		toValue = actualValue
-	}
-
-	// If we are converting from float32 to float64, the converted value will
-	// have trailing non zero decimals due to binary representation differences
-	// For example: float64(float32(10.1)) = 10.100000381469727
-	// To remove the trailing decimals we can round the 64-bit value to
-	// expected precision of 32-bit which is 6 decimal places
-	newValue := fromValue.Convert(toType).Interface()
-	if fromType.Kind() == reflect.Float32 && toType.Kind() == reflect.Float64 {
-		scale := math.Pow(10, 6)
-		newValue = math.Round(newValue.(float64)*scale) / scale
-	}
-
-	return newValue == toValue.Interface()
+	if actual != actual || expected != expected {
+		// NaN is not equal to NaN
+		return false
+	}
+
+	// Both are numeric but their types are different, otherwise ObjectsAreEqual would have returned true already.
+	// We need to convert the smaller type to the larger type and then compare.
+
+	smallestTypeValue, largestTypeValue := expectedValue, actualValue
+	if actualType.Size() < expectedType.Size() {
+		smallestTypeValue, largestTypeValue = largestTypeValue, smallestTypeValue
+
+		if !actualType.ConvertibleTo(expectedType) {
+			return false
+		}
+		actualValueCmp = actualValue.Convert(expectedType).Interface()
+		expectedValueCmp = expected
+	}
+
+	if actualValueCmp == expectedValueCmp {
+		// fast path
+		return true
+	}
+
+	if smallestTypeValue.Kind() == reflect.Float32 && largestTypeValue.Kind() == reflect.Float64 {
+		a, b := expected, actual
+		if af, aIsNumber := toFloat(expected); aIsNumber && af == 0 {
+			// avoid division by zero in calcRelativeError
+			a, b = b, a
+		}
+
+		epsilon, err := calcRelativeError(a, b)
+		if err != nil {
+			return false
+		}
+
+		// The threshold of 1e-6 is somewhat arbitrary, but it is a common choice for comparing floating point numbers.
+		return epsilon <= 1e-6
+	}
+
+	return false
 }
 
 // isNumericType returns true if the type is one of:

assert/assertions_test.go

@@ -171,8 +171,7 @@ func TestObjectsAreEqualValues(t *testing.T) {
 		{complex128(1e+10 + 1e+10i), complex64(1e+10 + 1e+10i), true},
 		{complex64(1e+10 + 1e+10i), complex128(1e+10 + 1e+10i), true},
 
-		// cases for float32/float64 comparison, which should not be equal due to precision differences
-		{float32(1.0 / 3.0), float64(1.0 / 3.0), false},
+		{float32(1.0 / 3.0), float64(1.0 / 3.0), true},
 
 		// cases for float32/float64 comparison, which should be equal within float32 precision
 		{float32(10.1), float64(10.1), true},