@@ -95,7 +95,7 @@ func (d *Daemon) CheckActiveContainerCount(c *testing.T) (interface{}, check.Com

 	if len(strings.TrimSpace(out)) == 0 {

 		return 0, nil

 	}

-	return len(strings.Split(strings.TrimSpace(out), "\n")), check.Commentf("output: %q", string(out))

+	return len(strings.Split(strings.TrimSpace(out), "\n")), fmt.Sprintf("output: %q", string(out))

 }

 // WaitRun waits for a container to be running for 10s

@@ -70,10 +70,10 @@ func (d *Daemon) CheckPluginRunning(plugin string) func(c *testing.T) (interface

 		apiclient := d.NewClientT(c)

 		resp, _, err := apiclient.PluginInspectWithRaw(context.Background(), plugin)

 		if client.IsErrNotFound(err) {

-			return false, check.Commentf("%v", err)

+			return false, fmt.Sprintf("%v", err)

 		}

 		assert.NilError(c, err)

-		return resp.Enabled, check.Commentf("%+v", resp)

+		return resp.Enabled, fmt.Sprintf("%+v", resp)

 	}

 }

@@ -83,10 +83,10 @@ func (d *Daemon) CheckPluginImage(plugin string) func(c *testing.T) (interface{}

 		apiclient := d.NewClientT(c)

 		resp, _, err := apiclient.PluginInspectWithRaw(context.Background(), plugin)

 		if client.IsErrNotFound(err) {

-			return false, check.Commentf("%v", err)

+			return false, fmt.Sprintf("%v", err)

 		}

 		assert.NilError(c, err)

-		return resp.PluginReference, check.Commentf("%+v", resp)

+		return resp.PluginReference, fmt.Sprintf("%+v", resp)

 	}

 }

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

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

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

 	assert.NilError(c, err)

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

+	assert.Equal(c, len(top.Titles), 11, fmt.Sprintf("expected 11 titles, found %d: %v", len(top.Titles), top.Titles))

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

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

 	}

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

+	assert.Equal(c, len(top.Processes), 2, fmt.Sprintf("expected 2 processes, found %d: %v", len(top.Processes), top.Processes))

 	assert.Equal(c, top.Processes[0][10], "/bin/sh -c top")

 	assert.Equal(c, top.Processes[1][10], "top")

 }

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

 	assert.NilError(c, err)

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

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

+	assert.Equal(c, cmd, "[/bin/sh -c touch /test]", fmt.Sprintf("got wrong Cmd from commit: %q", cmd))

 	// sanity check, make sure the image is what we think it is

 	dockerCmd(c, "run", img.ID, "ls", "/test")

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

 	assert.Equal(c, label2, "value2")

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

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

+	assert.Equal(c, cmd, "[/bin/sh -c touch /test]", fmt.Sprintf("got wrong Cmd from commit: %q", cmd))

 	// sanity check, make sure the image is what we think it is

 	dockerCmd(c, "run", img.ID, "ls", "/test")

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

 	assert.NilError(c, err)

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

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

+	assert.Equal(c, state, "false", fmt.Sprintf("got wrong State from container %s: %q", name, state))

 }

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

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

 	assert.NilError(c, err)

 	_, err = os.Stat(source)

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

+	assert.Assert(c, os.IsNotExist(err), fmt.Sprintf("expected to get ErrNotExist error, got %v", err))

 }

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

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

 	assert.NilError(c, err)

 	b, err := request.ReadBody(body)

-	comment := check.Commentf("response body: %s", b)

+	comment := fmt.Sprintf("response body: %s", b)

 	assert.NilError(c, err, comment)

 	assert.Equal(c, resp.StatusCode, http.StatusOK, comment)

 }

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

 	assert.NilError(c, err)

 	b, err := request.ReadBody(body)

-	comment := check.Commentf("response body: %s", b)

+	comment := fmt.Sprintf("response body: %s", b)

 	assert.NilError(c, err, comment)

 	resp, _, err := request.Get("/_ping")

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

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

 	nodes := d1.ListNodes(c)

-	assert.Equal(c, len(nodes), 3, check.Commentf("nodes: %#v", nodes))

