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

 	assert.NilError(c, err)

 	assert.Equal(c, len(containers), startCount+1)

 	actual := containers[0].Names[0]

-	assert.Assert(c, actual, checker.Equals, "/"+name)

+	assert.Equal(c, actual, "/"+name)

 }

 // regression test for empty json field being omitted #13691

@@ -411,8 +411,8 @@ func (s *DockerSuite) TestContainerAPITop(c *testing.T) {

 		c.Fatalf("expected `USER` at `Titles[0]` and `COMMAND` at Titles[10]: %v", top.Titles)

 	}

 	assert.Assert(c, top.Processes, checker.HasLen, 2, check.Commentf("expected 2 processes, found %d: %v", len(top.Processes), top.Processes))

-	assert.Assert(c, top.Processes[0][10], checker.Equals, "/bin/sh -c top")

-	assert.Assert(c, top.Processes[1][10], checker.Equals, "top")

+	assert.Equal(c, top.Processes[0][10], "/bin/sh -c top")

+	assert.Equal(c, top.Processes[1][10], "top")

 }

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

@@ -462,7 +462,7 @@ func (s *DockerSuite) TestContainerAPICommit(c *testing.T) {

 	assert.NilError(c, err)

 	cmd := inspectField(c, img.ID, "Config.Cmd")

-	assert.Assert(c, cmd, checker.Equals, "[/bin/sh -c touch /test]", check.Commentf("got wrong Cmd from commit: %q", cmd))

+	assert.Equal(c, cmd, "[/bin/sh -c touch /test]", check.Commentf("got wrong Cmd from commit: %q", cmd))

 	// sanity check, make sure the image is what we think it is

 	dockerCmd(c, "run", img.ID, "ls", "/test")

@@ -488,13 +488,13 @@ func (s *DockerSuite) TestContainerAPICommitWithLabelInConfig(c *testing.T) {

 	assert.NilError(c, err)

 	label1 := inspectFieldMap(c, img.ID, "Config.Labels", "key1")

-	assert.Assert(c, label1, checker.Equals, "value1")

+	assert.Equal(c, label1, "value1")

 	label2 := inspectFieldMap(c, img.ID, "Config.Labels", "key2")

-	assert.Assert(c, label2, checker.Equals, "value2")

+	assert.Equal(c, label2, "value2")

 	cmd := inspectField(c, img.ID, "Config.Cmd")

-	assert.Assert(c, cmd, checker.Equals, "[/bin/sh -c touch /test]", check.Commentf("got wrong Cmd from commit: %q", cmd))

+	assert.Equal(c, cmd, "[/bin/sh -c touch /test]", check.Commentf("got wrong Cmd from commit: %q", cmd))

 	// sanity check, make sure the image is what we think it is

 	dockerCmd(c, "run", img.ID, "ls", "/test")

@@ -615,7 +615,7 @@ func UtilCreateNetworkMode(c *testing.T, networkMode containertypes.NetworkMode)

 	containerJSON, err := cli.ContainerInspect(context.Background(), container.ID)

 	assert.NilError(c, err)

-	assert.Assert(c, containerJSON.HostConfig.NetworkMode, checker.Equals, containertypes.NetworkMode(networkMode), check.Commentf("Mismatched NetworkMode"))

+	assert.Equal(c, containerJSON.HostConfig.NetworkMode, containertypes.NetworkMode(networkMode), check.Commentf("Mismatched NetworkMode"))

 }

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

@@ -646,7 +646,7 @@ func (s *DockerSuite) TestContainerAPICreateWithCpuSharesCpuset(c *testing.T) {

 	assert.Equal(c, out, "512")

 	outCpuset := inspectField(c, containerJSON.ID, "HostConfig.CpusetCpus")

-	assert.Assert(c, outCpuset, checker.Equals, "0")

+	assert.Equal(c, outCpuset, "0")

 }

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

@@ -845,9 +845,9 @@ func (s *DockerSuite) TestContainerAPIPostCreateNull(c *testing.T) {

 	assert.Equal(c, out, "")

 	outMemory := inspectField(c, container.ID, "HostConfig.Memory")

-	assert.Assert(c, outMemory, checker.Equals, "0")

+	assert.Equal(c, outMemory, "0")

 	outMemorySwap := inspectField(c, container.ID, "HostConfig.MemorySwap")

-	assert.Assert(c, outMemorySwap, checker.Equals, "0")

+	assert.Equal(c, outMemorySwap, "0")

 }

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

@@ -888,7 +888,7 @@ func (s *DockerSuite) TestContainerAPIRename(c *testing.T) {

 	assert.NilError(c, err)

 	name := inspectField(c, containerID, "Name")

-	assert.Assert(c, name, checker.Equals, "/"+newName, check.Commentf("Failed to rename container"))

+	assert.Equal(c, name, "/"+newName, check.Commentf("Failed to rename container"))

 }

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

@@ -903,7 +903,7 @@ func (s *DockerSuite) TestContainerAPIKill(c *testing.T) {

 	assert.NilError(c, err)

 	state := inspectField(c, name, "State.Running")

-	assert.Assert(c, state, checker.Equals, "false", check.Commentf("got wrong State from container %s: %q", name, state))

+	assert.Equal(c, state, "false", check.Commentf("got wrong State from container %s: %q", name, state))

 }

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

@@ -1000,7 +1000,7 @@ func (s *DockerSuite) TestContainerAPIWait(c *testing.T) {

 	case err = <-errC:

 		assert.NilError(c, err)

 	case waitres := <-waitresC:

-		assert.Assert(c, waitres.StatusCode, checker.Equals, int64(0))

+		assert.Equal(c, waitres.StatusCode, int64(0))

 	}

 }

