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

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

 	assert.NilError(c, err)

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

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

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

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

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

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

 	assert.NilError(c, err)

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

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

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

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

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

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

 	assert.NilError(c, err)

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

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

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

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

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

 	assert.NilError(c, err)

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

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

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

 	} else {

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

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

 	}

 }

@@ -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), check.IsNil)

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

 	type b struct {

 		stats types.ContainerStats

@@ -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(), check.IsNil)

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

 	defer func() {

 		cmd.Process.Kill()

 		cmd.Wait()

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

 	assert.NilError(c, err)

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

 	assert.NilError(c, err)

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

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

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

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

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

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

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

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

 }

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

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

 	case err := <-errChan:

 		tty.Close()

 		out, _ := ioutil.ReadAll(pty)

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

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

 	case <-time.After(attachWait):

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

 	}

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

 		close(cmdExit)

 	}()

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

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

 	cpty.Write([]byte{16})

 	time.Sleep(100 * time.Millisecond)

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

 	)

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

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

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

 	var resArr []string

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

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

 	id1 := getIDByName(c, "tag1")

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

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

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

 }

 // #17290

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

   `))

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

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

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

 }

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

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

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

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

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

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

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

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

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

 }

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

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

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

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

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

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

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

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

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

 }

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

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

 	})

 	_, err = os.Stat(tmpIidFile)

 	assert.ErrorContains(c, err, "")

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

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

 }

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

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

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

-	assert.Assert(c, c2.Memory, check.Not(checker.Equals), int64(64*1024*1024), check.Commentf("resource leaked from build for Memory"))

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

-	assert.Assert(c, c2.CpusetCpus, check.Not(checker.Equals), "0", check.Commentf("resource leaked from build for CpusetCpus"))

-	assert.Assert(c, c2.CpusetMems, check.Not(checker.Equals), "0", check.Commentf("resource leaked from build for CpusetMems"))

-	assert.Assert(c, c2.CPUShares, check.Not(checker.Equals), int64(100), check.Commentf("resource leaked from build for CPUShares"))

-	assert.Assert(c, c2.CPUQuota, check.Not(checker.Equals), int64(8000), check.Commentf("resource leaked from build for CPUQuota"))

+	assert.Assert(c, c2.Memory, checker.Not(checker.Equals), int64(64*1024*1024), check.Commentf("resource leaked from build for Memory"))

+	assert.Assert(c, c2.MemorySwap, checker.Not(checker.Equals), int64(-1), check.Commentf("resource leaked from build for MemorySwap"))

+	assert.Assert(c, c2.CpusetCpus, checker.Not(checker.Equals), "0", check.Commentf("resource leaked from build for CpusetCpus"))

+	assert.Assert(c, c2.CpusetMems, checker.Not(checker.Equals), "0", check.Commentf("resource leaked from build for CpusetMems"))

+	assert.Assert(c, c2.CPUShares, checker.Not(checker.Equals), int64(100), check.Commentf("resource leaked from build for CPUShares"))

+	assert.Assert(c, c2.CPUQuota, checker.Not(checker.Equals), 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"))

 }

@@ -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, check.IsNil, check.Commentf("error setting up image"))

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

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

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

 	// Pull from the registry using the <name>@<digest> reference.

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

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

-	assert.Assert(c, exitStatus, checker.Not(check.Equals), 0)

+	assert.Assert(c, exitStatus, checker.Not(checker.Equals), 0)

 	expectedErrorMsg := fmt.Sprintf("manifest verification failed for digest %s", manifestDigest)

 	assert.Assert(c, is.Contains(out, expectedErrorMsg))

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

 	// Pull from the registry using the <name>@<digest> reference.

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

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

-	assert.Assert(c, exitStatus, checker.Not(check.Equals), 0)

+	assert.Assert(c, exitStatus, checker.Not(checker.Equals), 0)

 	expectedErrorMsg := fmt.Sprintf("image verification failed for digest %s", manifestDigest)

 	assert.Assert(c, out, checker.Contains, expectedErrorMsg)

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

 	// Pull from the registry using the <name>@<digest> reference.

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

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

-	assert.Assert(c, exitStatus, checker.Not(check.Equals), 0, check.Commentf("expected a non-zero exit status"))

+	assert.Assert(c, exitStatus, checker.Not(checker.Equals), 0, check.Commentf("expected a non-zero exit status"))

 	expectedErrorMsg := fmt.Sprintf("filesystem layer verification failed for digest %s", targetLayerDigest)

 	assert.Assert(c, out, checker.Contains, expectedErrorMsg, check.Commentf("expected error message in output: %s", out))

@@ -684,7 +684,7 @@ func (s *DockerSchema1RegistrySuite) TestPullFailsWithAlteredLayer(c *testing.T)

 	// Pull from the registry using the <name>@<digest> reference.

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

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

-	assert.Assert(c, exitStatus, checker.Not(check.Equals), 0, check.Commentf("expected a non-zero exit status"))

+	assert.Assert(c, exitStatus, checker.Not(checker.Equals), 0, check.Commentf("expected a non-zero exit status"))

 	expectedErrorMsg := fmt.Sprintf("filesystem layer verification failed for digest %s", targetLayerDigest)

 	assert.Assert(c, out, checker.Contains, expectedErrorMsg, check.Commentf("expected error message in output: %s", out))

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

 	}

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

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

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

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

 	cont := containers[0]

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

 	}

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

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

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

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

 	cont := containers[0]

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

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

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

 }

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

 		}

 	}

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

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

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

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

 	cont := containers[0]

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

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

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

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

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

 	}

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

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

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

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

 	cont := containers[0]

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

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

 	assert.Assert(c, cont.HostConfig.PortBindings, checker.HasLen, 65535)

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

@@ -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, check.IsNil, check.Commentf("Error getting volume host path: %q", err))

+	assert.Assert(c, err, checker.IsNil, 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")

@@ -354,9 +354,9 @@ exec "$@"`,

 	out := cli.DockerCmd(c, "create", "--entrypoint=", name, "echo", "foo").Combined()

 	id := strings.TrimSpace(out)

