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

 	assert.NilError(c, err)

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

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

+	assert.Assert(c, <-chErr == nil)

 }

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

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

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

 		jsonData := bytes.NewBuffer(nil)

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

+		assert.Assert(c, json.NewEncoder(jsonData).Encode(config) == nil)

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

 	}

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

 		ID string

 	}

 	var container createResp

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

+	assert.Assert(c, json.Unmarshal(b, &container) == nil)

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

 	assert.Equal(c, out, "")

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

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

 	assert.NilError(c, err)

 	b, err2 := request.ReadBody(body)

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

+	assert.Assert(c, err2 == nil)

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

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

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

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

 	assert.NilError(c, err)

-	assert.Assert(c, 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) == nil)

 }

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

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

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

 	assert.NilError(c, err)

-	assert.Assert(c, 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) == nil)

 }

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

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

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

 	assert.NilError(c, err)

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

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

 	// second call to start should give 304

 	// maybe add ContainerStartWithRaw to test it

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

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

 	id2 := strings.TrimSpace(out)

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

+	assert.Assert(c, waitRun(id2) == nil)

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

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

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

 		req.ContentLength = -1

 		return nil

 	}))

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

+	assert.Assert(c, err == nil, 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 *testing.T) {

 	out := runSleepingContainer(c)

 	containerID := strings.TrimSpace(out)

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

+	assert.Assert(c, waitRun(containerID) == nil)

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

 	assert.NilError(c, err)

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

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

 	assert.NilError(c, err)

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

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

 }

 // #14170

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

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

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

 	} else {

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

+		assert.Assert(c, containerJSON.HostConfig.MemorySwappiness == nil)

 	}

 }

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

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

 	assert.NilError(c, err)

-	assert.Assert(c, waitRun(name), checker.IsNil)

+	assert.Assert(c, waitRun(name) == nil)

 	type b struct {

 		stats types.ContainerStats

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

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

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

 	case sr := <-bc:

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

+		assert.Assert(c, sr.err == nil)

 		sr.stats.Body.Close()

 	}

 }

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

 			assert.NilError(c, err)

 			defer os.RemoveAll(tmpDir3)

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

