refactor: refactor files.

Author: ghosind

equal.go renamed to compare.go

@@ -2,6 +2,7 @@ package assert
 
 import (
 	"fmt"
+	"math"
 	"reflect"
 	"testing"
 )
@@ -356,3 +357,114 @@ func tryNotTrue(t *testing.T, failedNow bool, val any, message ...any) error {
 		message...,
 	)
 }
+
+// isEqual checks the equality of the values.
+func isEqual(x, y any) bool {
+	if x == nil || y == nil {
+		return x == y
+	}
+
+	var v1, v2 reflect.Value
+	if xv, ok := x.(reflect.Value); ok {
+		v1 = xv
+	} else {
+		v1 = reflect.ValueOf(x)
+	}
+	if yv, ok := y.(reflect.Value); ok {
+		v2 = yv
+	} else {
+		v2 = reflect.ValueOf(y)
+	}
+
+	if isSame, isMixSign := isSameType(v1.Type(), v2.Type()); !isSame {
+		if isMixSign {
+			return isEqualForMixSignInt(v1, v2)
+		}
+		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,
+		reflect.Uintptr:
+		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.String:
+		return v1.String() == v2.String()
+	case reflect.Slice:
+		return isSliceEqual(v1, v2)
+	default:
+		return v1.Interface() == v2.Interface()
+	}
+}
+
+// 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 {
+	if val == nil {
+		return true
+	}
+
+	v := reflect.ValueOf(val)
+
+	switch v.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Map, reflect.Pointer, reflect.UnsafePointer,
+		reflect.Interface, reflect.Slice:
+		return v.IsNil()
+	default:
+		return false
+	}
+}
+
+// isTrue checks whether a value is truthy or not. It'll return true if the value is not the zero
+// value for its type. For a slice, a truthy value should not be the zero value and the length must
+// be greater than 0. For nil, it'll always return false.
+func isTrue(v any) bool {
+	rv := reflect.ValueOf(v)
+
+	switch rv.Kind() {
+	case reflect.Invalid:
+		return false // always false
+	case reflect.Slice:
+		return v != nil && rv.Len() > 0
+	default:
+		return !rv.IsZero()
+	}
+}
+
+// isComparable gets the type of the value, and checks whether the type is comparable or not.
+func isComparable(v any) bool {
+	switch v.(type) {
+	case
+		int, int8, int16, int32, int64, // Signed integer
+		uint, uint8, uint16, uint32, uint64, uintptr, // Unsigned integer
+		float32, float64, // Floating-point number
+		string: // string
+		return true
+	default:
+		return false
+	}
+}

equal_test.go renamed to compare_test.go

@@ -1,6 +1,7 @@
 package assert
 
 import (
+	"math"
 	"testing"
 )
 
@@ -226,3 +227,116 @@ func testTrueAndNotTrue(a, mockA *Assertion, v any, isTruthy bool) {
 		mockA.NotTrueNow(v)
 	}, isTruthy)
 }
+
+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(uint(1), uintptr(1)), true)
+	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 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)
+
+	assert.NotTrue(isNil(1))  // int
+	assert.NotTrue(isNil("")) // string
+	assert.True(isNil(nil))
+	var testAssert *Assertion
+	assert.True(isNil(testAssert))
+	assert.NotTrue(isNil(assert))
+}
+
+func TestIsTrue(t *testing.T) {
+	assert := New(t)
+
+	// reflect.Invalid
+	assert.NotTrue(isTrue(nil))
+
+	// reflect.Slice
+	assert.True(isTrue([]int{0}))
+	assert.NotTrue(isTrue([]int{}))
+
+	// other kinds
+	assert.True(isTrue(1))
+	assert.NotTrue(isTrue(0))
+	assert.True(isTrue(1.0))
+	assert.NotTrue(isTrue(0.0))
+	assert.True(isTrue("Hello"))
+	assert.NotTrue(isTrue(""))
+	assert.True(isTrue(func() {}))
+}
+
+func TestIsComparable(t *testing.T) {
+	assert := New(t)
+
+	assert.Equal(isComparable(1), true)
+	assert.Equal(isComparable(int64(1)), true)
+	assert.Equal(isComparable(uint64(1)), true)
+	assert.Equal(isComparable(float32(1.0)), true)
+	assert.Equal(isComparable(1.0), true)
+	assert.Equal(isComparable("Hello"), true)
+	assert.Equal(isComparable([]byte{'H', 'e', 'l', 'l', 'o'}), false)
+	assert.Equal(isComparable([]int{1, 2, 3}), false)
+}