@@ -1156,7 +1156,7 @@ func (s *DockerSuite) TestContainerAPIDeleteRemoveLinks(c *testing.T) {

 	assert.Assert(c, waitRun(id2), checker.IsNil)

 	links := inspectFieldJSON(c, id2, "HostConfig.Links")

-	assert.Assert(c, links, checker.Equals, "[\"/tlink1:/tlink2/tlink1\"]", check.Commentf("expected to have links between containers"))

+	assert.Equal(c, links, "[\"/tlink1:/tlink2/tlink1\"]", check.Commentf("expected to have links between containers"))

 	removeOptions := types.ContainerRemoveOptions{

 		RemoveLinks: true,

@@ -1170,7 +1170,7 @@ func (s *DockerSuite) TestContainerAPIDeleteRemoveLinks(c *testing.T) {

 	assert.NilError(c, err)

 	linksPostRm := inspectFieldJSON(c, id2, "HostConfig.Links")

-	assert.Assert(c, linksPostRm, checker.Equals, "null", check.Commentf("call to api deleteContainer links should have removed the specified links"))

+	assert.Equal(c, linksPostRm, "null", check.Commentf("call to api deleteContainer links should have removed the specified links"))

 }

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

@@ -1457,7 +1457,7 @@ func (s *DockerSuite) TestPostContainersCreateShmSizeHostConfigOmitted(c *testin

 	containerJSON, err := cli.ContainerInspect(context.Background(), container.ID)

 	assert.NilError(c, err)

-	assert.Assert(c, containerJSON.HostConfig.ShmSize, checker.Equals, defaultSHMSize)

+	assert.Equal(c, containerJSON.HostConfig.ShmSize, defaultSHMSize)

 	out, _ := dockerCmd(c, "start", "-i", containerJSON.ID)

 	shmRegexp := regexp.MustCompile(`shm on /dev/shm type tmpfs(.*)size=65536k`)

@@ -1484,7 +1484,7 @@ func (s *DockerSuite) TestPostContainersCreateShmSizeOmitted(c *testing.T) {

 	containerJSON, err := cli.ContainerInspect(context.Background(), container.ID)

 	assert.NilError(c, err)

-	assert.Assert(c, containerJSON.HostConfig.ShmSize, checker.Equals, int64(67108864))

+	assert.Equal(c, containerJSON.HostConfig.ShmSize, int64(67108864))

 	out, _ := dockerCmd(c, "start", "-i", containerJSON.ID)

 	shmRegexp := regexp.MustCompile(`shm on /dev/shm type tmpfs(.*)size=65536k`)

@@ -1515,7 +1515,7 @@ func (s *DockerSuite) TestPostContainersCreateWithShmSize(c *testing.T) {

 	containerJSON, err := cli.ContainerInspect(context.Background(), container.ID)

 	assert.NilError(c, err)

-	assert.Assert(c, containerJSON.HostConfig.ShmSize, checker.Equals, int64(1073741824))

+	assert.Equal(c, containerJSON.HostConfig.ShmSize, int64(1073741824))

 	out, _ := dockerCmd(c, "start", "-i", containerJSON.ID)

 	shmRegex := regexp.MustCompile(`shm on /dev/shm type tmpfs(.*)size=1048576k`)

@@ -1542,7 +1542,7 @@ func (s *DockerSuite) TestPostContainersCreateMemorySwappinessHostConfigOmitted(

 	assert.NilError(c, err)

 	if versions.LessThan(testEnv.DaemonAPIVersion(), "1.31") {

-		assert.Assert(c, *containerJSON.HostConfig.MemorySwappiness, checker.Equals, int64(-1))

+		assert.Equal(c, *containerJSON.HostConfig.MemorySwappiness, int64(-1))

 	} else {

 		assert.Assert(c, containerJSON.HostConfig.MemorySwappiness, checker.IsNil)

 	}

@@ -17,7 +17,7 @@ func (s *DockerSwarmSuite) TestAPISwarmListNodes(c *testing.T) {

 	d3 := s.AddDaemon(c, true, false)

 	nodes := d1.ListNodes(c)

-	assert.Assert(c, len(nodes), checker.Equals, 3, check.Commentf("nodes: %#v", nodes))

+	assert.Equal(c, len(nodes), 3, check.Commentf("nodes: %#v", nodes))

 loop0:

 	for _, n := range nodes {

@@ -40,7 +40,7 @@ func (s *DockerSwarmSuite) TestAPISwarmNodeUpdate(c *testing.T) {

 	})

 	n := d.GetNode(c, nodes[0].ID)

-	assert.Assert(c, n.Spec.Availability, checker.Equals, swarm.NodeAvailabilityPause)

+	assert.Equal(c, n.Spec.Availability, swarm.NodeAvailabilityPause)

 }

 func (s *DockerSwarmSuite) TestAPISwarmNodeRemove(c *testing.T) {

@@ -50,7 +50,7 @@ func (s *DockerSwarmSuite) TestAPISwarmNodeRemove(c *testing.T) {

 	_ = s.AddDaemon(c, true, false)

 	nodes := d1.ListNodes(c)

-	assert.Assert(c, len(nodes), checker.Equals, 3, check.Commentf("nodes: %#v", nodes))

+	assert.Equal(c, len(nodes), 3, check.Commentf("nodes: %#v", nodes))

 	// Getting the info so we can take the NodeID

 	d2Info := d2.SwarmInfo(c)

@@ -59,7 +59,7 @@ func (s *DockerSwarmSuite) TestAPISwarmNodeRemove(c *testing.T) {

 	d1.RemoveNode(c, d2Info.NodeID, true)

 	nodes = d1.ListNodes(c)

-	assert.Assert(c, len(nodes), checker.Equals, 2, check.Commentf("nodes: %#v", nodes))

+	assert.Equal(c, len(nodes), 2, check.Commentf("nodes: %#v", nodes))

 	// Restart the node that was removed

 	d2.RestartNode(c)

@@ -69,7 +69,7 @@ func (s *DockerSwarmSuite) TestAPISwarmNodeRemove(c *testing.T) {

 	// Make sure the node didn't rejoin

 	nodes = d1.ListNodes(c)

-	assert.Assert(c, len(nodes), checker.Equals, 2, check.Commentf("nodes: %#v", nodes))

+	assert.Equal(c, len(nodes), 2, check.Commentf("nodes: %#v", nodes))

 }

 func (s *DockerSwarmSuite) TestAPISwarmNodeDrainPause(c *testing.T) {

@@ -157,13 +157,13 @@ func (s *DockerSuite) TestAttachDisconnect(c *testing.T) {

 	assert.NilError(c, err)

 	out, err = bufio.NewReader(stdout).ReadString('\n')

 	assert.NilError(c, err)

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, "hello")

+	assert.Equal(c, strings.TrimSpace(out), "hello")

 	assert.Assert(c, stdin.Close(), checker.IsNil)

 	// Expect container to still be running after stdin is closed

 	running := inspectField(c, id, "State.Running")

-	assert.Assert(c, running, checker.Equals, "true")

+	assert.Equal(c, running, "true")

 }

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

@@ -2082,7 +2082,7 @@ CMD ["cat", "/foo"]`),

 	}).Assert(c, icmd.Success)

 	res := inspectField(c, name, "Config.Cmd")

-	assert.Assert(c, strings.TrimSpace(string(res)), checker.Equals, `[cat /foo]`)

+	assert.Equal(c, strings.TrimSpace(string(res)), `[cat /foo]`)

 }

 // FIXME(vdemeester) migrate to docker/cli tests (unit or e2e)

@@ -2142,9 +2142,9 @@ COPY . /baz`),

 	result = cli.DockerCmd(c, "run", "--rm", name, "ls", "-A", "/baz")

 	if hasDockerignore && !ignoreDockerignore {

-		assert.Assert(c, result.Stdout(), checker.Equals, ".dockerignore\nfoo\n")

+		assert.Equal(c, result.Stdout(), ".dockerignore\nfoo\n")

 	} else {

-		assert.Assert(c, result.Stdout(), checker.Equals, "foo\n")

+		assert.Equal(c, result.Stdout(), "foo\n")

 	}

 }

@@ -4178,7 +4178,7 @@ func (s *DockerSuite) TestBuildTimeArgHistoryExclusions(c *testing.T) {

 	result.Assert(c, icmd.Expected{Out: fmt.Sprintf("%s=%s", explicitProxyKey, explicitProxyVal)})

 	cacheID := buildImage(imgName + "-two")

-	assert.Assert(c, origID, checker.Equals, cacheID)

+	assert.Equal(c, origID, cacheID)

 }

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

@@ -4373,7 +4373,7 @@ func (s *DockerSuite) TestBuildBuildTimeArgExpansion(c *testing.T) {

 	)

 	res := inspectField(c, imgName, "Config.WorkingDir")

-	assert.Assert(c, filepath.ToSlash(res), checker.Equals, filepath.ToSlash(wdVal))

+	assert.Equal(c, filepath.ToSlash(res), filepath.ToSlash(wdVal))

 	var resArr []string

 	inspectFieldAndUnmarshall(c, imgName, "Config.Env", &resArr)

@@ -4754,7 +4754,7 @@ func (s *DockerSuite) TestBuildMultipleTags(c *testing.T) {

 	id1 := getIDByName(c, "tag1")

 	id2 := getIDByName(c, "tag2:v2")

-	assert.Assert(c, id1, checker.Equals, id2)

+	assert.Equal(c, id1, id2)

 }

 // #17290

@@ -4949,7 +4949,7 @@ func (s *DockerSuite) TestBuildLabelOneNode(c *testing.T) {

 	if !ok {

 		c.Fatal("label `foo` not found in image")

 	}

-	assert.Assert(c, v, checker.Equals, "bar")

+	assert.Equal(c, v, "bar")

 }

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

@@ -5425,8 +5425,8 @@ func (s *DockerSuite) TestBuildCacheFromEqualDiffIDsLength(c *testing.T) {

 	// rebuild with cache-from

 	result := cli.BuildCmd(c, "build2", cli.WithFlags("--cache-from=build1"), build.WithExternalBuildContext(ctx))

 	id2 := getIDByName(c, "build2")

-	assert.Assert(c, id1, checker.Equals, id2)

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 2)

+	assert.Equal(c, id1, id2)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 2)

 }

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

@@ -5450,15 +5450,15 @@ func (s *DockerSuite) TestBuildCacheFrom(c *testing.T) {

 	// rebuild with cache-from

 	result := cli.BuildCmd(c, "build2", cli.WithFlags("--cache-from=build1"), build.WithExternalBuildContext(ctx))

 	id2 := getIDByName(c, "build2")

-	assert.Assert(c, id1, checker.Equals, id2)

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 3)

+	assert.Equal(c, id1, id2)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 3)

 	cli.DockerCmd(c, "rmi", "build2")

 	// no cache match with unknown source

 	result = cli.BuildCmd(c, "build2", cli.WithFlags("--cache-from=nosuchtag"), build.WithExternalBuildContext(ctx))

 	id2 = getIDByName(c, "build2")

 	assert.Assert(c, id1 != id2)

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 0)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 0)

 	cli.DockerCmd(c, "rmi", "build2")

 	// clear parent images

@@ -5472,23 +5472,23 @@ func (s *DockerSuite) TestBuildCacheFrom(c *testing.T) {

 	cli.DockerCmd(c, "rmi", "build1")

 	cli.DockerCmd(c, "load", "-i", tempFile)

 	parentID := cli.DockerCmd(c, "inspect", "-f", "{{.Parent}}", "build1").Combined()

-	assert.Assert(c, strings.TrimSpace(parentID), checker.Equals, "")

+	assert.Equal(c, strings.TrimSpace(parentID), "")

 	// cache still applies without parents

 	result = cli.BuildCmd(c, "build2", cli.WithFlags("--cache-from=build1"), build.WithExternalBuildContext(ctx))

 	id2 = getIDByName(c, "build2")

-	assert.Assert(c, id1, checker.Equals, id2)

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 3)

+	assert.Equal(c, id1, id2)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 3)

 	history1 := cli.DockerCmd(c, "history", "-q", "build2").Combined()

 	// Retry, no new intermediate images

 	result = cli.BuildCmd(c, "build3", cli.WithFlags("--cache-from=build1"), build.WithExternalBuildContext(ctx))

 	id3 := getIDByName(c, "build3")

-	assert.Assert(c, id1, checker.Equals, id3)

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 3)