+	assert.Equal(c, len(nodes), 3, fmt.Sprintf("nodes: %#v", nodes))

 loop0:

 	for _, n := range nodes {

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

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

 	nodes := d1.ListNodes(c)

-	assert.Equal(c, len(nodes), 3, check.Commentf("nodes: %#v", nodes))

+	assert.Equal(c, len(nodes), 3, fmt.Sprintf("nodes: %#v", nodes))

 	// Getting the info so we can take the NodeID

 	d2Info := d2.SwarmInfo(c)

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

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

 	nodes = d1.ListNodes(c)

-	assert.Equal(c, len(nodes), 2, check.Commentf("nodes: %#v", nodes))

+	assert.Equal(c, len(nodes), 2, fmt.Sprintf("nodes: %#v", nodes))

 	// Restart the node that was removed

 	d2.RestartNode(c)

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

 	// Make sure the node didn't rejoin

 	nodes = d1.ListNodes(c)

-	assert.Equal(c, len(nodes), 2, check.Commentf("nodes: %#v", nodes))

+	assert.Equal(c, len(nodes), 2, fmt.Sprintf("nodes: %#v", nodes))

 }

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

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

 	waitAndAssert(c, defaultReconciliationTimeout, func(c *testing.T) (interface{}, check.CommentInterface) {

 		certBytes, err := ioutil.ReadFile(filepath.Join(d2.Folder, "root", "swarm", "certificates", "swarm-node.crt"))

 		if err != nil {

-			return "", check.Commentf("error: %v", err)

+			return "", fmt.Sprintf("error: %v", err)

 		}

 		certs, err := helpers.ParseCertificatesPEM(certBytes)

 		if err == nil && len(certs) > 0 && len(certs[0].Subject.OrganizationalUnit) > 0 {

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

 					return false

 				})

 				if n == nil {

-					return false, check.Commentf("failed to get node: %v", lastErr)

+					return false, fmt.Sprintf("failed to get node: %v", lastErr)

 				}

 				if n.ManagerStatus.Leader {

 					leader = d

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

 				return false, check.Commentf("no leader elected")

 			}

-			return true, check.Commentf("elected %v", leader.ID())

+			return true, fmt.Sprintf("elected %v", leader.ID())

 		}

 	}

@@ -761,7 +761,7 @@ func checkClusterHealth(c *testing.T, cl []*daemon.Daemon, managerCount, workerC

 				}

 				nn := d.GetNode(c, n.ID)

 				n = *nn

-				return n.Status.State == swarm.NodeStateReady, check.Commentf("state of node %s, reported by %s", n.ID, d.NodeID())

+				return n.Status.State == swarm.NodeStateReady, fmt.Sprintf("state of node %s, reported by %s", n.ID, d.NodeID())

 			}

 			waitAndAssert(c, defaultReconciliationTimeout, waitReady, checker.True)

@@ -771,7 +771,7 @@ func checkClusterHealth(c *testing.T, cl []*daemon.Daemon, managerCount, workerC

 				}

 				nn := d.GetNode(c, n.ID)

 				n = *nn

-				return n.Spec.Availability == swarm.NodeAvailabilityActive, check.Commentf("availability of node %s, reported by %s", n.ID, d.NodeID())

+				return n.Spec.Availability == swarm.NodeAvailabilityActive, fmt.Sprintf("availability of node %s, reported by %s", n.ID, d.NodeID())

 			}

 			waitAndAssert(c, defaultReconciliationTimeout, waitActive, checker.True)

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

 	case err := <-errChan:

 		tty.Close()

 		out, _ := ioutil.ReadAll(pty)

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

+		assert.Assert(c, err == nil, fmt.Sprintf("out: %v", string(out)))

 	case <-time.After(attachWait):

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

 	}

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

 		}

 	}

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

+	assert.Assert(c, foundTag, fmt.Sprintf("No tag event found:\n%s", out))

 }

 // #15780

@@ -151,8 +151,8 @@ func (s *DockerRegistrySuite) TestRunByDigest(c *testing.T) {

 	foundRegex := regexp.MustCompile("found=([^\n]+)")

 	matches := foundRegex.FindStringSubmatch(out)

-	assert.Equal(c, len(matches), 2, check.Commentf("unable to parse digest from pull output: %s", out))

-	assert.Equal(c, matches[1], "1", check.Commentf("Expected %q, got %q", "1", matches[1]))

+	assert.Equal(c, len(matches), 2, fmt.Sprintf("unable to parse digest from pull output: %s", out))

+	assert.Equal(c, matches[1], "1", fmt.Sprintf("Expected %q, got %q", "1", matches[1]))

 	res := inspectField(c, containerName, "Config.Image")

 	assert.Equal(c, res, imageReference)

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

 	// make sure repo shown, tag=<none>, digest = $digest1

 	re1 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest1.String() + `\s`)

-	assert.Assert(c, re1.MatchString(out), check.Commentf("expected %q: %s", re1.String(), out))

+	assert.Assert(c, re1.MatchString(out), fmt.Sprintf("expected %q: %s", re1.String(), out))

 	// setup image2

 	digest2, err := setupImageWithTag(c, "tag2")

 	//error setting up image

@@ -271,11 +271,11 @@ func (s *DockerRegistrySuite) TestListImagesWithDigests(c *testing.T) {

 	out, _ = dockerCmd(c, "images", "--digests")

 	// make sure repo shown, tag=<none>, digest = $digest1

-	assert.Assert(c, re1.MatchString(out), check.Commentf("expected %q: %s", re1.String(), out))

+	assert.Assert(c, re1.MatchString(out), fmt.Sprintf("expected %q: %s", re1.String(), out))

 	// make sure repo shown, tag=<none>, digest = $digest2

 	re2 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest2.String() + `\s`)