map.go

@@ -2,6 +2,7 @@ package assert
 
 import (
 	"fmt"
+	"reflect"
 	"testing"
 )
 
@@ -186,3 +187,49 @@ func tryNotMapHasValue(
 		message...,
 	)
 }
+
+// isMapHasValue checks whether the map contains the specified key or not.
+func isMapHasKey(m, k any) bool {
+	if m == nil || reflect.TypeOf(m).Kind() != reflect.Map {
+		return false
+	}
+
+	mv := reflect.ValueOf(m)
+	if mv.Len() == 0 {
+		return false
+	}
+
+	if !reflect.TypeOf(k).AssignableTo(mv.Type().Key()) {
+		return false
+	}
+
+	return mv.MapIndex(reflect.ValueOf(k)).Kind() != reflect.Invalid
+}
+
+// isMapHasValue checks whether the map contains the specified value or not.
+func isMapHasValue(m, v any) bool {
+	if m == nil || reflect.TypeOf(m).Kind() != reflect.Map {
+		return false
+	}
+
+	mv := reflect.ValueOf(m)
+	if mv.Len() == 0 {
+		return false
+	}
+
+	if !reflect.TypeOf(v).AssignableTo(mv.Type().Elem()) {
+		return false
+	}
+
+	vv := reflect.ValueOf(v)
+	iter := mv.MapRange()
+
+	for iter.Next() {
+		mvv := iter.Value()
+		if isEqual(mvv, vv.Convert(mvv.Type())) {
+			return true
+		}
+	}
+
+	return false
+}

map_test.go

@@ -105,3 +105,81 @@ func tesMapHasValueAndNotMapHasValue(
 		mockA.NotMapHasValueNow(m, key)
 	}, isHasValue)
 }
+
+func TestIsMapHasKey(t *testing.T) {
+	assert := New(t)
+
+	assert.NotTrue(isMapHasKey(nil, nil))
+	assert.NotTrue(isMapHasKey(map[string]int{}, "a"))
+	assert.True(isMapHasKey(map[string]int{
+		"a": 1,
+		"b": 2,
+	}, "a"))
+	assert.NotTrue(isMapHasKey(map[string]int{
+		"a": 1,
+		"b": 2,
+	}, "c"))
+	assert.NotTrue(isMapHasKey(map[string]int{
+		"a": 1,
+		"b": 2,
+	}, 1))
+	assert.True(isMapHasKey(map[any]int{
+		"a": 1,
+		1:   2,
+	}, 1))
+	assert.True(isMapHasKey(map[any]int{
+		"a": 1,
+		1:   2,
+	}, "a"))
+	assert.NotTrue(isMapHasKey(map[any]int{
+		"a": 1,
+		1:   2,
+	}, 2))
+	assert.NotTrue(isMapHasKey(map[any]int{
+		"a": 1,
+		1:   2,
+	}, "b"))
+	assert.NotTrue(isMapHasKey(map[any]int{
+		"a": 1,
+		1:   2,
+	}, 1.1))
+}
+
+func TestIsMapHasValue(t *testing.T) {
+	assert := New(t)
+
+	assert.NotTrue(isMapHasValue(nil, nil))
+	assert.NotTrue(isMapHasValue(map[string]int{}, 3))
+	assert.True(isMapHasValue(map[string]int{
+		"a": 1,
+		"b": 2,
+	}, 1))
+	assert.NotTrue(isMapHasValue(map[string]int{
+		"a": 1,
+		"b": 2,
+	}, 3))
+	assert.NotTrue(isMapHasValue(map[string]int{
+		"a": 1,
+		"b": 2,
+	}, true))
+	assert.True(isMapHasValue(map[any]any{
+		"a": "b",
+		1:   2,
+	}, "b"))
+	assert.True(isMapHasValue(map[any]any{
+		"a": "b",
+		1:   2,
+	}, 2))
+	assert.NotTrue(isMapHasValue(map[any]any{
+		"a": "b",
+		1:   2,
+	}, "a"))
+	assert.NotTrue(isMapHasValue(map[any]any{
+		"a": "b",
+		1:   2,
+	}, 1))
+	assert.NotTrue(isMapHasValue(map[any]any{
+		"a": "b",
+		1:   2,
+	}, 1.1))
+}