-	assert.Assert(c, id, check.Not(check.Equals), "")

+	assert.Assert(c, id, checker.Not(checker.Equals), "")

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

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

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

 }

 // #22471

@@ -130,13 +130,13 @@ 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, check.IsNil, check.Commentf("run ps: %v", out))

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

 			if shouldRun {

 				format = "%scontainer %q is not running"

 			} else {

 				format = "%scontainer %q is running"

 			}

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

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

 		}

 	}

@@ -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, check.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, checker.NotNil, 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 {

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

 	}

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

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

+	assert.Assert(c, err, checker.IsNil, 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, check.IsNil, check.Commentf("Error in converting base device size: %v", err))

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

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

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

 	s.d.Stop(c)

 }

@@ -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"), check.NotNil, check.Commentf("Daemon shouldn't start with wrong log level"))

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

 }

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

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

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

 	ip = net.ParseIP(containerIP)

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

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

 	deleteInterface(c, defaultNetworkBridge)

 }

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

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

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

 	assert.NilError(c, err, out)

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

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

 	deleteInterface(c, defaultNetworkBridge)

 }

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

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

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

 	assert.NilError(c, err, out)

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

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

 	deleteInterface(c, defaultNetworkBridge)

 }

@@ -844,8 +844,8 @@ 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, check.NotNil, check.Commentf("Running a container must fail with an invalid --ip option"))

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

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

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

 	ifName := "dummy"

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

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

 	result.Assert(c, icmd.Success)

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

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

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

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

 }

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

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

 	result.Assert(c, icmd.Success)

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

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

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

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

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

 	pingContainers(c, d, true)

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

 	result.Assert(c, icmd.Success)

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

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

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

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

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

 	assert.NilError(c, err, out)

@@ -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, check.NotNil, check.Commentf("Logs should fail with 'none' driver"))

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

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

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

 }

@@ -1151,8 +1151,8 @@ 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, check.IsNil, comment)

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

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

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

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

 }

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

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

 	assert.NilError(c, err, out)

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

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

 }

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

@@ -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, check.NotNil, check.Commentf("should not be able to remove in use volume after daemon restart"))

+	assert.Assert(c, err, checker.NotNil, 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"), check.NotNil)

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

 	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"), check.NotNil)

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

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

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

 }

