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

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

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

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

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

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

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

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

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

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

 }

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

 	// pull from the registry using the <name>@<digest> reference

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

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

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

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

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

 }

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

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

 	cont := containers[0]

-	assert.Assert(c, cont.HostConfig, checker.NotNil, check.Commentf("Expected HostConfig, got none"))

+	assert.Assert(c, cont.HostConfig != nil, check.Commentf("Expected HostConfig, got none"))

 	assert.Assert(c, cont.HostConfig.PublishAllPorts, checker.True, check.Commentf("Expected PublishAllPorts, got false"))

 }

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

 	cont := containers[0]

-	assert.Assert(c, cont.HostConfig, checker.NotNil, check.Commentf("Expected HostConfig, got none"))

+	assert.Assert(c, cont.HostConfig != nil, check.Commentf("Expected HostConfig, got none"))

 	assert.Equal(c, len(cont.HostConfig.PortBindings), 4, check.Commentf("Expected 4 ports bindings, got %d", len(cont.HostConfig.PortBindings)))

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

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

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

 	cont := containers[0]

-	assert.Assert(c, cont.HostConfig, checker.NotNil, check.Commentf("Expected HostConfig, got none"))

+	assert.Assert(c, cont.HostConfig != nil, check.Commentf("Expected HostConfig, got none"))

 	assert.Equal(c, len(cont.HostConfig.PortBindings), 65535)

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

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

 	if newBasesizeBytes < oldBasesizeBytes {

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

-		assert.Assert(c, err, checker.NotNil, check.Commentf("daemon should not have started as new base device size is less than existing base device size: %v", err))

+		assert.Assert(c, err != nil, check.Commentf("daemon should not have started as new base device size is less than existing base device size: %v", err))

 		// 'err != nil' is expected behaviour, no new daemon started,

 		// so no need to stop daemon.

 		if err != nil {

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

 	out = strings.Trim(out, " \r\n'")

 	ip := net.ParseIP(out)

-	assert.Assert(c, ip, checker.NotNil, check.Commentf("Container should have a global IPv6 address"))

+	assert.Assert(c, ip != nil, check.Commentf("Container should have a global IPv6 address"))

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

 	assert.NilError(c, err, out)

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

 }

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

-	assert.Assert(c, s.d.StartWithError("--log-level=bogus"), checker.NotNil, check.Commentf("Daemon shouldn't start with wrong log level"))

+	assert.Assert(c, s.d.StartWithError("--log-level=bogus") != nil, check.Commentf("Daemon shouldn't start with wrong log level"))

 }

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

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

 	defer d.Restart(c)

 	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, err != nil, check.Commentf("Running a container must fail with an invalid --ip option"))

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

 	ifName := "dummy"

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

 	assert.NilError(c, err, out)

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

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Logs should fail with 'none' driver"))

+	assert.Assert(c, err != nil, check.Commentf("Logs should fail with 'none' driver"))

 	expected := `configured logging driver does not support reading`

 	assert.Assert(c, strings.Contains(out, expected))

 }

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

 	s.d.Restart(c)

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

-	assert.Assert(c, err, checker.NotNil, check.Commentf("should not be able to remove in use volume after daemon restart"))

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

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

 }

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

 // FIXME(vdemeester) should be a unit test

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

 	d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))

-	assert.Assert(c, d.StartWithError("--log-driver=syslog", "--log-opt", "syslog-address=corrupted:42"), checker.NotNil)

+	assert.Assert(c, d.StartWithError("--log-driver=syslog", "--log-opt", "syslog-address=corrupted:42") != nil)

 	expected := "syslog-address should be in form proto://address"

 	icmd.RunCommand("grep", expected, d.LogFileName()).Assert(c, icmd.Success)

 }

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

 // FIXME(vdemeester) should be a unit test

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

 	d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))

-	assert.Assert(c, d.StartWithError("--log-driver=fluentd", "--log-opt", "fluentd-address=corrupted:c"), checker.NotNil)

+	assert.Assert(c, d.StartWithError("--log-driver=fluentd", "--log-opt", "fluentd-address=corrupted:c") != nil)

 	expected := "invalid fluentd-address corrupted:c: "

 	icmd.RunCommand("grep", expected, d.LogFileName()).Assert(c, icmd.Success)

 }

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

 	assert.NilError(c, err)

 	conn.Close()

