feat: mixed signed and unsigned are not allowed anymore.

Author: ghosind

builtin.go

@@ -169,7 +169,7 @@ func NotDeepEqualNow(t *testing.T, actual, expect any, message ...any) error {
 //	Equal(t, 1, 1) // success
 //	Equal(t, "ABC", "ABC") // success
 //	Equal(t, 1, int64(1)) // success
-//	Equal(t, 1, uint64(1)) // success
+//	Equal(t, 1, uint64(1)) // fail
 //	Equal(t, 1, 0) // fail
 func Equal(t *testing.T, actual, expect any, message ...any) error {
 	t.Helper()
@@ -183,7 +183,6 @@ func Equal(t *testing.T, actual, expect any, message ...any) error {
 //	EqualNow(t, 1, 1) // success
 //	EqualNow(t, "ABC", "ABC") // success
 //	EqualNow(t, 1, int64(1)) // success
-//	EqualNow(t, 1, uint64(1)) // success
 //	EqualNow(t, 1, 0) // fail and terminate
 //	never run
 func EqualNow(t *testing.T, actual, expect any, message ...any) error {
@@ -197,10 +196,10 @@ func EqualNow(t *testing.T, actual, expect any, message ...any) error {
 //
 //	NotEqual(t, 1, 0) // success
 //	NotEqual(t, "ABC", "CBA") // success
+//	NotEqual(t, 1, uint64(1)) // success
 //	NotEqual(t, 1, 1) // fail
 //	NotEqual(t, "ABC", "ABC") // fail
 //	NotEqual(t, 1, int64(1)) // fail
-//	NotEqual(t, 1, uint64(1)) // fail
 func NotEqual(t *testing.T, actual, expect any, message ...any) error {
 	t.Helper()
 

compare.go

@@ -2,7 +2,6 @@ package assert
 
 import (
 	"fmt"
-	"math"
 	"reflect"
 	"testing"
 )
@@ -93,7 +92,7 @@ func tryNotDeepEqual(t *testing.T, failedNow bool, actual, expect any, message .
 //	assertion.Equal(1, 1) // success
 //	assertion.Equal("ABC", "ABC") // success
 //	assertion.Equal(1, int64(1)) // success
-//	assertion.Equal(1, uint64(1)) // success
+//	assertion.Equal(1, uint64(1)) // fail
 //	assertion.Equal(1, 0) // fail
 func (a *Assertion) Equal(actual, expect any, message ...any) error {
 	a.Helper()
@@ -107,7 +106,6 @@ func (a *Assertion) Equal(actual, expect any, message ...any) error {
 //	assertion.EqualNow(1, 1) // success
 //	assertion.EqualNow("ABC", "ABC") // success
 //	assertion.EqualNow(1, int64(1)) // success
-//	assertion.EqualNow(1, uint64(1)) // success
 //	assertion.EqualNow(1, 0) // fail and terminate
 //	never run
 func (a *Assertion) EqualNow(actual, expect any, message ...any) error {
@@ -121,10 +119,10 @@ func (a *Assertion) EqualNow(actual, expect any, message ...any) error {
 //
 //	assertion.NotEqual(1, 0) // success
 //	assertion.NotEqual("ABC", "CBA") // success
+//	assertion.NotEqual(1, uint64(1)) // success
 //	assertion.NotEqual(1, 1) // fail
 //	assertion.NotEqual("ABC", "ABC") // fail
 //	assertion.NotEqual(1, int64(1)) // fail
-//	assertion.NotEqual(1, uint64(1)) // fail
 func (a *Assertion) NotEqual(actual, expect any, message ...any) error {
 	a.Helper()
 
@@ -376,10 +374,7 @@ func isEqual(x, y any) bool {
 		v2 = reflect.ValueOf(y)
 	}
 
-	if isSame, isMixSign := isSameType(v1.Type(), v2.Type()); !isSame {
-		if isMixSign {
-			return isEqualForMixSignInt(v1, v2)
-		}
+	if ok := isSameType(v1.Type(), v2.Type()); !ok {
 		return false
 	}
 
@@ -402,25 +397,6 @@ func isEqual(x, y any) bool {
 	}
 }
 
-// isEqualForMixSignInt checks the equality of two integers one of an integer is signed, but
-// another one is unsigned.
-func isEqualForMixSignInt(v1, v2 reflect.Value) bool {
-	intVal := v1
-	uintVal := v2
-	if v1.Kind() >= reflect.Uint && v1.Kind() <= reflect.Uintptr {
-		intVal = v2
-		uintVal = v1
-	}
-
-	if intVal.Int() < 0 {
-		return false
-	} else if uintVal.Uint() > uint64(math.MaxInt64) {
-		return false
-	}
-
-	return intVal.Int() == int64(uintVal.Uint())
-}
-
 // 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

@@ -1,7 +1,6 @@
 package assert
 
 import (
-	"math"
 	"testing"
 )
 
@@ -74,7 +73,7 @@ func TestEqualAndNotEqual(t *testing.T) {
 	testEqualAndNotEqual(a, mockA, 1, 1, true)
 	testEqualAndNotEqual(a, mockA, 1, 2, false)
 	testEqualAndNotEqual(a, mockA, 1, int64(1), true)
-	testEqualAndNotEqual(a, mockA, 1, uint64(1), true)
+	testEqualAndNotEqual(a, mockA, 1, uint64(1), false)
 	testEqualAndNotEqual(a, mockA, 1, 1.0, false)
 	testEqualAndNotEqual(a, mockA, 1, "1", false)
 	testEqualAndNotEqual(a, mockA, 1, '1', false)
@@ -285,18 +284,6 @@ func TestIsEqual(t *testing.T) {
 	assert.Equal(isEqual(testStruct1{A: 0}, testStruct2{A: 0}), false)
 }
 
-func TestIsEqualOfMixSignInt(t *testing.T) {
-	assert := New(t)
-
-	assert.True(isEqual(0, uint(0)))
-	assert.True(isEqual(1, uint(1)))
-	assert.True(isEqual(uint(1), 1))
-	assert.True(isEqual(math.MaxInt64, uint64(math.MaxInt64)))
-	assert.NotTrue(isEqual(-1, uint64(math.MaxUint64)))
-	assert.NotTrue(isEqual(uint64(math.MaxUint64), -1))
-	assert.NotTrue(isEqual(uint64(math.MaxUint64), 0))
-}
-
 func TestIsNil(t *testing.T) {
 	assert := New(t)
 

slice.go

@@ -109,7 +109,7 @@ func isContainsElement(source, elem any) bool {
 	if st.Kind() != reflect.Array && st.Kind() != reflect.Slice {
 		panic("require array or slice")
 	}
-	if ok, isMixed := isSameType(st.Type().Elem(), reflect.TypeOf(elem)); !ok && !isMixed {
+	if ok := isSameType(st.Type().Elem(), reflect.TypeOf(elem)); !ok {
 		panic("require same type")
 	}
 

slice_test.go

@@ -73,8 +73,8 @@ func TestIsContainsElement(t *testing.T) {
 	assert.NotTrueNow(isContainsElement([]int{1, 2, 3}, 4))
 	assert.TrueNow(isContainsElement([]int64{1, 2, 3}, 3))
 	assert.NotTrueNow(isContainsElement([]int64{1, 2, 3}, 4))
-	assert.TrueNow(isContainsElement([]uint64{1, 2, 3}, 3))
-	assert.NotTrueNow(isContainsElement([]uint64{1, 2, 3}, 4))
+	assert.TrueNow(isContainsElement([]uint64{1, 2, 3}, uint(3)))
+	assert.NotTrueNow(isContainsElement([]uint64{1, 2, 3}, uint(4)))
 	assert.TrueNow(isContainsElement(&[]int{1, 2, 3}, 3))
 	assert.TrueNow(isContainsElement([3]int{1, 2, 3}, 3))
 	assert.NotTrueNow(isContainsElement([3]int{1, 2, 3}, 4))

util.go

@@ -52,22 +52,20 @@ func failed(t *testing.T, err error, failedNow bool) {
 //
 // It will returns a bool value to tell the callee function that one of the values is an integer,
 // but another one is unsigned. For this case, it needs to check the value to compare them.
-func isSameType(t1, t2 reflect.Type) (isSame bool, isMixSign bool) {
+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,
-			kind >= reflect.Uint && kind <= reflect.Uintptr
+		return kind >= reflect.Int && kind <= reflect.Int64
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
 		reflect.Uintptr:
-		return kind >= reflect.Uint && kind <= reflect.Uintptr,
-			kind >= reflect.Int && kind <= reflect.Int64
+		return kind >= reflect.Uint && kind <= reflect.Uintptr
 	case reflect.Float32, reflect.Float64:
-		return kind == reflect.Float32 || kind == reflect.Float64, false
+		return kind == reflect.Float32 || kind == reflect.Float64
 	case reflect.Complex64, reflect.Complex128:
-		return kind == reflect.Complex64 || kind == reflect.Complex128, false
+		return kind == reflect.Complex64 || kind == reflect.Complex128
 	default:
-		return t1 == t2, false
+		return t1 == t2
 	}
 }