feat: add floating number comparison function

Signed-off-by: ghosind <ghosind@gmail.com>

Author: ghosind

builtin.go

@@ -390,6 +390,54 @@ func NotEqualNow(t *testing.T, actual, expect any, message ...any) error {
 	return tryNotEqual(t, true, actual, expect, message...)
 }
 
+// FloatEqual tests the equality between actual and expect floating numbers with epsilon. It'll
+// set the result to fail if they are not equal, and it doesn't stop the execution.
+//
+//	FloatEqual(t, 1.0, 1.0, 0.1) // success
+//	FloatEqual(t, 1.0, 1.01, 0.1) // success
+//	FloatEqual(t, 1.0, 1.2, 0.1) // fail
+func FloatEqual(t *testing.T, actual, expect, epsilon any, message ...any) error {
+	t.Helper()
+
+	return tryFloatEqual(t, false, actual, expect, epsilon, message...)
+}
+
+// FloatEqualNow tests the equality between actual and expect floating numbers with epsilon, and
+// it'll stop the execution if they are not equal.
+//
+//	FloatEqualNow(t, 1.0, 1.0, 0.1) // success
+//	FloatEqualNow(t, 1.0, 1.01, 0.1) // success
+//	FloatEqualNow(t, 1.0, 1.2, 0.1) // fail and terminate
+func FloatEqualNow(t *testing.T, actual, expect, epsilon any, message ...any) error {
+	t.Helper()
+
+	return tryFloatEqual(t, true, actual, expect, epsilon, message...)
+}
+
+// FloatNotEqual tests the inequality between actual and expect floating numbers with epsilon. It'll
+// set the result to fail if they are equal, but it doesn't stop the execution.
+//
+//	FloatNotEqual(t, 1.0, 1.2, 0.1) // success
+//	FloatNotEqual(t, 1.0, 1.1, 0.1) // success
+//	FloatNotEqual(t, 1.0, 1.0, 0.1) // fail
+func FloatNotEqual(t *testing.T, actual, expect, epsilon any, message ...any) error {
+	t.Helper()
+
+	return tryFloatNotEqual(t, false, actual, expect, epsilon, message...)
+}
+
+// FloatNotEqualNow tests the inequality between actual and expect floating numbers with epsilon,
+// and it'll stop the execution if they are equal.
+//
+//	FloatNotEqualNow(t, 1.0, 1.2, 0.1) // success
+//	FloatNotEqualNow(t, 1.0, 1.1, 0.1) // success
+//	FloatNotEqualNow(t, 1.0, 1.0, 0.1) // fail and terminate
+func FloatNotEqualNow(t *testing.T, actual, expect, epsilon any, message ...any) error {
+	t.Helper()
+
+	return tryFloatNotEqual(t, true, actual, expect, epsilon, message...)
+}
+
 // HasPrefixString tests whether the string has the prefix string or not, and it set the result to
 // fail if the string does not have the prefix string.
 //

compare.go

@@ -178,6 +178,86 @@ func tryNotEqual(t *testing.T, failedNow bool, actual, expect any, message ...an
 	)
 }
 
