test: add SliceEqOp

examples_test.go

@@ -782,6 +782,13 @@ func ExampleSliceEqual() {
 	// Output:
 }
 
+func ExampleSliceEqOp() {
+	s1 := []int{1, 3, 3, 7}
+	s2 := []int{1, 3, 3, 7}
+	SliceEqOp(t, s1, s2)
+	// Output:
+}
+
 func ExampleSliceLen() {
 	SliceLen(t, 4, []float64{32, 1.2, 0.01, 9e4})
 	// Output:

internal/assertions/assertions.go

@@ -332,6 +332,27 @@ func SliceEqual[E interfaces.EqualFunc[E]](exp, val []E) (s string) {
 	return
 }
 
+func SliceEqOp[A comparable, S ~[]A](exp, val S) (s string) {
+	lenA, lenB := len(exp), len(val)
+
+	if lenA != lenB {
+		s = "expected slices of same length\n"
+		s += bullet("len(exp): %d\n", lenA)
+		s += bullet("len(val): %d\n", lenB)
+		s += diff(exp, val, nil)
+		return
+	}
+
+	for i := 0; i < lenA; i++ {
+		if exp[i] != val[i] {
+			s += "expected slice equality via ==\n"
+			s += diff(exp[i], val[i], nil)
+			return
+		}
+	}
+	return
+}
+
 func Lesser[L interfaces.LessFunc[L]](exp, val L) (s string) {
 	if !val.Less(exp) {
 		s = "expected val to be less via .Less method\n"

test.go

@@ -163,6 +163,12 @@ func SliceEqual[E interfaces.EqualFunc[E]](t T, exp, val []E, settings ...Settin
 	invoke(t, assertions.SliceEqual(exp, val), settings...)
 }
 
+// SliceEqOp asserts exp[n] == val[n] for each element n.
+func SliceEqOp[A comparable, S ~[]A](t T, exp, val S, settings ...Setting) {
+	t.Helper()
+	invoke(t, assertions.SliceEqOp(exp, val), settings...)
+}
+
 // SliceEmpty asserts slice is empty.
 func SliceEmpty[A any](t T, slice []A, settings ...Setting) {
 	t.Helper()

test_test.go

@@ -511,6 +511,26 @@ func TestSliceEqual(t *testing.T) {
 	})
 }
 
+func TestSliceEqOp(t *testing.T) {
+	t.Run("length", func(t *testing.T) {
+		tc := newCase(t, `expected slices of same length`)
+		t.Cleanup(tc.assert)
+
+		a := []int{1, 2, 3}
+		b := []int{1, 2, 3, 4}
+		SliceEqOp(tc, a, b)
+	})
+
+	t.Run("elements", func(t *testing.T) {
+		tc := newCase(t, `expected slice equality via ==`)
+		t.Cleanup(tc.assert)
+
+		a := []int{1, 2, 3}
+		b := []int{1, 2, 4}
+		SliceEqOp(tc, a, b)
+	})
+}
+
 func TestLesser(t *testing.T) {
 	tc := newCase(t, `expected val to be less via .Less method`)
 	t.Cleanup(tc.assert)