feat: add Equal and NotEqual.

Author: ghosind

builtin.go

@@ -36,6 +36,38 @@ func NotDeepEqualNow(t *testing.T, actual, expect any, message ...string) error
 	return tryNotDeepEqual(t, true, actual, expect, message...)
 }
 
+// Equal tests the equality between actual and expect parameters. It'll set the result to fail if
+// they are not equal, and it doesn't stop the execution.
+func Equal(t *testing.T, actual, expect any, message ...string) error {
+	t.Helper()
+
+	return tryEqual(t, false, actual, expect, message...)
+}
+
+// EqualNow tests the equality between actual and expect parameters, and it'll stop the execution
+// if they are not equal.
+func EqualNow(t *testing.T, actual, expect any, message ...string) error {
+	t.Helper()
+
+	return tryEqual(t, true, actual, expect, message...)
+}
+
+// NotEqual tests the inequality between actual and expected parameters. It'll set the result to
+// fail if they are equal, but it doesn't stop the execution.
+func NotEqual(t *testing.T, actual, expect any, message ...string) error {
+	t.Helper()
+
+	return tryNotEqual(t, false, actual, expect, message...)
+}
+
+// NotEqualNow tests the inequality between actual and expected parameters, and it'll stop the
+// execution if they are equal.
+func NotEqualNow(t *testing.T, actual, expect any, message ...string) error {
+	t.Helper()
+
+	return tryNotEqual(t, true, 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.

equal.go

@@ -68,6 +68,68 @@ func tryNotDeepEqual(t *testing.T, failedNow bool, actual, expect any, message .
 	return err
 }
 
+// Equal tests the equality between actual and expect parameters. It'll set the result to fail if
+// they are not equal, and it doesn't stop the execution.
+func (a *Assertion) Equal(actual, expect any, message ...string) error {
+	a.Helper()
+
+	return tryEqual(a.T, false, actual, expect, message...)
+}
+
+// EqualNow tests the equality between actual and expect parameters, and it'll stop the execution
+// if they are not equal.
+func (a *Assertion) EqualNow(actual, expect any, message ...string) error {
+	a.Helper()
+
+	return tryEqual(a.T, true, actual, expect, message...)
+}
+
+// NotEqual tests the inequality between actual and expected parameters. It'll set the result to
+// fail if they are equal, but it doesn't stop the execution.
+func (a *Assertion) NotEqual(actual, expect any, message ...string) error {
+	a.Helper()
+
+	return tryNotEqual(a.T, false, actual, expect, message...)
+}
+
+// NotEqualNow tests the inequality between actual and expected parameters, and it'll stop the
+// execution if they are equal.
+func (a *Assertion) NotEqualNow(actual, expect any, message ...string) error {
+	a.Helper()
+
+	return tryNotEqual(a.T, true, actual, expect, message...)
+}
+
+// tryEqual try to testing the equality between actual and expect values, and it'll fail if the
+// values are not equal.
+func tryEqual(t *testing.T, failedNow bool, actual, expect any, message ...string) error {
+	t.Helper()
+
+	if isEqual(actual, expect) {
+		return nil
+	}
+
+	err := newAssertionError(fmt.Sprintf("%v == %v", actual, expect), message...)
+	failed(t, err, failedNow)
+
+	return err
+}
+
+// tryNotEqual try to testing the inequality between actual and expect values, and it'll fail if
+// the values are equal.
+func tryNotEqual(t *testing.T, failedNow bool, actual, expect any, message ...string) error {
+	t.Helper()
+
+	if !isEqual(actual, expect) {
+		return nil
+	}
+
+	err := newAssertionError(fmt.Sprintf("%v != %v", actual, expect), message...)
+	failed(t, err, failedNow)
+
+	return err
+}
+
 // 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.

equal_test.go

@@ -47,32 +47,32 @@ func testDeepEqualAndNotDeepEqual(t *testing.T, assertion *Assertion, v1, v2 any
 func testDeepEqual(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
 	err := assertion.DeepEqual(v1, v2)
 	if isEqual && err != nil {
-		t.Errorf("Equal(%v, %v) = %v, want = nil", v1, v2, err)
+		t.Errorf("DeepEqual(%v, %v) = %v, want = nil", v1, v2, err)
 	} else if !isEqual && err == nil {
-		t.Errorf("Equal(%v, %v) = nil, want = error", v1, v2)
+		t.Errorf("DeepEqual(%v, %v) = nil, want = error", v1, v2)
 	}
 
 	err = DeepEqual(assertion.T, v1, v2)
 	if isEqual && err != nil {
-		t.Errorf("Equal(%v, %v) = %v, want = nil", v1, v2, err)
+		t.Errorf("DeepEqual(%v, %v) = %v, want = nil", v1, v2, err)
 	} else if !isEqual && err == nil {
-		t.Errorf("Equal(%v, %v) = nil, want = error", v1, v2)
+		t.Errorf("DeepEqual(%v, %v) = nil, want = error", v1, v2)
 	}
 }
 
 func testNotDeepEqual(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
 	err := assertion.NotDeepEqual(v1, v2)
 	if isEqual && err == nil {
-		t.Errorf("NotEqual(%v, %v) = nil, want = error", v1, v2)
+		t.Errorf("NotDeepEqual(%v, %v) = nil, want = error", v1, v2)
 	} else if !isEqual && err != nil {
-		t.Errorf("NotEqual(%v, %v) = %v, want = nil", v1, v2, err)
+		t.Errorf("NotDeepEqual(%v, %v) = %v, want = nil", v1, v2, err)
 	}
 
 	err = NotDeepEqual(assertion.T, v1, v2)
 	if isEqual && err == nil {
-		t.Errorf("NotEqual(%v, %v) = nil, want = error", v1, v2)
+		t.Errorf("NotDeepEqual(%v, %v) = nil, want = error", v1, v2)
 	} else if !isEqual && err != nil {
-		t.Errorf("NotEqual(%v, %v) = %v, want = nil", v1, v2, err)
+		t.Errorf("NotDeepEqual(%v, %v) = %v, want = nil", v1, v2, err)
 	}
 }
 
@@ -116,6 +116,112 @@ func testNotDeepEqualNow(t *testing.T, assertion *Assertion, v1, v2 any, isEqual
 	}
 }
 
+func TestEqualAndNotEqual(t *testing.T) {
+	mockT := new(testing.T)
+	assertion := New(mockT)
+
+	testEqualAndNotEqual(t, assertion, 1, 1, true)
+	testEqualAndNotEqual(t, assertion, 1, 2, false)
+	testEqualAndNotEqual(t, assertion, 1, int64(1), true)
+	testEqualAndNotEqual(t, assertion, 1, 1.0, false)
+	testEqualAndNotEqual(t, assertion, 1, "1", false)
+	testEqualAndNotEqual(t, assertion, 1, '1', false)
+	testEqualAndNotEqual(t, assertion, 1, []int{1}, false)
+	testEqualAndNotEqual(t, assertion, []int{1}, []int{1}, true)
+
+	obj1 := testStruct{v: 1}
+	obj2 := testStruct{v: 1}
+
+	testEqualAndNotEqual(t, assertion, obj1, obj2, true)
+	testEqualAndNotEqual(t, assertion, obj1, &obj2, false)
+	testEqualAndNotEqual(t, assertion, &obj1, &obj2, false)
+
+	obj2.v = 2
+	testEqualAndNotEqual(t, assertion, obj1, obj2, false)
+}
+
+func testEqualAndNotEqual(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	testEqual(t, assertion, v1, v2, isEqual)
+
+	testNotEqual(t, assertion, v1, v2, isEqual)
+
+	testEqualNow(t, assertion, v1, v2, isEqual)
+
+	testNotEqualNow(t, assertion, v1, v2, isEqual)
+}
+
+func testEqual(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	err := assertion.Equal(v1, v2)
+	if isEqual && err != nil {
+		t.Errorf("Equal(%v, %v) = %v, want = nil", v1, v2, err)
+	} else if !isEqual && err == nil {
+		t.Errorf("Equal(%v, %v) = nil, want = error", v1, v2)
+	}
+
+	err = Equal(assertion.T, v1, v2)
+	if isEqual && err != nil {
+		t.Errorf("Equal(%v, %v) = %v, want = nil", v1, v2, err)
+	} else if !isEqual && err == nil {
+		t.Errorf("Equal(%v, %v) = nil, want = error", v1, v2)
+	}
+}
+
+func testNotEqual(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	err := assertion.NotEqual(v1, v2)
+	if isEqual && err == nil {
+		t.Errorf("NotEqual(%v, %v) = nil, want = error", v1, v2)
+	} else if !isEqual && err != nil {
+		t.Errorf("NotEqual(%v, %v) = %v, want = nil", v1, v2, err)
+	}
+
+	err = NotEqual(assertion.T, v1, v2)
+	if isEqual && err == nil {
+		t.Errorf("NotEqual(%v, %v) = nil, want = error", v1, v2)
+	} else if !isEqual && err != nil {
+		t.Errorf("NotEqual(%v, %v) = %v, want = nil", v1, v2, err)
+	}
+}
+
+func testEqualNow(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	isTerminated := internal.CheckTermination(func() {
+		assertion.EqualNow(v1, v2)
+	})
+	if isEqual && isTerminated {
+		t.Error("execution stopped, want do not stop")
+	} else if !isEqual && !isTerminated {
+		t.Error("execution do not stopped, want stop")
+	}
+
+	isTerminated = internal.CheckTermination(func() {
+		EqualNow(assertion.T, v1, v2)
+	})
+	if isEqual && isTerminated {
+		t.Error("execution stopped, want do not stop")
+	} else if !isEqual && !isTerminated {
+		t.Error("execution do not stopped, want stop")
+	}
+}
+
+func testNotEqualNow(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	isTerminated := internal.CheckTermination(func() {
+		assertion.NotEqualNow(v1, v2)
+	})
+	if !isEqual && isTerminated {
+		t.Error("execution stopped, want do not stop")
+	} else if isEqual && !isTerminated {
+		t.Error("execution do not stopped, want stop")
+	}
+
+	isTerminated = internal.CheckTermination(func() {
+		NotEqualNow(assertion.T, v1, v2)
+	})
+	if !isEqual && isTerminated {
+		t.Error("execution stopped, want do not stop")
+	} else if isEqual && !isTerminated {
+		t.Error("execution do not stopped, want stop")
+	}
+}
+
 func TestNilAndNotNil(t *testing.T) {
 	mockT := new(testing.T)
 	assert := New(mockT)

util.go

@@ -26,6 +26,67 @@ func failed(t *testing.T, err error, failedNow bool) {
 // ## Assertion Helper Functions ##
 // ################################
 
+// isEqual checks the equality of the values.
+func isEqual(x, y any) bool {
+	if x == nil || y == nil {
+		return x == y
+	}
+	v1 := reflect.ValueOf(x)
+	v2 := reflect.ValueOf(y)
+	if !isSameType(v1.Type(), v2.Type()) {
+		return false
+	}
+
+	switch v1.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v1.Int() == v2.Int()
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return v1.Uint() == v2.Uint()
+	case reflect.Float32, reflect.Float64:
+		return v1.Float() == v2.Float()
+	case reflect.Complex64, reflect.Complex128:
+		return v1.Complex() == v2.Complex()
+	case reflect.Slice:
+		return isSliceEqual(v1, v2)
+	default:
+		return v1 == v2
+	}
+}
+
+// isSameType indicates the equality of two types, and it will ignore the bit size of the same
+// type. For example, `int32` and `int64` will be the same type.
+func isSameType(t1, t2 reflect.Type) bool {
+	kind := t2.Kind()
+
+	switch t1.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return kind >= reflect.Int && kind <= reflect.Int64
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return kind >= reflect.Uint && kind <= reflect.Uint64
+	case reflect.Float32, reflect.Float64:
+		return kind == reflect.Float32 || kind == reflect.Float64
+	case reflect.Complex64, reflect.Complex128:
+		return kind == reflect.Complex64 || kind == reflect.Complex128
+	default:
+		return t1 == t2
+	}
+}
+
+// isSliceEqual checks the equality of each elements in the slices.
+func isSliceEqual(v1, v2 reflect.Value) bool {
+	if v1.Len() != v2.Len() {
+		return false
+	}
+
+	for i := 0; i < v1.Len(); i++ {
+		if v1.Index(i).Interface() != v2.Index(i).Interface() {
+			return false
+		}
+	}
+
+	return true
+}
+
 // 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 {

util_test.go

@@ -22,6 +22,62 @@ func TestFailedHandler(t *testing.T) {
 	assert.DeepEqual(isTerminated, true)
 }
 
+func TestIsEqual(t *testing.T) {
+	assert := New(t)
+
+	type testStruct1 struct {
+		A int
+	}
+	type testStruct2 struct {
+		A int
+	}
+
+	var s1 *testStruct1
+
+	assert.Equal(isEqual(nil, nil), true)
+	assert.Equal(isEqual(nil, s1), false) // s1 is nil
+	assert.Equal(isEqual(true, false), false)
+	assert.Equal(isEqual(1, 1), true)
+	assert.Equal(isEqual(1, 2), false)
+	assert.Equal(isEqual(1, int64(1)), true)
+	assert.Equal(isEqual(1, int64(2)), false)
+	assert.Equal(isEqual(uint(1), uint(1)), true)
+	assert.Equal(isEqual(uint(1), uint(2)), false)
+	assert.Equal(isEqual(uint(1), uint64(1)), true)
+	assert.Equal(isEqual(uint(1), uint64(2)), false)
+	assert.Equal(isEqual(1.0, 1.0), true)
+	assert.Equal(isEqual(1.0, 2.0), false)
+	assert.Equal(isEqual(1.0, float32(1.0)), true)
+	assert.Equal(isEqual(1.0, float32(2.0)), false)
+	assert.Equal(isEqual(complex(1, 1), complex(1, 1)), true)
+	assert.Equal(isEqual(complex(1, 1), complex(2, 2)), false)
+	assert.Equal(isEqual(complex(1, 1), complex64(complex(1, 1))), true)
+	assert.Equal(isEqual(complex(1, 1), complex64(complex(2, 2))), false)
+	assert.Equal(isEqual([1]int{0}, [1]int{0}), true)
+	assert.Equal(isEqual([1]int{0}, [1]int{1}), false)
+	assert.Equal(isEqual([1]int{0}, [2]int{0, 0}), false)
+	assert.Equal(isEqual([1]int{0}, [1]float64{0.0}), false)
+	assert.Equal(isEqual("hello", "hello"), true)
+	assert.Equal(isEqual("hello", "world"), false)
+
+	slice1 := []int{0}
+	slice2 := []int{0}
+	slice3 := []int{0, 0}
+	slice4 := []int{1}
+	slice5 := []float64{0.0}
+	assert.Equal(isEqual(slice1, slice1), true)
+	assert.Equal(isEqual(slice1, slice2), true)
+	assert.Equal(isEqual(slice1, slice3), false)
+	assert.Equal(isEqual(slice1, slice4), false)
+	assert.Equal(isEqual(slice1, slice5), false)
+
+	assert.Equal(isEqual(testStruct1{A: 0}, testStruct1{A: 0}), true)
+	assert.Equal(isEqual(testStruct1{A: 0}, testStruct1{A: 1}), false)
+	assert.Equal(isEqual(s1, s1), true)
+	assert.Equal(isEqual(&testStruct1{A: 0}, &testStruct1{A: 1}), false)
+	assert.Equal(isEqual(testStruct1{A: 0}, testStruct2{A: 0}), false)
+}
+
 func TestIsNil(t *testing.T) {
 	assert := New(t)