-	assert.Assert(c, certRequestInfo, checker.NotNil)

+	assert.Assert(c, certRequestInfo != nil)

 	assert.Equal(c, len(certRequestInfo.AcceptableCAs), 1)

 	assert.DeepEqual(c, certRequestInfo.AcceptableCAs[0], rootCert.RawSubject)

 }

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

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

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

-	assert.Assert(c, err, checker.NotNil, check.Commentf("%s", pullOut))

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

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

 }

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

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

 	s.d.Stop(c)

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

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

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

 	assert.NilError(c, err)

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

 	dockerCmd(c, "volume", "create", "test")

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

-	assert.Assert(c, err, checker.NotNil, check.Commentf("volume create exception name already in use with another driver"))

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

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

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

@@ -585,7 +585,7 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverOutOfBandDelete(c *t

 	assert.NilError(c, err)

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

 	assert.Equal(c, vs[0].Driver, driverName)

-	assert.Assert(c, vs[0].Options, checker.NotNil)

+	assert.Assert(c, vs[0].Options != nil)

 	assert.Equal(c, vs[0].Options["foo"], "bar")

 	assert.Equal(c, vs[0].Driver, driverName)

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

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

 	_, _, err := dockerCmdWithError("history", "testHistoryNonExistentImage")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("history on a non-existent image should fail."))

+	assert.Assert(c, err != nil, check.Commentf("history on a non-existent image should fail."))

 }

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

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

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

 	out, _, err := dockerCmdWithError("import", "http://nourl/bad")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("import was supposed to fail but didn't"))

+	assert.Assert(c, err != nil, check.Commentf("import was supposed to fail but didn't"))

 	// Depending on your system you can get either of these errors

 	if !strings.Contains(out, "dial tcp") &&

 		!strings.Contains(out, "ApplyLayer exit status 1 stdout:  stderr: archive/tar: invalid tar header") &&

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

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

 	_, _, err := dockerCmdWithError("import", "example.com/myImage.tar")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("import non-existing file must failed"))

+	assert.Assert(c, err != nil, check.Commentf("import non-existing file must failed"))

 }

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

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

 	dockerCmd(c, "run", "--name=busybox", "-d", "busybox", "true")

 	out, exitCode, err := dockerCmdWithError("inspect", "--type=foobar", "busybox")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("%d", exitCode))

+	assert.Assert(c, err != nil, check.Commentf("%d", exitCode))

 	assert.Equal(c, exitCode, 1, check.Commentf("%s", err))

 	assert.Assert(c, out, checker.Contains, "not a valid value for --type")

 }

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

 	out, _, err := dockerCmdWithError("run", "--link", "bogus:alias", "busybox", "true")

 	// an invalid container target should produce an error

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	// an invalid container target should produce an error

 	// note: convert the output to lowercase first as the error string

 	// capitalization was changed after API version 1.32

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

 	getIP := func(hosts []byte, hostname string) string {

 		re := regexp.MustCompile(fmt.Sprintf(`(\S*)\t%s`, regexp.QuoteMeta(hostname)))

 		matches := re.FindSubmatch(hosts)

-		assert.Assert(c, matches, checker.NotNil, check.Commentf("Hostname %s have no matches in hosts", hostname))

+		assert.Assert(c, matches != nil, check.Commentf("Hostname %s have no matches in hosts", hostname))

 		return string(matches[1])

 	}

 	ip := getIP(content, "one")

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

 	out, _, err := dockerCmdWithError("run", "--name", "should_fail", "--link", "host_container:tester", "busybox", "true")

 	// Running container linking to a container with --net host should have failed

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	// Running container linking to a container with --net host should have failed

 	assert.Assert(c, out, checker.Contains, runconfig.ErrConflictHostNetworkAndLinks.Error())

 }

@@ -19,7 +19,7 @@ const stringCheckPS = "PID   USER"

 // stop the tests.

 func dockerCmdWithFail(c *testing.T, args ...string) (string, int) {

 	out, status, err := dockerCmdWithError(args...)

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

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

 	return out, status

 }

