[feature] add deep equal methods and remove unneeded assertion methods (#13)

* removed EqualSlice, NotEqualSlice, EqualMap, NotEqualMap as DeepEqual can achieve the same
* improved SimilarSlice and NotSimilarSlice to work with any type

Author: golanglibs

README.md

@@ -43,12 +43,8 @@ func Test_1Plus1ShouldEqual2(t *testing.T) {
 * `NotEqual` - asserts two values are not equal. Values must be comparable
 * `Nil` - asserts the value is nil
 * `NotNil` - asserts the value is not nil
-* `EqualSlice` - asserts two slices have the same values in the same order. The elements must be comparable
-* `NotEqualSlice` - asserts two slices do not have the same values in the same order. The elements must be comparable
 * `SimilarSlice` - asserts two slices have the same values in any order. The elements must be comparable
 * `NotSimilarSlice` - asserts two slices do not have the same values. The elements must be comparable
-* `EqualMap` - asserts two maps have same key-value pairs. The values must be comparable
-* `NotEqualMap` - asserts two maps do not have same key-value pairs. The values must be comparable
 
 ### Collection
 * `EmptySlice` - asserts the slice is empty. The assertion will fail if the slice is nil

assert_equality.go

@@ -28,82 +28,68 @@ func NotEqual[K comparable](t testing.TB, expected K, actual K) {
 }
 
 /*
-Asserts that the given value is nil
+Asserts that the two given valus are deeply equal. Internally uses reflect.DeepEqual.
+The equality of arrays, slices and maps can be asserted with this method
 */
-func Nil(t testing.TB, actual interface{}) {
+func DeepEqual[T any](t testing.TB, expected T, actual T) {
 	t.Helper()
 
-	if !isNil(actual) {
-		t.Error(inequalityMsg(nil, actual))
+	if !reflect.DeepEqual(expected, actual) {
+		t.Error(inequalityMsg(expected, actual))
 	}
 }
 
 /*
-Asserts that the given value is not nil
+Asserts that the two given valus are not deeply equal. Internally uses reflect.DeepEqual.
+The inequality of arrays, slices and maps can be asserted with this method
 */
-func NotNil(t testing.TB, actual interface{}) {
+func NotDeepEqual[T any](t testing.TB, expected T, actual T) {
 	t.Helper()
 
-	if isNil(actual) {
-		t.Error(equalityMsg("nil"))
-	}
-}
-
-func isNil(value interface{}) bool {
-	if value == nil {
-		return true
-	}
-
-	switch reflect.TypeOf(value).Kind() {
-	case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Chan, reflect.Func:
-		return reflect.ValueOf(value).IsNil()
+	if reflect.DeepEqual(expected, actual) {
+		t.Error(equalityMsg(expected))
 	}
-
-	return false
 }
 
 /*
-Asserts that the two given slices have the same elements in the same order. The elements must be [comparable]
+Asserts that the given value is nil
 */
-func EqualSlice[K comparable](t testing.TB, expected []K, actual []K) {
+func Nil(t testing.TB, actual interface{}) {
 	t.Helper()
 
-	if !areEqualSlices(expected, actual) {
-		t.Error(inequalityMsg(expected, actual))
+	if !isNil(actual) {
+		t.Error(inequalityMsg(nil, actual))
 	}
 }
 
 /*
-Asserts that the two given slices does not have the same elements in the same order. The elements must be [comparable]
+Asserts that the given value is not nil
 */
-func NotEqualSlice[K comparable](t testing.TB, expected []K, actual []K) {
+func NotNil(t testing.TB, actual interface{}) {
 	t.Helper()
 
-	if areEqualSlices(expected, actual) {
-		t.Error(equalityMsg(expected))
+	if isNil(actual) {
+		t.Error(equalityMsg("nil"))
 	}
 }
 
-func areEqualSlices[K comparable](expected []K, actual []K) bool {
-	expectedLength := len(expected)
-	actualLength := len(actual)
-	if actualLength != expectedLength {
-		return false
+func isNil(value interface{}) bool {
+	if value == nil {
+		return true
 	}
 
-	for i := 0; i < expectedLength; i++ {
-		if actual[i] != expected[i] {
-			return false
-		}
+	switch reflect.TypeOf(value).Kind() {
+	case reflect.Pointer, reflect.Map, reflect.Slice, reflect.Chan, reflect.Func:
+		return reflect.ValueOf(value).IsNil()
 	}
 
-	return true
+	return false
 }
 
 /*
 Asserts that the two given slices have the same values in any order. The elements must be [comparable]
 */
-func SimilarSlice[K comparable](t testing.TB, expected []K, actual []K) {
+func SimilarSlice[T any](t testing.TB, expected []T, actual []T) {
 	t.Helper()
 
 	if !areSimilarSlices(expected, actual) {
@@ -114,69 +100,34 @@ func SimilarSlice[K comparable](t testing.TB, expected []K, actual []K) {
 /*
 Asserts that the two given slices does not have the same values. The elements must be [comparable]
 */
-func NotSimilarSlice[K comparable](t testing.TB, expected []K, actual []K) {
+func NotSimilarSlice[T any](t testing.TB, expected []T, actual []T) {
 	t.Helper()
 
 	if areSimilarSlices(expected, actual) {
 		t.Error(equalityMsg(expected))
 	}
 }
 
-func areSimilarSlices[K comparable](expected []K, actual []K) bool {
+func areSimilarSlices[T any](expected []T, actual []T) bool {
 	expectedLength := len(expected)
 	actualLength := len(actual)
 	if actualLength != expectedLength {
 		return false
 	}
 
-	expectedElementsMap := make(map[K]int, expectedLength)
-	for _, v := range expected {
-		expectedElementsMap[v] += 1
-	}
-
-	actualElementsMap := make(map[K]int, actualLength)
-	for _, v := range actual {
-		actualElementsMap[v] += 1
-	}
-
-	return isEqualMap(expectedElementsMap, actualElementsMap)
-}
-
-/*
-Asserts that the two given maps have the same key-value pairs. The values must be [comparable]
-*/
-func EqualMap[K, V comparable](t testing.TB, expected map[K]V, actual map[K]V) {
-	t.Helper()
-
-	if !isEqualMap(expected, actual) {
-		t.Error(inequalityMsg(expected, actual))
-	}
-}
-
-/*
-Asserts that the two given maps does not have the same key-value pairs. The values must be [comparable]
-*/
-func NotEqualMap[K, V comparable](t testing.TB, expected map[K]V, actual map[K]V) {
-	t.Helper()
-
-	if isEqualMap(expected, actual) {
-		t.Error(equalityMsg(expected))
-	}
-}
-
-func isEqualMap[K, V comparable](expected map[K]V, actual map[K]V) bool {
-	expectedLength := len(expected)
-	actualLength := len(actual)
-	if actualLength != expectedLength {
-		return false
-	}
+	matchedIndexMap := make(map[int]interface{}, expectedLength)
+	for _, expectedValue := range expected {
+		for j, actualValue := range actual {
+			if !reflect.DeepEqual(expectedValue, actualValue) {
+				continue
+			}
 
-	for actualKey, actualValue := range actual {
-		expectedValue, found := expected[actualKey]
-		if !found || actualValue != expectedValue {
-			return false
+			if _, alreadyMatched := matchedIndexMap[j]; !alreadyMatched {
+				matchedIndexMap[j] = nil
+				break
+			}
 		}
 	}
 
-	return true
+	return len(matchedIndexMap) == expectedLength
 }