+			assert.Assert(c, mount.Mount(tmpDir3, tmpDir3, "none", "bind,shared") == nil)

 			cases = append(cases, []testCase{

 				{

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

 	stdout, err := cmd.StdoutPipe()

 	assert.NilError(c, err)

 	defer stdout.Close()

-	assert.Assert(c, cmd.Start(), checker.IsNil)

+	assert.Assert(c, cmd.Start() == nil)

 	defer func() {

 		cmd.Process.Kill()

 		cmd.Wait()

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

 	assert.NilError(c, err)

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

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

+	assert.Assert(c, stdin.Close() == nil)

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

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

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

 	case err := <-errChan:

 		tty.Close()

 		out, _ := ioutil.ReadAll(pty)

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

+		assert.Assert(c, err == nil, 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 *testing.T) {

 		close(cmdExit)

 	}()

-	assert.Assert(c, waitRun(name), checker.IsNil)

+	assert.Assert(c, waitRun(name) == nil)

 	cpty.Write([]byte{16})

 	time.Sleep(100 * time.Millisecond)

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

 	var layers1 []string

 	var layers2 []string

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

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

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

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

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

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

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

 	var c1 hostConfig

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

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

+	assert.Assert(c, err == nil, check.Commentf(cfg))

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

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

 	var c2 hostConfig

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

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

+	assert.Assert(c, err == nil, check.Commentf(cfg))

 	assert.Assert(c, c2.Memory != int64(64*1024*1024), check.Commentf("resource leaked from build for Memory"))

 	assert.Assert(c, c2.MemorySwap != int64(-1), check.Commentf("resource leaked from build for MemorySwap"))

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

 	assert.Assert(c, c2.CpusetMems != "0", check.Commentf("resource leaked from build for CpusetMems"))

 	assert.Assert(c, c2.CPUShares != int64(100), check.Commentf("resource leaked from build for CPUShares"))

 	assert.Assert(c, c2.CPUQuota != int64(8000), check.Commentf("resource leaked from build for CPUQuota"))

-	assert.Assert(c, c2.Ulimits, checker.IsNil, check.Commentf("resource leaked from build for Ulimits"))

+	assert.Assert(c, c2.Ulimits == nil, check.Commentf("resource leaked from build for Ulimits"))

 }

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

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

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

 	digest, err := setupImage(c)

-	assert.Assert(c, err, checker.IsNil, check.Commentf("error setting up image"))

+	assert.Assert(c, err == nil, check.Commentf("error setting up image"))

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

@@ -568,14 +568,14 @@ func (s *DockerRegistrySuite) TestPullFailsWithAlteredManifest(c *testing.T) {

 func (s *DockerSchema1RegistrySuite) TestPullFailsWithAlteredManifest(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	manifestDigest, err := setupImage(c)

-	assert.Assert(c, err, checker.IsNil, check.Commentf("error setting up image"))

+	assert.Assert(c, err == nil, check.Commentf("error setting up image"))

 	// Load the target manifest blob.

 	manifestBlob := s.reg.ReadBlobContents(c, manifestDigest)

 	var imgManifest schema1.Manifest

 	err = json.Unmarshal(manifestBlob, &imgManifest)

-	assert.Assert(c, err, checker.IsNil, check.Commentf("unable to decode image manifest from blob"))

+	assert.Assert(c, err == nil, check.Commentf("unable to decode image manifest from blob"))

 	// Change a layer in the manifest.

 	imgManifest.FSLayers[0] = schema1.FSLayer{

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

 	defer undo()

 	alteredManifestBlob, err := json.MarshalIndent(imgManifest, "", "   ")

-	assert.Assert(c, err, checker.IsNil, check.Commentf("unable to encode altered image manifest to JSON"))

+	assert.Assert(c, err == nil, check.Commentf("unable to encode altered image manifest to JSON"))

 	s.reg.WriteBlobContents(c, manifestDigest, alteredManifestBlob)

@@ -610,14 +610,14 @@ func (s *DockerSchema1RegistrySuite) TestPullFailsWithAlteredManifest(c *testing

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

 	testRequires(c, DaemonIsLinux)

 	manifestDigest, err := setupImage(c)

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

+	assert.Assert(c, err == nil)

 	// Load the target manifest blob.

 	manifestBlob := s.reg.ReadBlobContents(c, manifestDigest)

 	var imgManifest schema2.Manifest

 	err = json.Unmarshal(manifestBlob, &imgManifest)

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

+	assert.Assert(c, err == nil)

 	// Next, get the digest of one of the layers from the manifest.

 	targetLayerDigest := imgManifest.Layers[0].Digest

@@ -653,14 +653,14 @@ func (s *DockerRegistrySuite) TestPullFailsWithAlteredLayer(c *testing.T) {

 func (s *DockerSchema1RegistrySuite) TestPullFailsWithAlteredLayer(c *testing.T) {

 	testRequires(c, DaemonIsLinux)

 	manifestDigest, err := setupImage(c)

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

+	assert.Assert(c, err == nil)

 	// Load the target manifest blob.

 	manifestBlob := s.reg.ReadBlobContents(c, manifestDigest)

 	var imgManifest schema1.Manifest

 	err = json.Unmarshal(manifestBlob, &imgManifest)

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

+	assert.Assert(c, err == nil)

 	// Next, get the digest of one of the layers from the manifest.

 	targetLayerDigest := imgManifest.FSLayers[0].BlobSum

@@ -36,38 +36,38 @@ func (s *DockerSuite) TestCpFromSymlinkDestination(c *testing.T) {

 	srcPath := containerCpPath(containerID, "/file2")

 	dstPath := cpPath(tmpDir, "symlinkToFile1")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, dstPath, "file1"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, dstPath, "file1") == nil)

 	// The file should have the contents of "file2" now.

-	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "file1"), "file2\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "file1"), "file2\n") == nil)

 	// Next, copy a file from the container to a symlink to a directory. This

 	// should copy the file into the symlink target directory.

 	dstPath = cpPath(tmpDir, "symlinkToDir1")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dir1"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dir1") == nil)

 	// The file should have the contents of "file2" now.

-	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "file2"), "file2\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "file2"), "file2\n") == nil)

 	// Next, copy a file from the container to a symlink to a file that does

 	// not exist (a broken symlink). This should create the target file with

 	// the contents of the source file.

 	dstPath = cpPath(tmpDir, "brokenSymlinkToFileX")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, dstPath, "fileX"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, dstPath, "fileX") == nil)

 	// The file should have the contents of "file2" now.

-	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "fileX"), "file2\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "fileX"), "file2\n") == nil)

 	// Next, copy a directory from the container to a symlink to a local

 	// directory. This should copy the directory into the symlink target

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

 	srcPath = containerCpPath(containerID, "/dir2")

 	dstPath = cpPath(tmpDir, "symlinkToDir1")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dir1"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dir1") == nil)

 	// The directory should now contain a copy of "dir2".