+// FloatEqual tests the equality between actual and expect floating numbers with epsilon. It'll
+// set the result to fail if they are not equal, and it doesn't stop the execution.
+//
+//	a := assert.New(t)
+//	a.FloatEqual(1.0, 1.0, 0.1) // success
+//	a.FloatEqual(1.0, 1.01, 0.1) // success
+//	a.FloatEqual(1.0, 1.2, 0.1) // fail
+func (a *Assertion) FloatEqual(actual, expect, epsilon any, message ...any) error {
+	a.Helper()
+
+	return tryFloatEqual(a.T, false, actual, expect, epsilon, message...)
+}
+
+// FloatEqualNow tests the equality between actual and expect floating numbers with epsilon, and
+// it'll stop the execution if they are not equal.
+//
+//	a := assert.New(t)
+//	a.FloatEqualNow(1.0, 1.0, 0.1) // success
+//	a.FloatEqualNow(1.0, 1.01, 0.1) // success
+//	a.FloatEqualNow(1.0, 1.2, 0.1) // fail and terminate
+func (a *Assertion) FloatEqualNow(actual, expect, epsilon any, message ...any) error {
+	a.Helper()
+
+	return tryFloatEqual(a.T, true, actual, expect, epsilon, message...)
+}
+
+// FloatNotEqual tests the inequality between actual and expect floating numbers with epsilon. It'll
+// set the result to fail if they are equal, but it doesn't stop the execution.
+//
+//	a := assert.New(t)
+//	a.FloatNotEqual(1.0, 1.2, 0.1) // success
+//	a.FloatNotEqual(1.0, 1.1, 0.1) // success
+//	a.FloatNotEqual(1.0, 1.0, 0.1) // fail
+func (a *Assertion) FloatNotEqual(actual, expect, epsilon any, message ...any) error {
+	a.Helper()
+
+	return tryFloatNotEqual(a.T, false, actual, expect, epsilon, message...)
+}
+
+// FloatNotEqualNow tests the inequality between actual and expect floating numbers with epsilon,
+// and it'll stop the execution if they are equal.
+//
+//	a := assert.New(t)
+//	a.FloatNotEqualNow(1.0, 1.2, 0.1) // success
+//	a.FloatNotEqualNow(1.0, 1.1, 0.1) // success
+//	a.FloatNotEqualNow(1.0, 1.0, 0.1) // fail and terminate
+func (a *Assertion) FloatNotEqualNow(actual, expect, epsilon any, message ...any) error {
+	a.Helper()
+
+	return tryFloatNotEqual(a.T, true, actual, expect, epsilon, message...)
+}
+
+// tryFloatEqual try to testing the equality between actual and expect floating numbers, and it'll
+// fail if the values are not equal.
+func tryFloatEqual(t *testing.T, failedNow bool, actual, expect, epsilon any, message ...any) error {
+	t.Helper()
+
+	return test(
+		t,
+		func() bool { return isFloatEqual(actual, expect, epsilon) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageEqual, actual, expect),
+		message...,
+	)
+}
+
+// tryFloatNotEqual try to testing the inequality between actual and expect floating numbers, and
+// it'll fail if the values are equal.
+func tryFloatNotEqual(t *testing.T, failedNow bool, actual, expect, epsilon any, message ...any) error {
+	t.Helper()
+
+	return test(
+		t,
+		func() bool { return !isFloatEqual(actual, expect, epsilon) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageEqual, actual, expect),
+		message...,
+	)
+}
+
 // Nil tests whether a value is nil or not, and it'll fail when the value is not nil. It will
 // always return false if the value is a bool, an integer, a floating number, a complex, or a
 // string.
@@ -413,6 +493,24 @@ func isEqual(x, y any) bool {
 	}
 }
 
+// isFloatEqual checks the equality of two floating numbers with epsilon.
+func isFloatEqual(x, y, epsilon any) bool {
+	xv := toFloat(x)
+	yv := toFloat(y)
+	ev := toFloat(epsilon)
+
+	if xv == yv {
+		return true
+	}
+
+	diff := xv - yv
+	if diff < 0 {
+		diff = -diff
+	}
+
+	return diff < ev
+}
+
 // isNil checks whether a value is nil or not. It'll always return false if the value is not a
 // channel, a function, a map, a point, an unsafe point, an interface, or a slice.
 func isNil(val any) bool {

compare_test.go

@@ -135,6 +135,55 @@ func testEqualAndNotEqual(a, mockA *Assertion, v1, v2 any, isEqual bool) {
 	}, isEqual)
 }
 