+	assert.Equal(c, id1, id3)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 3)

 	history2 := cli.DockerCmd(c, "history", "-q", "build3").Combined()

-	assert.Assert(c, history1, checker.Equals, history2)

+	assert.Equal(c, history1, history2)

 	cli.DockerCmd(c, "rmi", "build2")

 	cli.DockerCmd(c, "rmi", "build3")

 	cli.DockerCmd(c, "rmi", "build1")

@@ -5506,7 +5506,7 @@ func (s *DockerSuite) TestBuildCacheFrom(c *testing.T) {

 	result = cli.BuildCmd(c, "build2", cli.WithFlags("--cache-from=build1"), build.WithExternalBuildContext(ctx))

 	id2 = getIDByName(c, "build2")

 	assert.Assert(c, id1 != id2)

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 2)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 2)

 	layers1Str := cli.DockerCmd(c, "inspect", "-f", "{{json .RootFS.Layers}}", "build1").Combined()

 	layers2Str := cli.DockerCmd(c, "inspect", "-f", "{{json .RootFS.Layers}}", "build2").Combined()

@@ -5516,9 +5516,9 @@ func (s *DockerSuite) TestBuildCacheFrom(c *testing.T) {

 	assert.Assert(c, json.Unmarshal([]byte(layers1Str), &layers1), checker.IsNil)

 	assert.Assert(c, json.Unmarshal([]byte(layers2Str), &layers2), checker.IsNil)

-	assert.Assert(c, len(layers1), checker.Equals, len(layers2))

+	assert.Equal(c, len(layers1), len(layers2))

 	for i := 0; i < len(layers1)-1; i++ {

-		assert.Assert(c, layers1[i], checker.Equals, layers2[i])

+		assert.Equal(c, layers1[i], layers2[i])

 	}

 	assert.Assert(c, layers1[len(layers1)-1] != layers2[len(layers1)-1])

 }