-	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "dir1/dir2/file2-1"), "file2-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "dir1/dir2/file2-1"), "file2-1\n") == nil)

 	// Next, copy a directory from the container to a symlink to a local

 	// directory that does not exist (a broken symlink). This should create

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

 	// should not modify the symlink.

 	dstPath = cpPath(tmpDir, "brokenSymlinkToDirX")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dirX"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, dstPath, "dirX") == nil)

 	// The "dirX" directory should now be a copy of "dir2".

-	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "dirX/file2-1"), "file2-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(tmpDir, "dirX/file2-1"), "file2-1\n") == nil)

 }

 // Possibilities are reduced to the remaining 10 cases:

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

 	srcPath := containerCpPath(containerID, "/root/file1")

 	dstPath := cpPath(tmpDir, "itWorks.txt")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n") == nil)

 }

 // B. SRC specifies a file and DST (with trailing path separator) doesn't

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

 	dstPath := cpPath(tmpDir, "file2")

 	// Ensure the local file starts with different content.

-	assert.Assert(c, fileContentEquals(c, dstPath, "file2\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file2\n") == nil)

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n") == nil)

 }

 // D. SRC specifies a file and DST exists as a directory. This should place

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

 	_, err := os.Stat(dstPath)

 	assert.Assert(c, os.IsNotExist(err), checker.True, check.Commentf("did not expect dstPath %q to exist", dstPath))

-	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

 	// unable to remove dstDir

-	assert.Assert(c, os.RemoveAll(dstDir), checker.IsNil)

+	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 	// unable to make dstDir

-	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)), checker.IsNil)

+	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)) == nil)

 	dstDir = cpPathTrailingSep(tmpDir, "dir1")

-	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1\n") == nil)

 }

 // E. SRC specifies a directory and DST does not exist. This should create a

@@ -231,20 +231,20 @@ func (s *DockerSuite) TestCpFromCaseE(c *testing.T) {

 	dstDir := cpPath(tmpDir, "testDir")

 	dstPath := filepath.Join(dstDir, "file1-1")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

 	// unable to remove dstDir

-	assert.Assert(c, os.RemoveAll(dstDir), checker.IsNil)

+	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 	dstDir = cpPathTrailingSep(tmpDir, "testDir")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 }

 // F. SRC specifies a directory and DST exists as a file. This should cause an

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

 	resultDir := filepath.Join(dstDir, "dir1")

 	dstPath := filepath.Join(resultDir, "file1-1")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

 	// unable to remove dstDir

-	assert.Assert(c, os.RemoveAll(dstDir), checker.IsNil)

+	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 	// unable to make dstDir

-	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)), checker.IsNil)

+	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)) == nil)

 	dstDir = cpPathTrailingSep(tmpDir, "dir2")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 }

 // H. SRC specifies a directory's contents only and DST does not exist. This