-	assert.Assert(c, re2.MatchString(out), check.Commentf("expected %q: %s", re2.String(), out))

+	assert.Assert(c, re2.MatchString(out), fmt.Sprintf("expected %q: %s", re2.String(), out))

 	// pull tag1

 	dockerCmd(c, "pull", repoName+":tag1")

@@ -285,9 +285,9 @@ func (s *DockerRegistrySuite) TestListImagesWithDigests(c *testing.T) {

 	// make sure image 1 has repo, tag, <none> AND repo, <none>, digest

 	reWithDigest1 := regexp.MustCompile(`\s*` + repoName + `\s*tag1\s*` + digest1.String() + `\s`)

-	assert.Assert(c, reWithDigest1.MatchString(out), check.Commentf("expected %q: %s", reWithDigest1.String(), out))

+	assert.Assert(c, reWithDigest1.MatchString(out), fmt.Sprintf("expected %q: %s", reWithDigest1.String(), out))

 	// make sure image 2 has repo, <none>, digest

-	assert.Assert(c, re2.MatchString(out), check.Commentf("expected %q: %s", re2.String(), out))

+	assert.Assert(c, re2.MatchString(out), fmt.Sprintf("expected %q: %s", re2.String(), out))

 	// pull tag 2

 	dockerCmd(c, "pull", repoName+":tag2")

@@ -296,22 +296,22 @@ func (s *DockerRegistrySuite) TestListImagesWithDigests(c *testing.T) {

 	out, _ = dockerCmd(c, "images", "--digests")

 	// make sure image 1 has repo, tag, digest

-	assert.Assert(c, reWithDigest1.MatchString(out), check.Commentf("expected %q: %s", reWithDigest1.String(), out))

+	assert.Assert(c, reWithDigest1.MatchString(out), fmt.Sprintf("expected %q: %s", reWithDigest1.String(), out))

 	// make sure image 2 has repo, tag, digest

 	reWithDigest2 := regexp.MustCompile(`\s*` + repoName + `\s*tag2\s*` + digest2.String() + `\s`)

-	assert.Assert(c, reWithDigest2.MatchString(out), check.Commentf("expected %q: %s", reWithDigest2.String(), out))

+	assert.Assert(c, reWithDigest2.MatchString(out), fmt.Sprintf("expected %q: %s", reWithDigest2.String(), out))

 	// list images

 	out, _ = dockerCmd(c, "images", "--digests")

 	// make sure image 1 has repo, tag, digest

-	assert.Assert(c, reWithDigest1.MatchString(out), check.Commentf("expected %q: %s", reWithDigest1.String(), out))

+	assert.Assert(c, reWithDigest1.MatchString(out), fmt.Sprintf("expected %q: %s", reWithDigest1.String(), out))

 	// make sure image 2 has repo, tag, digest

-	assert.Assert(c, reWithDigest2.MatchString(out), check.Commentf("expected %q: %s", reWithDigest2.String(), out))

+	assert.Assert(c, reWithDigest2.MatchString(out), fmt.Sprintf("expected %q: %s", reWithDigest2.String(), out))

 	// make sure busybox has tag, but not digest

 	busyboxRe := regexp.MustCompile(`\s*busybox\s*latest\s*<none>\s`)

-	assert.Assert(c, busyboxRe.MatchString(out), check.Commentf("expected %q: %s", busyboxRe.String(), out))

+	assert.Assert(c, busyboxRe.MatchString(out), fmt.Sprintf("expected %q: %s", busyboxRe.String(), out))

 }

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

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

 	// make sure repo shown, tag=<none>, digest = $digest1

 	re1 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest1.String() + `\s`)

-	assert.Assert(c, re1.MatchString(out), check.Commentf("expected %q: %s", re1.String(), out))

+	assert.Assert(c, re1.MatchString(out), fmt.Sprintf("expected %q: %s", re1.String(), out))

 	// setup image2

 	digest2, err := setupImageWithTag(c, "dangle2")

 	//error setting up image

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

 	out, _ = dockerCmd(c, "images", "--digests", "--filter=dangling=true")

 	// make sure repo shown, tag=<none>, digest = $digest1

-	assert.Assert(c, re1.MatchString(out), check.Commentf("expected %q: %s", re1.String(), out))

+	assert.Assert(c, re1.MatchString(out), fmt.Sprintf("expected %q: %s", re1.String(), out))

 	// make sure repo shown, tag=<none>, digest = $digest2

 	re2 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest2.String() + `\s`)

-	assert.Assert(c, re2.MatchString(out), check.Commentf("expected %q: %s", re2.String(), out))

+	assert.Assert(c, re2.MatchString(out), fmt.Sprintf("expected %q: %s", re2.String(), out))

 	// pull dangle1 tag

 	dockerCmd(c, "pull", repoName+":dangle1")

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

 	// make sure image 1 has repo, tag, <none> AND repo, <none>, digest

 	reWithDigest1 := regexp.MustCompile(`\s*` + repoName + `\s*dangle1\s*` + digest1.String() + `\s`)