@@ -1749,9 +1749,9 @@ func (s *DockerDaemonSuite) TestBridgeIPIsExcludedFromAllocatorPool(c *testing.T

 			break

 		}

 		ip, err := s.d.Cmd("inspect", "--format", "'{{.NetworkSettings.IPAddress}}'", contName)

-		assert.Assert(c, err, check.IsNil, check.Commentf("%s", ip))

+		assert.Assert(c, err, checker.IsNil, check.Commentf("%s", ip))

-		assert.Assert(c, ip, check.Not(check.Equals), bridgeIP)

+		assert.Assert(c, ip, checker.Not(checker.Equals), bridgeIP)

 		cont++

 	}

 }

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

 	assert.NilError(c, err, out)

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

 	assert.NilError(c, err, out)

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

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

 }

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

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

 	id := strings.TrimSpace(out)

 	// kill the daemon

-	assert.Assert(c, s.d.Kill(), check.IsNil)

+	assert.Assert(c, s.d.Kill(), checker.IsNil)

 	// Check if there are mounts with container id visible from the host.

 	// If not, those mounts exist in container's own mount ns, and so

 	// the following check for mounts being cleared is pointless.

 	skipMountCheck := false

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

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

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

 	if !strings.Contains(string(mountOut), id) {

 		skipMountCheck = true

 	}

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

 	}

 	// Now, container mounts should be gone.

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

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

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

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

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

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

 }

 // TestDaemonRestartWithUnpausedRunningContainer requires live restore of running containers.

@@ -2112,12 +2112,12 @@ func (s *DockerDaemonSuite) TestRunLinksChanged(c *testing.T) {

 	assert.NilError(c, err, out)

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

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, check.Not(checker.Contains), "1 packets transmitted, 1 packets received")

+	assert.Assert(c, out, checker.Not(checker.Contains), "1 packets transmitted, 1 packets received")

 	s.d.Restart(c)

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

 	assert.ErrorContains(c, err, "", out)

-	assert.Assert(c, out, check.Not(checker.Contains), "1 packets transmitted, 1 packets received")

+	assert.Assert(c, out, checker.Not(checker.Contains), "1 packets transmitted, 1 packets received")

 }

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

@@ -2166,8 +2166,8 @@ func (s *DockerDaemonSuite) TestDaemonStartWithoutColors(c *testing.T) {

 	s.d.Stop(c)

 	// Wait for io.Copy() before checking output

 	<-done

-	assert.Assert(c, b.String(), check.Not(check.Equals), "")

-	assert.Assert(c, b.String(), check.Not(checker.Contains), infoLog)

+	assert.Assert(c, b.String(), checker.Not(checker.Equals), "")

+	assert.Assert(c, b.String(), checker.Not(checker.Contains), infoLog)

 }

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

@@ -2369,8 +2369,8 @@ func (s *DockerDaemonSuite) TestBuildOnDisabledBridgeNetworkDaemon(c *testing.T)

 		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, check.IsNil, comment)

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

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

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

 }

 // Test case for #21976

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

 	// Wait for shell command to be completed

 	_, err = s.d.Cmd("exec", "top", "sh", "-c", `for i in $(seq 1 5); do if [ -e /adduser_end ]; then rm -f /adduser_end && break; else sleep 1 && false; fi; done`)

-	assert.Assert(c, err, check.IsNil, check.Commentf("Timeout waiting for shell command to be completed"))

+	assert.Assert(c, err, checker.IsNil, check.Commentf("Timeout waiting for shell command to be completed"))

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

 	// uid=100(test) gid=101(test) groups=101(test)

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

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

 	// restart daemon.

 	s.d.Restart(c, "--live-restore")

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

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

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

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

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

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

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

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

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

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

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

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

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

 }

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

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

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

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

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

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

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

 	size = 67108864 * 3

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

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

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

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

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

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

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

 }

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

@@ -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, check.NotNil, check.Commentf("volume create exception name already in use with another driver"))

+	assert.Assert(c, err, checker.NotNil, 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")

@@ -463,21 +463,21 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverList(c *testing.T) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 }

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

 	out, _, err := dockerCmdWithError("volume", "inspect", "dummy")

 	assert.ErrorContains(c, err, "", out)

 	assert.Assert(c, out, checker.Contains, "No such volume")