@@ -322,20 +322,20 @@ func (s *DockerSuite) TestCpFromCaseH(c *testing.T) {

 	dstDir := cpPath(tmpDir, "testDir")

 	dstPath := filepath.Join(dstDir, "file1-1")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

 	// unable to remove resultDir

-	assert.Assert(c, os.RemoveAll(dstDir), checker.IsNil)

+	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 	dstDir = cpPathTrailingSep(tmpDir, "testDir")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 }

 // I. SRC specifies a directory's contents only and DST exists as a file. This

@@ -380,21 +380,21 @@ func (s *DockerSuite) TestCpFromCaseJ(c *testing.T) {

 	dstDir := cpPath(tmpDir, "dir2")

 	dstPath := filepath.Join(dstDir, "file1-1")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

 	// unable to remove dstDir

-	assert.Assert(c, os.RemoveAll(dstDir), checker.IsNil)

+	assert.Assert(c, os.RemoveAll(dstDir) == nil)

 	// unable to make dstDir

-	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)), checker.IsNil)

+	assert.Assert(c, os.MkdirAll(dstDir, os.FileMode(0755)) == nil)

 	dstDir = cpPathTrailingSep(tmpDir, "dir2")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

-	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, dstPath, "file1-1\n") == nil)

 }

@@ -40,38 +40,38 @@ func (s *DockerSuite) TestCpToSymlinkDestination(c *testing.T) {

 	srcPath := cpPath(testVol, "file2")

 	dstPath := containerCpPath(containerID, "/vol2/symlinkToFile1")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "symlinkToFile1"), "file1"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "symlinkToFile1"), "file1") == nil)

 	// The file should have the contents of "file2" now.

-	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "file1"), "file2\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "file1"), "file2\n") == nil)

 	// Next, copy a local file to a symlink to a directory in the container.

 	// This should copy the file into the symlink target directory.

 	dstPath = containerCpPath(containerID, "/vol2/symlinkToDir1")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "symlinkToDir1"), "dir1"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "symlinkToDir1"), "dir1") == nil)

 	// The file should have the contents of "file2" now.

-	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "file2"), "file2\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "file2"), "file2\n") == nil)

 	// Next, copy a file to a symlink to a file that does not exist (a broken

 	// symlink) in the container. This should create the target file with the

 	// contents of the source file.

 	dstPath = containerCpPath(containerID, "/vol2/brokenSymlinkToFileX")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "brokenSymlinkToFileX"), "fileX"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "brokenSymlinkToFileX"), "fileX") == nil)

 	// The file should have the contents of "file2" now.

-	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "fileX"), "file2\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "fileX"), "file2\n") == nil)

 	// Next, copy a local directory to a symlink to a directory in the

 	// container. This should copy the directory into the symlink target

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

 	srcPath = cpPath(testVol, "/dir2")

 	dstPath = containerCpPath(containerID, "/vol2/symlinkToDir1")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "symlinkToDir1"), "dir1"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "symlinkToDir1"), "dir1") == nil)

 	// The directory should now contain a copy of "dir2".

-	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "dir1/dir2/file2-1"), "file2-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "dir1/dir2/file2-1"), "file2-1\n") == nil)

 	// Next, copy a local directory to a symlink to a local directory that does

 	// not exist (a broken symlink) in the container. This should create the

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

 	// should not modify the symlink.

 	dstPath = containerCpPath(containerID, "/vol2/brokenSymlinkToDirX")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// The symlink should not have been modified.

-	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "brokenSymlinkToDirX"), "dirX"), checker.IsNil)

+	assert.Assert(c, symlinkTargetEquals(c, cpPath(testVol, "brokenSymlinkToDirX"), "dirX") == nil)

 	// The "dirX" directory should now be a copy of "dir2".

-	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "dirX/file2-1"), "file2-1\n"), checker.IsNil)