-	assert.Assert(c, !reWithDigest1.MatchString(out), check.Commentf("unexpected %q: %s", reWithDigest1.String(), out))

+	assert.Assert(c, !reWithDigest1.MatchString(out), fmt.Sprintf("unexpected %q: %s", reWithDigest1.String(), out))

 	// make sure image 2 has repo, <none>, digest

-	assert.Assert(c, re2.MatchString(out), check.Commentf("expected %q: %s", re2.String(), out))

+	assert.Assert(c, re2.MatchString(out), fmt.Sprintf("expected %q: %s", re2.String(), out))

 	// pull dangle2 tag

 	dockerCmd(c, "pull", repoName+":dangle2")

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

 	out, _ = dockerCmd(c, "images", "--digests")

 	// make sure image 1 has repo, tag, digest

-	assert.Assert(c, reWithDigest1.MatchString(out), check.Commentf("expected %q: %s", reWithDigest1.String(), out))

+	assert.Assert(c, reWithDigest1.MatchString(out), fmt.Sprintf("expected %q: %s", reWithDigest1.String(), out))

 	// make sure image 2 has repo, tag, digest

 	reWithDigest2 := regexp.MustCompile(`\s*` + repoName + `\s*dangle2\s*` + digest2.String() + `\s`)

-	assert.Assert(c, reWithDigest2.MatchString(out), check.Commentf("expected %q: %s", reWithDigest2.String(), out))

+	assert.Assert(c, reWithDigest2.MatchString(out), fmt.Sprintf("expected %q: %s", reWithDigest2.String(), out))

 	// list images, no longer dangling, should not match

 	out, _ = dockerCmd(c, "images", "--digests", "--filter=dangling=true")

 	// make sure image 1 has repo, tag, digest

-	assert.Assert(c, !reWithDigest1.MatchString(out), check.Commentf("unexpected %q: %s", reWithDigest1.String(), out))

+	assert.Assert(c, !reWithDigest1.MatchString(out), fmt.Sprintf("unexpected %q: %s", reWithDigest1.String(), out))

 	// make sure image 2 has repo, tag, digest

-	assert.Assert(c, !reWithDigest2.MatchString(out), check.Commentf("unexpected %q: %s", reWithDigest2.String(), out))

+	assert.Assert(c, !reWithDigest2.MatchString(out), fmt.Sprintf("unexpected %q: %s", reWithDigest2.String(), out))

 }

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

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

 	assert.Assert(c, exitStatus != 0, check.Commentf("expected a non-zero exit status"))

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

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

+	assert.Assert(c, strings.Contains(out, expectedErrorMsg), fmt.Sprintf("expected error message in output: %s", out))

 }

 // TestPullFailsWithAlteredLayer tests that a `docker pull` fails when

@@ -687,5 +687,5 @@ func (s *DockerSchema1RegistrySuite) TestPullFailsWithAlteredLayer(c *testing.T)

 	assert.Assert(c, exitStatus != 0, check.Commentf("expected a non-zero exit status"))

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

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

+	assert.Assert(c, strings.Contains(out, expectedErrorMsg), fmt.Sprintf("expected error message in output: %s", out))

 }

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

 	chunks := strings.Split(strings.TrimSpace(firstOutput), " ")

 	inode := chunks[0]

 	chunks = strings.SplitAfterN(strings.TrimSpace(firstOutput), " ", 2)

-	assert.Assert(c, strings.Contains(chunks[1], chunks[0]), check.Commentf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:]))

+	assert.Assert(c, strings.Contains(chunks[1], chunks[0]), fmt.Sprintf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:]))

 	imageID, _ := dockerCmd(c, "commit", "hardlinks", "hardlinks")

 	imageID = strings.TrimSpace(imageID)

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

 	chunks = strings.Split(strings.TrimSpace(secondOutput), " ")

 	inode = chunks[0]

 	chunks = strings.SplitAfterN(strings.TrimSpace(secondOutput), " ", 2)

-	assert.Assert(c, strings.Contains(chunks[1], chunks[0]), check.Commentf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:]))

+	assert.Assert(c, strings.Contains(chunks[1], chunks[0]), fmt.Sprintf("Failed to create hardlink in a container. Expected to find %q in %q", inode, chunks[1:]))

 }

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

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

 	err := runDockerCp(c, srcPath, dstDir, nil)

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, isCpDirNotExist(err), check.Commentf("expected DirNotExists error, but got %T: %s", err, err))

+	assert.Assert(c, isCpDirNotExist(err), fmt.Sprintf("expected DirNotExists error, but got %T: %s", err, err))

 }

 // C. SRC specifies a file and DST exists as a file. This should overwrite

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

 	// Ensure that dstPath doesn't exist.

 	_, err := os.Stat(dstPath)

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