@@ -5540,11 +5540,11 @@ func (s *DockerSuite) TestBuildMultiStageCache(c *testing.T) {

 	result := cli.BuildCmd(c, "build1", build.WithExternalBuildContext(ctx))

 	// second part of dockerfile was a repeat of first so should be cached

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 1)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 1)

 	result = cli.BuildCmd(c, "build2", cli.WithFlags("--cache-from=build1"), build.WithExternalBuildContext(ctx))

 	// now both parts of dockerfile should be cached

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 2)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 2)

 }

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

@@ -5572,7 +5572,7 @@ func (s *DockerSuite) TestBuildNetContainer(c *testing.T) {

   `))

 	host, _ := dockerCmd(c, "run", "testbuildnetcontainer", "cat", "/otherhost")

-	assert.Assert(c, strings.TrimSpace(host), checker.Equals, "foobar")

+	assert.Equal(c, strings.TrimSpace(host), "foobar")

 }

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

@@ -5681,22 +5681,22 @@ func (s *DockerSuite) TestBuildMultiStageCopyFromSyntax(c *testing.T) {

 	result := cli.BuildCmd(c, "build2", build.WithExternalBuildContext(ctx))

 	// all commands should be cached

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 7)

-	assert.Assert(c, getIDByName(c, "build1"), checker.Equals, getIDByName(c, "build2"))

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 7)

+	assert.Equal(c, getIDByName(c, "build1"), getIDByName(c, "build2"))

 	err := ioutil.WriteFile(filepath.Join(ctx.Dir, "Dockerfile"), []byte(fmt.Sprintf(dockerfile, "COPY baz/aa foo")), 0644)

 	assert.NilError(c, err)

 	// changing file in parent block should not affect last block

 	result = cli.BuildCmd(c, "build3", build.WithExternalBuildContext(ctx))

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 5)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 5)

 	err = ioutil.WriteFile(filepath.Join(ctx.Dir, "foo"), []byte("pqr"), 0644)

 	assert.NilError(c, err)

 	// changing file in parent block should affect both first and last block

 	result = cli.BuildCmd(c, "build4", build.WithExternalBuildContext(ctx))

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 5)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 5)

 	cli.DockerCmd(c, "run", "build4", "cat", "bay").Assert(c, icmd.Expected{Out: "pqr"})

 	cli.DockerCmd(c, "run", "build4", "cat", "baz").Assert(c, icmd.Expected{Out: "pqr"})

@@ -5777,9 +5777,9 @@ func (s *DockerSuite) TestBuildMultiStageMultipleBuilds(c *testing.T) {

 	cli.BuildCmd(c, "build2", build.WithExternalBuildContext(ctx))

 	out := cli.DockerCmd(c, "run", "build2", "cat", "bar").Combined()

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, "abc")

+	assert.Equal(c, strings.TrimSpace(out), "abc")

 	out = cli.DockerCmd(c, "run", "build2", "cat", "foo").Combined()

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, "def")

+	assert.Equal(c, strings.TrimSpace(out), "def")

 }

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

@@ -5893,9 +5893,9 @@ func (s *DockerSuite) TestBuildMultiStageMultipleBuildsWindows(c *testing.T) {

 	cli.BuildCmd(c, "build2", build.WithExternalBuildContext(ctx))

 	out := cli.DockerCmd(c, "run", "build2", "cmd.exe", "/s", "/c", "type", "c:\\bar").Combined()

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, "abc")

+	assert.Equal(c, strings.TrimSpace(out), "abc")

 	out = cli.DockerCmd(c, "run", "build2", "cmd.exe", "/s", "/c", "type", "c:\\foo").Combined()

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, "def")

+	assert.Equal(c, strings.TrimSpace(out), "def")

 }

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

@@ -5969,7 +5969,7 @@ func (s *DockerSuite) TestBuildMultiStageResetScratch(c *testing.T) {

 	cli.BuildCmd(c, "build1", build.WithExternalBuildContext(ctx))

 	res := cli.InspectCmd(c, "build1", cli.Format(".Config.WorkingDir")).Combined()

-	assert.Assert(c, strings.TrimSpace(res), checker.Equals, "")

+	assert.Equal(c, strings.TrimSpace(res), "")

 }

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

@@ -5990,14 +5990,14 @@ func (s *DockerSuite) TestBuildIntermediateTarget(c *testing.T) {

 		cli.WithFlags("--target", "build-env"))

 	res := cli.InspectCmd(c, "build1", cli.Format("json .Config.Cmd")).Combined()

-	assert.Assert(c, strings.TrimSpace(res), checker.Equals, `["/dev"]`)

+	assert.Equal(c, strings.TrimSpace(res), `["/dev"]`)

 	// Stage name is case-insensitive by design

 	cli.BuildCmd(c, "build1", build.WithExternalBuildContext(ctx),

 		cli.WithFlags("--target", "BUIld-EnV"))

 	res = cli.InspectCmd(c, "build1", cli.Format("json .Config.Cmd")).Combined()

-	assert.Assert(c, strings.TrimSpace(res), checker.Equals, `["/dev"]`)

+	assert.Equal(c, strings.TrimSpace(res), `["/dev"]`)

 	result := cli.Docker(cli.Build("build1"), build.WithExternalBuildContext(ctx),

 		cli.WithFlags("--target", "nosuchtarget"))

@@ -6100,7 +6100,7 @@ func (s *DockerSuite) TestBuildWorkdirCmd(c *testing.T) {

 	buildImageSuccessfully(c, name, build.WithDockerfile(dockerFile))

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

 	result.Assert(c, icmd.Success)

-	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 1)

+	assert.Equal(c, strings.Count(result.Combined(), "Using cache"), 1)

 }

 // FIXME(vdemeester) should be a unit test

@@ -6200,7 +6200,7 @@ ENV BAR BAZ`),

 	assert.NilError(c, err)

 	d, err := digest.Parse(string(id))

 	assert.NilError(c, err)