@@ -64,7 +64,7 @@ func (s *DockerNetworkSuite) TearDownTest(c *testing.T) {

 func (s *DockerNetworkSuite) SetUpSuite(c *testing.T) {

 	mux := http.NewServeMux()

 	s.server = httptest.NewServer(mux)

-	assert.Assert(c, s.server, checker.NotNil, check.Commentf("Failed to start an HTTP Server"))

+	assert.Assert(c, s.server != nil, check.Commentf("Failed to start an HTTP Server"))

 	setupRemoteNetworkDrivers(c, mux, s.server.URL, dummyNetworkDriver, dummyIPAMDriver)

 }

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

 	// contains active container, its deletion should fail.

 	out, _, err := dockerCmdWithError("network", "rm", "testDelMulti0", "testDelMulti1", "testDelMulti2")

 	// err should not be nil due to deleting testDelMulti2 failed.

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	// testDelMulti2 should fail due to network has active endpoints

 	assert.Assert(c, out, checker.Contains, "has active endpoints")

 	assertNwNotAvailable(c, "testDelMulti0")

@@ -765,7 +765,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkDriverOptions(c *testing.T) {

 	dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, "-o", "opt1=drv1", "-o", "opt2=drv2", "testopt")

 	assertNwIsAvailable(c, "testopt")

 	gopts := remoteDriverNetworkRequest.Options[netlabel.GenericData]

-	assert.Assert(c, gopts, checker.NotNil)

+	assert.Assert(c, gopts != nil)

 	opts, ok := gopts.(map[string]interface{})

 	assert.Equal(c, ok, true)

 	assert.Equal(c, opts["opt1"], "drv1")

@@ -1149,7 +1149,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkDisconnectFromHost(c *testing.T) {

 	dockerCmd(c, "run", "-d", "--name", "container1", "--net=host", "busybox", "top")

 	assert.Assert(c, waitRun("container1") == nil)

 	out, _, err := dockerCmdWithError("network", "disconnect", "host", "container1")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Should err out disconnect from host"))

+	assert.Assert(c, err != nil, check.Commentf("Should err out disconnect from host"))

 	assert.Assert(c, out, checker.Contains, runconfig.ErrConflictHostNetwork.Error())

 }

@@ -1317,7 +1317,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkConnectPreferredIP(c *testing.T) {

 	// Still it should fail to connect to the default network with a specified IP (whatever ip)

 	out, _, err := dockerCmdWithError("network", "connect", "--ip", "172.21.55.44", "bridge", "c0")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	assert.Assert(c, out, checker.Contains, runconfig.ErrUnsupportedNetworkAndIP.Error())

 }

@@ -1356,11 +1356,11 @@ func (s *DockerNetworkSuite) TestDockerNetworkUnsupportedRequiredIP(c *testing.T

 	assertNwIsAvailable(c, "n0")

 	out, _, err := dockerCmdWithError("run", "-d", "--ip", "172.28.99.88", "--net", "n0", "busybox", "top")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	assert.Assert(c, out, checker.Contains, runconfig.ErrUnsupportedNetworkNoSubnetAndIP.Error())

 	out, _, err = dockerCmdWithError("run", "-d", "--ip6", "2001:db8:1234::9988", "--net", "n0", "busybox", "top")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	assert.Assert(c, out, checker.Contains, runconfig.ErrUnsupportedNetworkNoSubnetAndIP.Error())

 	dockerCmd(c, "network", "rm", "n0")

@@ -1369,7 +1369,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkUnsupportedRequiredIP(c *testing.T

 func checkUnsupportedNetworkAndIP(c *testing.T, nwMode string) {

 	out, _, err := dockerCmdWithError("run", "-d", "--net", nwMode, "--ip", "172.28.99.88", "--ip6", "2001:db8:1234::9988", "busybox", "top")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	assert.Assert(c, out, checker.Contains, runconfig.ErrUnsupportedNetworkAndIP.Error())

 }

@@ -1560,12 +1560,12 @@ func (s *DockerSuite) TestUserDefinedNetworkConnectDisconnectAlias(c *testing.T)

 	// verify the alias option is rejected when running on predefined network

 	out, _, err := dockerCmdWithError("run", "--rm", "--name=any", "--net-alias=any", "busybox:glibc", "top")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	assert.Assert(c, out, checker.Contains, runconfig.ErrUnsupportedNetworkAndAlias.Error())

 	// verify the alias option is rejected when connecting to predefined network

 	out, _, err = dockerCmdWithError("network", "connect", "--alias=any", "bridge", "first")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	assert.Assert(c, out, checker.Contains, runconfig.ErrUnsupportedNetworkAndAlias.Error())

 }

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

 			"-p", "9090-9092:80",

 			"busybox", "top")

 		// Exhausted port range did not return an error

-		assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

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

 			dockerCmd(c, "rm", "-f", IDs[i])

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

 			"-p", invalidRange,

 			"busybox", "top")

 		// Port range should have returned an error

