added more assertions

Author: MarvinJWendt

assert.go

@@ -1,6 +1,9 @@
 package assert
 
-import "reflect"
+import (
+	"reflect"
+	"strings"
+)
 
 // Equal compares two values and returns true if they are equal.
 func Equal[T any](a, b T) bool {
@@ -86,65 +89,65 @@ func Unique[T any](s []T) bool {
 	return true
 }
 
-// Contains returns true if the slice contains the value.
-// Items are considered equal if they are deep equal.
-func Contains[T any](s []T, v T) bool {
-	// Use reflection DeepEqual to compare values.
-	// This is necessary because slices of interfaces cannot be compared with ==.
-	for _, item := range s {
-		if reflect.DeepEqual(item, v) {
-			return true
+// Contains returns true if a contains b.
+func Contains(a any, b any) bool {
+	objectValue := reflect.ValueOf(a)
+	objectKind := reflect.TypeOf(a).Kind()
+
+	switch objectKind {
+	case reflect.String:
+		return strings.Contains(objectValue.String(), reflect.ValueOf(b).String())
+	case reflect.Map:
+	default:
+		for i := 0; i < objectValue.Len(); i++ {
+			if Equal(objectValue.Index(i).Interface(), b) {
+				return true
+			}
 		}
 	}
+
 	return false
 }
 
-// ContainsAll returns true if the slice contains all the values.
-// Items are considered equal if they are deep equal.
-func ContainsAll[T any](s []T, v []T) bool {
-	// Use reflection DeepEqual to compare values.
-	// This is necessary because slices of interfaces cannot be compared with ==.
-	for _, item := range v {
-		found := false
-		for _, item2 := range s {
-			if reflect.DeepEqual(item, item2) {
-				found = true
-				break
-			}
-		}
-		if !found {
+// ContainsAll returns true if all values are contained in a.
+func ContainsAll[T any](a T, v []T) bool {
+	for _, t := range v {
+		if !Contains(a, t) {
 			return false
 		}
 	}
+
 	return true
 }
 
-// ContainsAny returns true if the slice contains any of the values.
-// Items are considered equal if they are deep equal.
-func ContainsAny[T any](s []T, v []T) bool {
-	// Use reflection DeepEqual to compare values.
-	// This is necessary because slices of interfaces cannot be compared with ==.
-	for _, item := range v {
-		for _, item2 := range s {
-			if reflect.DeepEqual(item, item2) {
-				return true
-			}
+// ContainsAny returns true if any of the values are contained in a.
+func ContainsAny[T any](a T, v []T) bool {
+	for _, t := range v {
+		if Contains(a, t) {
+			return true
 		}
 	}
+
 	return false
 }
 
-// ContainsNone returns true if the slice contains none of the values.
-// Items are considered equal if they are deep equal.
-func ContainsNone[T any](s []T, v []T) bool {
-	// Use reflection DeepEqual to compare values.
-	// This is necessary because slices of interfaces cannot be compared with ==.
-	for _, item := range v {
-		for _, item2 := range s {
-			if reflect.DeepEqual(item, item2) {
-				return false
-			}
+// ContainsNone returns true if none of the values are contained in a.
+func ContainsNone[T any](a T, v []T) bool {
+	for _, t := range v {
+		if Contains(a, t) {
+			return false
 		}
 	}
+
 	return true
 }
+
+// Uppercase returns true if the string is uppercase.
+func Uppercase(s string) bool {
+	return s == strings.ToUpper(s)
+}
+
+// Lowercase returns true if the string is lowercase.
+func Lowercase(s string) bool {
+	return s == strings.ToLower(s)
+}

assert_test.go

@@ -229,14 +229,17 @@ func TestUnique(t *testing.T) {
 
 func TestContains(t *testing.T) {
 	tests := []struct {
-		a    []any
+		a    any
 		b    any
 		pass bool
 	}{
 		{[]any{1, 2, 3}, 1, true},
 		{[]any{1, 2, 3}, 4, false},
 		{[]any{"a", "b", "c"}, "a", true},
 		{[]any{"a", "b", "c"}, "d", false},
+		{"Hello, World!", "Hello", true},
+		{"Hello, World!", "Hello, World!", true},
+		{"Hello", "X", false},
 	}
 	for i, test := range tests {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
@@ -249,14 +252,15 @@ func TestContains(t *testing.T) {
 
 func TestContainsAll(t *testing.T) {
 	tests := []struct {
-		a    []any
+		a    any
 		b    []any
 		pass bool
 	}{
 		{[]any{1, 2, 3}, []any{1, 2}, true},
 		{[]any{1, 2, 3}, []any{1, 4}, false},
 		{[]any{"a", "b", "c"}, []any{"a", "b"}, true},
 		{[]any{"a", "b", "c"}, []any{"a", "d"}, false},
+		{"Hello, World!", []any{"Hello", "World"}, true},
 	}
 	for i, test := range tests {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
@@ -269,7 +273,7 @@ func TestContainsAll(t *testing.T) {
 
 func TestContainsAny(t *testing.T) {
 	tests := []struct {
-		a    []any
+		a    any
 		b    []any
 		pass bool
 	}{
@@ -279,6 +283,7 @@ func TestContainsAny(t *testing.T) {
 		{[]any{"a", "b", "c"}, []any{"a", "b"}, true},
 		{[]any{"a", "b", "c"}, []any{"a", "d"}, true},
 		{[]any{"a", "b", "c"}, []any{"d", "e"}, false},
+		{"Hello, World!", []any{"Hello", "World", "XXX"}, true},
 	}
 	for i, test := range tests {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
@@ -291,7 +296,7 @@ func TestContainsAny(t *testing.T) {
 
 func TestContainsNone(t *testing.T) {
 	tests := []struct {
-		a    []any
+		a    any
 		b    []any
 		pass bool
 	}{
@@ -310,3 +315,39 @@ func TestContainsNone(t *testing.T) {
 		})
 	}
 }
+
+func TestUppercase(t *testing.T) {
+	tests := []struct {
+		a    string
+		pass bool
+	}{
+		{"ABC", true},
+		{"abc", false},
+		{"Abc", false},
+	}
+	for i, test := range tests {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			if assert.Uppercase(test.a) != test.pass {
+				fail(t, fmt.Sprintf("Uppercase(%v) != %v", test.a, test.pass))
+			}
+		})
+	}
+}
+
+func TestLowercase(t *testing.T) {
+	tests := []struct {
+		a    string
+		pass bool
+	}{
+		{"ABC", false},
+		{"abc", true},
+		{"Abc", false},
+	}
+	for i, test := range tests {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			if assert.Lowercase(test.a) != test.pass {
+				fail(t, fmt.Sprintf("Lowercase(%v) != %v", test.a, test.pass))
+			}
+		})
+	}
+}