feat contains

test.go

@@ -1,6 +1,7 @@
 package test
 
 import (
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -108,22 +109,52 @@ func False(t testing.TB, value bool) {
 	}
 }
 
-// Contains calls t.Fatalf if needle is not contained in the string haystack.
-func Contains[S ~string](t testing.TB, haystack S, needle S) {
+// Contains calls t.Fatalf if needle is not contained in haystack.
+// H can be either a string type (including custom string types) or a slice of comparable type N.
+// When H is a string type and N is any type, fmt.Sprintf is used to convert N to string for comparison.
+// When H is a slice, N is same type as the slice elements for direct comparison.
+func Contains[H interface{ ~string | []N }, N comparable](t testing.TB, haystack H, needle N) {
 	t.Helper()
-	if !contains(haystack, needle) {
-		t.Fatalf("%q not in %q", needle, haystack)
+	msg, found := containsElement(haystack, needle)
+	// TODO: Fix this to use t.Fatal
+	if !found {
+		t.Fatalf("%s", msg)
 	}
 }
 
-// NotContains calls t.Fatalf if needle is contained in the string haystack.
-func NotContains[S ~string](t testing.TB, haystack S, needle S) {
+// NotContains calls t.Fatalf if needle is contained in haystack.
+// For type of H, N see [Contains]
+func NotContains[H interface{ ~string | []N }, N comparable](t testing.TB, haystack H, needle N) {
 	t.Helper()
-	if contains(haystack, needle) {
-		t.Fatalf("%q in %q", needle, haystack)
+	msg, found := containsElement(haystack, needle)
+	// TODO: Fix this to use t.Fatal
+	if found {
+		t.Fatalf("%s", msg)
 	}
 }
 
-func contains[S ~string](haystack S, needle S) bool {
-	return strings.Contains(string(haystack), string(needle))
+func containsElement[H interface{ ~string | []N }, N comparable](haystack H, needle N) (string, bool) {
+	switch h := any(haystack).(type) {
+	case string:
+		n := fmt.Sprintf("%v", needle)
+		if strings.Contains(h, n) {
+			return fmt.Sprintf("%q in %q", n, h), true
+		}
+		return fmt.Sprintf("%q not in %q", n, h), false
+	case []N:
+		// TODO: refactor this using slices.Contains
+		for _, v := range h {
+			if v == needle {
+				return fmt.Sprintf("%v in %v", needle, haystack), true
+			}
+		}
+		return fmt.Sprintf("%v not in %v", needle, haystack), false
+	default: // h is custom string type
+		hs := fmt.Sprintf("%v", haystack)
+		n := fmt.Sprintf("%v", needle)
+		if strings.Contains(hs, n) {
+			return fmt.Sprintf("%q in %q", n, hs), true
+		}
+		return fmt.Sprintf("%q not in %q", n, hs), false
+	}
 }

test_example_test.go

@@ -32,11 +32,15 @@ func Example() {
 
 	type mytype string
 	var mystring mytype = "hello, world"
-	test.Contains(t, mystring, "world") // good
-	test.Contains(t, mystring, "World") // bad
+	test.Contains(t, mystring, "world")       // good
+	test.Contains(t, mystring, "World")       // bad
+	test.Contains(t, []int{1, 2, 3, 4, 5}, 3) // good
+	test.Contains(t, []int{1, 2, 3, 4, 5}, 6) // bad
 
-	test.NotContains(t, mystring, "World") // good
-	test.NotContains(t, mystring, "world") // bad
+	test.NotContains(t, mystring, "World")       // good
+	test.NotContains(t, mystring, "world")       // bad
+	test.NotContains(t, []int{1, 2, 3, 4, 5}, 6) // good
+	test.NotContains(t, []int{1, 2, 3, 4, 5}, 3) // bad
 
 	// Output:
 	// want: hello; got: world
@@ -46,5 +50,7 @@ func Example() {
 	// got: <nil>
 	// got: (O_o)
 	// "World" not in "hello, world"
+	// 6 not in [1 2 3 4 5]
 	// "world" in "hello, world"
+	// 3 in [1 2 3 4 5]
 }

test_test.go

@@ -34,7 +34,9 @@ func Test(t *testing.T) {
 	beOkay(func(tb testing.TB) { test.True(tb, true) })
 	beOkay(func(tb testing.TB) { test.False(tb, false) })
 	beOkay(func(tb testing.TB) { test.Contains(tb, "hello world", "world") })
+	beOkay(func(tb testing.TB) { test.Contains(t, []int{1, 2, 3, 4, 5}, 3) })
 	beOkay(func(tb testing.TB) { test.NotContains(tb, "hello world", "World") })
+	beOkay(func(tb testing.TB) { test.NotContains(t, []int{1, 2, 3, 4, 5}, 6) })
 	beBad := func(callback func(tb testing.TB)) {
 		t.Helper()
 		var buf strings.Builder
@@ -56,7 +58,37 @@ func Test(t *testing.T) {
 	beBad(func(tb testing.TB) { test.True(tb, false) })
 	beBad(func(tb testing.TB) { test.False(tb, true) })
 	beBad(func(tb testing.TB) { test.Contains(tb, "hello world", "World") })
+	beBad(func(tb testing.TB) { test.Contains(tb, []int{1, 2, 3, 4, 5}, 6) })
 	beBad(func(tb testing.TB) { test.NotContains(tb, "hello world", "world") })
+	beBad(func(tb testing.TB) { test.NotContains(tb, []int{1, 2, 3, 4, 5}, 3) })
+}
+
+func TestContains(t *testing.T) {
+	// Case 1: String containment - when first parameter is string
+	// The second parameter is automatically converted to string for comparison
+	test.Contains(t, "3.141592", "3.14")
+	test.Contains(t, "3.141592", 3)    // Integer is converted to string
+	test.Contains(t, "3.141592", 3.14) // Float is converted to string
+
+	// Case 2: Custom string type compatibility
+	// Contains works with custom string types (~string) in any combination
+	type customString string
+	test.Contains(t, customString("abc"), customString("a"))
+	test.Contains(t, customString("abc"), "a")
+	test.Contains(t, "abc", customString("a"))
+
+	// Case 3: Slice element containment
+	// When first parameter is a slice, Contains checks if the second parameter exists as an element
+	test.Contains(t, []int{1, 2, 3, 4, 5}, 3)
+	test.Contains(t, []string{"apple", "banana", "orange"}, "banana")
+	test.Contains(t, []float64{1.1, 2.2, 3.3}, 2.2)
+	test.Contains(t, []byte{1, 2, 3}, byte(2))
+
+	// Case 4: Custom type slice compatibility
+	// Contains works with slices of any comparable type
+	type customInt int
+	nums := []customInt{1, 2, 3, 4}
+	test.Contains(t, nums, customInt(2))
 }
 
 type mockingT struct {