+	assert.Assert(c, fileContentEquals(c, cpPath(testVol, "dirX/file2-1"), "file2-1\n") == nil)

 }

 // Possibilities are reduced to the remaining 10 cases:

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

 	srcPath := cpPath(tmpDir, "file1")

 	dstPath := containerCpPath(containerID, "/root/itWorks.txt")

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1\n") == nil)

 }

 // B. SRC specifies a file and DST (with trailing path separator) doesn't

@@ -179,12 +179,12 @@ func (s *DockerSuite) TestCpToCaseC(c *testing.T) {

 	dstPath := containerCpPath(containerID, "/root/file2")

 	// Ensure the container's file starts with the original content.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file2\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file2\n") == nil)

-	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstPath, nil) == nil)

 	// Should now contain file1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1\n") == nil)

 }

 // D. SRC specifies a file and DST exists as a directory. This should place

@@ -206,12 +206,12 @@ func (s *DockerSuite) TestCpToCaseD(c *testing.T) {

 	dstDir := containerCpPath(containerID, "dir1")

 	// Ensure that dstPath doesn't exist.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, ""), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "") == nil)

-	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil) == nil)

 	// Should now contain file1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

@@ -224,12 +224,12 @@ func (s *DockerSuite) TestCpToCaseD(c *testing.T) {

 	dstDir = containerCpPathTrailingSep(containerID, "dir1")

 	// Ensure that dstPath doesn't exist.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, ""), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "") == nil)

-	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcPath, dstDir, nil) == nil)

 	// Should now contain file1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1\n") == nil)

 }

 // E. SRC specifies a directory and DST does not exist. This should create a

@@ -249,10 +249,10 @@ func (s *DockerSuite) TestCpToCaseE(c *testing.T) {

 	srcDir := cpPath(tmpDir, "dir1")

 	dstDir := containerCpPath(containerID, "testDir")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	// Should now contain file1-1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

@@ -263,10 +263,10 @@ func (s *DockerSuite) TestCpToCaseE(c *testing.T) {

 	dstDir = containerCpPathTrailingSep(containerID, "testDir")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	// Should now contain file1-1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n") == nil)

 }

 // F. SRC specifies a directory and DST exists as a file. This should cause an

@@ -310,12 +310,12 @@ func (s *DockerSuite) TestCpToCaseG(c *testing.T) {

 	dstDir := containerCpPath(containerID, "/root/dir2")

 	// Ensure that dstPath doesn't exist.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, ""), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "") == nil)

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	// Should now contain file1-1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

@@ -328,12 +328,12 @@ func (s *DockerSuite) TestCpToCaseG(c *testing.T) {

 	dstDir = containerCpPathTrailingSep(containerID, "/dir2")

 	// Ensure that dstPath doesn't exist.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, ""), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "") == nil)

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	// Should now contain file1-1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n") == nil)

 }

 // H. SRC specifies a directory's contents only and DST does not exist. This

@@ -353,10 +353,10 @@ func (s *DockerSuite) TestCpToCaseH(c *testing.T) {

 	srcDir := cpPathTrailingSep(tmpDir, "dir1") + "."

 	dstDir := containerCpPath(containerID, "testDir")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	// Should now contain file1-1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

@@ -367,10 +367,10 @@ func (s *DockerSuite) TestCpToCaseH(c *testing.T) {

 	dstDir = containerCpPathTrailingSep(containerID, "testDir")

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	// Should now contain file1-1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n") == nil)

 }

 // I. SRC specifies a directory's contents only and DST exists as a file. This

@@ -416,12 +416,12 @@ func (s *DockerSuite) TestCpToCaseJ(c *testing.T) {

 	dstDir := containerCpPath(containerID, "/dir2")

 	// Ensure that dstPath doesn't exist.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, ""), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "") == nil)

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	// Should now contain file1-1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n") == nil)

 	// Now try again but using a trailing path separator for dstDir.

@@ -433,12 +433,12 @@ func (s *DockerSuite) TestCpToCaseJ(c *testing.T) {

 	dstDir = containerCpPathTrailingSep(containerID, "/dir2")

 	// Ensure that dstPath doesn't exist.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, ""), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "") == nil)

-	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil), checker.IsNil)

+	assert.Assert(c, runDockerCp(c, srcDir, dstDir, nil) == nil)

 	// Should now contain file1-1's contents.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n"), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "file1-1\n") == nil)

 }

 // The `docker cp` command should also ensure that you cannot

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

 	assert.Assert(c, isCpCannotCopyReadOnly(err), checker.True, check.Commentf("expected ErrContainerRootfsReadonly error, but got %T: %s", err, err))

 	// Ensure that dstPath doesn't exist.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, ""), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "") == nil)

 }

 // The `docker cp` command should also ensure that you

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

 	assert.Assert(c, isCpCannotCopyReadOnly(err), checker.True, check.Commentf("expected ErrVolumeReadonly error, but got %T: %s", err, err))

 	// Ensure that dstPath doesn't exist.

-	assert.Assert(c, containerStartOutputEquals(c, containerID, ""), checker.IsNil)

+	assert.Assert(c, containerStartOutputEquals(c, containerID, "") == nil)

 }

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

 	}

 	err := json.Unmarshal([]byte(out), &containers)