+func TestFloatEqualAndFloatNotEqual(t *testing.T) {
+	a := New(t)
+	mockA := New(new(testing.T))
+
+	testFloatEqualAndFloatNotEqual(a, mockA, 1, 1, 1e-7, true)
+	testFloatEqualAndFloatNotEqual(a, mockA, 1, 1.1, 1e-7, false)
+	testFloatEqualAndFloatNotEqual(a, mockA, 1, 2, 1e-7, false)
+	testFloatEqualAndFloatNotEqual(a, mockA, 0.999999999999, 1, 1e-7, true)
+	testFloatEqualAndFloatNotEqual(a, mockA, 1.00000000001, 1, 1e-7, true)
+	testFloatEqualAndFloatNotEqual(a, mockA, 1.00001, 1, 1e-7, false)
+	testFloatEqualAndFloatNotEqual(a, mockA, 0.9999, 1, 1e-7, false)
+}
+
+func testFloatEqualAndFloatNotEqual(a, mockA *Assertion, v1, v2, epsilon any, isEqual bool) {
+	// a.T.Helper()
+
+	// FloatEqual
+	testAssertionFunction(a, "FloatEqual", func() error {
+		return FloatEqual(mockA.T, v1, v2, epsilon)
+	}, isEqual)
+	testAssertionFunction(a, "Assertion.FloatEqual", func() error {
+		return mockA.FloatEqual(v1, v2, epsilon)
+	}, isEqual)
+
+	// FloatNotEqual
+	testAssertionFunction(a, "FloatNotEqual", func() error {
+		return FloatNotEqual(mockA.T, v1, v2, epsilon)
+	}, !isEqual)
+	testAssertionFunction(a, "Assertion.FloatNotEqual", func() error {
+		return mockA.FloatNotEqual(v1, v2, epsilon)
+	}, !isEqual)
+
+	// FloatEqualNow
+	testAssertionNowFunction(a, "FloatEqualNow", func() {
+		FloatEqualNow(mockA.T, v1, v2, epsilon)
+	}, !isEqual)
+	testAssertionNowFunction(a, "Assertion.FloatEqualNow", func() {
+		mockA.FloatEqualNow(v1, v2, epsilon)
+	}, !isEqual)
+
+	// FloatNotEqualNow
+	testAssertionNowFunction(a, "FloatNotEqualNow", func() {
+		FloatNotEqualNow(mockA.T, v1, v2, epsilon)
+	}, isEqual)
+	testAssertionNowFunction(a, "Assertion.FloatNotEqualNow", func() {
+		mockA.FloatNotEqualNow(v1, v2, epsilon)
+	}, isEqual)
+}
+
 func TestNilAndNotNil(t *testing.T) {
 	a := New(t)
 	mockA := New(new(testing.T))

error.go

@@ -41,6 +41,8 @@ const (
 var (
 	// ErrNotArray indicates that the value must be a slice or an array.
 	ErrNotArray error = errors.New("the value must be a slice or an array")
+	// ErrNotFloat indicates that the value must be a floating number.
+	ErrNotFloat error = errors.New("the value must be a floating number")
 	// ErrNotMap indicates that the value must be a map.
 	ErrNotMap error = errors.New("the value must be a map")
 	// ErrNotOrderable indicates that the value must be orderable.

util.go

@@ -5,6 +5,10 @@ import (
 	"testing"
 )
 
+var (
+	floatType = reflect.TypeOf(float64(0))
+)
+
 // test tries to run the test function, and creates an assertion error if the result is fail.
 func test(
 	t *testing.T,
@@ -69,3 +73,17 @@ func isSameType(t1, t2 reflect.Type) bool {
 		return t1 == t2
 	}
 }
+
+// toFloat converts the value to a float64, and it'll panic if the value can't be converted.
+func toFloat(v any) float64 {
+	vv := reflect.ValueOf(v)
+	if vv.CanFloat() {
+		return vv.Float()
+	}
+
+	if vv.CanConvert(floatType) {
+		return vv.Convert(floatType).Float()
+	}
+
+	panic(ErrNotFloat)
+}

util_test.go

@@ -21,3 +21,17 @@ func TestFailedHandler(t *testing.T) {
 	})
 	assert.True(isTerminated)
 }
+
+func TestToFloat(t *testing.T) {
+	a := New(t)
+
+	a.NotPanicNow(func() {
+		a.Equal(toFloat(1), 1.0)
+	})
+	a.NotPanicNow(func() {
+		a.Equal(toFloat(1.0), 1.0)
+	})
+	a.PanicNow(func() {
+		toFloat("1.0")
+	})
+}