+	assert.Assert(c, os.IsNotExist(err), fmt.Sprintf("did not expect dstPath %q to exist", dstPath))

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

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

 	err := runDockerCp(c, srcDir, dstFile, nil)

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, isCpCannotCopyDir(err), check.Commentf("expected ErrCannotCopyDir error, but got %T: %s", err, err))

+	assert.Assert(c, isCpCannotCopyDir(err), fmt.Sprintf("expected ErrCannotCopyDir error, but got %T: %s", err, err))

 }

 // G. SRC specifies a directory and DST exists as a directory. This should copy

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

 	err := runDockerCp(c, srcDir, dstFile, nil)

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, isCpCannotCopyDir(err), check.Commentf("expected ErrCannotCopyDir error, but got %T: %s", err, err))

+	assert.Assert(c, isCpCannotCopyDir(err), fmt.Sprintf("expected ErrCannotCopyDir error, but got %T: %s", err, err))

 }

 // J. SRC specifies a directory's contents only and DST exists as a directory.

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

 	err := runDockerCp(c, srcPath, dstDir, nil)

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, isCpDirNotExist(err), check.Commentf("expected DirNotExists error, but got %T: %s", err, err))

+	assert.Assert(c, isCpDirNotExist(err), fmt.Sprintf("expected DirNotExists error, but got %T: %s", err, err))

 }

 // C. SRC specifies a file and DST exists as a file. This should overwrite

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

 	err := runDockerCp(c, srcDir, dstFile, nil)

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, isCpCannotCopyDir(err), check.Commentf("expected ErrCannotCopyDir error, but got %T: %s", err, err))

+	assert.Assert(c, isCpCannotCopyDir(err), fmt.Sprintf("expected ErrCannotCopyDir error, but got %T: %s", err, err))

 }

 // G. SRC specifies a directory and DST exists as a directory. This should copy

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

 	err := runDockerCp(c, srcDir, dstFile, nil)

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, isCpCannotCopyDir(err), check.Commentf("expected ErrCannotCopyDir error, but got %T: %s", err, err))

+	assert.Assert(c, isCpCannotCopyDir(err), fmt.Sprintf("expected ErrCannotCopyDir error, but got %T: %s", err, err))

 }

 // J. SRC specifies a directory's contents only and DST exists as a directory.

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

 	err := runDockerCp(c, srcPath, dstPath, nil)

 	assert.ErrorContains(c, err, "")

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

+	assert.Assert(c, isCpCannotCopyReadOnly(err), fmt.Sprintf("expected ErrContainerRootfsReadonly error, but got %T: %s", err, err))

 	// Ensure that dstPath doesn't exist.

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

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

 	err := runDockerCp(c, srcPath, dstPath, nil)

 	assert.ErrorContains(c, err, "")

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

+	assert.Assert(c, isCpCannotCopyReadOnly(err), fmt.Sprintf("expected ErrVolumeReadonly error, but got %T: %s", err, err))

 	// Ensure that dstPath doesn't exist.

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

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

 	}

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

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

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

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

 	cont := containers[0]

-	assert.Equal(c, string(cont.Path), "command", check.Commentf("Unexpected container path. Expected command, received: %s", cont.Path))

+	assert.Equal(c, string(cont.Path), "command", fmt.Sprintf("Unexpected container path. Expected command, received: %s", cont.Path))

 	b := false

 	expected := []string{"arg1", "arg2", "arg with space", "-c", "flags"}

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

 	}

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

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

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

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

 	cont := containers[0]

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

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

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

+	assert.Assert(c, cont.HostConfig.PublishAllPorts, fmt.Sprintf("Expected PublishAllPorts, got false"))

 }

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

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

 		}

 	}

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

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

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

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

 	cont := containers[0]

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

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

+	assert.Equal(c, len(cont.HostConfig.PortBindings), 4, fmt.Sprintf("Expected 4 ports bindings, got %d", len(cont.HostConfig.PortBindings)))

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

-		assert.Equal(c, len(v), 1, check.Commentf("Expected 1 ports binding, for the port  %s but found %s", k, v))

-		assert.Equal(c, k.Port(), v[0].HostPort, check.Commentf("Expected host port %s to match published port %s", k.Port(), v[0].HostPort))

+		assert.Equal(c, len(v), 1, fmt.Sprintf("Expected 1 ports binding, for the port  %s but found %s", k, v))

+		assert.Equal(c, k.Port(), v[0].HostPort, fmt.Sprintf("Expected host port %s to match published port %s", k.Port(), v[0].HostPort))

 	}

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

 	}

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

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

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

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

 	cont := containers[0]

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

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

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

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

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

-		assert.Equal(c, k.Port(), v[0].HostPort, check.Commentf("Expected host port %s to match published port %s", k.Port(), v[0].HostPort))