-		assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	}

 	// test host range:container range spec.

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

 	out, _, err = dockerCmdWithError("run", "--net=host", "busybox", "nc", "localhost", "9876")

 	// Port is still bound after the Container is removed

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 }

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

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

 	out, _, err = dockerCmdWithError("run", "--net=host", "busybox",

 		"nc", "localhost", strings.TrimSpace(exposedPort))

 	// Port is still bound after the Container is removed

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 }

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

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

 	assert.Assert(c, waitRun("c1") == nil)

 	_, _, err := dockerCmdWithError("run", "--net=host", "busybox", "nc", "localhost", "8080")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Port mapping on internal network is expected to fail"))

+	assert.Assert(c, err != nil, check.Commentf("Port mapping on internal network is expected to fail"))

 	// Connect container to another normal bridge network

 	dockerCmd(c, "network", "create", "-d", "bridge", "foo-net")

 	dockerCmd(c, "network", "connect", "foo-net", "c1")

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

 	secondZero, _ := dockerCmd(c, "run", "-d", "busybox", "true")

 	out, _, err := dockerCmdWithError("run", "--name", "nonzero1", "busybox", "false")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Should fail. out: %s", out))

+	assert.Assert(c, err != nil, check.Commentf("Should fail. out: %s", out))

 	firstNonZero := getIDByName(c, "nonzero1")

 	out, _, err = dockerCmdWithError("run", "--name", "nonzero2", "busybox", "false")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Should fail. out: %s", out))

+	assert.Assert(c, err != nil, check.Commentf("Should fail. out: %s", out))

 	secondNonZero := getIDByName(c, "nonzero2")

 	// filter containers by exited=0

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

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

 	out, _, err := dockerCmdWithError("run", "--expose", "80000", "busybox")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("--expose with an invalid port should error out"))

+	assert.Assert(c, err != nil, check.Commentf("--expose with an invalid port should error out"))

 	assert.Assert(c, out, checker.Contains, "invalid range format for --expose")

 }

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

 	testRequires(c, DaemonIsLinux)

 	name := "unique_name"

 	_, _, err := dockerCmdWithError("run", "--name", name, "--link", "nothing:nothing", "busybox")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Expected docker run to fail!"))

+	assert.Assert(c, err != nil, check.Commentf("Expected docker run to fail!"))

 	containerID, err := inspectFieldWithError(name, "Id")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Expected not to have this container: %s!", containerID))

+	assert.Assert(c, err != nil, check.Commentf("Expected not to have this container: %s!", containerID))

 	assert.Equal(c, containerID, "", check.Commentf("Expected not to have this container: %s!", containerID))

 }

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

 	// We will need the following `inspect` to diagnose the issue if test fails (#21247)

 	out1, err1 := dockerCmd(c, "inspect", "--format", "{{json .State}}", "test")

 	out2, err2 := dockerCmd(c, "inspect", "--format", "{{json .State}}", "fail")

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Command should have failed but succeeded with: %s\nContainer 'test' [%+v]: %s\nContainer 'fail' [%+v]: %s", out, err1, out1, err2, out2))

