rm-gocheck: NotNil

sed -E -i 's#\bassert\.Assert\(c, (.*), checker\.NotNil\b#assert.Assert(c, \1 != nil#g' \
-- "integration-cli/docker_cli_build_test.go" "integration-cli/docker_cli_by_digest_test.go" "integration-cli/docker_cli_create_test.go" "integration-cli/docker_cli_daemon_test.go" "integration-cli/docker_cli_external_volume_driver_unix_test.go" "integration-cli/docker_cli_history_test.go" "integration-cli/docker_cli_import_test.go" "integration-cli/docker_cli_inspect_test.go" "integration-cli/docker_cli_links_test.go" "integration-cli/docker_cli_netmode_test.go" "integration-cli/docker_cli_network_unix_test.go" "integration-cli/docker_cli_port_test.go" "integration-cli/docker_cli_ps_test.go" "integration-cli/docker_cli_run_test.go" "integration-cli/docker_cli_service_create_test.go" "integration-cli/docker_cli_start_test.go" "integration-cli/docker_cli_swarm_test.go" "integration-cli/docker_cli_volume_test.go" "pkg/discovery/discovery_test.go" "pkg/discovery/file/file_test.go" "pkg/discovery/kv/kv_test.go" "pkg/discovery/nodes/nodes_test.go"

Signed-off-by: Tibor Vass <tibor@docker.com>

integration-cli/docker_cli_build_test.go

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

integration-cli/docker_cli_by_digest_test.go

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

integration-cli/docker_cli_create_test.go

@@ -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 {

integration-cli/docker_cli_daemon_test.go

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

integration-cli/docker_cli_external_volume_driver_unix_test.go

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

integration-cli/docker_cli_history_test.go

@@ -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) {

integration-cli/docker_cli_import_test.go

@@ -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) {

integration-cli/docker_cli_inspect_test.go

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

integration-cli/docker_cli_links_test.go

@@ -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())
 }

integration-cli/docker_cli_netmode_test.go

@@ -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
 }
 

integration-cli/docker_cli_network_unix_test.go

@@ -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())
 }
 

integration-cli/docker_cli_port_test.go

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

integration-cli/docker_cli_ps_test.go

@@ -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

integration-cli/docker_cli_run_test.go

@@ -2294,7 +2294,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")
 }
 
@@ -3210,10 +3210,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))
 }
 
@@ -3950,7 +3950,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") ||
@@ -4162,7 +4162,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))
 	}
 }
@@ -4501,7 +4501,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))
 			}
 		}
 	}

integration-cli/docker_cli_service_create_test.go

@@ -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

integration-cli/docker_cli_start_test.go

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

integration-cli/docker_cli_swarm_test.go

@@ -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()

integration-cli/docker_cli_volume_test.go

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

pkg/discovery/discovery_test.go

@@ -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) {

pkg/discovery/file/file_test.go

@@ -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()

pkg/discovery/kv/kv_test.go

@@ -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 != nil)
-	assert.Assert(c, s.Options.TLS.RootCAs, checker.NotNil)
+	assert.Assert(c, s.Options.TLS.RootCAs != nil)
 	assert.Equal(c, len(s.Options.TLS.Certificates), 1)
 }
 

pkg/discovery/nodes/nodes_test.go

@@ -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)
 }