+		assert.Equal(c, k.Port(), v[0].HostPort, fmt.Sprintf("Expected host port %s to match published port %s", k.Port(), v[0].HostPort))

 	}

 }

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

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

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

 		c.Fatalf("Volume was not created")

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

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

 			if shouldRun {

 				format = "%scontainer %q is not running"

 			} else {

 				format = "%scontainer %q is running"

 			}

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

+			assert.Equal(c, strings.Contains(out, name), shouldRun, fmt.Sprintf(format, prefix, name))

 		}

 	}

@@ -217,7 +217,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 != nil, 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, fmt.Sprintf("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 {

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

 	}

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

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

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

+	assert.Assert(c, err == nil, fmt.Sprintf("Error in converting base device size: %v", err))

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

 	s.d.Stop(c)

 }

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

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

 	ip = net.ParseIP(containerIP)

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

+	assert.Equal(c, bridgeIPNet.Contains(ip), true, fmt.Sprintf("Container IP-Address must be in the same subnet range : %s", containerIP))

 	deleteInterface(c, defaultNetworkBridge)

 }

@@ -784,7 +784,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.Equal(c, strings.Contains(out, expectedMessage), true, check.Commentf("Implicit default gateway should be bridge IP %s, but default route was '%s'", bridgeIP, strings.TrimSpace(out)))

+	assert.Equal(c, strings.Contains(out, expectedMessage), true, fmt.Sprintf("Implicit default gateway should be bridge IP %s, but default route was '%s'", bridgeIP, strings.TrimSpace(out)))

 	deleteInterface(c, defaultNetworkBridge)

 }

@@ -804,7 +804,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.Equal(c, strings.Contains(out, expectedMessage), true, check.Commentf("Explicit default gateway should be %s, but default route was '%s'", gatewayIP, strings.TrimSpace(out)))

+	assert.Equal(c, strings.Contains(out, expectedMessage), true, fmt.Sprintf("Explicit default gateway should be %s, but default route was '%s'", gatewayIP, strings.TrimSpace(out)))

 	deleteInterface(c, defaultNetworkBridge)

 }

@@ -859,7 +859,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.Equal(c, matched, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

+	assert.Equal(c, matched, true, fmt.Sprintf("iptables output should have contained %q, but was %q", regex, result.Combined()))

 }

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

@@ -879,7 +879,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.Equal(c, matched, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

+	assert.Equal(c, matched, true, fmt.Sprintf("iptables output should have contained %q, but was %q", regex, result.Combined()))

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

 	pingContainers(c, d, true)

@@ -912,7 +912,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.Equal(c, matched, true, check.Commentf("iptables output should have contained %q, but was %q", regex, result.Combined()))

+	assert.Equal(c, matched, true, fmt.Sprintf("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)

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

         RUN echo foo`),

 		build.WithoutCache,

 	)

-	comment := check.Commentf("Failed to build image. output %s, exitCode %d, err %v", result.Combined(), result.ExitCode, result.Error)

+	comment := fmt.Sprintf("Failed to build image. output %s, exitCode %d, err %v", result.Combined(), result.ExitCode, result.Error)

 	assert.Assert(c, result.Error == nil, comment)

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

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

@@ -1750,7 +1750,7 @@ func (s *DockerDaemonSuite) TestBridgeIPIsExcludedFromAllocatorPool(c *testing.T

 			break

 		}

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

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

+		assert.Assert(c, err == nil, fmt.Sprintf("%s", ip))

 		assert.Assert(c, ip != bridgeIP)

 		cont++

@@ -1780,7 +1780,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 != nil, check.Commentf("%s", pullOut))

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

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

 }

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

 	out, err := s.d.Cmd("run", "--name", name, "busybox", "cat", "/proc/self/cgroup")

 	assert.NilError(c, err)

 	cgroupPaths := ParseCgroupPaths(string(out))

-	assert.Assert(c, len(cgroupPaths) != 0, check.Commentf("unexpected output - %q", string(out)))

+	assert.Assert(c, len(cgroupPaths) != 0, fmt.Sprintf("unexpected output - %q", string(out)))

 	out, err = s.d.Cmd("inspect", "-f", "{{.Id}}", name)

 	assert.NilError(c, err)

 	id := strings.TrimSpace(string(out))

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

 			break

 		}

 	}

-	assert.Assert(c, found, check.Commentf("Cgroup path for container (%s) doesn't found in cgroups file: %s", expectedCgroup, cgroupPaths))

+	assert.Assert(c, found, fmt.Sprintf("Cgroup path for container (%s) doesn't found in cgroups file: %s", expectedCgroup, cgroupPaths))

 }

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

@@ -1890,7 +1890,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.Equal(c, strings.Contains(out, "1 packets transmitted, 1 packets received"), true, check.Commentf("%s", out))

+	assert.Equal(c, strings.Contains(out, "1 packets transmitted, 1 packets received"), true, fmt.Sprintf("%s", out))

 }

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

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

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

 	skipMountCheck := false

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

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

+	assert.Assert(c, err == nil, fmt.Sprintf("Output: %s", mountOut))

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

 		skipMountCheck = true

 	}

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

 	}

 	// Now, container mounts should be gone.

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

-	assert.Assert(c, err == nil, 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, err == nil, fmt.Sprintf("Output: %s", mountOut))

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

 	assert.Equal(c, strings.Contains(string(mountOut), id), false, comment)

 }

@@ -2363,7 +2363,7 @@ func (s *DockerDaemonSuite) TestBuildOnDisabledBridgeNetworkDaemon(c *testing.T)

         RUN cat /etc/hosts`),

 		build.WithoutCache,

 	)

-	comment := check.Commentf("Failed to build image. output %s, exitCode %d, err %v", result.Combined(), result.ExitCode, result.Error)

+	comment := fmt.Sprintf("Failed to build image. output %s, exitCode %d, err %v", result.Combined(), result.ExitCode, result.Error)

 	assert.Assert(c, result.Error == nil, comment)

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

 }