+	assert.Assert(c, err != nil, check.Commentf("Command should have failed but succeeded with: %s\nContainer 'test' [%+v]: %s\nContainer 'fail' [%+v]: %s", out, err1, out1, err2, out2))

 	// check for windows error as well

 	// TODO Windows Post TP5. Fix the error message string

 	assert.Assert(c, strings.Contains(string(out), "port is already allocated") ||

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

 	}

 	for _, attempt := range attempts {

 		_, _, err := dockerCmdWithError("run", "--security-opt=credentialspec="+attempt.value, "busybox", "true")

-		assert.Assert(c, err, checker.NotNil, check.Commentf("%s expected non-nil err", attempt.value))

+		assert.Assert(c, err != nil, check.Commentf("%s expected non-nil err", attempt.value))

 		assert.Assert(c, err.Error(), checker.Contains, attempt.expectedError, check.Commentf("%s expected %s got %s", attempt.value, attempt.expectedError, err))

 	}

 }

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

 				assert.Assert(c, testCase.fn(cName) == nil, check.Commentf("got error while executing test for %v (%s)", opts, cName))

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

 			} else {

-				assert.Assert(c, err, checker.NotNil, check.Commentf("got nil while creating a container with %v (%s)", opts, cName))

+				assert.Assert(c, err != nil, check.Commentf("got nil while creating a container with %v (%s)", opts, cName))

 			}

 		}

 	}

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

 	assert.Equal(c, mountConfig[0].Source, "foo")

 	assert.Equal(c, mountConfig[0].Target, "/foo")

 	assert.Equal(c, mountConfig[0].Type, mount.TypeVolume)

-	assert.Assert(c, mountConfig[0].VolumeOptions, checker.NotNil)

+	assert.Assert(c, mountConfig[0].VolumeOptions != nil)

 	assert.Assert(c, mountConfig[0].VolumeOptions.NoCopy, checker.True)

 	// check container mounts actual

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

 	assert.Equal(c, mountConfig[0].Source, "")

 	assert.Equal(c, mountConfig[0].Target, "/foo")

 	assert.Equal(c, mountConfig[0].Type, mount.TypeTmpfs)

-	assert.Assert(c, mountConfig[0].TmpfsOptions, checker.NotNil)

+	assert.Assert(c, mountConfig[0].TmpfsOptions != nil)

 	assert.Equal(c, mountConfig[0].TmpfsOptions.SizeBytes, int64(1048576))

 	// check container mounts actual

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

 	// Expect this to fail because the above container is stopped, this is what we want

 	out, _, err := dockerCmdWithError("run", "--name", "test2", "--link", "test:test", "busybox")

 	// err shouldn't be nil because container test2 try to link to stopped container

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	ch := make(chan error)

 	go func() {

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

 	// Expect this to fail and records error because of ports conflict

 	out, _, err := dockerCmdWithError("run", "-d", "--name", "test2", "-p", "9999:9999", "busybox", "top")

 	// err shouldn't be nil because docker run will fail

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	stateErr = inspectField(c, "test2", "State.Error")

 	assert.Assert(c, stateErr, checker.Contains, "port is already allocated")

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

 	out, _, err := dockerCmdWithError("start", "testing")

 	// an error should have been shown that you cannot start paused container

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	// an error should have been shown that you cannot start paused container

 	assert.Assert(c, strings.ToLower(out), checker.Contains, "cannot start a paused container, try unpause instead")

 }

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

 	expErr := "failed to start containers: [child_first]"

 	out, _, err := dockerCmdWithError("start", "child_first", "parent", "child_second")

 	// err shouldn't be nil because start will fail

