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

 	assert.NilError(c, err)

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

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

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

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

 }

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

@@ -121,7 +121,7 @@ func (s *DockerSuite) TestContainerAPIGetExport(c *check.C) {

 			break

 		}

 	}

-	c.Assert(found, checker.True, check.Commentf("The created test file has not been found in the exported image"))

+	assert.Assert(c, found, checker.True, check.Commentf("The created test file has not been found in the exported image"))

 }

 func (s *DockerSuite) TestContainerAPIGetChanges(c *check.C) {

@@ -144,7 +144,7 @@ func (s *DockerSuite) TestContainerAPIGetChanges(c *check.C) {

 			success = true

 		}

 	}

-	c.Assert(success, checker.True, check.Commentf("/etc/passwd has been removed but is not present in the diff"))

+	assert.Assert(c, success, checker.True, check.Commentf("/etc/passwd has been removed but is not present in the diff"))

 }

 func (s *DockerSuite) TestGetContainerStats(c *check.C) {

@@ -215,12 +215,12 @@ func (s *DockerSuite) TestGetContainerStatsRmRunning(c *check.C) {

 	// Now remove without `-f` and make sure we are still pulling stats

 	_, _, err = dockerCmdWithError("rm", id)

-	c.Assert(err, checker.Not(checker.IsNil), check.Commentf("rm should have failed but didn't"))

+	assert.Assert(c, err, checker.Not(checker.IsNil), check.Commentf("rm should have failed but didn't"))

 	_, err = buf.ReadTimeout(b, 2*time.Second)

 	assert.NilError(c, err)

 	dockerCmd(c, "rm", "-f", id)

-	c.Assert(<-chErr, checker.IsNil)

+	assert.Assert(c, <-chErr, checker.IsNil)

 }

 // ChannelBuffer holds a chan of byte array that can be populate in a goroutine.

@@ -389,7 +389,7 @@ func (s *DockerSuite) TestContainerAPIPause(c *check.C) {

 	assert.NilError(c, err)

 	pausedContainers = getPaused(c)

-	c.Assert(pausedContainers, checker.HasLen, 0, check.Commentf("There should be no paused container."))

+	assert.Assert(c, pausedContainers, checker.HasLen, 0, check.Commentf("There should be no paused container."))

 }

 func (s *DockerSuite) TestContainerAPITop(c *check.C) {

@@ -405,14 +405,14 @@ func (s *DockerSuite) TestContainerAPITop(c *check.C) {

 	// sort by comm[andline] to make sure order stays the same in case of PID rollover

 	top, err := cli.ContainerTop(context.Background(), id, []string{"aux", "--sort=comm"})

 	assert.NilError(c, err)

-	c.Assert(top.Titles, checker.HasLen, 11, check.Commentf("expected 11 titles, found %d: %v", len(top.Titles), top.Titles))

+	assert.Assert(c, top.Titles, checker.HasLen, 11, check.Commentf("expected 11 titles, found %d: %v", len(top.Titles), top.Titles))

 	if top.Titles[0] != "USER" || top.Titles[10] != "COMMAND" {

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

 	}

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

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

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

+	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")

 }

 func (s *DockerSuite) TestContainerAPITopWindows(c *check.C) {

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

 	assert.NilError(c, err)

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

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

+	assert.Assert(c, cmd, checker.Equals, "[/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 *check.C) {

 	assert.NilError(c, err)

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

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

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

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

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

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

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

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

+	assert.Assert(c, cmd, checker.Equals, "[/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")

@@ -577,10 +577,10 @@ func (s *DockerSuite) TestContainerAPICreateMultipleNetworksConfig(c *check.C) {

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

 	msg := err.Error()

 	// network name order in error message is not deterministic

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

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

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

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

+	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")

 }

 func (s *DockerSuite) TestContainerAPICreateBridgeNetworkMode(c *check.C) {

@@ -615,7 +615,7 @@ func UtilCreateNetworkMode(c *check.C, networkMode containertypes.NetworkMode) {

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

 	assert.NilError(c, err)

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

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

 }

 func (s *DockerSuite) TestContainerAPICreateWithCpuSharesCpuset(c *check.C) {

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

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

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

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

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

 }

 func (s *DockerSuite) TestContainerAPIVerifyHeader(c *check.C) {

@@ -656,7 +656,7 @@ func (s *DockerSuite) TestContainerAPIVerifyHeader(c *check.C) {

 	create := func(ct string) (*http.Response, io.ReadCloser, error) {

 		jsonData := bytes.NewBuffer(nil)

-		c.Assert(json.NewEncoder(jsonData).Encode(config), checker.IsNil)

+		assert.Assert(c, json.NewEncoder(jsonData).Encode(config), checker.IsNil)

 		return request.Post("/containers/create", request.RawContent(ioutil.NopCloser(jsonData)), request.ContentType(ct))

 	}

@@ -668,7 +668,7 @@ func (s *DockerSuite) TestContainerAPIVerifyHeader(c *check.C) {

 	if versions.GreaterThanOrEqualTo(testEnv.DaemonAPIVersion(), "1.32") {

 		assert.Equal(c, res.StatusCode, http.StatusBadRequest)

 	} else {

-		c.Assert(res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

+		assert.Assert(c, res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

 	}

 	body.Close()

@@ -678,7 +678,7 @@ func (s *DockerSuite) TestContainerAPIVerifyHeader(c *check.C) {

 	if versions.GreaterThanOrEqualTo(testEnv.DaemonAPIVersion(), "1.32") {

 		assert.Equal(c, res.StatusCode, http.StatusBadRequest)

 	} else {

-		c.Assert(res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

+		assert.Assert(c, res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

 	}

 	body.Close()

@@ -708,12 +708,12 @@ func (s *DockerSuite) TestContainerAPIInvalidPortSyntax(c *check.C) {

 	if versions.GreaterThanOrEqualTo(testEnv.DaemonAPIVersion(), "1.32") {

 		assert.Equal(c, res.StatusCode, http.StatusBadRequest)

 	} else {

-		c.Assert(res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

+		assert.Assert(c, res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

 	}

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

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

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

 }

 func (s *DockerSuite) TestContainerAPIRestartPolicyInvalidPolicyName(c *check.C) {

@@ -732,12 +732,12 @@ func (s *DockerSuite) TestContainerAPIRestartPolicyInvalidPolicyName(c *check.C)

 	if versions.GreaterThanOrEqualTo(testEnv.DaemonAPIVersion(), "1.32") {

 		assert.Equal(c, res.StatusCode, http.StatusBadRequest)

 	} else {

-		c.Assert(res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

+		assert.Assert(c, res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

 	}

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

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

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

 }

 func (s *DockerSuite) TestContainerAPIRestartPolicyRetryMismatch(c *check.C) {

@@ -756,12 +756,12 @@ func (s *DockerSuite) TestContainerAPIRestartPolicyRetryMismatch(c *check.C) {

 	if versions.GreaterThanOrEqualTo(testEnv.DaemonAPIVersion(), "1.32") {

 		assert.Equal(c, res.StatusCode, http.StatusBadRequest)

 	} else {

-		c.Assert(res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

+		assert.Assert(c, res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

 	}

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

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

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

 }

 func (s *DockerSuite) TestContainerAPIRestartPolicyNegativeRetryCount(c *check.C) {

@@ -780,12 +780,12 @@ func (s *DockerSuite) TestContainerAPIRestartPolicyNegativeRetryCount(c *check.C

 	if versions.GreaterThanOrEqualTo(testEnv.DaemonAPIVersion(), "1.32") {

 		assert.Equal(c, res.StatusCode, http.StatusBadRequest)

 	} else {

-		c.Assert(res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

+		assert.Assert(c, res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

 	}

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

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

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

 }

 func (s *DockerSuite) TestContainerAPIRestartPolicyDefaultRetryCount(c *check.C) {

@@ -840,14 +840,14 @@ func (s *DockerSuite) TestContainerAPIPostCreateNull(c *check.C) {

 		ID string

 	}

 	var container createResp

-	c.Assert(json.Unmarshal(b, &container), checker.IsNil)

+	assert.Assert(c, json.Unmarshal(b, &container), checker.IsNil)

 	out := inspectField(c, container.ID, "HostConfig.CpusetCpus")

 	assert.Equal(c, out, "")

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

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

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

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

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

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

 }

 func (s *DockerSuite) TestCreateWithTooLowMemoryLimit(c *check.C) {

@@ -864,14 +864,14 @@ func (s *DockerSuite) TestCreateWithTooLowMemoryLimit(c *check.C) {

 	res, body, err := request.Post("/containers/create", request.RawString(config), request.JSON)

 	assert.NilError(c, err)

 	b, err2 := request.ReadBody(body)

-	c.Assert(err2, checker.IsNil)

+	assert.Assert(c, err2, checker.IsNil)

 	if versions.GreaterThanOrEqualTo(testEnv.DaemonAPIVersion(), "1.32") {

 		assert.Equal(c, res.StatusCode, http.StatusBadRequest)

 	} else {

-		c.Assert(res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

+		assert.Assert(c, res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

 	}

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

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

 }

 func (s *DockerSuite) TestContainerAPIRename(c *check.C) {

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

 	assert.NilError(c, err)

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

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

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

 }

 func (s *DockerSuite) TestContainerAPIKill(c *check.C) {

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

 	assert.NilError(c, err)

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

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

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

 }

 func (s *DockerSuite) TestContainerAPIRestart(c *check.C) {

@@ -917,7 +917,7 @@ func (s *DockerSuite) TestContainerAPIRestart(c *check.C) {

 	err = cli.ContainerRestart(context.Background(), name, &timeout)

 	assert.NilError(c, err)

-	c.Assert(waitInspect(name, "{{ .State.Restarting  }} {{ .State.Running  }}", "false true", 15*time.Second), checker.IsNil)

+	assert.Assert(c, waitInspect(name, "{{ .State.Restarting  }} {{ .State.Running  }}", "false true", 15*time.Second), checker.IsNil)

 }

 func (s *DockerSuite) TestContainerAPIRestartNotimeoutParam(c *check.C) {

@@ -933,7 +933,7 @@ func (s *DockerSuite) TestContainerAPIRestartNotimeoutParam(c *check.C) {

 	err = cli.ContainerRestart(context.Background(), name, nil)

 	assert.NilError(c, err)

-	c.Assert(waitInspect(name, "{{ .State.Restarting  }} {{ .State.Running  }}", "false true", 15*time.Second), checker.IsNil)

+	assert.Assert(c, waitInspect(name, "{{ .State.Restarting  }} {{ .State.Running  }}", "false true", 15*time.Second), checker.IsNil)

 }

 func (s *DockerSuite) TestContainerAPIStart(c *check.C) {

@@ -973,7 +973,7 @@ func (s *DockerSuite) TestContainerAPIStop(c *check.C) {

 	err = cli.ContainerStop(context.Background(), name, &timeout)

 	assert.NilError(c, err)

-	c.Assert(waitInspect(name, "{{ .State.Running  }}", "false", 60*time.Second), checker.IsNil)

+	assert.Assert(c, waitInspect(name, "{{ .State.Running  }}", "false", 60*time.Second), checker.IsNil)

 	// second call to start should give 304

 	// maybe add ContainerStartWithRaw to test it

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

 	case err = <-errC:

 		assert.NilError(c, err)

 	case waitres := <-waitresC:

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

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

 	}

 }

@@ -1044,7 +1044,7 @@ func (s *DockerSuite) TestContainerAPICopyPre124(c *check.C) {

 			break

 		}

 	}

-	c.Assert(found, checker.True)

+	assert.Assert(c, found, checker.True)

 }

 func (s *DockerSuite) TestContainerAPICopyResourcePathEmptyPre124(c *check.C) {

@@ -1061,11 +1061,11 @@ func (s *DockerSuite) TestContainerAPICopyResourcePathEmptyPre124(c *check.C) {

 	if versions.GreaterThanOrEqualTo(testEnv.DaemonAPIVersion(), "1.32") {

 		assert.Equal(c, res.StatusCode, http.StatusBadRequest)

 	} else {

-		c.Assert(res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

+		assert.Assert(c, res.StatusCode, checker.Not(checker.Equals), http.StatusOK)

 	}

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

-	c.Assert(string(b), checker.Matches, "Path cannot be empty\n")

+	assert.Assert(c, string(b), checker.Matches, "Path cannot be empty\n")

 }

 func (s *DockerSuite) TestContainerAPICopyResourcePathNotFoundPre124(c *check.C) {

@@ -1086,7 +1086,7 @@ func (s *DockerSuite) TestContainerAPICopyResourcePathNotFoundPre124(c *check.C)

 	}

 	b, err := request.ReadBody(body)

 	assert.NilError(c, err)

-	c.Assert(string(b), checker.Matches, "Could not find the file /notexist in container "+name+"\n")

+	assert.Assert(c, string(b), checker.Matches, "Could not find the file /notexist in container "+name+"\n")

 }

 func (s *DockerSuite) TestContainerAPICopyContainerNotFoundPr124(c *check.C) {

@@ -1153,10 +1153,10 @@ func (s *DockerSuite) TestContainerAPIDeleteRemoveLinks(c *check.C) {

 	out, _ = dockerCmd(c, "run", "--link", "tlink1:tlink1", "--name", "tlink2", "-d", "busybox", "top")

 	id2 := strings.TrimSpace(out)

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

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

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

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

+	assert.Assert(c, links, checker.Equals, "[\"/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 *check.C) {

 	assert.NilError(c, err)

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

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

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

 }

 func (s *DockerSuite) TestContainerAPIDeleteConflict(c *check.C) {

@@ -1219,7 +1219,7 @@ func (s *DockerSuite) TestContainerAPIDeleteRemoveVolume(c *check.C) {

 	assert.NilError(c, err)

 	_, err = os.Stat(source)

-	c.Assert(os.IsNotExist(err), checker.True, check.Commentf("expected to get ErrNotExist error, got %v", err))

+	assert.Assert(c, os.IsNotExist(err), checker.True, check.Commentf("expected to get ErrNotExist error, got %v", err))

 }

 // Regression test for https://github.com/docker/docker/issues/6231

@@ -1238,7 +1238,7 @@ func (s *DockerSuite) TestContainerAPIChunkedEncoding(c *check.C) {

 		req.ContentLength = -1

 		return nil

 	}))

-	c.Assert(err, checker.IsNil, check.Commentf("error creating container with chunked encoding"))

+	assert.Assert(c, err, checker.IsNil, check.Commentf("error creating container with chunked encoding"))

 	defer resp.Body.Close()

 	assert.Equal(c, resp.StatusCode, http.StatusCreated)

 }

@@ -1247,7 +1247,7 @@ func (s *DockerSuite) TestContainerAPIPostContainerStop(c *check.C) {

 	out := runSleepingContainer(c)

 	containerID := strings.TrimSpace(out)

-	c.Assert(waitRun(containerID), checker.IsNil)

+	assert.Assert(c, waitRun(containerID), checker.IsNil)

 	cli, err := client.NewClientWithOpts(client.FromEnv)

 	assert.NilError(c, err)

@@ -1255,7 +1255,7 @@ func (s *DockerSuite) TestContainerAPIPostContainerStop(c *check.C) {

 	err = cli.ContainerStop(context.Background(), containerID, nil)

 	assert.NilError(c, err)

-	c.Assert(waitInspect(containerID, "{{ .State.Running  }}", "false", 60*time.Second), checker.IsNil)

+	assert.Assert(c, waitInspect(containerID, "{{ .State.Running  }}", "false", 60*time.Second), checker.IsNil)

 }

 // #14170

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

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

 	assert.NilError(c, err)

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

+	assert.Assert(c, containerJSON.HostConfig.ShmSize, check.Equals, 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 *check.C) {

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

 	assert.NilError(c, err)

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

+	assert.Assert(c, containerJSON.HostConfig.ShmSize, check.Equals, 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 *check.C) {

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

 	assert.NilError(c, err)

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

+	assert.Assert(c, containerJSON.HostConfig.ShmSize, check.Equals, int64(1073741824))

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

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

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

 	assert.NilError(c, err)

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

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

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

 	} else {

-		c.Assert(containerJSON.HostConfig.MemorySwappiness, check.IsNil)

+		assert.Assert(c, containerJSON.HostConfig.MemorySwappiness, check.IsNil)

 	}

 }

@@ -1614,7 +1614,7 @@ func (s *DockerSuite) TestContainerAPIStatsWithNetworkDisabled(c *check.C) {

 	err = cli.ContainerStart(context.Background(), name, types.ContainerStartOptions{})

 	assert.NilError(c, err)

-	c.Assert(waitRun(name), check.IsNil)

+	assert.Assert(c, waitRun(name), check.IsNil)

 	type b struct {

 		stats types.ContainerStats

@@ -1636,7 +1636,7 @@ func (s *DockerSuite) TestContainerAPIStatsWithNetworkDisabled(c *check.C) {

 	case <-time.After(2 * time.Second):

 		c.Fatal("stream was not closed after container was removed")

 	case sr := <-bc:

-		c.Assert(sr.err, checker.IsNil)

+		assert.Assert(c, sr.err, checker.IsNil)

 		sr.stats.Body.Close()

 	}

 }

@@ -2052,7 +2052,7 @@ func (s *DockerSuite) TestContainersAPICreateMountsCreate(c *check.C) {

 			assert.NilError(c, err)

 			defer os.RemoveAll(tmpDir3)

-			c.Assert(mount.Mount(tmpDir3, tmpDir3, "none", "bind,shared"), checker.IsNil)

+			assert.Assert(c, mount.Mount(tmpDir3, tmpDir3, "none", "bind,shared"), checker.IsNil)

 			cases = append(cases, []testCase{

 				{

@@ -2219,7 +2219,7 @@ func (s *DockerSuite) TestContainersAPICreateMountsTmpfs(c *check.C) {

 		assert.NilError(c, err)

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

 		for _, option := range x.expectedOptions {

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

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

 		}

 	}

 }

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

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

 	nodes := d1.ListNodes(c)

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

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

 loop0:

 	for _, n := range nodes {

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

 	})

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

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

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

 }

 func (s *DockerSwarmSuite) TestAPISwarmNodeRemove(c *check.C) {

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

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

 	nodes := d1.ListNodes(c)

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

+	assert.Assert(c, len(nodes), checker.Equals, 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 *check.C) {

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

 	nodes = d1.ListNodes(c)

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

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

 	// Restart the node that was removed

 	d2.RestartNode(c)

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

 	// Make sure the node didn't rejoin

 	nodes = d1.ListNodes(c)

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

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

 }

 func (s *DockerSwarmSuite) TestAPISwarmNodeDrainPause(c *check.C) {

@@ -147,7 +147,7 @@ func (s *DockerSuite) TestAttachDisconnect(c *check.C) {

 	stdout, err := cmd.StdoutPipe()

 	assert.NilError(c, err)

 	defer stdout.Close()

-	c.Assert(cmd.Start(), check.IsNil)

+	assert.Assert(c, cmd.Start(), check.IsNil)

 	defer func() {

 		cmd.Process.Kill()

 		cmd.Wait()

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

 	assert.NilError(c, err)

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

 	assert.NilError(c, err)

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

+	assert.Assert(c, strings.TrimSpace(out), check.Equals, "hello")

-	c.Assert(stdin.Close(), check.IsNil)

+	assert.Assert(c, stdin.Close(), check.IsNil)

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

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

-	c.Assert(running, check.Equals, "true")

+	assert.Assert(c, running, check.Equals, "true")

 }

 func (s *DockerSuite) TestAttachPausedContainer(c *check.C) {

@@ -51,7 +51,7 @@ func (s *DockerSuite) TestAttachClosedOnContainerStop(c *check.C) {

 	case err := <-errChan:

 		tty.Close()

 		out, _ := ioutil.ReadAll(pty)

-		c.Assert(err, check.IsNil, check.Commentf("out: %v", string(out)))

+		assert.Assert(c, err, check.IsNil, check.Commentf("out: %v", string(out)))

 	case <-time.After(attachWait):

 		c.Fatal("timed out without attach returning")

 	}

@@ -74,7 +74,7 @@ func (s *DockerSuite) TestAttachAfterDetach(c *check.C) {

 		close(cmdExit)

 	}()

-	c.Assert(waitRun(name), check.IsNil)

+	assert.Assert(c, waitRun(name), check.IsNil)

 	cpty.Write([]byte{16})

 	time.Sleep(100 * time.Millisecond)

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

 	}).Assert(c, icmd.Success)

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

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

+	assert.Assert(c, strings.TrimSpace(string(res)), checker.Equals, `[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 {

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

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

 	} else {

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

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

 	}

 }

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

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

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

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

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

 }

 func (s *DockerSuite) TestBuildBuildTimeArgCacheHit(c *check.C) {

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

 	)

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

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

+	assert.Assert(c, filepath.ToSlash(res), check.Equals, filepath.ToSlash(wdVal))

 	var resArr []string

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

@@ -4579,9 +4579,9 @@ func (s *DockerSuite) TestBuildBuildTimeArgEnv(c *check.C) {

 	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

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

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

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

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

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

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

 }

 func (s *DockerSuite) TestBuildBuildTimeArgQuotedValVariants(c *check.C) {

@@ -4652,11 +4652,11 @@ func (s *DockerSuite) TestBuildMultiStageArg(c *check.C) {

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

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

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

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

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

-	c.Assert(result.Stdout(), checker.Not(checker.Contains), "foo")

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

+	assert.Assert(c, result.Stdout(), checker.Not(checker.Contains), "foo")

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

 }

 func (s *DockerSuite) TestBuildMultiStageGlobalArg(c *check.C) {

@@ -4678,10 +4678,10 @@ func (s *DockerSuite) TestBuildMultiStageGlobalArg(c *check.C) {

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

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

-	c.Assert(result.Stdout(), checker.Not(checker.Contains), "tag")

+	assert.Assert(c, result.Stdout(), checker.Not(checker.Contains), "tag")

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

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

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

 }

 func (s *DockerSuite) TestBuildMultiStageUnusedArg(c *check.C) {

@@ -4696,12 +4696,12 @@ func (s *DockerSuite) TestBuildMultiStageUnusedArg(c *check.C) {

 		build.WithDockerfile(dockerfile),

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

 	result.Assert(c, icmd.Success)

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

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

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

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

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

-	c.Assert(result.Stdout(), checker.Not(checker.Contains), "bar")

-	c.Assert(result.Stdout(), checker.Not(checker.Contains), "baz")

+	assert.Assert(c, result.Stdout(), checker.Not(checker.Contains), "bar")

+	assert.Assert(c, result.Stdout(), checker.Not(checker.Contains), "baz")

 }

 func (s *DockerSuite) TestBuildNoNamedVolume(c *check.C) {

@@ -4741,7 +4741,7 @@ func (s *DockerSuite) TestBuildTagEvent(c *check.C) {

 		}

 	}

-	c.Assert(foundTag, checker.True, check.Commentf("No tag event found:\n%s", out))

+	assert.Assert(c, foundTag, checker.True, check.Commentf("No tag event found:\n%s", out))

 }

 // #15780

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

 	id1 := getIDByName(c, "tag1")

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

-	c.Assert(id1, check.Equals, id2)

+	assert.Assert(c, id1, check.Equals, id2)

 }

 // #17290

@@ -4802,17 +4802,17 @@ func (s *DockerSuite) TestBuildFollowSymlinkToFile(c *check.C) {

 	cli.BuildCmd(c, name, build.WithExternalBuildContext(ctx))

 	out := cli.DockerCmd(c, "run", "--rm", name, "cat", "target").Combined()

-	c.Assert(out, checker.Matches, "bar")

+	assert.Assert(c, out, checker.Matches, "bar")

 	// change target file should invalidate cache

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

 	assert.NilError(c, err)

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

-	c.Assert(result.Combined(), checker.Not(checker.Contains), "Using cache")

+	assert.Assert(c, result.Combined(), checker.Not(checker.Contains), "Using cache")

 	out = cli.DockerCmd(c, "run", "--rm", name, "cat", "target").Combined()

-	c.Assert(out, checker.Matches, "baz")

+	assert.Assert(c, out, checker.Matches, "baz")

 }

 func (s *DockerSuite) TestBuildFollowSymlinkToDir(c *check.C) {

@@ -4833,17 +4833,17 @@ func (s *DockerSuite) TestBuildFollowSymlinkToDir(c *check.C) {

 	cli.BuildCmd(c, name, build.WithExternalBuildContext(ctx))

 	out := cli.DockerCmd(c, "run", "--rm", name, "cat", "abc", "def").Combined()

-	c.Assert(out, checker.Matches, "barbaz")

+	assert.Assert(c, out, checker.Matches, "barbaz")

 	// change target file should invalidate cache

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

 	assert.NilError(c, err)

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

-	c.Assert(result.Combined(), checker.Not(checker.Contains), "Using cache")

+	assert.Assert(c, result.Combined(), checker.Not(checker.Contains), "Using cache")

 	out = cli.DockerCmd(c, "run", "--rm", name, "cat", "abc", "def").Combined()

-	c.Assert(out, checker.Matches, "barbax")

+	assert.Assert(c, out, checker.Matches, "barbax")

 }

@@ -4866,7 +4866,7 @@ func (s *DockerSuite) TestBuildSymlinkBasename(c *check.C) {

 	cli.BuildCmd(c, name, build.WithExternalBuildContext(ctx))

 	out := cli.DockerCmd(c, "run", "--rm", name, "cat", "asymlink").Combined()

-	c.Assert(out, checker.Matches, "bar")

+	assert.Assert(c, out, checker.Matches, "bar")

 }

 // #17827

@@ -4890,7 +4890,7 @@ func (s *DockerSuite) TestBuildCacheRootSource(c *check.C) {

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

-	c.Assert(result.Combined(), checker.Not(checker.Contains), "Using cache")

+	assert.Assert(c, result.Combined(), checker.Not(checker.Contains), "Using cache")

 }

 // #19375

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

 	if !ok {

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

 	}

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

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

 }

 func (s *DockerSuite) TestBuildLabelCacheCommit(c *check.C) {

@@ -5044,7 +5044,7 @@ func (s *DockerRegistryAuthHtpasswdSuite) TestBuildWithExternalAuth(c *check.C)

 	b, err := ioutil.ReadFile(configPath)

 	assert.NilError(c, err)

-	c.Assert(string(b), checker.Not(checker.Contains), "\"auth\":")

+	assert.Assert(c, string(b), checker.Not(checker.Contains), "\"auth\":")

 	dockerCmd(c, "--config", tmp, "tag", "busybox", repoName)

 	dockerCmd(c, "--config", tmp, "push", repoName)

@@ -5383,9 +5383,9 @@ func (s *DockerSuite) TestBuildStepsWithProgress(c *check.C) {

 	totalRun := 5

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

 	result.Assert(c, icmd.Success)

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

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

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

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

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

 	}

 }

@@ -5395,16 +5395,16 @@ func (s *DockerSuite) TestBuildWithFailure(c *check.C) {

 	// First test case can only detect `nobody` in runtime so all steps will show up

 	dockerfile := "FROM busybox\nRUN nobody"

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

-	c.Assert(result.Error, checker.NotNil)

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

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

+	assert.Assert(c, result.Error, checker.NotNil)

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

+	assert.Assert(c, result.Stdout(), checker.Contains, "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))

-	c.Assert(result.Error, checker.NotNil)

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

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

+	assert.Assert(c, result.Error, checker.NotNil)

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

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

 }

 func (s *DockerSuite) TestBuildCacheFromEqualDiffIDsLength(c *check.C) {

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

 	// rebuild with cache-from

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

 	id2 := getIDByName(c, "build2")

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

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

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

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

 }

 func (s *DockerSuite) TestBuildCacheFrom(c *check.C) {

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

 	// rebuild with cache-from

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

 	id2 := getIDByName(c, "build2")

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

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

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

+	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 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")

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

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

+	assert.Assert(c, id1, checker.Not(checker.Equals), id2)

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

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

 	// clear parent images

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

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

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

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

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

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

 	// cache still applies without parents

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

 	id2 = getIDByName(c, "build2")

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

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

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

+	assert.Assert(c, strings.Count(result.Combined(), "Using cache"), checker.Equals, 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")

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

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

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

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

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

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

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

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

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

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

@@ -5505,22 +5505,22 @@ func (s *DockerSuite) TestBuildCacheFrom(c *check.C) {

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

 	id2 = getIDByName(c, "build2")

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

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

+	assert.Assert(c, id1, checker.Not(checker.Equals), id2)

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

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

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

 	var layers1 []string

 	var layers2 []string

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

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

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

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

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

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

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

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

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

 	}

-	c.Assert(layers1[len(layers1)-1], checker.Not(checker.Equals), layers2[len(layers1)-1])

+	assert.Assert(c, layers1[len(layers1)-1], checker.Not(checker.Equals), layers2[len(layers1)-1])

 }

 func (s *DockerSuite) TestBuildMultiStageCache(c *check.C) {

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

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

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

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

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

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

 	// now both parts of dockerfile should be cached

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