@@ -2376,11 +2376,11 @@ func (s *DockerDaemonSuite) TestDaemonDNSFlagsInHostMode(c *testing.T) {

 	expectedOutput := "nameserver 1.2.3.4"

 	out, _ := s.d.Cmd("run", "--net=host", "busybox", "cat", "/etc/resolv.conf")

-	assert.Assert(c, strings.Contains(out, expectedOutput), check.Commentf("Expected '%s', but got %q", expectedOutput, out))

+	assert.Assert(c, strings.Contains(out, expectedOutput), fmt.Sprintf("Expected '%s', but got %q", expectedOutput, out))

 	expectedOutput = "search example.com"

-	assert.Assert(c, strings.Contains(out, expectedOutput), check.Commentf("Expected '%s', but got %q", expectedOutput, out))

+	assert.Assert(c, strings.Contains(out, expectedOutput), fmt.Sprintf("Expected '%s', but got %q", expectedOutput, out))

 	expectedOutput = "options timeout:3"

-	assert.Assert(c, strings.Contains(out, expectedOutput), check.Commentf("Expected '%s', but got %q", expectedOutput, out))

+	assert.Assert(c, strings.Contains(out, expectedOutput), fmt.Sprintf("Expected '%s', but got %q", expectedOutput, out))

 }

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

@@ -2555,10 +2555,10 @@ func (s *DockerDaemonSuite) TestDaemonRestartWithAutoRemoveContainer(c *testing.

 	// top1 will exist after daemon restarts

 	out, err := s.d.Cmd("run", "-d", "--name", "top1", "busybox:latest", "top")

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

+	assert.Assert(c, err == nil, fmt.Sprintf("run top1: %v", out))

 	// top2 will be removed after daemon restarts

 	out, err = s.d.Cmd("run", "-d", "--rm", "--name", "top2", "busybox:latest", "top")

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

+	assert.Assert(c, err == nil, fmt.Sprintf("run top2: %v", out))

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

 	assert.NilError(c, err)

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

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

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

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

+	assert.Assert(c, err == nil, fmt.Sprintf("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 == nil, check.Commentf("Output: %s", out2))

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

+	assert.Assert(c, err == nil, fmt.Sprintf("Output: %s", out2))

+	assert.Equal(c, out2, out1, fmt.Sprintf("Output: before restart '%s', after restart '%s'", out1, out2))

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

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

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

 		StartedAt time.Time

 	}

 	out, err = s.d.Cmd("inspect", "-f", "{{json .State}}", id)

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

+	assert.Assert(c, err == nil, fmt.Sprintf("output: %s", out))

 	var origState state

 	err = json.Unmarshal([]byte(strings.TrimSpace(out)), &origState)

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

 		}

 		out, err := s.d.Cmd("inspect", "-f", "{{json .State}}", id)

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

+		assert.Assert(c, err == nil, fmt.Sprintf("output: %s", out))

 		var newState state

 		err = json.Unmarshal([]byte(strings.TrimSpace(out)), &newState)

@@ -304,7 +304,7 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverNamed(c *testing.T)

 	p := hostVolumePath("external-volume-test")

 	_, err = os.Lstat(p)

 	assert.ErrorContains(c, err, "")

-	assert.Assert(c, os.IsNotExist(err), check.Commentf("Expected volume path in host to not exist: %s, %v\n", p, err))

+	assert.Assert(c, os.IsNotExist(err), fmt.Sprintf("Expected volume path in host to not exist: %s, %v\n", p, err))

 	assert.Equal(c, s.ec.activations, 1)

 	assert.Equal(c, s.ec.creations, 1)

@@ -449,7 +449,7 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverBindExternalVolume(c

 	}

 	out := inspectFieldJSON(c, "testing", "Mounts")

 	assert.Assert(c, json.NewDecoder(strings.NewReader(out)).Decode(&mounts) == nil)

-	assert.Equal(c, len(mounts), 1, check.Commentf("%s", out))

+	assert.Equal(c, len(mounts), 1, fmt.Sprintf("%s", out))

 	assert.Equal(c, mounts[0].Name, "foo")

 	assert.Equal(c, mounts[0].Driver, volumePluginName)

 }

