test: Add Equal, Func, and Op variants of SliceContainsSubset and SliceContainsAll

.gitattributes

@@ -1 +1 @@
-*.go text eol=lf
+* text eol=lf

examples_test.go

@@ -720,6 +720,42 @@ func ExampleSliceContainsAll() {
 	// Output:
 }
 
+func ExampleSliceContainsAllEqual() {
+	dave := &employee{first: "dave", id: 8}
+	armon := &employee{first: "armon", id: 2}
+	mitchell := &employee{first: "mitchell", id: 1}
+	SliceContainsAllEqual(t,
+		[]*employee{dave, armon, mitchell},
+		[]*employee{mitchell, dave, armon})
+	// Output:
+}
+
+func ExampleSliceContainsAllFunc() {
+	// comparing slice to element of same type
+	SliceContainsAllFunc(t,
+		[]string{"UP", "DoWn", "LefT", "RiGHT"},
+		[]string{"left", "down", "up", "right"},
+		func(a, b string) bool {
+			return strings.EqualFold(a, b)
+		})
+
+	// comparing slice to element of different type
+	SliceContainsAllFunc(t,
+		[]string{"2", "4", "6", "8"},
+		[]int{2, 6, 4, 8},
+		func(a string, b int) bool {
+			return a == strconv.Itoa(b)
+		})
+	// Output:
+}
+
+func ExampleSliceContainsAllOp() {
+	SliceContainsAllOp(t,
+		[]int{1, 2, 3, 4, 5},
+		[]int{5, 4, 3, 2, 1})
+	// Output:
+}
+
 func ExampleSliceContainsEqual() {
 	dave := &employee{first: "dave", id: 8}
 	armon := &employee{first: "armon", id: 2}
@@ -756,6 +792,40 @@ func ExampleSliceContainsSubset() {
 	// Output:
 }
 
+func ExampleSliceContainsSubsetEqual() {
+	dave := &employee{first: "dave", id: 8}
+	armon := &employee{first: "armon", id: 2}
+	mitchell := &employee{first: "mitchell", id: 1}
+	employees := []*employee{dave, armon, mitchell}
+	subset := []*employee{mitchell, dave}
+	SliceContainsSubsetEqual(t, employees, subset)
+	// Output:
+}
+
+func ExampleSliceContainsSubsetFunc() {
+	// comparing slice to element of same type
+	words := []string{"UP", "DoWn", "LefT", "RiGHT"}
+	wordsSubset := []string{"left", "down"}
+	SliceContainsSubsetFunc(t, words, wordsSubset, func(a, b string) bool {
+		return strings.EqualFold(a, b)
+	})
+
+	// comparing slice to element of different type
+	nums := []string{"2", "4", "6", "8"}
+	numsSubset := []int{4, 6}
+	SliceContainsSubsetFunc(t, nums, numsSubset, func(a string, b int) bool {
+		return a == strconv.Itoa(b)
+	})
+	// Output:
+}
+
+func ExampleSliceContainsSubsetOp() {
+	nums := []int{1, 2, 3, 4, 5}
+	subset := []int{5, 4, 3}
+	SliceContainsSubsetOp(t, nums, subset)
+	// Output:
+}
+
 func ExampleSliceEmpty() {
 	var ints []int
 	SliceEmpty(t, ints)

internal/assertions/assertions.go

@@ -79,6 +79,20 @@ func containsFunc[A, B any](slice []A, item B, eq func(a A, b B) bool) bool {
 	return found
 }
 
+func containsSubsetFunc[A, B any](slice []A, items []B, eq func(a A, b B) bool) (ok bool, missing B) {
+OUTER:
+	for _, target := range items {
+		var item A
+		for _, item = range slice {
+			if eq(item, target) {
+				continue OUTER
+			}
+		}
+		return false, target
+	}
+	return true, missing
+}
+
 func isNil(a any) bool {
 	// comparable check only works for simple types
 	if a == nil {
@@ -456,6 +470,36 @@ func SliceNotContainsFunc[A, B any](slice []A, item B, eq func(a A, b B) bool) (
 	return
 }
 
+func SliceContainsAllOp[C comparable](slice, items []C) (s string) {
+	if len(slice) != len(items) {
+		s = "expected slice and items to contain same number of elements\n"
+		s += bullet("len(slice): %d\n", len(slice))
+		s += bullet("len(items): %d\n", len(items))
+		return s
+	}
+	return SliceContainsSubsetOp(slice, items)
+}
+
+func SliceContainsAllFunc[A, B any](slice []A, items []B, eq func(a A, b B) bool) (s string) {
+	if len(slice) != len(items) {
+		s = "expected slice and items to contain same number of elements\n"
+		s += bullet("len(slice): %d\n", len(slice))
+		s += bullet("len(items): %d\n", len(items))
+		return s
+	}
+	return SliceContainsSubsetFunc(slice, items, eq)
+}
+
+func SliceContainsAllEqual[E interfaces.EqualFunc[E]](slice, items []E) (s string) {
+	if len(slice) != len(items) {
+		s = "expected slice and items to contain same number of elements\n"
+		s += bullet("len(slice): %d\n", len(slice))
+		s += bullet("len(items): %d\n", len(items))
+		return s
+	}
+	return SliceContainsSubsetEqual(slice, items)
+}
+
 func SliceContainsAll[A any](slice, items []A, opts ...cmp.Option) (s string) {
 	if len(slice) != len(items) {
 		s = "expected slice and items to contain same number of elements\n"
@@ -466,6 +510,40 @@ func SliceContainsAll[A any](slice, items []A, opts ...cmp.Option) (s string) {
 	return SliceContainsSubset(slice, items, opts...)
 }
 
+func SliceContainsSubsetOp[C comparable](slice, items []C) (s string) {
+OUTER:
+	for _, target := range items {
+		var item C
+		for _, item = range slice {
+			if target == item {
+				continue OUTER
+			}
+		}
+		s = "expected slice to contain missing item via == operator\n"
+		s += bullet("slice is missing %#v\n", item)
+		return
+	}
+	return
+}
+
+func SliceContainsSubsetFunc[A, B any](slice []A, items []B, eq func(a A, b B) bool) (s string) {
+	ok, missing := containsSubsetFunc(slice, items, eq)
+	if !ok {
+		s = "expected slice to contain missing item via 'eq' function\n"
+		s += bullet("slice is missing %#v\n", missing)
+	}
+	return
+}
+
+func SliceContainsSubsetEqual[E interfaces.EqualFunc[E]](slice, items []E) (s string) {
+	ok, missing := containsSubsetFunc(slice, items, E.Equal)
+	if !ok {
+		s = "expected slice to contain missing item via .Equal method\n"
+		s += bullet("slice is missing %#v\n", missing)
+	}
+	return
+}
+
 func SliceContainsSubset[A any](slice, items []A, opts ...cmp.Option) (s string) {
 OUTER:
 	for _, target := range items {