@@ -23,7 +23,6 @@ import (

 	networktypes "github.com/docker/docker/api/types/network"

 	"github.com/docker/docker/api/types/versions"

 	"github.com/docker/docker/client"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/cli"

 	"github.com/docker/docker/integration-cli/cli/build"

 	"github.com/docker/docker/internal/test/request"

@@ -578,10 +577,10 @@ func (s *DockerSuite) TestContainerAPICreateMultipleNetworksConfig(c *testing.T)

 	_, err = cli.ContainerCreate(context.Background(), &config, &containertypes.HostConfig{}, &networkingConfig, "")

 	msg := err.Error()

 	// network name order in error message is not deterministic

-	assert.Assert(c, msg, checker.Contains, "Container cannot be connected to network endpoints")

-	assert.Assert(c, msg, checker.Contains, "net1")

-	assert.Assert(c, msg, checker.Contains, "net2")

-	assert.Assert(c, msg, checker.Contains, "net3")

+	assert.Assert(c, strings.Contains(msg, "Container cannot be connected to network endpoints"))

+	assert.Assert(c, strings.Contains(msg, "net1"))

+	assert.Assert(c, strings.Contains(msg, "net2"))

+	assert.Assert(c, strings.Contains(msg, "net3"))

 }

 func (s *DockerSuite) TestContainerAPICreateBridgeNetworkMode(c *testing.T) {

@@ -714,7 +713,7 @@ func (s *DockerSuite) TestContainerAPIInvalidPortSyntax(c *testing.T) {

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

-	assert.Assert(c, string(b[:]), checker.Contains, "invalid port")

+	assert.Assert(c, strings.Contains(string(b[:]), "invalid port"))

 }

 func (s *DockerSuite) TestContainerAPIRestartPolicyInvalidPolicyName(c *testing.T) {

@@ -738,7 +737,7 @@ func (s *DockerSuite) TestContainerAPIRestartPolicyInvalidPolicyName(c *testing.

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

-	assert.Assert(c, string(b[:]), checker.Contains, "invalid restart policy")

+	assert.Assert(c, strings.Contains(string(b[:]), "invalid restart policy"))

 }

 func (s *DockerSuite) TestContainerAPIRestartPolicyRetryMismatch(c *testing.T) {

@@ -762,7 +761,7 @@ func (s *DockerSuite) TestContainerAPIRestartPolicyRetryMismatch(c *testing.T) {

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

-	assert.Assert(c, string(b[:]), checker.Contains, "maximum retry count cannot be used with restart policy")

+	assert.Assert(c, strings.Contains(string(b[:]), "maximum retry count cannot be used with restart policy"))

 }

 func (s *DockerSuite) TestContainerAPIRestartPolicyNegativeRetryCount(c *testing.T) {

@@ -786,7 +785,7 @@ func (s *DockerSuite) TestContainerAPIRestartPolicyNegativeRetryCount(c *testing

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

-	assert.Assert(c, string(b[:]), checker.Contains, "maximum retry count cannot be negative")

+	assert.Assert(c, strings.Contains(string(b[:]), "maximum retry count cannot be negative"))

 }

 func (s *DockerSuite) TestContainerAPIRestartPolicyDefaultRetryCount(c *testing.T) {

@@ -872,7 +871,7 @@ func (s *DockerSuite) TestCreateWithTooLowMemoryLimit(c *testing.T) {

 	} else {

 		assert.Assert(c, res.StatusCode != http.StatusOK)

 	}

-	assert.Assert(c, string(b), checker.Contains, "Minimum memory limit allowed is 4MB")

+	assert.Assert(c, strings.Contains(string(b), "Minimum memory limit allowed is 4MB"))

 }

 func (s *DockerSuite) TestContainerAPIRename(c *testing.T) {

@@ -2232,7 +2231,7 @@ func (s *DockerSuite) TestContainersAPICreateMountsTmpfs(c *testing.T) {

 		assert.NilError(c, err)

 		out, _ := dockerCmd(c, "start", "-a", cName)

 		for _, option := range x.expectedOptions {

-			assert.Assert(c, out, checker.Contains, option)

+			assert.Assert(c, strings.Contains(out, option))

 		}

 	}

 }

@@ -17,7 +17,6 @@ import (

 	"text/template"

 	"time"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/cli"

 	"github.com/docker/docker/integration-cli/cli/build"

 	"github.com/docker/docker/internal/test/fakecontext"

@@ -4581,9 +4580,9 @@ func (s *DockerSuite) TestBuildBuildTimeArgEnv(c *testing.T) {

 	out := result.Combined()[i:] // "out" should contain just the warning message now

 	// These were specified on a --build-arg but no ARG was in the Dockerfile

-	assert.Assert(c, out, checker.Contains, "FOO7")

-	assert.Assert(c, out, checker.Contains, "FOO8")

-	assert.Assert(c, out, checker.Contains, "FOO9")

+	assert.Assert(c, strings.Contains(out, "FOO7"))

+	assert.Assert(c, strings.Contains(out, "FOO8"))

+	assert.Assert(c, strings.Contains(out, "FOO9"))

 }

 func (s *DockerSuite) TestBuildBuildTimeArgQuotedValVariants(c *testing.T) {

@@ -4654,11 +4653,10 @@ func (s *DockerSuite) TestBuildMultiStageArg(c *testing.T) {

 	parentID := strings.TrimSpace(result.Stdout())

 	result = cli.DockerCmd(c, "run", "--rm", parentID, "cat", "/out")

-	assert.Assert(c, result.Stdout(), checker.Contains, "foo=abc")

-

+	assert.Assert(c, strings.Contains(result.Stdout(), "foo=abc"))

 	result = cli.DockerCmd(c, "run", "--rm", imgName, "cat", "/out")

 	assert.Assert(c, !strings.Contains(result.Stdout(), "foo"))

-	assert.Assert(c, result.Stdout(), checker.Contains, "bar=def")

+	assert.Assert(c, strings.Contains(result.Stdout(), "bar=def"))

 }

 func (s *DockerSuite) TestBuildMultiStageGlobalArg(c *testing.T) {

@@ -4682,7 +4680,7 @@ func (s *DockerSuite) TestBuildMultiStageGlobalArg(c *testing.T) {

 	result = cli.DockerCmd(c, "run", "--rm", parentID, "cat", "/out")

 	assert.Assert(c, !strings.Contains(result.Stdout(), "tag"))

 	result = cli.DockerCmd(c, "run", "--rm", imgName, "cat", "/out")

-	assert.Assert(c, result.Stdout(), checker.Contains, "tag=latest")

+	assert.Assert(c, strings.Contains(result.Stdout(), "tag=latest"))

 }

 func (s *DockerSuite) TestBuildMultiStageUnusedArg(c *testing.T) {

@@ -4697,9 +4695,8 @@ func (s *DockerSuite) TestBuildMultiStageUnusedArg(c *testing.T) {

 		build.WithDockerfile(dockerfile),

 		cli.WithFlags("--build-arg", fmt.Sprintf("baz=abc")))

 	result.Assert(c, icmd.Success)

-	assert.Assert(c, result.Combined(), checker.Contains, "[Warning]")

-	assert.Assert(c, result.Combined(), checker.Contains, "[baz] were not consumed")

-

+	assert.Assert(c, strings.Contains(result.Combined(), "[Warning]"))

+	assert.Assert(c, strings.Contains(result.Combined(), "[baz] were not consumed"))

 	result = cli.DockerCmd(c, "run", "--rm", imgName, "cat", "/out")

 	assert.Assert(c, !strings.Contains(result.Stdout(), "bar"))

 	assert.Assert(c, !strings.Contains(result.Stdout(), "baz"))

@@ -5408,9 +5405,9 @@ func (s *DockerSuite) TestBuildStepsWithProgress(c *testing.T) {

 	totalRun := 5

 	result := buildImage(name, build.WithDockerfile("FROM busybox\n"+strings.Repeat("RUN echo foo\n", totalRun)))

 	result.Assert(c, icmd.Success)

-	assert.Assert(c, result.Combined(), checker.Contains, fmt.Sprintf("Step 1/%d : FROM busybox", 1+totalRun))

+	assert.Assert(c, strings.Contains(result.Combined(), fmt.Sprintf("Step 1/%d : FROM busybox", 1+totalRun)))

 	for i := 2; i <= 1+totalRun; i++ {

-		assert.Assert(c, result.Combined(), checker.Contains, fmt.Sprintf("Step %d/%d : RUN echo foo", i, 1+totalRun))

+		assert.Assert(c, strings.Contains(result.Combined(), fmt.Sprintf("Step %d/%d : RUN echo foo", i, 1+totalRun)))

 	}

 }

@@ -5421,9 +5418,8 @@ func (s *DockerSuite) TestBuildWithFailure(c *testing.T) {

 	dockerfile := "FROM busybox\nRUN nobody"

 	result := buildImage(name, build.WithDockerfile(dockerfile))

 	assert.Assert(c, result.Error != nil)

-	assert.Assert(c, result.Stdout(), checker.Contains, "Step 1/2 : FROM busybox")

-	assert.Assert(c, result.Stdout(), checker.Contains, "Step 2/2 : RUN nobody")

-

+	assert.Assert(c, strings.Contains(result.Stdout(), "Step 1/2 : FROM busybox"))

+	assert.Assert(c, strings.Contains(result.Stdout(), "Step 2/2 : RUN nobody"))

 	// Second test case `FFOM` should have been detected before build runs so no steps

 	dockerfile = "FFOM nobody\nRUN nobody"

 	result = buildImage(name, build.WithDockerfile(dockerfile))

@@ -5653,20 +5649,18 @@ func (s *DockerSuite) TestBuildContChar(c *testing.T) {

 	result := buildImage(name, build.WithDockerfile(`FROM busybox

 		 RUN echo hi \`))

 	result.Assert(c, icmd.Success)

-	assert.Assert(c, result.Combined(), checker.Contains, "Step 1/2 : FROM busybox")

-	assert.Assert(c, result.Combined(), checker.Contains, "Step 2/2 : RUN echo hi\n")

-

+	assert.Assert(c, strings.Contains(result.Combined(), "Step 1/2 : FROM busybox"))

+	assert.Assert(c, strings.Contains(result.Combined(), "Step 2/2 : RUN echo hi\n"))

 	result = buildImage(name, build.WithDockerfile(`FROM busybox

 		 RUN echo hi \\`))

 	result.Assert(c, icmd.Success)

-	assert.Assert(c, result.Combined(), checker.Contains, "Step 1/2 : FROM busybox")

-	assert.Assert(c, result.Combined(), checker.Contains, "Step 2/2 : RUN echo hi \\\n")

-

+	assert.Assert(c, strings.Contains(result.Combined(), "Step 1/2 : FROM busybox"))

+	assert.Assert(c, strings.Contains(result.Combined(), "Step 2/2 : RUN echo hi \\\n"))

 	result = buildImage(name, build.WithDockerfile(`FROM busybox

 		 RUN echo hi \\\`))

 	result.Assert(c, icmd.Success)

-	assert.Assert(c, result.Combined(), checker.Contains, "Step 1/2 : FROM busybox")

-	assert.Assert(c, result.Combined(), checker.Contains, "Step 2/2 : RUN echo hi \\\\\n")

+	assert.Assert(c, strings.Contains(result.Combined(), "Step 1/2 : FROM busybox"))

+	assert.Assert(c, strings.Contains(result.Combined(), "Step 2/2 : RUN echo hi \\\\\n"))

 }

 func (s *DockerSuite) TestBuildMultiStageCopyFromSyntax(c *testing.T) {

@@ -12,7 +12,6 @@ import (

 	"github.com/docker/distribution/manifest/schema1"

 	"github.com/docker/distribution/manifest/schema2"

 	"github.com/docker/docker/api/types"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/cli"

 	"github.com/docker/docker/integration-cli/cli/build"

 	"github.com/go-check/check"

@@ -117,7 +116,7 @@ func testPullByDigestNoFallback(c *testing.T) {

 	imageReference := fmt.Sprintf("%s@sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", repoName)

 	out, _, err := dockerCmdWithError("pull", imageReference)

 	assert.Assert(c, err != nil, check.Commentf("expected non-zero exit status and correct error message when pulling non-existing image"))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("manifest for %s not found", imageReference), check.Commentf("expected non-zero exit status and correct error message when pulling non-existing image"))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("manifest for %s not found", imageReference)), check.Commentf("expected non-zero exit status and correct error message when pulling non-existing image"))

 }

 func (s *DockerRegistrySuite) TestPullByDigestNoFallback(c *testing.T) {

@@ -602,7 +601,7 @@ func (s *DockerSchema1RegistrySuite) TestPullFailsWithAlteredManifest(c *testing

 	assert.Assert(c, exitStatus != 0)

 	expectedErrorMsg := fmt.Sprintf("image verification failed for digest %s", manifestDigest)

-	assert.Assert(c, out, checker.Contains, expectedErrorMsg)

+	assert.Assert(c, strings.Contains(out, expectedErrorMsg))

 }

 // TestPullFailsWithAlteredLayer tests that a `docker pull` fails when

@@ -645,7 +644,7 @@ func (s *DockerRegistrySuite) TestPullFailsWithAlteredLayer(c *testing.T) {

 	assert.Assert(c, exitStatus != 0, check.Commentf("expected a non-zero exit status"))

 	expectedErrorMsg := fmt.Sprintf("filesystem layer verification failed for digest %s", targetLayerDigest)

-	assert.Assert(c, out, checker.Contains, expectedErrorMsg, check.Commentf("expected error message in output: %s", out))

+	assert.Assert(c, strings.Contains(out, expectedErrorMsg), check.Commentf("expected error message in output: %s", out))

 }

 // TestPullFailsWithAlteredLayer tests that a `docker pull` fails when

@@ -688,5 +687,5 @@ func (s *DockerSchema1RegistrySuite) TestPullFailsWithAlteredLayer(c *testing.T)

 	assert.Assert(c, exitStatus != 0, check.Commentf("expected a non-zero exit status"))

 	expectedErrorMsg := fmt.Sprintf("filesystem layer verification failed for digest %s", targetLayerDigest)

-	assert.Assert(c, out, checker.Contains, expectedErrorMsg, check.Commentf("expected error message in output: %s", out))

+	assert.Assert(c, strings.Contains(out, expectedErrorMsg), check.Commentf("expected error message in output: %s", out))

 }

@@ -5,7 +5,6 @@ import (

 	"testing"

 	"github.com/docker/docker/api/types/versions"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/cli"

 	"github.com/go-check/check"

 	"gotest.tools/assert"

@@ -52,7 +51,7 @@ func (s *DockerSuite) TestCommitPausedContainer(c *testing.T) {

 	out = inspectField(c, cleanedContainerID, "State.Paused")

 	// commit should not unpause a paused container

-	assert.Assert(c, out, checker.Contains, "true")

+	assert.Assert(c, strings.Contains(out, "true"))

 }

 func (s *DockerSuite) TestCommitNewFile(c *testing.T) {

@@ -73,8 +72,7 @@ func (s *DockerSuite) TestCommitHardlink(c *testing.T) {

 	chunks := strings.Split(strings.TrimSpace(firstOutput), " ")

 	inode := chunks[0]

 	chunks = strings.SplitAfterN(strings.TrimSpace(firstOutput), " ", 2)

-	assert.Assert(c, chunks[1], checker.Contains, chunks[0], check.Commentf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:]))

-

+	assert.Assert(c, strings.Contains(chunks[1], chunks[0]), check.Commentf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:]))

 	imageID, _ := dockerCmd(c, "commit", "hardlinks", "hardlinks")

 	imageID = strings.TrimSpace(imageID)

@@ -83,7 +81,7 @@ func (s *DockerSuite) TestCommitHardlink(c *testing.T) {

 	chunks = strings.Split(strings.TrimSpace(secondOutput), " ")

 	inode = chunks[0]

 	chunks = strings.SplitAfterN(strings.TrimSpace(secondOutput), " ", 2)

-	assert.Assert(c, chunks[1], checker.Contains, chunks[0], check.Commentf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:]))

+	assert.Assert(c, strings.Contains(chunks[1], chunks[0]), check.Commentf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:]))

 }

 func (s *DockerSuite) TestCommitTTY(c *testing.T) {

@@ -9,7 +9,6 @@ import (

 	"testing"

 	"time"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/cli"

 	"github.com/docker/docker/integration-cli/cli/build"

 	"github.com/docker/docker/internal/test/fakecontext"

@@ -79,7 +78,7 @@ func (s *DockerSuite) TestCreateShrinkRootfs(c *testing.T) {

 	// Ensure this fails because of the defaultBaseFsSize is 10G

 	out, _, err := dockerCmdWithError("create", "--storage-opt", "size=5G", "busybox")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "Container size cannot be smaller than")

+	assert.Assert(c, strings.Contains(out, "Container size cannot be smaller than"))

 }

 // Make sure we can set hostconfig options too

@@ -296,8 +295,7 @@ func (s *DockerSuite) TestCreateStopSignal(c *testing.T) {

 	dockerCmd(c, "create", "--name", name, "--stop-signal", "9", "busybox")

 	res := inspectFieldJSON(c, name, "Config.StopSignal")

-	assert.Assert(c, res, checker.Contains, "9")

-

+	assert.Assert(c, strings.Contains(res, "9"))

 }

 func (s *DockerSuite) TestCreateWithWorkdir(c *testing.T) {

@@ -326,7 +324,7 @@ func (s *DockerSuite) TestCreateWithInvalidLogOpts(c *testing.T) {

 	name := "test-invalidate-log-opts"

 	out, _, err := dockerCmdWithError("create", "--name", name, "--log-opt", "invalid=true", "busybox")

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, out, checker.Contains, "unknown log opt")

+	assert.Assert(c, strings.Contains(out, "unknown log opt"))

 	assert.Assert(c, is.Contains(out, "unknown log opt"))

 	out, _ = dockerCmd(c, "ps", "-a")

@@ -374,11 +372,10 @@ func (s *DockerSuite) TestCreateStopTimeout(c *testing.T) {

 	dockerCmd(c, "create", "--name", name1, "--stop-timeout", "15", "busybox")

 	res := inspectFieldJSON(c, name1, "Config.StopTimeout")

-	assert.Assert(c, res, checker.Contains, "15")

-

+	assert.Assert(c, strings.Contains(res, "15"))

 	name2 := "test_create_stop_timeout_2"

 	dockerCmd(c, "create", "--name", name2, "busybox")

 	res = inspectFieldJSON(c, name2, "Config.StopTimeout")

-	assert.Assert(c, res, checker.Contains, "null")

+	assert.Assert(c, strings.Contains(res, "null"))

 }

@@ -474,7 +474,7 @@ func (s *DockerDaemonSuite) TestDaemonIPv6HostMode(c *testing.T) {

 	out, err = s.d.Cmd("exec", "hostcnt", "ip", "-6", "addr", "show", "docker0")

 	assert.NilError(c, err, out)

-	assert.Assert(c, strings.Trim(out, " \r\n'"), checker.Contains, "2001:db8:2::1")

+	assert.Assert(c, strings.Contains(strings.Trim(out, " \r\n'"), "2001:db8:2::1"))

 }

 func (s *DockerDaemonSuite) TestDaemonLogLevelWrong(c *testing.T) {

@@ -1154,7 +1154,7 @@ func (s *DockerDaemonSuite) TestDaemonLoggingDriverShouldBeIgnoredForBuild(c *te

 	comment := check.Commentf("Failed to build image. output %s, exitCode %d, err %v", result.Combined(), result.ExitCode, result.Error)

 	assert.Assert(c, result.Error == nil, comment)

 	assert.Equal(c, result.ExitCode, 0, comment)

-	assert.Assert(c, result.Combined(), checker.Contains, "foo", comment)

+	assert.Assert(c, strings.Contains(result.Combined(), "foo"), comment)

 }

 func (s *DockerDaemonSuite) TestDaemonUnixSockCleanedUp(c *testing.T) {

@@ -1632,7 +1632,7 @@ func (s *DockerDaemonSuite) TestDaemonRestartRmVolumeInUse(c *testing.T) {

 	out, err = s.d.Cmd("volume", "rm", "test")

 	assert.Assert(c, err != nil, check.Commentf("should not be able to remove in use volume after daemon restart"))

-	assert.Assert(c, out, checker.Contains, "in use")

+	assert.Assert(c, strings.Contains(out, "in use"))

 }

 func (s *DockerDaemonSuite) TestDaemonRestartLocalVolumes(c *testing.T) {

@@ -1781,7 +1781,7 @@ func (s *DockerDaemonSuite) TestDaemonNoSpaceLeftOnDeviceError(c *testing.T) {

 	// pull a repository large enough to overfill the mounted filesystem

 	pullOut, err := s.d.Cmd("pull", "debian:stretch")

 	assert.Assert(c, err != nil, check.Commentf("%s", pullOut))

-	assert.Assert(c, pullOut, checker.Contains, "no space left on device")

+	assert.Assert(c, strings.Contains(pullOut, "no space left on device"))

 }

 // Test daemon restart with container links + auto restart

@@ -2104,8 +2104,7 @@ func (s *DockerDaemonSuite) TestRunLinksChanged(c *testing.T) {

 	out, err = s.d.Cmd("run", "--name=test2", "--link=test:abc", "busybox", "sh", "-c", "ping -c 1 abc")

 	assert.NilError(c, err, out)

-	assert.Assert(c, out, checker.Contains, "1 packets transmitted, 1 packets received")

-

+	assert.Assert(c, strings.Contains(out, "1 packets transmitted, 1 packets received"))

 	out, err = s.d.Cmd("rm", "-f", "test")

 	assert.NilError(c, err, out)

@@ -2145,8 +2144,7 @@ func (s *DockerDaemonSuite) TestDaemonStartWithoutColors(c *testing.T) {

 	s.d.Stop(c)

 	// Wait for io.Copy() before checking output

 	<-done

-	assert.Assert(c, b.String(), checker.Contains, infoLog)

-

+	assert.Assert(c, strings.Contains(b.String(), infoLog))

 	b.Reset()

 	// "tty" is already closed in prev s.d.Stop(),

@@ -2187,7 +2185,7 @@ func (s *DockerDaemonSuite) TestDaemonDebugLog(c *testing.T) {

 	s.d.StartWithLogFile(tty, "--debug")

 	s.d.Stop(c)

-	assert.Assert(c, b.String(), checker.Contains, debugLog)

+	assert.Assert(c, strings.Contains(b.String(), debugLog))

 }

 func (s *DockerDaemonSuite) TestDaemonDiscoveryBackendConfigReload(c *testing.T) {

@@ -2231,8 +2229,8 @@ func (s *DockerDaemonSuite) TestDaemonDiscoveryBackendConfigReload(c *testing.T)

 	out, err := s.d.Cmd("info")

 	assert.NilError(c, err)

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Store: consul://consuladdr:consulport/some/path"))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Advertise: 192.168.56.100:0"))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Store: consul://consuladdr:consulport/some/path")))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Advertise: 192.168.56.100:0")))

 }

 // Test for #21956

@@ -2245,7 +2243,7 @@ func (s *DockerDaemonSuite) TestDaemonLogOptions(c *testing.T) {

 	out, err = s.d.Cmd("inspect", "--format='{{.HostConfig.LogConfig}}'", id)

 	assert.NilError(c, err, out)

-	assert.Assert(c, out, checker.Contains, "{json-file map[]}")

+	assert.Assert(c, strings.Contains(out, "{json-file map[]}"))

 }

 // Test case for #20936, #22443

@@ -2256,8 +2254,8 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrency(c *testing.T) {

 	expectedMaxConcurrentDownloads := `level=debug msg="Max Concurrent Downloads: 8"`

 	content, err := s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentUploads)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentDownloads)

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentUploads))

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentDownloads))

 }

 // Test case for #20936, #22443

@@ -2279,9 +2277,8 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrencyWithConfigFile(c *testing.T)

 	expectedMaxConcurrentDownloads := `level=debug msg="Max Concurrent Downloads: 8"`

 	content, err := s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentUploads)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentDownloads)

-

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentUploads))

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentDownloads))

 	configFile, err = os.Create(configFilePath)

 	assert.NilError(c, err)

 	daemonConfig = `{ "max-concurrent-uploads" : 7, "max-concurrent-downloads" : 9 }`

@@ -2297,8 +2294,8 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrencyWithConfigFile(c *testing.T)

 	expectedMaxConcurrentDownloads = `level=debug msg="Reset Max Concurrent Downloads: 9"`

 	content, err = s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentUploads)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentDownloads)

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentUploads))

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentDownloads))

 }

 // Test case for #20936, #22443

@@ -2320,9 +2317,8 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrencyWithConfigFileReload(c *test

 	expectedMaxConcurrentDownloads := `level=debug msg="Max Concurrent Downloads: 3"`

 	content, err := s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentUploads)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentDownloads)

-

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentUploads))

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentDownloads))

 	configFile, err = os.Create(configFilePath)

 	assert.NilError(c, err)

 	daemonConfig = `{ "max-concurrent-uploads" : 1, "max-concurrent-downloads" : null }`

@@ -2338,9 +2334,8 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrencyWithConfigFileReload(c *test

 	expectedMaxConcurrentDownloads = `level=debug msg="Reset Max Concurrent Downloads: 3"`

 	content, err = s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentUploads)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentDownloads)

-

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentUploads))

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentDownloads))

 	configFile, err = os.Create(configFilePath)

 	assert.NilError(c, err)

 	daemonConfig = `{ "labels":["foo=bar"] }`

@@ -2355,8 +2350,8 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrencyWithConfigFileReload(c *test

 	expectedMaxConcurrentDownloads = `level=debug msg="Reset Max Concurrent Downloads: 3"`

 	content, err = s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentUploads)

-	assert.Assert(c, string(content), checker.Contains, expectedMaxConcurrentDownloads)

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentUploads))

+	assert.Assert(c, strings.Contains(string(content), expectedMaxConcurrentDownloads))

 }

 func (s *DockerDaemonSuite) TestBuildOnDisabledBridgeNetworkDaemon(c *testing.T) {

@@ -2381,11 +2376,11 @@ func (s *DockerDaemonSuite) TestDaemonDNSFlagsInHostMode(c *testing.T) {

 	expectedOutput := "nameserver 1.2.3.4"

 	out, _ := s.d.Cmd("run", "--net=host", "busybox", "cat", "/etc/resolv.conf")

-	assert.Assert(c, out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))

+	assert.Assert(c, strings.Contains(out, expectedOutput), check.Commentf("Expected '%s', but got %q", expectedOutput, out))

 	expectedOutput = "search example.com"

-	assert.Assert(c, out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))

+	assert.Assert(c, strings.Contains(out, expectedOutput), check.Commentf("Expected '%s', but got %q", expectedOutput, out))

 	expectedOutput = "options timeout:3"

-	assert.Assert(c, out, checker.Contains, expectedOutput, check.Commentf("Expected '%s', but got %q", expectedOutput, out))

+	assert.Assert(c, strings.Contains(out, expectedOutput), check.Commentf("Expected '%s', but got %q", expectedOutput, out))

 }

 func (s *DockerDaemonSuite) TestRunWithRuntimeFromConfigFile(c *testing.T) {

@@ -2428,8 +2423,7 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromConfigFile(c *testing.T) {

 	// Run with "vm"

 	out, err = s.d.Cmd("run", "--rm", "--runtime=vm", "busybox", "ls")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "/usr/local/bin/vm-manager: no such file or directory")

-

+	assert.Assert(c, strings.Contains(out, "/usr/local/bin/vm-manager: no such file or directory"))

 	// Reset config to only have the default

 	config = `

 {

@@ -2449,13 +2443,11 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromConfigFile(c *testing.T) {

 	// Run with "oci"

 	out, err = s.d.Cmd("run", "--rm", "--runtime=oci", "busybox", "ls")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "Unknown runtime specified oci")

-

+	assert.Assert(c, strings.Contains(out, "Unknown runtime specified oci"))

 	// Start previously created container with oci

 	out, err = s.d.Cmd("start", "oci-runtime-ls")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "Unknown runtime specified oci")

-

+	assert.Assert(c, strings.Contains(out, "Unknown runtime specified oci"))

 	// Check that we can't override the default runtime

 	config = `

 {

@@ -2473,8 +2465,7 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromConfigFile(c *testing.T) {

 	content, err := s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, `file configuration validation failed: runtime name 'runc' is reserved`)

-

+	assert.Assert(c, strings.Contains(string(content), `file configuration validation failed: runtime name 'runc' is reserved`))

 	// Check that we can select a default runtime

 	config = `

 {

@@ -2499,8 +2490,7 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromConfigFile(c *testing.T) {

 	out, err = s.d.Cmd("run", "--rm", "busybox", "ls")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "/usr/local/bin/vm-manager: no such file or directory")

-

+	assert.Assert(c, strings.Contains(out, "/usr/local/bin/vm-manager: no such file or directory"))

 	// Run with default runtime explicitly

 	out, err = s.d.Cmd("run", "--rm", "--runtime=runc", "busybox", "ls")

 	assert.NilError(c, err, out)

@@ -2524,8 +2514,7 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromCommandLine(c *testing.T) {

 	// Run with "vm"

 	out, err = s.d.Cmd("run", "--rm", "--runtime=vm", "busybox", "ls")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "/usr/local/bin/vm-manager: no such file or directory")

-

+	assert.Assert(c, strings.Contains(out, "/usr/local/bin/vm-manager: no such file or directory"))

 	// Start a daemon without any extra runtimes

 	s.d.Stop(c)

 	s.d.StartWithBusybox(c)

@@ -2537,29 +2526,25 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromCommandLine(c *testing.T) {

 	// Run with "oci"

 	out, err = s.d.Cmd("run", "--rm", "--runtime=oci", "busybox", "ls")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "Unknown runtime specified oci")

-

+	assert.Assert(c, strings.Contains(out, "Unknown runtime specified oci"))

 	// Start previously created container with oci

 	out, err = s.d.Cmd("start", "oci-runtime-ls")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "Unknown runtime specified oci")

-

+	assert.Assert(c, strings.Contains(out, "Unknown runtime specified oci"))

 	// Check that we can't override the default runtime

 	s.d.Stop(c)

 	assert.Assert(c, s.d.StartWithError("--add-runtime", "runc=my-runc") != nil)

 	content, err := s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, `runtime name 'runc' is reserved`)

-

+	assert.Assert(c, strings.Contains(string(content), `runtime name 'runc' is reserved`))

 	// Check that we can select a default runtime

 	s.d.Stop(c)

 	s.d.StartWithBusybox(c, "--default-runtime=vm", "--add-runtime", "oci=runc", "--add-runtime", "vm=/usr/local/bin/vm-manager")

 	out, err = s.d.Cmd("run", "--rm", "busybox", "ls")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "/usr/local/bin/vm-manager: no such file or directory")

-

+	assert.Assert(c, strings.Contains(out, "/usr/local/bin/vm-manager: no such file or directory"))

 	// Run with default runtime explicitly

 	out, err = s.d.Cmd("run", "--rm", "--runtime=runc", "busybox", "ls")

 	assert.NilError(c, err, out)

@@ -2577,15 +2562,14 @@ func (s *DockerDaemonSuite) TestDaemonRestartWithAutoRemoveContainer(c *testing.

 	out, err = s.d.Cmd("ps")

 	assert.NilError(c, err)

-	assert.Assert(c, out, checker.Contains, "top1", check.Commentf("top1 should be running"))

-	assert.Assert(c, out, checker.Contains, "top2", check.Commentf("top2 should be running"))

-

+	assert.Assert(c, strings.Contains(out, "top1"), check.Commentf("top1 should be running"))

+	assert.Assert(c, strings.Contains(out, "top2"), check.Commentf("top2 should be running"))

 	// now restart daemon gracefully

 	s.d.Restart(c)

 	out, err = s.d.Cmd("ps", "-a")

 	assert.NilError(c, err, "out: %v", out)

-	assert.Assert(c, out, checker.Contains, "top1", check.Commentf("top1 should exist after daemon restarts"))

+	assert.Assert(c, strings.Contains(out, "top1"), check.Commentf("top1 should exist after daemon restarts"))

 	assert.Assert(c, !strings.Contains(out, "top2"), check.Commentf("top2 should be removed after daemon restarts"))

 }

@@ -2613,8 +2597,7 @@ func (s *DockerDaemonSuite) TestDaemonRestartSaveContainerExitCode(c *testing.T)

 	errMsg1, err := s.d.Cmd("inspect", "-f", "{{.State.Error}}", containerName)

 	errMsg1 = strings.TrimSpace(errMsg1)

 	assert.NilError(c, err)

-	assert.Assert(c, errMsg1, checker.Contains, "executable file not found")

-

+	assert.Assert(c, strings.Contains(errMsg1, "executable file not found"))

 	// now restart daemon

 	s.d.Restart(c)

@@ -2656,8 +2639,8 @@ func (s *DockerDaemonSuite) TestDaemonWithUserlandProxyPath(c *testing.T) {

 	s.d.Restart(c, "--userland-proxy-path", "/does/not/exist")

 	out, err = s.d.Cmd("run", "-p", "5000:5000", "busybox:latest", "true")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "driver failed programming external connectivity on endpoint")

-	assert.Assert(c, out, checker.Contains, "/does/not/exist: no such file or directory")

+	assert.Assert(c, strings.Contains(out, "driver failed programming external connectivity on endpoint"))

+	assert.Assert(c, strings.Contains(out, "/does/not/exist: no such file or directory"))

 }

 // Test case for #22471

@@ -2678,7 +2661,7 @@ func (s *DockerDaemonSuite) TestDaemonShutdownTimeout(c *testing.T) {

 	expectedMessage := `level=debug msg="daemon configured with a 3 seconds minimum shutdown timeout"`

 	content, err := s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, expectedMessage)

+	assert.Assert(c, strings.Contains(string(content), expectedMessage))

 }

 // Test case for #22471

@@ -2712,7 +2695,7 @@ func (s *DockerDaemonSuite) TestDaemonShutdownTimeoutWithConfigFile(c *testing.T

 	expectedMessage := `level=debug msg="Reset Shutdown Timeout: 5"`

 	content, err := s.d.ReadLogFile()

 	assert.NilError(c, err)

-	assert.Assert(c, string(content), checker.Contains, expectedMessage)

+	assert.Assert(c, strings.Contains(string(content), expectedMessage))

 }

 // Test case for 29342

@@ -17,7 +17,6 @@ import (

 	"time"

 	"github.com/docker/docker/api/types"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/daemon"

 	testdaemon "github.com/docker/docker/internal/test/daemon"

 	"github.com/docker/docker/pkg/stringid"

@@ -287,8 +286,7 @@ func (s *DockerExternalVolumeSuite) TestVolumeCLICreateOptionConflict(c *testing

 	out, _, err := dockerCmdWithError("volume", "create", "test", "--driver", volumePluginName)

 	assert.Assert(c, err != nil, check.Commentf("volume create exception name already in use with another driver"))

-	assert.Assert(c, out, checker.Contains, "must be unique")

-

+	assert.Assert(c, strings.Contains(out, "must be unique"))

 	out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Driver }}", "test")

 	_, _, err = dockerCmdWithError("volume", "create", "test", "--driver", strings.TrimSpace(out))

 	assert.NilError(c, err)

@@ -299,8 +297,7 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverNamed(c *testing.T)

 	out, err := s.d.Cmd("run", "--rm", "--name", "test-data", "-v", "external-volume-test:/tmp/external-volume-test", "--volume-driver", volumePluginName, "busybox:latest", "cat", "/tmp/external-volume-test/test")

 	assert.NilError(c, err, out)

-	assert.Assert(c, out, checker.Contains, s.Server.URL)

-

+	assert.Assert(c, strings.Contains(out, s.Server.URL))

 	_, err = s.d.Cmd("volume", "rm", "external-volume-test")

 	assert.NilError(c, err)

@@ -321,8 +318,7 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnnamed(c *testing.T

 	out, err := s.d.Cmd("run", "--rm", "--name", "test-data", "-v", "/tmp/external-volume-test", "--volume-driver", volumePluginName, "busybox:latest", "cat", "/tmp/external-volume-test/test")

 	assert.NilError(c, err, out)

-	assert.Assert(c, out, checker.Contains, s.Server.URL)

-

+	assert.Assert(c, strings.Contains(out, s.Server.URL))

 	assert.Equal(c, s.ec.activations, 1)

 	assert.Equal(c, s.ec.creations, 1)

 	assert.Equal(c, s.ec.removals, 1)

@@ -475,7 +471,7 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverList(c *testing.T) {

 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGet(c *testing.T) {

 	out, _, err := dockerCmdWithError("volume", "inspect", "dummy")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "No such volume")

+	assert.Assert(c, strings.Contains(out, "No such volume"))

 	assert.Equal(c, s.ec.gets, 1)

 	dockerCmd(c, "volume", "create", "test", "-d", volumePluginName)

@@ -513,7 +509,7 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGetEmptyResponse(c *

 	out, err = s.d.Cmd("volume", "inspect", "abc2")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "No such volume")

+	assert.Assert(c, strings.Contains(out, "No such volume"))

 }

 // Ensure only cached paths are used in volume list to prevent N+1 calls to `VolumeDriver.Path`

@@ -568,8 +564,7 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverOutOfBandDelete(c *t

 	out, err = s.d.Cmd("volume", "create", "-d", "local", "--name", "test")

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, checker.Contains, "must be unique")

-

+	assert.Assert(c, strings.Contains(out, "must be unique"))

 	// simulate out of band volume deletion on plugin level

 	delete(p.vols, "test")

@@ -7,7 +7,6 @@ import (

 	"strings"

 	"testing"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/cli/build"

 	"github.com/go-check/check"

 	"gotest.tools/assert"

@@ -53,7 +52,7 @@ LABEL label.Z="Z"`))

 	for i := 0; i < 26; i++ {

 		echoValue := fmt.Sprintf("LABEL label.%s=%s", expectedValues[i], expectedValues[i])

 		actualValue := actualValues[i]

-		assert.Assert(c, actualValue, checker.Contains, echoValue)

+		assert.Assert(c, strings.Contains(actualValue, echoValue))

 	}

 }

@@ -83,7 +82,7 @@ func (s *DockerSuite) TestHistoryImageWithComment(c *testing.T) {

 	out, _ := dockerCmd(c, "history", name)

 	outputTabs := strings.Fields(strings.Split(out, "\n")[1])

 	actualValue := outputTabs[len(outputTabs)-1]

-	assert.Assert(c, actualValue, checker.Contains, comment)

+	assert.Assert(c, strings.Contains(actualValue, comment))

 }

 func (s *DockerSuite) TestHistoryHumanOptionFalse(c *testing.T) {

@@ -11,7 +11,6 @@ import (

 	"testing"

 	"time"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/cli/build"

 	"github.com/docker/docker/pkg/stringid"

 	"github.com/go-check/check"

@@ -22,7 +21,7 @@ import (

 func (s *DockerSuite) TestImagesEnsureImageIsListed(c *testing.T) {

 	imagesOut, _ := dockerCmd(c, "images")

-	assert.Assert(c, imagesOut, checker.Contains, "busybox")

+	assert.Assert(c, strings.Contains(imagesOut, "busybox"))

 }

 func (s *DockerSuite) TestImagesEnsureImageWithTagIsListed(c *testing.T) {

@@ -32,15 +31,15 @@ func (s *DockerSuite) TestImagesEnsureImageWithTagIsListed(c *testing.T) {

 	dockerCmd(c, "tag", "busybox", name+":v2")

 	imagesOut, _ := dockerCmd(c, "images", name+":v1")

-	assert.Assert(c, imagesOut, checker.Contains, name)

-	assert.Assert(c, imagesOut, checker.Contains, "v1")

+	assert.Assert(c, strings.Contains(imagesOut, name))

+	assert.Assert(c, strings.Contains(imagesOut, "v1"))

 	assert.Assert(c, !strings.Contains(imagesOut, "v2"))

 	assert.Assert(c, !strings.Contains(imagesOut, "v1v1"))

 	imagesOut, _ = dockerCmd(c, "images", name)

-	assert.Assert(c, imagesOut, checker.Contains, name)

-	assert.Assert(c, imagesOut, checker.Contains, "v1")

-	assert.Assert(c, imagesOut, checker.Contains, "v1v1")

-	assert.Assert(c, imagesOut, checker.Contains, "v2")

+	assert.Assert(c, strings.Contains(imagesOut, name))

+	assert.Assert(c, strings.Contains(imagesOut, "v1"))

+	assert.Assert(c, strings.Contains(imagesOut, "v1v1"))

+	assert.Assert(c, strings.Contains(imagesOut, "v2"))

 }

 func (s *DockerSuite) TestImagesEnsureImageWithBadTagIsNotListed(c *testing.T) {

@@ -71,7 +70,7 @@ func (s *DockerSuite) TestImagesOrderedByCreationDate(c *testing.T) {

 func (s *DockerSuite) TestImagesErrorWithInvalidFilterNameTest(c *testing.T) {

 	out, _, err := dockerCmdWithError("images", "-f", "FOO=123")

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, out, checker.Contains, "Invalid filter")

+	assert.Assert(c, strings.Contains(out, "Invalid filter"))

 }

 func (s *DockerSuite) TestImagesFilterLabelMatch(c *testing.T) {

@@ -258,15 +257,14 @@ func (s *DockerSuite) TestImagesEnsureDanglingImageOnlyListedOnce(c *testing.T)

 	assert.Assert(c, !strings.Contains(out, imageID))

 	out, _ = dockerCmd(c, "images")

 	//docker images still include dangling images

-	assert.Assert(c, out, checker.Contains, imageID)

-

+	assert.Assert(c, strings.Contains(out, imageID))

 }

 // FIXME(vdemeester) should be a unit test for `docker image ls`

 func (s *DockerSuite) TestImagesWithIncorrectFilter(c *testing.T) {

 	out, _, err := dockerCmdWithError("images", "-f", "dangling=invalid")

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, out, checker.Contains, "Invalid filter")

+	assert.Assert(c, strings.Contains(out, "Invalid filter"))

 }

 func (s *DockerSuite) TestImagesEnsureOnlyHeadsImagesShown(c *testing.T) {

@@ -289,7 +287,7 @@ func (s *DockerSuite) TestImagesEnsureOnlyHeadsImagesShown(c *testing.T) {

 	// images shouldn't show non-heads images

 	assert.Assert(c, !strings.Contains(out, intermediate))

 	// images should contain final built images

-	assert.Assert(c, out, checker.Contains, stringid.TruncateID(id))

+	assert.Assert(c, strings.Contains(out, stringid.TruncateID(id)))

 }

 func (s *DockerSuite) TestImagesEnsureImagesFromScratchShown(c *testing.T) {

@@ -304,7 +302,7 @@ func (s *DockerSuite) TestImagesEnsureImagesFromScratchShown(c *testing.T) {

 	out, _ := dockerCmd(c, "images")

 	// images should contain images built from scratch

-	assert.Assert(c, out, checker.Contains, stringid.TruncateID(id))

+	assert.Assert(c, strings.Contains(out, stringid.TruncateID(id)))

 }

 // For W2W - equivalent to TestImagesEnsureImagesFromScratchShown but Windows

@@ -320,7 +318,7 @@ func (s *DockerSuite) TestImagesEnsureImagesFromBusyboxShown(c *testing.T) {

 	out, _ := dockerCmd(c, "images")

 	// images should contain images built from busybox

-	assert.Assert(c, out, checker.Contains, stringid.TruncateID(id))

+	assert.Assert(c, strings.Contains(out, stringid.TruncateID(id)))

 }

 // #18181

@@ -328,11 +326,9 @@ func (s *DockerSuite) TestImagesFilterNameWithPort(c *testing.T) {

 	tag := "a.b.c.d:5000/hello"

 	dockerCmd(c, "tag", "busybox", tag)

 	out, _ := dockerCmd(c, "images", tag)

-	assert.Assert(c, out, checker.Contains, tag)

-

+	assert.Assert(c, strings.Contains(out, tag))

 	out, _ = dockerCmd(c, "images", tag+":latest")

-	assert.Assert(c, out, checker.Contains, tag)

-

+	assert.Assert(c, strings.Contains(out, tag))

 	out, _ = dockerCmd(c, "images", tag+":no-such-tag")

 	assert.Assert(c, !strings.Contains(out, tag))

 }

@@ -7,7 +7,6 @@ import (

 	"strings"

 	"testing"

-	"github.com/docker/docker/integration-cli/checker"

 	"github.com/docker/docker/integration-cli/daemon"

 	testdaemon "github.com/docker/docker/internal/test/daemon"

 	"github.com/go-check/check"

@@ -54,7 +53,7 @@ func (s *DockerSuite) TestInfoEnsureSucceeds(c *testing.T) {

 	}

 	for _, linePrefix := range stringsToCheck {

-		assert.Assert(c, out, checker.Contains, linePrefix, check.Commentf("couldn't find string %v in output", linePrefix))

+		assert.Assert(c, strings.Contains(out, linePrefix), check.Commentf("couldn't find string %v in output", linePrefix))

 	}

 }

@@ -82,8 +81,8 @@ func (s *DockerSuite) TestInfoDiscoveryBackend(c *testing.T) {

 	out, err := d.Cmd("info")

 	assert.NilError(c, err)

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Advertise: %s\n", discoveryAdvertise))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend)))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Advertise: %s\n", discoveryAdvertise)))

 }

 // TestInfoDiscoveryInvalidAdvertise verifies that a daemon run with

@@ -125,8 +124,8 @@ func (s *DockerSuite) TestInfoDiscoveryAdvertiseInterfaceName(c *testing.T) {

 	out, err := d.Cmd("info")

 	assert.NilError(c, err)

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("Cluster Advertise: %s:2375\n", ip.String()))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend)))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Advertise: %s:2375\n", ip.String())))

 }

 func (s *DockerSuite) TestInfoDisplaysRunningContainers(c *testing.T) {

@@ -136,10 +135,10 @@ func (s *DockerSuite) TestInfoDisplaysRunningContainers(c *testing.T) {

 	dockerCmd(c, "run", "-d", "busybox", "top")

 	out, _ := dockerCmd(c, "info")

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]+1))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1)))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]+1)))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"])))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"])))

 }

 func (s *DockerSuite) TestInfoDisplaysPausedContainers(c *testing.T) {

@@ -153,10 +152,10 @@ func (s *DockerSuite) TestInfoDisplaysPausedContainers(c *testing.T) {

 	dockerCmd(c, "pause", cleanedContainerID)

 	out, _ = dockerCmd(c, "info")

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]+1))

-	assert.Assert(c, out, checker.Contains, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]))

+	assert.Assert(c, strings.Contains(out, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1)))