@@ -458,10 +458,10 @@ 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.Equal(c, len(ls), 2, check.Commentf("\n%s", out))

+	assert.Equal(c, len(ls), 2, fmt.Sprintf("\n%s", out))

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

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

+	assert.Equal(c, len(vol), 2, fmt.Sprintf("%v", vol))

 	assert.Equal(c, vol[0], volumePluginName)

 	assert.Equal(c, vol[1], "abc3")

@@ -484,8 +484,8 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGet(c *testing.T) {

 	assert.Assert(c, json.Unmarshal([]byte(out), &st) == nil)

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

-	assert.Equal(c, len(st[0].Status), 1, check.Commentf("%v", st[0]))

-	assert.Equal(c, st[0].Status["Hello"], "world", check.Commentf("%v", st[0].Status))

+	assert.Equal(c, len(st[0].Status), 1, fmt.Sprintf("%v", st[0]))

+	assert.Equal(c, st[0].Status["Hello"], "world", fmt.Sprintf("%v", st[0].Status))

 }

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

@@ -605,9 +605,9 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnmountOnMountFail(c

 	s.d.Cmd("volume", "create", "-d", "test-external-volume-driver", "--opt=invalidOption=1", "--name=testumount")

 	out, _ := s.d.Cmd("run", "-v", "testumount:/foo", "busybox", "true")

-	assert.Equal(c, s.ec.unmounts, 0, check.Commentf("%s", out))

+	assert.Equal(c, s.ec.unmounts, 0, fmt.Sprintf("%s", out))

 	out, _ = s.d.Cmd("run", "-w", "/foo", "-v", "testumount:/foo", "busybox", "true")

-	assert.Equal(c, s.ec.unmounts, 0, check.Commentf("%s", out))

+	assert.Equal(c, s.ec.unmounts, 0, fmt.Sprintf("%s", out))

 }

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

@@ -615,12 +615,12 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnmountOnCp(c *testi

 	s.d.Cmd("volume", "create", "-d", "test-external-volume-driver", "--name=test")

 	out, _ := s.d.Cmd("run", "-d", "--name=test", "-v", "test:/foo", "busybox", "/bin/sh", "-c", "touch /test && top")

-	assert.Equal(c, s.ec.mounts, 1, check.Commentf("%s", out))

+	assert.Equal(c, s.ec.mounts, 1, fmt.Sprintf("%s", out))

 	out, _ = s.d.Cmd("cp", "test:/test", "/tmp/test")

-	assert.Equal(c, s.ec.mounts, 2, check.Commentf("%s", out))

-	assert.Equal(c, s.ec.unmounts, 1, check.Commentf("%s", out))

+	assert.Equal(c, s.ec.mounts, 2, fmt.Sprintf("%s", out))

+	assert.Equal(c, s.ec.unmounts, 1, fmt.Sprintf("%s", out))

 	out, _ = s.d.Cmd("kill", "test")

-	assert.Equal(c, s.ec.unmounts, 2, check.Commentf("%s", out))

+	assert.Equal(c, s.ec.unmounts, 2, fmt.Sprintf("%s", out))

 }

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

 		sizeString := lines[i][startIndex:endIndex]

 		_, err := strconv.Atoi(strings.TrimSpace(sizeString))

-		assert.Assert(c, err == nil, check.Commentf("The size '%s' was not an Integer", sizeString))

+		assert.Assert(c, err == nil, fmt.Sprintf("The size '%s' was not an Integer", sizeString))

 	}

 }

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

 			humanSizeRegexRaw+

 			"$",

-			strings.TrimSpace(sizeString)), check.Commentf("The size '%s' was not in human format", sizeString))

+			strings.TrimSpace(sizeString)), fmt.Sprintf("The size '%s' was not in human format", sizeString))

 	}

 }

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

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

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

-	assert.Equal(c, imgs[0], id3, check.Commentf("First image must be %s, got %s", id3, imgs[0]))

-	assert.Equal(c, imgs[1], id2, check.Commentf("First image must be %s, got %s", id2, imgs[1]))

-	assert.Equal(c, imgs[2], id1, check.Commentf("First image must be %s, got %s", id1, imgs[2]))

+	assert.Equal(c, imgs[0], id3, fmt.Sprintf("First image must be %s, got %s", id3, imgs[0]))

+	assert.Equal(c, imgs[1], id2, fmt.Sprintf("First image must be %s, got %s", id2, imgs[1]))

+	assert.Equal(c, imgs[2], id1, fmt.Sprintf("First image must be %s, got %s", id1, imgs[2]))

 }

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

@@ -139,34 +139,34 @@ LABEL number=3`))

 	expected := []string{imageID3, imageID2}