-	assert.Assert(c, s.ec.gets, check.Equals, 1)

+	assert.Assert(c, s.ec.gets, checker.Equals, 1)

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

 	out, _ = dockerCmd(c, "volume", "inspect", "test")

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

 	failsStr, _ := dockerCmd(c, "inspect", "--format={{.State.Health.FailingStreak}}", "fatal_healthcheck")

 	fails, err := strconv.Atoi(strings.TrimSpace(failsStr))

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

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

 	assert.Assert(c, fails >= 3, checker.Equals, true)

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

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

 	out, _ := dockerCmd(c, "images", "--no-trunc", "-q", "-f", "label=match")

 	out = strings.TrimSpace(out)

-	assert.Assert(c, out, check.Matches, fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image1ID))

-	assert.Assert(c, out, check.Matches, fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image2ID))

-	assert.Assert(c, out, check.Not(check.Matches), fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image3ID))

+	assert.Assert(c, out, checker.Matches, fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image1ID))

+	assert.Assert(c, out, checker.Matches, fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image2ID))

+	assert.Assert(c, out, checker.Not(checker.Matches), fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image3ID))

 	out, _ = dockerCmd(c, "images", "--no-trunc", "-q", "-f", "label=match=me too")

 	out = strings.TrimSpace(out)

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

 	assert.NilError(c, err)

 	// check that there is only one mountpoint

-	assert.Assert(c, mp, check.HasLen, 1)

+	assert.Assert(c, mp, checker.HasLen, 1)

 	m := mp[0]

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

 	formatStr := "--format={{.SizeRw}},{{.SizeRootFs}}"

 	out, _ := dockerCmd(c, "inspect", "--type=container", formatStr, "busybox")

-	assert.Assert(c, strings.TrimSpace(out), check.Equals, "<nil>,<nil>", check.Commentf("Expected not to display size info: %s", out))

+	assert.Assert(c, strings.TrimSpace(out), checker.Equals, "<nil>,<nil>", check.Commentf("Expected not to display size info: %s", out))

 }

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

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

 	out, _ := dockerCmd(c, "inspect", "-s", "--type=container", formatStr, "busybox")

 	sz := strings.Split(out, ",")

-	assert.Assert(c, strings.TrimSpace(sz[0]), check.Not(check.Equals), "<nil>")

-	assert.Assert(c, strings.TrimSpace(sz[1]), check.Not(check.Equals), "<nil>")

+	assert.Assert(c, strings.TrimSpace(sz[0]), checker.Not(checker.Equals), "<nil>")

+	assert.Assert(c, strings.TrimSpace(sz[1]), checker.Not(checker.Equals), "<nil>")

 }

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

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

 	runSleepingContainer(c, "--name=container1", "-d")

 	out, _, err := dockerCmdWithError("inspect", "--type=container", "--format='Format container: {{.ThisDoesNotExist}}'", "container1")

-	assert.Assert(c, err, check.Not(check.IsNil))

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

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

 	out, _, err = dockerCmdWithError("inspect", "--type=image", "--format='Format container: {{.ThisDoesNotExist}}'", "busybox")

-	assert.Assert(c, err, check.Not(check.IsNil))

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

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

 }

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

 	runSleepingContainer(c, "--name=busybox2", "-d")

 	result := dockerCmdWithResult("inspect", "--type=container", "--format='{{.Name}}'", "busybox1", "busybox2", "missing")

-	assert.Assert(c, result.Error, checker.Not(check.IsNil))

+	assert.Assert(c, result.Error, checker.Not(checker.IsNil))

 	assert.Assert(c, result.Stdout(), checker.Contains, "busybox1")

 	assert.Assert(c, result.Stdout(), checker.Contains, "busybox2")

 	assert.Assert(c, result.Stderr(), checker.Contains, "Error: No such container: missing")

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

 	// test inspect would not fast fail

 	result = dockerCmdWithResult("inspect", "--type=container", "--format='{{.Name}}'", "missing", "busybox1", "busybox2")

-	assert.Assert(c, result.Error, checker.Not(check.IsNil))