-	assert.Assert(c, d.String(), checker.Equals, getIDByName(c, name))

+	assert.Equal(c, d.String(), getIDByName(c, name))

 }

 // FIXME(vdemeester) should migrate to docker/cli tests

@@ -6223,5 +6223,5 @@ func (s *DockerSuite) TestBuildIidFileCleanupOnFail(c *testing.T) {

 	})

 	_, err = os.Stat(tmpIidFile)

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, os.IsNotExist(err), checker.Equals, true)

+	assert.Equal(c, os.IsNotExist(err), true)

 }

@@ -58,14 +58,14 @@ func (s *DockerSuite) TestBuildResourceConstraintsAreUsed(c *testing.T) {

 	err := json.Unmarshal([]byte(cfg), &c1)

 	assert.Assert(c, err, checker.IsNil, check.Commentf(cfg))

-	assert.Assert(c, c1.Memory, checker.Equals, int64(64*1024*1024), check.Commentf("resource constraints not set properly for Memory"))

-	assert.Assert(c, c1.MemorySwap, checker.Equals, int64(-1), check.Commentf("resource constraints not set properly for MemorySwap"))

-	assert.Assert(c, c1.CpusetCpus, checker.Equals, "0", check.Commentf("resource constraints not set properly for CpusetCpus"))

-	assert.Assert(c, c1.CpusetMems, checker.Equals, "0", check.Commentf("resource constraints not set properly for CpusetMems"))

-	assert.Assert(c, c1.CPUShares, checker.Equals, int64(100), check.Commentf("resource constraints not set properly for CPUShares"))

-	assert.Assert(c, c1.CPUQuota, checker.Equals, int64(8000), check.Commentf("resource constraints not set properly for CPUQuota"))

-	assert.Assert(c, c1.Ulimits[0].Name, checker.Equals, "nofile", check.Commentf("resource constraints not set properly for Ulimits"))

-	assert.Assert(c, c1.Ulimits[0].Hard, checker.Equals, int64(42), check.Commentf("resource constraints not set properly for Ulimits"))

+	assert.Equal(c, c1.Memory, int64(64*1024*1024), check.Commentf("resource constraints not set properly for Memory"))

+	assert.Equal(c, c1.MemorySwap, int64(-1), check.Commentf("resource constraints not set properly for MemorySwap"))

+	assert.Equal(c, c1.CpusetCpus, "0", check.Commentf("resource constraints not set properly for CpusetCpus"))

+	assert.Equal(c, c1.CpusetMems, "0", check.Commentf("resource constraints not set properly for CpusetMems"))

+	assert.Equal(c, c1.CPUShares, int64(100), check.Commentf("resource constraints not set properly for CPUShares"))

+	assert.Equal(c, c1.CPUQuota, int64(8000), check.Commentf("resource constraints not set properly for CPUQuota"))

+	assert.Equal(c, c1.Ulimits[0].Name, "nofile", check.Commentf("resource constraints not set properly for Ulimits"))

+	assert.Equal(c, c1.Ulimits[0].Hard, int64(42), check.Commentf("resource constraints not set properly for Ulimits"))

 	// Make sure constraints aren't saved to image

 	cli.DockerCmd(c, "run", "--name=test", name)

@@ -73,7 +73,7 @@ func testPullByTagDisplaysDigest(c *testing.T) {

 	pullDigest := matches[1]

 	// make sure the pushed and pull digests match

-	assert.Assert(c, pushDigest.String(), checker.Equals, pullDigest)

+	assert.Equal(c, pushDigest.String(), pullDigest)

 }

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

@@ -99,7 +99,7 @@ func testPullByDigest(c *testing.T) {

 	pullDigest := matches[1]

 	// make sure the pushed and pull digests match

-	assert.Assert(c, pushDigest.String(), checker.Equals, pullDigest)

+	assert.Equal(c, pushDigest.String(), pullDigest)

 }

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

@@ -152,7 +152,7 @@ func (s *DockerRegistrySuite) TestRunByDigest(c *testing.T) {

 	foundRegex := regexp.MustCompile("found=([^\n]+)")

 	matches := foundRegex.FindStringSubmatch(out)

 	assert.Assert(c, matches, checker.HasLen, 2, check.Commentf("unable to parse digest from pull output: %s", out))

-	assert.Assert(c, matches[1], checker.Equals, "1", check.Commentf("Expected %q, got %q", "1", matches[1]))

+	assert.Equal(c, matches[1], "1", check.Commentf("Expected %q, got %q", "1", matches[1]))

 	res := inspectField(c, containerName, "Config.Image")

 	assert.Equal(c, res, imageReference)

@@ -61,7 +61,7 @@ func (s *DockerSuite) TestCommitNewFile(c *testing.T) {

 	out, _ := dockerCmd(c, "run", imageID, "cat", "/foo")

 	actual := strings.TrimSpace(out)

-	assert.Assert(c, actual, checker.Equals, "koye")

+	assert.Equal(c, actual, "koye")

 }

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

@@ -161,7 +161,7 @@ func (s *DockerSuite) TestCommitChangeLabels(c *testing.T) {

 		"test", "test-commit")

 	imageID = strings.TrimSpace(imageID)

-	assert.Assert(c, inspectField(c, imageID, "Config.Labels"), checker.Equals, "map[some:label2]")

+	assert.Equal(c, inspectField(c, imageID, "Config.Labels"), "map[some:label2]")

 	// check that container labels didn't change

-	assert.Assert(c, inspectField(c, "test", "Config.Labels"), checker.Equals, "map[some:label]")

+	assert.Equal(c, inspectField(c, "test", "Config.Labels"), "map[some:label]")

 }

@@ -41,7 +41,7 @@ func (s *DockerSuite) TestCreateArgs(c *testing.T) {

 	assert.Equal(c, len(containers), 1)

 	cont := containers[0]

-	assert.Assert(c, string(cont.Path), checker.Equals, "command", check.Commentf("Unexpected container path. Expected command, received: %s", cont.Path))

+	assert.Equal(c, string(cont.Path), "command", check.Commentf("Unexpected container path. Expected command, received: %s", cont.Path))

 	b := false

 	expected := []string{"arg1", "arg2", "arg with space", "-c", "flags"}

@@ -68,7 +68,7 @@ func (s *DockerSuite) TestCreateGrowRootfs(c *testing.T) {

 	cleanedContainerID := strings.TrimSpace(out)

 	inspectOut := inspectField(c, cleanedContainerID, "HostConfig.StorageOpt")

-	assert.Assert(c, inspectOut, checker.Equals, "map[size:120G]")

+	assert.Equal(c, inspectOut, "map[size:120G]")

 }

 // Make sure we cannot shrink the container's rootfs at creation time.

@@ -127,7 +127,7 @@ func (s *DockerSuite) TestCreateWithPortRange(c *testing.T) {

 	for k, v := range cont.HostConfig.PortBindings {

 		assert.Assert(c, v, checker.HasLen, 1, check.Commentf("Expected 1 ports binding, for the port  %s but found %s", k, v))

-		assert.Assert(c, k.Port(), checker.Equals, v[0].HostPort, check.Commentf("Expected host port %s to match published port %s", k.Port(), v[0].HostPort))

+		assert.Equal(c, k.Port(), v[0].HostPort, check.Commentf("Expected host port %s to match published port %s", k.Port(), v[0].HostPort))

 	}

@@ -156,7 +156,7 @@ func (s *DockerSuite) TestCreateWithLargePortRange(c *testing.T) {

 	for k, v := range cont.HostConfig.PortBindings {

 		assert.Assert(c, v, checker.HasLen, 1)

-		assert.Assert(c, k.Port(), checker.Equals, v[0].HostPort, check.Commentf("Expected host port %s to match published port %s", k.Port(), v[0].HostPort))

+		assert.Equal(c, k.Port(), v[0].HostPort, check.Commentf("Expected host port %s to match published port %s", k.Port(), v[0].HostPort))

 	}

 }

@@ -364,7 +364,7 @@ exec "$@"`,

 	id := strings.TrimSpace(out)

 	assert.Assert(c, id != "")

 	out = cli.DockerCmd(c, "start", "-a", id).Combined()

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, "foo")

+	assert.Equal(c, strings.TrimSpace(out), "foo")

 }

 // #22471

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

 			} else {

 				format = "%scontainer %q is running"

 			}

-			assert.Assert(c, strings.Contains(out, name), checker.Equals, shouldRun, check.Commentf(format, prefix, name))

+			assert.Equal(c, strings.Contains(out, name), shouldRun, check.Commentf(format, prefix, name))

 		}

 	}

@@ -245,7 +245,7 @@ func (s *DockerDaemonSuite) TestDaemonRestartWithIncreasedBasesize(c *testing.T)

 	basesizeAfterRestart := getBaseDeviceSize(c, s.d)

 	newBasesize, err := convertBasesize(newBasesizeBytes)

 	assert.Assert(c, err, checker.IsNil, check.Commentf("Error in converting base device size: %v", err))

-	assert.Assert(c, newBasesize, checker.Equals, basesizeAfterRestart, check.Commentf("Basesize passed is not equal to Basesize set"))

+	assert.Equal(c, newBasesize, basesizeAfterRestart, check.Commentf("Basesize passed is not equal to Basesize set"))

 	s.d.Stop(c)

 }

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

 	out, err = s.d.Cmd("inspect", "--format", "{{.NetworkSettings.Networks.bridge.IPv6Gateway}}", "ipv6test")

 	assert.NilError(c, err, out)

-	assert.Assert(c, strings.Trim(out, " \r\n'"), checker.Equals, "2001:db8:2::100", check.Commentf("Container should have a global IPv6 gateway"))

+	assert.Equal(c, strings.Trim(out, " \r\n'"), "2001:db8:2::100", check.Commentf("Container should have a global IPv6 gateway"))

 }

 // TestDaemonIPv6FixedCIDRAndMac checks that when the daemon is started with ipv6 fixed CIDR

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

 	out, err = s.d.Cmd("inspect", "--format", "{{.NetworkSettings.Networks.bridge.GlobalIPv6Address}}", "ipv6test")

 	assert.NilError(c, err, out)

-	assert.Assert(c, strings.Trim(out, " \r\n'"), checker.Equals, "2001:db8:1::aabb:ccdd:eeff")

+	assert.Equal(c, strings.Trim(out, " \r\n'"), "2001:db8:1::aabb:ccdd:eeff")

 }

 // TestDaemonIPv6HostMode checks that when the running a container with

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

 	containerIP := d.FindContainerIP(c, "test")

 	ip = net.ParseIP(containerIP)

-	assert.Assert(c, bridgeIPNet.Contains(ip), checker.Equals, true, check.Commentf("Container IP-Address must be in the same subnet range : %s", containerIP))

+	assert.Equal(c, bridgeIPNet.Contains(ip), true, check.Commentf("Container IP-Address must be in the same subnet range : %s", containerIP))

 	deleteInterface(c, defaultNetworkBridge)

 }

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

 	expectedMessage := fmt.Sprintf("default via %s dev", bridgeIP)

 	out, err := d.Cmd("run", "busybox", "ip", "-4", "route", "list", "0/0")

 	assert.NilError(c, err, out)

-	assert.Assert(c, strings.Contains(out, expectedMessage), checker.Equals, true, check.Commentf("Implicit default gateway should be bridge IP %s, but default route was '%s'", bridgeIP, strings.TrimSpace(out)))

+	assert.Equal(c, strings.Contains(out, expectedMessage), true, check.Commentf("Implicit default gateway should be bridge IP %s, but default route was '%s'", bridgeIP, strings.TrimSpace(out)))

 	deleteInterface(c, defaultNetworkBridge)

 }

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

 	expectedMessage := fmt.Sprintf("default via %s dev", gatewayIP)

 	out, err := d.Cmd("run", "busybox", "ip", "-4", "route", "list", "0/0")

 	assert.NilError(c, err, out)

-	assert.Assert(c, strings.Contains(out, expectedMessage), checker.Equals, true, check.Commentf("Explicit default gateway should be %s, but default route was '%s'", gatewayIP, strings.TrimSpace(out)))

+	assert.Equal(c, strings.Contains(out, expectedMessage), true, check.Commentf("Explicit default gateway should be %s, but default route was '%s'", gatewayIP, strings.TrimSpace(out)))

 	deleteInterface(c, defaultNetworkBridge)

 }

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

 	out, err := d.Cmd("run", "-d", "-p", "8000:8000", "busybox", "top")

 	assert.Assert(c, err, checker.NotNil, check.Commentf("Running a container must fail with an invalid --ip option"))

-	assert.Assert(c, strings.Contains(out, "Error starting userland proxy"), checker.Equals, true)

+	assert.Equal(c, strings.Contains(out, "Error starting userland proxy"), true)

 	ifName := "dummy"

 	createInterface(c, "dummy", ifName, ipStr)

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

 	result.Assert(c, icmd.Success)

 	regex := fmt.Sprintf("DNAT.*%s.*dpt:8000", ip.String())

 	matched, _ := regexp.MatchString(regex, result.Combined())

-	assert.Assert(c, matched, checker.Equals, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

+	assert.Equal(c, matched, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

 }

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

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

 	result.Assert(c, icmd.Success)

 	regex := fmt.Sprintf("DROP.*all.*%s.*%s", bridgeName, bridgeName)

 	matched, _ := regexp.MatchString(regex, result.Combined())

-	assert.Assert(c, matched, checker.Equals, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

+	assert.Equal(c, matched, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

 	// Pinging another container must fail with --icc=false

 	pingContainers(c, d, true)

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

 	result.Assert(c, icmd.Success)

 	regex := fmt.Sprintf("DROP.*all.*%s.*%s", bridgeName, bridgeName)

 	matched, _ := regexp.MatchString(regex, result.Combined())

-	assert.Assert(c, matched, checker.Equals, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

+	assert.Equal(c, matched, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

 	out, err := d.Cmd("run", "-d", "--expose", "4567", "--name", "icc1", "busybox", "nc", "-l", "-p", "4567")

 	assert.NilError(c, err, out)

@@ -1152,7 +1152,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, checker.IsNil, comment)

-	assert.Assert(c, result.ExitCode, checker.Equals, 0, comment)

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

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

 }

@@ -1569,7 +1569,7 @@ func (s *DockerDaemonSuite) TestDaemonRestartWithContainerWithRestartPolicyAlway

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

 	assert.NilError(c, err, out)

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, id[:12])

+	assert.Equal(c, strings.TrimSpace(out), id[:12])

 }

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

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

 	assert.NilError(c, err, out)

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

 	assert.NilError(c, err, out)

-	assert.Assert(c, strings.Contains(out, "1 packets transmitted, 1 packets received"), checker.Equals, true, check.Commentf("%s", out))

+	assert.Equal(c, strings.Contains(out, "1 packets transmitted, 1 packets received"), true, check.Commentf("%s", out))

 }

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

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

 	mountOut, err = ioutil.ReadFile("/proc/self/mountinfo")

 	assert.Assert(c, err, checker.IsNil, check.Commentf("Output: %s", mountOut))

 	comment := check.Commentf("%s is still mounted from older daemon start:\nDaemon root repository %s\n%s", id, s.d.Root, mountOut)

-	assert.Assert(c, strings.Contains(string(mountOut), id), checker.Equals, false, comment)

+	assert.Equal(c, strings.Contains(string(mountOut), id), false, comment)

 }

 // TestDaemonRestartWithUnpausedRunningContainer requires live restore of running containers.

@@ -2370,7 +2370,7 @@ func (s *DockerDaemonSuite) TestBuildOnDisabledBridgeNetworkDaemon(c *testing.T)

 	)

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

 	assert.Assert(c, result.Error, checker.IsNil, comment)

-	assert.Assert(c, result.ExitCode, checker.Equals, 0, comment)

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

 }

 // Test case for #21976

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

 	out2, err := s.d.Cmd("exec", "-u", "test", "top", "id")

 	assert.Assert(c, err, checker.IsNil, check.Commentf("Output: %s", out2))

-	assert.Assert(c, out2, checker.Equals, out1, check.Commentf("Output: before restart '%s', after restart '%s'", out1, out2))

+	assert.Equal(c, out2, out1, check.Commentf("Output: before restart '%s', after restart '%s'", out1, out2))

 	out, err = s.d.Cmd("stop", "top")

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

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

 	assert.Assert(c, pattern.MatchString(out), checker.True)

 	out, err = s.d.Cmd("inspect", "--format", "{{.HostConfig.ShmSize}}", name)

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

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, fmt.Sprintf("%v", size))

+	assert.Equal(c, strings.TrimSpace(out), fmt.Sprintf("%v", size))

 }

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

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

 	assert.Assert(c, pattern.MatchString(out), checker.True)

 	out, err = s.d.Cmd("inspect", "--format", "{{.HostConfig.ShmSize}}", name)

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

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, fmt.Sprintf("%v", size))

+	assert.Equal(c, strings.TrimSpace(out), fmt.Sprintf("%v", size))

 	size = 67108864 * 3

 	configData = []byte(fmt.Sprintf(`{"default-shm-size": "%dM"}`, size/1024/1024))

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

 	assert.Assert(c, pattern.MatchString(out), checker.True)

 	out, err = s.d.Cmd("inspect", "--format", "{{.HostConfig.ShmSize}}", name)

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

-	assert.Assert(c, strings.TrimSpace(out), checker.Equals, fmt.Sprintf("%v", size))

+	assert.Equal(c, strings.TrimSpace(out), fmt.Sprintf("%v", size))

 }

 func testDaemonStartIpcMode(c *testing.T, from, mode string, valid bool) {

@@ -310,11 +310,11 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverNamed(c *testing.T)

 	assert.ErrorContains(c, err, "")

 	assert.Assert(c, os.IsNotExist(err), checker.True, check.Commentf("Expected volume path in host to not exist: %s, %v\n", p, err))

-	assert.Assert(c, s.ec.activations, checker.Equals, 1)

-	assert.Assert(c, s.ec.creations, checker.Equals, 1)

-	assert.Assert(c, s.ec.removals, checker.Equals, 1)

-	assert.Assert(c, s.ec.mounts, checker.Equals, 1)

-	assert.Assert(c, s.ec.unmounts, checker.Equals, 1)

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

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

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

+	assert.Equal(c, s.ec.mounts, 1)

+	assert.Equal(c, s.ec.unmounts, 1)

 }

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

@@ -324,11 +324,11 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnnamed(c *testing.T

 	assert.NilError(c, err, out)

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

-	assert.Assert(c, s.ec.activations, checker.Equals, 1)

-	assert.Assert(c, s.ec.creations, checker.Equals, 1)

-	assert.Assert(c, s.ec.removals, checker.Equals, 1)

-	assert.Assert(c, s.ec.mounts, checker.Equals, 1)

-	assert.Assert(c, s.ec.unmounts, checker.Equals, 1)

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

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

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

+	assert.Equal(c, s.ec.mounts, 1)

+	assert.Equal(c, s.ec.unmounts, 1)

 }

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

@@ -343,11 +343,11 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverVolumesFrom(c *testi

 	out, err = s.d.Cmd("rm", "-fv", "vol-test1")

 	assert.NilError(c, err, out)

-	assert.Assert(c, s.ec.activations, checker.Equals, 1)

-	assert.Assert(c, s.ec.creations, checker.Equals, 1)

-	assert.Assert(c, s.ec.removals, checker.Equals, 1)

-	assert.Assert(c, s.ec.mounts, checker.Equals, 2)

-	assert.Assert(c, s.ec.unmounts, checker.Equals, 2)

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

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

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

+	assert.Equal(c, s.ec.mounts, 2)

+	assert.Equal(c, s.ec.unmounts, 2)

 }

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

@@ -359,11 +359,11 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverDeleteContainer(c *t

 	out, err = s.d.Cmd("rm", "-fv", "vol-test1")

 	assert.NilError(c, err, out)

-	assert.Assert(c, s.ec.activations, checker.Equals, 1)

-	assert.Assert(c, s.ec.creations, checker.Equals, 1)

-	assert.Assert(c, s.ec.removals, checker.Equals, 1)

-	assert.Assert(c, s.ec.mounts, checker.Equals, 1)

-	assert.Assert(c, s.ec.unmounts, checker.Equals, 1)

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

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

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

+	assert.Equal(c, s.ec.mounts, 1)

+	assert.Equal(c, s.ec.unmounts, 1)

 }

 func hostVolumePath(name string) string {

@@ -437,11 +437,11 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverRetryNotImmediatelyE

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

 	assert.NilError(c, err)

-	assert.Assert(c, p.ec.activations, checker.Equals, 1)

-	assert.Assert(c, p.ec.creations, checker.Equals, 1)

-	assert.Assert(c, p.ec.removals, checker.Equals, 1)

-	assert.Assert(c, p.ec.mounts, checker.Equals, 1)

-	assert.Assert(c, p.ec.unmounts, checker.Equals, 1)

+	assert.Equal(c, p.ec.activations, 1)

+	assert.Equal(c, p.ec.creations, 1)

+	assert.Equal(c, p.ec.removals, 1)

+	assert.Equal(c, p.ec.mounts, 1)

+	assert.Equal(c, p.ec.unmounts, 1)

 }

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

@@ -454,30 +454,30 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverBindExternalVolume(c

 	}

 	out := inspectFieldJSON(c, "testing", "Mounts")

 	assert.Assert(c, json.NewDecoder(strings.NewReader(out)).Decode(&mounts), checker.IsNil)

-	assert.Assert(c, len(mounts), checker.Equals, 1, check.Commentf("%s", out))

-	assert.Assert(c, mounts[0].Name, checker.Equals, "foo")

-	assert.Assert(c, mounts[0].Driver, checker.Equals, volumePluginName)

+	assert.Equal(c, len(mounts), 1, check.Commentf("%s", out))

+	assert.Equal(c, mounts[0].Name, "foo")

+	assert.Equal(c, mounts[0].Driver, volumePluginName)

 }

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

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

 	out, _ := dockerCmd(c, "volume", "ls")

 	ls := strings.Split(strings.TrimSpace(out), "\n")

-	assert.Assert(c, len(ls), checker.Equals, 2, check.Commentf("\n%s", out))

+	assert.Equal(c, len(ls), 2, check.Commentf("\n%s", out))

 	vol := strings.Fields(ls[len(ls)-1])

-	assert.Assert(c, len(vol), checker.Equals, 2, check.Commentf("%v", vol))

-	assert.Assert(c, vol[0], checker.Equals, volumePluginName)

-	assert.Assert(c, vol[1], checker.Equals, "abc3")

+	assert.Equal(c, len(vol), 2, check.Commentf("%v", vol))

+	assert.Equal(c, vol[0], volumePluginName)

+	assert.Equal(c, vol[1], "abc3")

-	assert.Assert(c, s.ec.lists, checker.Equals, 1)

+	assert.Equal(c, s.ec.lists, 1)