-	assert.Assert(c, err, checker.IsNil, check.Commentf("Error inspecting the container: %s", err))

+	assert.Assert(c, err == nil, check.Commentf("Error inspecting the container: %s", err))

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

 	cont := containers[0]

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

 	}

 	err := json.Unmarshal([]byte(out), &containers)

-	assert.Assert(c, err, checker.IsNil, check.Commentf("Error inspecting the container: %s", err))

+	assert.Assert(c, err == nil, check.Commentf("Error inspecting the container: %s", err))

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

 	cont := containers[0]

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

 		}

 	}

 	err := json.Unmarshal([]byte(out), &containers)

-	assert.Assert(c, err, checker.IsNil, check.Commentf("Error inspecting the container: %s", err))

+	assert.Assert(c, err == nil, check.Commentf("Error inspecting the container: %s", err))

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

 	cont := containers[0]

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

 	}

 	err := json.Unmarshal([]byte(out), &containers)

-	assert.Assert(c, err, checker.IsNil, check.Commentf("Error inspecting the container: %s", err))

+	assert.Assert(c, err == nil, check.Commentf("Error inspecting the container: %s", err))

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

 	cont := containers[0]

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

 	dockerCmd(c, "create", "--name", name, "-v", prefix+slash+"foo", "busybox")

 	dir, err := inspectMountSourceField(name, prefix+slash+"foo")

-	assert.Assert(c, err, checker.IsNil, check.Commentf("Error getting volume host path: %q", err))

+	assert.Assert(c, err == nil, check.Commentf("Error getting volume host path: %q", err))

 	if _, err := os.Stat(dir); err != nil && os.IsNotExist(err) {

 		c.Fatalf("Volume was not created")

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

 		var format string

 		for name, shouldRun := range m {

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

-			assert.Assert(c, err, checker.IsNil, check.Commentf("run ps: %v", out))

+			assert.Assert(c, err == nil, check.Commentf("run ps: %v", out))

 			if shouldRun {

 				format = "%scontainer %q is not running"

 			} else {

@@ -240,11 +240,11 @@ func (s *DockerDaemonSuite) TestDaemonRestartWithIncreasedBasesize(c *testing.T)

 	}

 	err := s.d.RestartWithError("--storage-opt", fmt.Sprintf("dm.basesize=%d", newBasesizeBytes))

-	assert.Assert(c, err, checker.IsNil, check.Commentf("we should have been able to start the daemon with increased base device size: %v", err))

+	assert.Assert(c, err == nil, check.Commentf("we should have been able to start the daemon with increased base device size: %v", err))

 	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, err == nil, check.Commentf("Error in converting base device size: %v", err))

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

 	s.d.Stop(c)

 }

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

 		build.WithoutCache,

 	)

 	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.Error == nil, comment)

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

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

 }

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

 	}

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