+	assert.Assert(c, result.Error, checker.Not(checker.IsNil))

 	assert.Assert(c, result.Stdout(), checker.Contains, "busybox1")

 	assert.Assert(c, result.Stdout(), checker.Contains, "busybox2")

 	assert.Assert(c, result.Stderr(), checker.Contains, "Error: No such container: missing")

@@ -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, check.NotNil, check.Commentf("%v", out))

+	assert.Assert(c, err, checker.NotNil, 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, check.NotNil, check.Commentf("Failed to start an HTTP Server"))

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

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

 }

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

 	out, _ = dockerCmd(c, "network", "ls", "-f", "label=nonexistent")

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

-	assert.Assert(c, len(outArr), check.Equals, 1, check.Commentf("%s\n", out))

+	assert.Assert(c, len(outArr), checker.Equals, 1, check.Commentf("%s\n", out))

 	out, _ = dockerCmd(c, "network", "ls", "-f", "driver=null")

 	assertNwList(c, out, []string{"none"})

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

 	out, _, err := dockerCmdWithError("network", "inspect", "--format={{ .Labels."+testLabel+" }}", testNet)

 	assert.NilError(c, err)

-	assert.Assert(c, strings.TrimSpace(out), check.Equals, testValue)

+	assert.Assert(c, strings.TrimSpace(out), checker.Equals, testValue)

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

 	assertNwNotAvailable(c, testNet)

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

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

 	out, _ = dockerCmd(c, "network", "inspect", "--format={{ .Name }}", "host")

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

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

 }

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

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

 	networkID := strings.TrimSpace(out)

 	assertNwIsAvailable(c, "test2")

 	out, _ = dockerCmd(c, "network", "inspect", "--format={{ .Id }}", "test2")

-	assert.Assert(c, strings.TrimSpace(out), check.Equals, networkID)

+	assert.Assert(c, strings.TrimSpace(out), checker.Equals, networkID)

 	out, _ = dockerCmd(c, "network", "inspect", "--format={{ .ID }}", "test2")

-	assert.Assert(c, strings.TrimSpace(out), check.Equals, networkID)

+	assert.Assert(c, strings.TrimSpace(out), checker.Equals, networkID)

 }

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

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

 	}()

 	out, _ := dockerCmd(c, "run", "-d", "--name", "testNetInspect1", "--net", "brNetForInspect", "busybox", "top")

-	assert.Assert(c, waitRun("testNetInspect1"), check.IsNil)

