assert: support byte slice in Contains

[nickajacks1]

Summary

Update assert.Contains and assert.NotContains to check if a byte slice contains another byte slice.

Changes

If both the list and element arguments are byte slices, use bytes.Contains to check if element is a subslice. This mirrors the way strings are treated by assert.Contains.

Motivation

The change makes Contains more consistent and predictable. One could argue that developers could easily cast byte slices to strings, but the fact that that Contains does not treat strings and byte slices the same way breaks the principle of least astonishment (and probably would warrant a new rule in testifylint).

foo := []byte(`Text`)
b, err := os.ReadFile("file.txt")
require.NoError(t, err)
require.Contains(t, b, foo)

[arjunmahishi]

Probably worth updating the examples

Here:

testify/assert/assertions.go

Lines 879 to 884 in 84e42a9

	// Contains asserts that the specified string, list(array, slice...) or map contains the
	// specified substring or element.
	//
	// assert.Contains(t, "Hello World", "World")
	// assert.Contains(t, ["Hello", "World"], "World")
	// assert.Contains(t, {"Hello": "World"}, "Hello")

And here:

testify/assert/assertions.go

Lines 902 to 907 in 84e42a9

	// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
	// specified substring or element.
	//
	// assert.NotContains(t, "Hello World", "Earth")
	// assert.NotContains(t, ["Hello", "World"], "Earth")
	// assert.NotContains(t, {"Hello": "World"}, "Earth")

So, that the godoc reflects that []byte is now supported.

[brackendawson]

Would this change be more useful to more people if when contains is a slice or array of the same type as s, then the assertion checks that the run of contains appears at least once in s? Rather than this only working with []byte, and not even array of byte.

eg:

Contains(t, []int{1,2,3,4,5,6,7,8,9}, []int{4,5,6})                        // -> true
Contains(t, []int{1,2,3,4,5,6,7,8,9}, []int{3,5,7})                        // -> false
Contains(t, []byte("My hovercraft is full of eels"), []byte("hovercraft")) // -> true
Contains(t, [...]byte("I am an array"), [...]byte("arr"))                  // -> true
Contains(t, []any{"hi", []byte{}, false, 9}, []byte{})                     // -> true

[nickajacks1]

Would this change be more useful to more people if when contains is a slice or array of the same type as s, then the assertion checks that the run of contains appears at least once in s? Rather than this only working with []byte, and not even array of byte.

eg:

Contains(t, []int{1,2,3,4,5,6,7,8,9}, []int{4,5,6})                        // -> true
Contains(t, []int{1,2,3,4,5,6,7,8,9}, []int{3,5,7})                        // -> false
Contains(t, []byte("My hovercraft is full of eels"), []byte("hovercraft")) // -> true
Contains(t, [...]byte("I am an array"), [...]byte("arr"))                  // -> true
Contains(t, []any{"hi", []byte{}, false, 9}, []byte{})                     // -> true

Yeah actually I think I was looking for that functionality before and was disappointed to find that it didn't exist.
This is a good idea, I'll look at reworking this to support "subslice" checking.

[dolmen]

@nickajacks1 Let's keep this PR focused on []byte support to allow us to merge this quickly, and submit other changes later.

[Antonboom]

should we do return false, false if !ok?

[nickajacks1]

I don't think so, at least with how the code is written - if list is a [][]byte, we want to fall through to the loop check on line 917.
Maybe it's valid to say that if list is neither a []byte or a [][]byte, we should return false, false, but I haven't thought very hard about that case yet.

[brackendawson]

It's a shame not to go with the generic subslice within slice approach first as it solves this case too. But this does not preclude doing that.

@dolmen are you satisfied with the changes you requested?