-	assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 	// output does not correspond to what was expected

 	if !(strings.Contains(out, expOut) || strings.Contains(err.Error(), expErr)) {

 		c.Fatalf("Expected out: %v with err: %v  but got out: %v with err: %v", expOut, expErr, out, err)

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

 	for _, option := range []string{"-a", "-i", "-ai"} {

 		out, _, err := dockerCmdWithError("start", option, "test1", "test2", "test3")

 		// err shouldn't be nil because start will fail

-		assert.Assert(c, err, checker.NotNil, check.Commentf("out: %s", out))

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

 		// output does not correspond to what was expected

 		assert.Assert(c, out, checker.Contains, "you cannot start and attach multiple containers at once")

 	}

@@ -803,7 +803,7 @@ func setupRemoteGlobalNetworkPlugin(c *testing.T, mux *http.ServeMux, url, netDr

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

 	mux := http.NewServeMux()

 	s.server = httptest.NewServer(mux)

-	assert.Assert(c, s.server, checker.NotNil) // check that HTTP server has started

+	assert.Assert(c, s.server != nil) // check that HTTP server has started

 	setupRemoteGlobalNetworkPlugin(c, mux, s.server.URL, globalNetworkPlugin, globalIPAMPlugin)

 	defer func() {

 		s.server.Close()

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

 	name := strings.TrimSpace(out)

 	out, exitCode, err := dockerCmdWithError("volume", "inspect", "--format='{{ .FooBar }}'", name)

-	assert.Assert(c, err, checker.NotNil, check.Commentf("Output: %s", out))

+	assert.Assert(c, err != nil, check.Commentf("Output: %s", out))

 	assert.Equal(c, exitCode, 1, check.Commentf("Output: %s", out))

 	assert.Assert(c, out, checker.Contains, "Template parsing error")

 }

@@ -25,7 +25,7 @@ func (s *DiscoverySuite) TestNewEntry(c *testing.T) {

 	assert.Equal(c, entry.String(), "[2001:db8:0:f101::2]:2375")

 	_, err = NewEntry("127.0.0.1")

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

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

 }

 func (s *DiscoverySuite) TestParse(c *testing.T) {

@@ -65,7 +65,7 @@ func (s *DiscoverySuite) TestCreateEntries(c *testing.T) {

 	assert.Equal(c, entries.Equals(expected), true)

 	_, err = CreateEntries([]string{"127.0.0.1", "127.0.0.2"})

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

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

 }

 func (s *DiscoverySuite) TestContainsEntry(c *testing.T) {

@@ -45,7 +45,7 @@ func (s *DiscoverySuite) TestContent(c *testing.T) {

 func (s *DiscoverySuite) TestRegister(c *testing.T) {

 	discovery := &Discovery{path: "/path/to/file"}

-	assert.Assert(c, discovery.Register("0.0.0.0"), checker.NotNil)

+	assert.Assert(c, discovery.Register("0.0.0.0") != nil)

 }

 func (s *DiscoverySuite) TestParsingContentsWithComments(c *testing.T) {

@@ -86,7 +86,7 @@ func (s *DiscoverySuite) TestWatch(c *testing.T) {

 	ch, errCh := d.Watch(stopCh)

 	// Make sure it fires errors since the file doesn't exist.

-	assert.Assert(c, <-errCh, checker.NotNil)

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

 	// We have to drain the error channel otherwise Watch will get stuck.

 	go func() {

 		for range errCh {

@@ -101,7 +101,7 @@ func (s *DiscoverySuite) TestWatch(c *testing.T) {

 	expected = append(expected, &discovery.Entry{Host: "3.3.3.3", Port: "3333"})

 	f, err := os.OpenFile(tmp.Name(), os.O_APPEND|os.O_WRONLY, 0600)

 	assert.Assert(c, err == nil)

-	assert.Assert(c, f, checker.NotNil)

+	assert.Assert(c, f != nil)

 	_, err = f.WriteString("\n3.3.3.3:3333\n")

 	assert.Assert(c, err == nil)

 	f.Close()

@@ -200,8 +200,8 @@ BFrwkQE4HQtQBV60hYQUzzlSk44VFDz+jxIEtacRHaomDRh2FtOTz+I=

 	})

 	assert.Assert(c, err == nil)

 	s := d.store.(*Mock)

-	assert.Assert(c, s.Options.TLS, checker.NotNil)

-	assert.Assert(c, s.Options.TLS.RootCAs, checker.NotNil)

+	assert.Assert(c, s.Options.TLS != nil)

+	assert.Assert(c, s.Options.TLS.RootCAs != nil)

 	assert.Equal(c, len(s.Options.TLS.Certificates), 1)

 }

@@ -47,5 +47,5 @@ func (s *DiscoverySuite) TestWatch(c *testing.T) {

 func (s *DiscoverySuite) TestRegister(c *testing.T) {

 	d := &Discovery{}

-	assert.Assert(c, d.Register("0.0.0.0"), checker.NotNil)

+	assert.Assert(c, d.Register("0.0.0.0") != nil)

 }