+	assert.Assert(c, waitRun("testNetInspect1"), checker.IsNil)

 	containerID := strings.TrimSpace(out)

 	defer func() {

 		// we don't stop container by name, because we'll rename it later

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

 	// run a container

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

-	assert.Assert(c, waitRun("test"), check.IsNil)

+	assert.Assert(c, waitRun("test"), checker.IsNil)

 	containerID := strings.TrimSpace(out)

 	// connect the container to the test network

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

 	// run another container

 	out, _ = dockerCmd(c, "run", "-d", "--net", "test", "--name", "test2", "busybox", "top")

-	assert.Assert(c, waitRun("test2"), check.IsNil)

+	assert.Assert(c, waitRun("test2"), checker.IsNil)

 	containerID = strings.TrimSpace(out)

 	nr = getNwResource(c, "test")

@@ -1138,7 +1138,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkHostModeUngracefulDaemonRestart(c

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

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

-	assert.Assert(c, waitRun("container1"), check.IsNil)

+	assert.Assert(c, waitRun("container1"), checker.IsNil)

 	dockerCmd(c, "network", "disconnect", "bridge", "container1")

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

 	assert.ErrorContains(c, err, "", out)

@@ -1147,7 +1147,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkConnectToHostFromOtherNetwork(c *t

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

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

-	assert.Assert(c, waitRun("container1"), check.IsNil)

+	assert.Assert(c, waitRun("container1"), checker.IsNil)

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

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

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

@@ -1157,7 +1157,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkConnectWithPortMapping(c *testing.

 	testRequires(c, NotArm)

 	dockerCmd(c, "network", "create", "test1")

 	dockerCmd(c, "run", "-d", "--name", "c1", "-p", "5000:5000", "busybox", "top")

-	assert.Assert(c, waitRun("c1"), check.IsNil)

+	assert.Assert(c, waitRun("c1"), checker.IsNil)

 	dockerCmd(c, "network", "connect", "test1", "c1")

 }

@@ -1181,7 +1181,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkConnectDisconnectWithPortMapping(c

 	dockerCmd(c, "network", "create", "ccc")

 	dockerCmd(c, "run", "-d", "--name", cnt, "-p", "9000:90", "-p", "70", "busybox", "top")

-	assert.Assert(c, waitRun(cnt), check.IsNil)

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

 	curPortMap, _ := dockerCmd(c, "port", cnt, "70")

 	curExplPortMap, _ := dockerCmd(c, "port", cnt, "90")

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

 	macAddress := "02:42:ac:11:00:02"

 	dockerCmd(c, "network", "create", "mynetwork")

 	dockerCmd(c, "run", "--name=test", "-d", "--mac-address", macAddress, "busybox", "top")

-	assert.Assert(c, waitRun("test"), check.IsNil)

+	assert.Assert(c, waitRun("test"), checker.IsNil)

 	mac1 := inspectField(c, "test", "NetworkSettings.Networks.bridge.MacAddress")

 	assert.Assert(c, strings.TrimSpace(mac1), checker.Equals, macAddress)

 	dockerCmd(c, "network", "connect", "mynetwork", "test")

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

 	// run a container on first network specifying the ip addresses

 	dockerCmd(c, "run", "-d", "--name", "c0", "--net=n0", "--ip", "172.28.99.88", "--ip6", "2001:db8:1234::9988", "busybox", "top")

-	assert.Assert(c, waitRun("c0"), check.IsNil)

+	assert.Assert(c, waitRun("c0"), checker.IsNil)

 	verifyIPAddressConfig(c, "c0", "n0", "172.28.99.88", "2001:db8:1234::9988")

 	verifyIPAddresses(c, "c0", "n0", "172.28.99.88", "2001:db8:1234::9988")

@@ -1336,7 +1336,7 @@ func (s *DockerNetworkSuite) TestDockerNetworkConnectPreferredIPStoppedContainer

 	// start the container, verify config has not changed and ip addresses are assigned

 	dockerCmd(c, "start", "c0")

-	assert.Assert(c, waitRun("c0"), check.IsNil)

+	assert.Assert(c, waitRun("c0"), checker.IsNil)

 	verifyIPAddressConfig(c, "c0", "n0", "172.30.55.44", "2001:db8:abcd::5544")

 	verifyIPAddresses(c, "c0", "n0", "172.30.55.44", "2001:db8:abcd::5544")

@@ -1376,21 +1376,21 @@ func checkUnsupportedNetworkAndIP(c *testing.T, nwMode string) {

 func verifyIPAddressConfig(c *testing.T, cName, nwname, ipv4, ipv6 string) {

 	if ipv4 != "" {

 		out := inspectField(c, cName, fmt.Sprintf("NetworkSettings.Networks.%s.IPAMConfig.IPv4Address", nwname))

-		assert.Assert(c, strings.TrimSpace(out), check.Equals, ipv4)

+		assert.Assert(c, strings.TrimSpace(out), checker.Equals, ipv4)

 	}

 	if ipv6 != "" {

 		out := inspectField(c, cName, fmt.Sprintf("NetworkSettings.Networks.%s.IPAMConfig.IPv6Address", nwname))

-		assert.Assert(c, strings.TrimSpace(out), check.Equals, ipv6)

+		assert.Assert(c, strings.TrimSpace(out), checker.Equals, ipv6)

 	}

 }

 func verifyIPAddresses(c *testing.T, cName, nwname, ipv4, ipv6 string) {

 	out := inspectField(c, cName, fmt.Sprintf("NetworkSettings.Networks.%s.IPAddress", nwname))

-	assert.Assert(c, strings.TrimSpace(out), check.Equals, ipv4)

+	assert.Assert(c, strings.TrimSpace(out), checker.Equals, ipv4)

 	out = inspectField(c, cName, fmt.Sprintf("NetworkSettings.Networks.%s.GlobalIPv6Address", nwname))

-	assert.Assert(c, strings.TrimSpace(out), check.Equals, ipv6)

+	assert.Assert(c, strings.TrimSpace(out), checker.Equals, ipv6)

 }