@@ -329,7 +329,7 @@ func (s *DockerSuite) TestGetContainerStatsRmRunning(c *check.C) {

 	c.Assert(err, check.IsNil)

 	// Now remove without `-f` and make sure we are still pulling stats

-	_, _, err = dockerCmdWithError(c, "rm", id)

+	_, _, err = dockerCmdWithError("rm", id)

 	c.Assert(err, check.Not(check.IsNil), check.Commentf("rm should have failed but didn't"))

 	_, err = buf.ReadTimeout(b, 2*time.Second)

 	c.Assert(err, check.IsNil)

@@ -4129,7 +4129,7 @@ func (s *DockerSuite) TestBuildFromGITwithF(c *check.C) {

 	}

 	defer git.Close()

-	out, _, err := dockerCmdWithError(c, "build", "-t", name, "--no-cache", "-f", "myApp/myDockerfile", git.RepoURL)

+	out, _, err := dockerCmdWithError("build", "-t", name, "--no-cache", "-f", "myApp/myDockerfile", git.RepoURL)

 	if err != nil {

 		c.Fatalf("Error on build. Out: %s\nErr: %v", out, err)

 	}

@@ -4364,7 +4364,7 @@ func (s *DockerSuite) TestBuildEntrypointInheritance(c *check.C) {

 		c.Fatal(err)

 	}

-	if _, status, _ := dockerCmdWithError(c, "run", "parent"); status != 130 {

+	if _, status, _ := dockerCmdWithError("run", "parent"); status != 130 {

 		c.Fatalf("expected exit code 130 but received %d", status)

 	}

@@ -4375,7 +4375,7 @@ func (s *DockerSuite) TestBuildEntrypointInheritance(c *check.C) {

 		c.Fatal(err)

 	}

-	if _, status, _ := dockerCmdWithError(c, "run", "child"); status != 5 {

+	if _, status, _ := dockerCmdWithError("run", "child"); status != 5 {

 		c.Fatalf("expected exit code 5 but received %d", status)

 	}

@@ -4471,7 +4471,7 @@ func (s *DockerSuite) TestBuildVerifySingleQuoteFails(c *check.C) {

 		c.Fatal(err)

 	}

-	if _, _, err := dockerCmdWithError(c, "run", "--rm", name); err == nil {

+	if _, _, err := dockerCmdWithError("run", "--rm", name); err == nil {

 		c.Fatal("The image was not supposed to be able to run")

 	}

@@ -5017,7 +5017,7 @@ func (s *DockerSuite) TestBuildDockerfileOutsideContext(c *check.C) {

 		filepath.Join(ctx, "dockerfile1"),

 		filepath.Join(ctx, "dockerfile2"),

 	} {

-		out, _, err := dockerCmdWithError(c, "build", "-t", name, "--no-cache", "-f", dockerfilePath, ".")

+		out, _, err := dockerCmdWithError("build", "-t", name, "--no-cache", "-f", dockerfilePath, ".")

 		if err == nil {

 			c.Fatalf("Expected error with %s. Out: %s", dockerfilePath, out)

 		}

@@ -5031,7 +5031,7 @@ func (s *DockerSuite) TestBuildDockerfileOutsideContext(c *check.C) {

 	// Path to Dockerfile should be resolved relative to working directory, not relative to context.

 	// There is a Dockerfile in the context, but since there is no Dockerfile in the current directory, the following should fail

-	out, _, err := dockerCmdWithError(c, "build", "-t", name, "--no-cache", "-f", "Dockerfile", ctx)

+	out, _, err := dockerCmdWithError("build", "-t", name, "--no-cache", "-f", "Dockerfile", ctx)

 	if err == nil {

 		c.Fatalf("Expected error. Out: %s", out)

 	}

@@ -26,7 +26,7 @@ func setupImageWithTag(c *check.C, tag string) (string, error) {

 	// tag the image to upload it to the private registry

 	repoAndTag := utils.ImageReference(repoName, tag)

-	if out, _, err := dockerCmdWithError(c, "commit", containerName, repoAndTag); err != nil {

+	if out, _, err := dockerCmdWithError("commit", containerName, repoAndTag); err != nil {

 		return "", fmt.Errorf("image tagging failed: %s, %v", out, err)

 	}

@@ -36,13 +36,13 @@ func setupImageWithTag(c *check.C, tag string) (string, error) {

 	}

 	// push the image

-	out, _, err := dockerCmdWithError(c, "push", repoAndTag)

+	out, _, err := dockerCmdWithError("push", repoAndTag)

 	if err != nil {

 		return "", fmt.Errorf("pushing the image to the private registry has failed: %s, %v", out, err)

 	}

 	// delete our local repo that we previously tagged

-	if rmiout, _, err := dockerCmdWithError(c, "rmi", repoAndTag); err != nil {

+	if rmiout, _, err := dockerCmdWithError("rmi", repoAndTag); err != nil {

 		return "", fmt.Errorf("error deleting images prior to real test: %s, %v", rmiout, err)

 	}

@@ -103,7 +103,7 @@ func (s *DockerRegistrySuite) TestPullByDigest(c *check.C) {

 func (s *DockerRegistrySuite) TestPullByDigestNoFallback(c *check.C) {

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

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

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

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

 	if err == nil || !strings.Contains(out, "manifest unknown") {

 		c.Fatalf("expected non-zero exit status and correct error message when pulling non-existing image: %s", out)

 	}

@@ -1369,7 +1369,7 @@ func pingContainers(c *check.C, d *Daemon, expectFailure bool) {

 	args = append(dargs, "run", "--rm", "--link", "container1:alias1", "busybox", "sh", "-c")

 	pingCmd := "ping -c 1 %s -W 1"

 	args = append(args, fmt.Sprintf(pingCmd, "alias1"))

-	_, _, err := dockerCmdWithError(c, args...)

+	_, _, err := dockerCmdWithError(args...)

 	if expectFailure {

 		c.Assert(err, check.NotNil)

@@ -82,7 +82,7 @@ func (s *DockerSuite) TestDiffEnsureOnlyKmsgAndPtmx(c *check.C) {

 // https://github.com/docker/docker/pull/14381#discussion_r33859347

 func (s *DockerSuite) TestDiffEmptyArgClientError(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "diff", "")

+	out, _, err := dockerCmdWithError("diff", "")

 	c.Assert(err, check.NotNil)

 	c.Assert(strings.TrimSpace(out), check.Equals, "Container name cannot be empty")

 }

@@ -75,7 +75,7 @@ func (s *DockerSuite) TestEventsContainerFailStartDie(c *check.C) {

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

 	image := strings.Split(out, "\n")[0]

-	if _, _, err := dockerCmdWithError(c, "run", "--name", "testeventdie", image, "blerg"); err == nil {

+	if _, _, err := dockerCmdWithError("run", "--name", "testeventdie", image, "blerg"); err == nil {

 		c.Fatalf("Container run with command blerg should have failed, but it did not")

 	}

@@ -148,7 +148,7 @@ func (s *DockerSuite) TestExecPausedContainer(c *check.C) {

 	ContainerID := strings.TrimSpace(out)

 	dockerCmd(c, "pause", "testing")

-	out, _, err := dockerCmdWithError(c, "exec", "-i", "-t", ContainerID, "echo", "hello")

+	out, _, err := dockerCmdWithError("exec", "-i", "-t", ContainerID, "echo", "hello")

 	if err == nil {

 		c.Fatal("container should fail to exec new command if it is paused")

 	}

@@ -268,7 +268,7 @@ func (s *DockerSuite) TestExecCgroup(c *check.C) {

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

 		wg.Add(1)

 		go func() {

-			out, _, err := dockerCmdWithError(c, "exec", "testing", "cat", "/proc/self/cgroup")

+			out, _, err := dockerCmdWithError("exec", "testing", "cat", "/proc/self/cgroup")

 			if err != nil {

 				errChan <- err

 				return

@@ -66,7 +66,7 @@ func (s *DockerSuite) TestHistoryExistentImage(c *check.C) {

 }

 func (s *DockerSuite) TestHistoryNonExistentImage(c *check.C) {

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

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

 	if err == nil {

 		c.Fatal("history on a non-existent image should fail.")

 	}

@@ -54,7 +54,7 @@ func (s *DockerSuite) TestImagesOrderedByCreationDate(c *check.C) {

 }

 func (s *DockerSuite) TestImagesErrorWithInvalidFilterNameTest(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "images", "-f", "FOO=123")

+	out, _, err := dockerCmdWithError("images", "-f", "FOO=123")

 	if err == nil || !strings.Contains(out, "Invalid filter") {

 		c.Fatalf("error should occur when listing images with invalid filter name FOO, %s", out)

 	}

@@ -34,7 +34,7 @@ func (s *DockerSuite) TestImportDisplay(c *check.C) {

 }

 func (s *DockerSuite) TestImportBadURL(c *check.C) {

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

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

 	if err == nil {

 		c.Fatal("import was supposed to fail but didn't")

 	}

@@ -73,7 +73,7 @@ func (s *DockerSuite) TestImportFile(c *check.C) {

 }

 func (s *DockerSuite) TestImportFileNonExistentFile(c *check.C) {

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

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

 	if exitCode == 0 || err == nil {

 		c.Fatalf("import non-existing file must failed")

 	}

@@ -55,7 +55,7 @@ func (s *DockerSuite) TestInspectTypeFlagContainer(c *check.C) {

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

 	formatStr := fmt.Sprintf("--format='{{.State.Running}}'")

-	out, exitCode, err := dockerCmdWithError(c, "inspect", "--type=container", formatStr, "busybox")

+	out, exitCode, err := dockerCmdWithError("inspect", "--type=container", formatStr, "busybox")

 	if exitCode != 0 || err != nil {

 		c.Fatalf("failed to inspect container: %s, %v", out, err)

 	}

@@ -73,7 +73,7 @@ func (s *DockerSuite) TestInspectTypeFlagWithNoContainer(c *check.C) {

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

-	_, exitCode, err := dockerCmdWithError(c, "inspect", "--type=container", "busybox")

+	_, exitCode, err := dockerCmdWithError("inspect", "--type=container", "busybox")

 	if exitCode == 0 || err == nil {

 		c.Fatalf("docker inspect should have failed, as there is no container named busybox")

 	}

@@ -87,7 +87,7 @@ func (s *DockerSuite) TestInspectTypeFlagWithImage(c *check.C) {

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

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

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

 	if exitCode != 0 || err != nil {

 		c.Fatalf("failed to inspect image: %s, %v", out, err)

 	}

@@ -104,7 +104,7 @@ func (s *DockerSuite) TestInspectTypeFlagWithInvalidValue(c *check.C) {

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

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

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

 	if exitCode != 0 || err != nil {

 		if !strings.Contains(out, "not a valid value for --type") {

 			c.Fatalf("failed to inspect image: %s, %v", out, err)

@@ -124,7 +124,7 @@ func (s *DockerSuite) TestInspectImageFilterInt(c *check.C) {

 	//now see if the size turns out to be the same

 	formatStr := fmt.Sprintf("--format='{{eq .Size %d}}'", size)

-	out, exitCode, err := dockerCmdWithError(c, "inspect", formatStr, imageTest)

+	out, exitCode, err := dockerCmdWithError("inspect", formatStr, imageTest)

 	if exitCode != 0 || err != nil {

 		c.Fatalf("failed to inspect image: %s, %v", out, err)

 	}

@@ -25,7 +25,7 @@ func (s *DockerSuite) TestKillofStoppedContainer(c *check.C) {

 	dockerCmd(c, "stop", cleanedContainerID)

-	_, _, err := dockerCmdWithError(c, "kill", "-s", "30", cleanedContainerID)

+	_, _, err := dockerCmdWithError("kill", "-s", "30", cleanedContainerID)

 	c.Assert(err, check.Not(check.IsNil), check.Commentf("Container %s is not running", cleanedContainerID))

 }

@@ -61,7 +61,7 @@ func (s *DockerSuite) TestKillWithInvalidSignal(c *check.C) {

 	cid := strings.TrimSpace(out)

 	c.Assert(waitRun(cid), check.IsNil)

-	out, _, err := dockerCmdWithError(c, "kill", "-s", "0", cid)

+	out, _, err := dockerCmdWithError("kill", "-s", "0", cid)

 	c.Assert(err, check.NotNil)

 	if !strings.ContainsAny(out, "Invalid signal: 0") {

 		c.Fatal("Kill with an invalid signal didn't error out correctly")

@@ -76,7 +76,7 @@ func (s *DockerSuite) TestKillWithInvalidSignal(c *check.C) {

 	cid = strings.TrimSpace(out)

 	c.Assert(waitRun(cid), check.IsNil)

-	out, _, err = dockerCmdWithError(c, "kill", "-s", "SIG42", cid)

+	out, _, err = dockerCmdWithError("kill", "-s", "SIG42", cid)

 	c.Assert(err, check.NotNil)

 	if !strings.ContainsAny(out, "Invalid signal: SIG42") {

 		c.Fatal("Kill with an invalid signal error out correctly")

@@ -11,7 +11,7 @@ import (

 func (s *DockerSuite) TestLinksPingUnlinkedContainers(c *check.C) {

-	_, exitCode, err := dockerCmdWithError(c, "run", "--rm", "busybox", "sh", "-c", "ping -c 1 alias1 -W 1 && ping -c 1 alias2 -W 1")

+	_, exitCode, err := dockerCmdWithError("run", "--rm", "busybox", "sh", "-c", "ping -c 1 alias1 -W 1 && ping -c 1 alias2 -W 1")

 	if exitCode == 0 {

 		c.Fatal("run ping did not fail")

@@ -24,7 +24,7 @@ func (s *DockerSuite) TestLinksPingUnlinkedContainers(c *check.C) {

 // Test for appropriate error when calling --link with an invalid target container

 func (s *DockerSuite) TestLinksInvalidContainerTarget(c *check.C) {

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

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

 	if err == nil {

 		c.Fatal("an invalid container target should produce an error")

@@ -34,7 +34,7 @@ func (s *DockerSuite) TestLinksEtcHostsContentMatch(c *check.C) {

 func (s *DockerSuite) TestLinksNetworkHostContainer(c *check.C) {

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

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

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

 	if err == nil || !strings.Contains(out, "--net=host can't be used with links. This would result in undefined behavior") {

 		c.Fatalf("Running container linking to a container with --net host should have failed: %s", out)

 	}

@@ -25,7 +25,7 @@ func (s *DockerSuite) TestPortHostBinding(c *check.C) {

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

-	if _, _, err := dockerCmdWithError(c, "run", "--net=host", "busybox",

+	if _, _, err := dockerCmdWithError("run", "--net=host", "busybox",

 		"nc", "localhost", "9876"); err == nil {

 		c.Error("Port is still bound after the Container is removed")

 	}

@@ -49,7 +49,7 @@ func (s *DockerSuite) TestPortExposeHostBinding(c *check.C) {

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

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

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

 		"nc", "localhost", strings.TrimSpace(exposedPort)); err == nil {

 		c.Error("Port is still bound after the Container is removed")

 	}

@@ -337,7 +337,7 @@ func (s *DockerSuite) TestPsListContainersFilterExited(c *check.C) {

 		c.Fatal(err)

 	}

-	if out, _, err := dockerCmdWithError(c, "run", "--name", "nonzero1", "busybox", "false"); err == nil {

+	if out, _, err := dockerCmdWithError("run", "--name", "nonzero1", "busybox", "false"); err == nil {

 		c.Fatal("Should fail.", out, err)

 	}

@@ -346,7 +346,7 @@ func (s *DockerSuite) TestPsListContainersFilterExited(c *check.C) {

 		c.Fatal(err)

 	}

-	if out, _, err := dockerCmdWithError(c, "run", "--name", "nonzero2", "busybox", "false"); err == nil {

+	if out, _, err := dockerCmdWithError("run", "--name", "nonzero2", "busybox", "false"); err == nil {

 		c.Fatal("Should fail.", out, err)

 	}

 	secondNonZero, err := getIDByName("nonzero2")

@@ -34,7 +34,7 @@ func (s *DockerRegistrySuite) TestPullImageWithAliases(c *check.C) {

 	dockerCmd(c, "pull", repos[0])

 	dockerCmd(c, "inspect", repos[0])

 	for _, repo := range repos[1:] {

-		if _, _, err := dockerCmdWithError(c, "inspect", repo); err == nil {

+		if _, _, err := dockerCmdWithError("inspect", repo); err == nil {

 			c.Fatalf("Image %v shouldn't have been pulled down", repo)

 		}

 	}

@@ -51,7 +51,7 @@ func (s *DockerSuite) TestPullVerified(c *check.C) {

 	// pull it

 	expected := "The image you are pulling has been verified"

-	if out, exitCode, err := dockerCmdWithError(c, "pull", verifiedName); err != nil || !strings.Contains(out, expected) {

+	if out, exitCode, err := dockerCmdWithError("pull", verifiedName); err != nil || !strings.Contains(out, expected) {

 		if err != nil || exitCode != 0 {

 			c.Skip(fmt.Sprintf("pulling the '%s' image from the registry has failed: %v", verifiedName, err))

 		}

@@ -59,7 +59,7 @@ func (s *DockerSuite) TestPullVerified(c *check.C) {

 	}

 	// pull it again

-	if out, exitCode, err := dockerCmdWithError(c, "pull", verifiedName); err != nil || strings.Contains(out, expected) {

+	if out, exitCode, err := dockerCmdWithError("pull", verifiedName); err != nil || strings.Contains(out, expected) {

 		if err != nil || exitCode != 0 {

 			c.Skip(fmt.Sprintf("pulling the '%s' image from the registry has failed: %v", verifiedName, err))

 		}

@@ -80,7 +80,7 @@ func (s *DockerSuite) TestPullNonExistingImage(c *check.C) {

 	testRequires(c, Network)

 	name := "sadfsadfasdf"

-	out, _, err := dockerCmdWithError(c, "pull", name)

+	out, _, err := dockerCmdWithError("pull", name)

 	if err == nil || !strings.Contains(out, fmt.Sprintf("Error: image library/%s:latest not found", name)) {

 		c.Fatalf("expected non-zero exit status when pulling non-existing image: %s", out)

@@ -98,7 +98,7 @@ func (s *DockerSuite) TestPullImageOfficialNames(c *check.C) {

 		"index.docker.io/library/hello-world",

 	}

 	for _, name := range names {

-		out, exitCode, err := dockerCmdWithError(c, "pull", name)

+		out, exitCode, err := dockerCmdWithError("pull", name)

 		if err != nil || exitCode != 0 {

 			c.Errorf("pulling the '%s' image from the registry has failed: %s", name, err)

 			continue

@@ -115,7 +115,7 @@ func (s *DockerSuite) TestPullImageOfficialNames(c *check.C) {

 func (s *DockerSuite) TestPullScratchNotAllowed(c *check.C) {

 	testRequires(c, Network)

-	out, exitCode, err := dockerCmdWithError(c, "pull", "scratch")

+	out, exitCode, err := dockerCmdWithError("pull", "scratch")

 	if err == nil {

 		c.Fatal("expected pull of scratch to fail, but it didn't")

 	}

@@ -23,7 +23,7 @@ func (s *DockerRegistrySuite) TestPushBusyboxImage(c *check.C) {

 // pushing an image without a prefix should throw an error

 func (s *DockerSuite) TestPushUnprefixedRepo(c *check.C) {

-	if out, _, err := dockerCmdWithError(c, "push", "busybox"); err == nil {

+	if out, _, err := dockerCmdWithError("push", "busybox"); err == nil {

 		c.Fatalf("pushing an unprefixed repo didn't result in a non-zero exit status: %s", out)

 	}

 }

@@ -32,7 +32,7 @@ func (s *DockerRegistrySuite) TestPushUntagged(c *check.C) {

 	repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)

 	expected := "Repository does not exist"

-	if out, _, err := dockerCmdWithError(c, "push", repoName); err == nil {

+	if out, _, err := dockerCmdWithError("push", repoName); err == nil {

 		c.Fatalf("pushing the image to the private registry should have failed: output %q", out)

 	} else if !strings.Contains(out, expected) {

 		c.Fatalf("pushing the image failed with an unexpected message: expected %q, got %q", expected, out)

@@ -44,7 +44,7 @@ func (s *DockerRegistrySuite) TestPushBadTag(c *check.C) {

 	expected := "does not exist"

-	if out, _, err := dockerCmdWithError(c, "push", repoName); err == nil {

+	if out, _, err := dockerCmdWithError("push", repoName); err == nil {

 		c.Fatalf("pushing the image to the private registry should have failed: output %q", out)

 	} else if !strings.Contains(out, expected) {

 		c.Fatalf("pushing the image failed with an unexpected message: expected %q, got %q", expected, out)

@@ -103,7 +103,7 @@ func (s *DockerRegistrySuite) TestPushInterrupt(c *check.C) {

 	if err := pushCmd.Process.Kill(); err != nil {

 		c.Fatalf("Failed to kill push process: %v", err)

 	}

-	if out, _, err := dockerCmdWithError(c, "push", repoName); err == nil {

+	if out, _, err := dockerCmdWithError("push", repoName); err == nil {

 		if !strings.Contains(out, "already in progress") {

 			c.Fatalf("Push should be continued on daemon side, but seems ok: %v, %s", err, out)

 		}

@@ -139,7 +139,7 @@ func (s *DockerRegistrySuite) TestPushEmptyLayer(c *check.C) {

 	}

 	// Now verify we can push it

-	if out, _, err := dockerCmdWithError(c, "push", repoName); err != nil {

+	if out, _, err := dockerCmdWithError("push", repoName); err != nil {

 		c.Fatalf("pushing the image to the private registry has failed: %s, %v", out, err)

 	}

 }

@@ -66,11 +66,11 @@ func (s *DockerSuite) TestRenameCheckNames(c *check.C) {

 func (s *DockerSuite) TestRenameInvalidName(c *check.C) {

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

-	if out, _, err := dockerCmdWithError(c, "rename", "myname", "new:invalid"); err == nil || !strings.Contains(out, "Invalid container name") {

+	if out, _, err := dockerCmdWithError("rename", "myname", "new:invalid"); err == nil || !strings.Contains(out, "Invalid container name") {

 		c.Fatalf("Renaming container to invalid name should have failed: %s\n%v", out, err)

 	}

-	if out, _, err := dockerCmdWithError(c, "ps", "-a"); err != nil || !strings.Contains(out, "myname") {

+	if out, _, err := dockerCmdWithError("ps", "-a"); err != nil || !strings.Contains(out, "myname") {

 		c.Fatalf("Output of docker ps should have included 'myname': %s\n%v", out, err)

 	}

 }

@@ -28,7 +28,7 @@ func (s *DockerSuite) TestRmContainerWithVolume(c *check.C) {

 func (s *DockerSuite) TestRmRunningContainer(c *check.C) {

 	createRunningContainer(c, "foo")

-	if _, _, err := dockerCmdWithError(c, "rm", "foo"); err == nil {

+	if _, _, err := dockerCmdWithError("rm", "foo"); err == nil {

 		c.Fatalf("Expected error, can't rm a running container")

 	}

 }

@@ -55,7 +55,7 @@ func (s *DockerSuite) TestRmContainerOrphaning(c *check.C) {

 		c.Fatalf("Could not build image %s: %v", img, err)

 	}

 	// run container on first image

-	if out, _, err := dockerCmdWithError(c, "run", img); err != nil {

+	if out, _, err := dockerCmdWithError("run", img); err != nil {

 		c.Fatalf("Could not run image %s: %v: %s", img, err, out)

 	}

@@ -64,12 +64,12 @@ func (s *DockerSuite) TestRmContainerOrphaning(c *check.C) {

 		c.Fatalf("Could not rebuild image %s: %v", img, err)

 	}

 	// try to remove the image, should error out.

-	if out, _, err := dockerCmdWithError(c, "rmi", img); err == nil {

+	if out, _, err := dockerCmdWithError("rmi", img); err == nil {

 		c.Fatalf("Expected to error out removing the image, but succeeded: %s", out)

 	}

 	// check if we deleted the first image

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

+	out, _, err := dockerCmdWithError("images", "-q", "--no-trunc")

 	if err != nil {

 		c.Fatalf("%v: %s", err, out)

 	}

@@ -79,7 +79,7 @@ func (s *DockerSuite) TestRmContainerOrphaning(c *check.C) {

 }

 func (s *DockerSuite) TestRmInvalidContainer(c *check.C) {

-	if out, _, err := dockerCmdWithError(c, "rm", "unknown"); err == nil {

+	if out, _, err := dockerCmdWithError("rm", "unknown"); err == nil {

 		c.Fatal("Expected error on rm unknown container, got none")

 	} else if !strings.Contains(out, "failed to remove containers") {

 		c.Fatalf("Expected output to contain 'failed to remove containers', got %q", out)

@@ -12,7 +12,7 @@ func (s *DockerSuite) TestRmiWithContainerFails(c *check.C) {

 	errSubstr := "is using it"

 	// create a container

-	out, _, err := dockerCmdWithError(c, "run", "-d", "busybox", "true")

+	out, _, err := dockerCmdWithError("run", "-d", "busybox", "true")

 	if err != nil {

 		c.Fatalf("failed to create a container: %s, %v", out, err)

 	}

@@ -20,7 +20,7 @@ func (s *DockerSuite) TestRmiWithContainerFails(c *check.C) {

 	cleanedContainerID := strings.TrimSpace(out)

 	// try to delete the image

-	out, _, err = dockerCmdWithError(c, "rmi", "busybox")

+	out, _, err = dockerCmdWithError("rmi", "busybox")

 	if err == nil {

 		c.Fatalf("Container %q is using image, should not be able to rmi: %q", cleanedContainerID, out)

 	}

@@ -73,13 +73,13 @@ func (s *DockerSuite) TestRmiTag(c *check.C) {

 }

 func (s *DockerSuite) TestRmiImgIDMultipleTag(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir '/busybox-one'")

+	out, _, err := dockerCmdWithError("run", "-d", "busybox", "/bin/sh", "-c", "mkdir '/busybox-one'")

 	if err != nil {

 		c.Fatalf("failed to create a container:%s, %v", out, err)

 	}

 	containerID := strings.TrimSpace(out)

-	out, _, err = dockerCmdWithError(c, "commit", containerID, "busybox-one")

+	out, _, err = dockerCmdWithError("commit", containerID, "busybox-one")

 	if err != nil {

 		c.Fatalf("failed to commit a new busybox-one:%s, %v", out, err)

 	}

@@ -97,7 +97,7 @@ func (s *DockerSuite) TestRmiImgIDMultipleTag(c *check.C) {

 	c.Assert(err, check.IsNil)

 	// run a container with the image

-	out, _, err = dockerCmdWithError(c, "run", "-d", "busybox-one", "top")

+	out, _, err = dockerCmdWithError("run", "-d", "busybox-one", "top")

 	if err != nil {

 		c.Fatalf("failed to create a container:%s, %v", out, err)

 	}

@@ -105,7 +105,7 @@ func (s *DockerSuite) TestRmiImgIDMultipleTag(c *check.C) {

 	containerID = strings.TrimSpace(out)

 	// first checkout without force it fails

-	out, _, err = dockerCmdWithError(c, "rmi", imgID)

+	out, _, err = dockerCmdWithError("rmi", imgID)

 	expected := fmt.Sprintf("Conflict, cannot delete %s because the running container %s is using it, stop it and use -f to force", imgID[:12], containerID[:12])

 	if err == nil || !strings.Contains(out, expected) {

 		c.Fatalf("rmi tagged in multiple repos should have failed without force: %s, %v, expected: %s", out, err, expected)

@@ -121,13 +121,13 @@ func (s *DockerSuite) TestRmiImgIDMultipleTag(c *check.C) {

 }

 func (s *DockerSuite) TestRmiImgIDForce(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "-d", "busybox", "/bin/sh", "-c", "mkdir '/busybox-test'")

+	out, _, err := dockerCmdWithError("run", "-d", "busybox", "/bin/sh", "-c", "mkdir '/busybox-test'")

 	if err != nil {

 		c.Fatalf("failed to create a container:%s, %v", out, err)

 	}

 	containerID := strings.TrimSpace(out)

-	out, _, err = dockerCmdWithError(c, "commit", containerID, "busybox-test")

+	out, _, err = dockerCmdWithError("commit", containerID, "busybox-test")

 	if err != nil {

 		c.Fatalf("failed to commit a new busybox-test:%s, %v", out, err)

 	}

@@ -147,7 +147,7 @@ func (s *DockerSuite) TestRmiImgIDForce(c *check.C) {

 	c.Assert(err, check.IsNil)

 	// first checkout without force it fails

-	out, _, err = dockerCmdWithError(c, "rmi", imgID)

+	out, _, err = dockerCmdWithError("rmi", imgID)

 	if err == nil || !strings.Contains(out, fmt.Sprintf("Conflict, cannot delete image %s because it is tagged in multiple repositories, use -f to force", imgID)) {

 		c.Fatalf("rmi tagged in multiple repos should have failed without force:%s, %v", out, err)

 	}

@@ -171,7 +171,7 @@ func (s *DockerSuite) TestRmiImageIDForceWithRunningContainersAndMultipleTags(c

 	dockerCmd(c, "tag", imgID, newTag)

 	dockerCmd(c, "run", "-d", imgID, "top")

-	out, _, err := dockerCmdWithError(c, "rmi", "-f", imgID)

+	out, _, err := dockerCmdWithError("rmi", "-f", imgID)

 	if err == nil || !strings.Contains(out, "stop it and retry") {

 		c.Log(out)

 		c.Fatalf("rmi -f should not delete image with running containers")

@@ -182,13 +182,13 @@ func (s *DockerSuite) TestRmiTagWithExistingContainers(c *check.C) {

 	container := "test-delete-tag"

 	newtag := "busybox:newtag"

 	bb := "busybox:latest"

-	if out, _, err := dockerCmdWithError(c, "tag", bb, newtag); err != nil {

+	if out, _, err := dockerCmdWithError("tag", bb, newtag); err != nil {

 		c.Fatalf("Could not tag busybox: %v: %s", err, out)

 	}

-	if out, _, err := dockerCmdWithError(c, "run", "--name", container, bb, "/bin/true"); err != nil {

+	if out, _, err := dockerCmdWithError("run", "--name", container, bb, "/bin/true"); err != nil {

 		c.Fatalf("Could not run busybox: %v: %s", err, out)

 	}

-	out, _, err := dockerCmdWithError(c, "rmi", newtag)

+	out, _, err := dockerCmdWithError("rmi", newtag)

 	if err != nil {

 		c.Fatalf("Could not remove tag %s: %v: %s", newtag, err, out)

 	}

@@ -208,11 +208,11 @@ MAINTAINER foo`)

 		c.Fatalf("Could not build %s: %s, %v", image, out, err)

 	}

-	if out, _, err := dockerCmdWithError(c, "run", "--name", "test-force-rmi", image, "/bin/true"); err != nil {

+	if out, _, err := dockerCmdWithError("run", "--name", "test-force-rmi", image, "/bin/true"); err != nil {

 		c.Fatalf("Could not run container: %s, %v", out, err)

 	}

-	if out, _, err := dockerCmdWithError(c, "rmi", "-f", image); err != nil {

+	if out, _, err := dockerCmdWithError("rmi", "-f", image); err != nil {

 		c.Fatalf("Could not remove image %s:  %s, %v", image, out, err)

 	}

 }

@@ -221,22 +221,22 @@ func (s *DockerSuite) TestRmiWithMultipleRepositories(c *check.C) {

 	newRepo := "127.0.0.1:5000/busybox"

 	oldRepo := "busybox"

 	newTag := "busybox:test"

-	out, _, err := dockerCmdWithError(c, "tag", oldRepo, newRepo)

+	out, _, err := dockerCmdWithError("tag", oldRepo, newRepo)

 	if err != nil {

 		c.Fatalf("Could not tag busybox: %v: %s", err, out)

 	}

-	out, _, err = dockerCmdWithError(c, "run", "--name", "test", oldRepo, "touch", "/home/abcd")

+	out, _, err = dockerCmdWithError("run", "--name", "test", oldRepo, "touch", "/home/abcd")

 	if err != nil {

 		c.Fatalf("failed to run container: %v, output: %s", err, out)

 	}

-	out, _, err = dockerCmdWithError(c, "commit", "test", newTag)

+	out, _, err = dockerCmdWithError("commit", "test", newTag)

 	if err != nil {

 		c.Fatalf("failed to commit container: %v, output: %s", err, out)

 	}

-	out, _, err = dockerCmdWithError(c, "rmi", newTag)

+	out, _, err = dockerCmdWithError("rmi", newTag)

 	if err != nil {

 		c.Fatalf("failed to remove image: %v, output: %s", err, out)

 	}

@@ -247,7 +247,7 @@ func (s *DockerSuite) TestRmiWithMultipleRepositories(c *check.C) {

 func (s *DockerSuite) TestRmiBlank(c *check.C) {

 	// try to delete a blank image name

-	out, _, err := dockerCmdWithError(c, "rmi", "")

+	out, _, err := dockerCmdWithError("rmi", "")

 	if err == nil {

 		c.Fatal("Should have failed to delete '' image")

 	}

@@ -258,7 +258,7 @@ func (s *DockerSuite) TestRmiBlank(c *check.C) {

 		c.Fatalf("Expected error message not generated: %s", out)

 	}

-	out, _, err = dockerCmdWithError(c, "rmi", " ")

+	out, _, err = dockerCmdWithError("rmi", " ")

 	if err == nil {

 		c.Fatal("Should have failed to delete '' image")

 	}

@@ -286,7 +286,7 @@ func (s *DockerSuite) TestRmiContainerImageNotFound(c *check.C) {

 	dockerCmd(c, "rmi", "-f", imageIds[1])

 	// Try to remove the image of the running container and see if it fails as expected.

-	out, _, err := dockerCmdWithError(c, "rmi", "-f", imageIds[0])

+	out, _, err := dockerCmdWithError("rmi", "-f", imageIds[0])

 	if err == nil || !strings.Contains(out, "is using it") {

 		c.Log(out)

 		c.Fatal("The image of the running container should not be removed.")

@@ -52,7 +52,7 @@ func (s *DockerSuite) TestRunWithSwappiness(c *check.C) {

 }

 func (s *DockerSuite) TestRunWithSwappinessInvalid(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "--memory-swappiness", "101", "busybox", "true")

+	out, _, err := dockerCmdWithError("run", "--memory-swappiness", "101", "busybox", "true")

 	if err == nil {

 		c.Fatalf("failed. test was able to set invalid value, output: %q", out)

 	}

@@ -108,7 +108,7 @@ func (s *DockerSuite) TestRunExitCodeZero(c *check.C) {

 // the exit code should be 1

 // some versions of lxc might make this test fail

 func (s *DockerSuite) TestRunExitCodeOne(c *check.C) {

-	_, exitCode, err := dockerCmdWithError(c, "run", "busybox", "false")

+	_, exitCode, err := dockerCmdWithError("run", "busybox", "false")

 	if err != nil && !strings.Contains("exit status 1", fmt.Sprintf("%s", err)) {

 		c.Fatal(err)

 	}

@@ -173,7 +173,7 @@ func (s *DockerSuite) TestRunWorkingDirectory(c *check.C) {

 // pinging Google's DNS resolver should fail when we disable the networking

 func (s *DockerSuite) TestRunWithoutNetworking(c *check.C) {

-	out, exitCode, err := dockerCmdWithError(c, "run", "--net=none", "busybox", "ping", "-c", "1", "8.8.8.8")

+	out, exitCode, err := dockerCmdWithError("run", "--net=none", "busybox", "ping", "-c", "1", "8.8.8.8")

 	if err != nil && exitCode != 1 {

 		c.Fatal(out, err)

 	}

@@ -181,7 +181,7 @@ func (s *DockerSuite) TestRunWithoutNetworking(c *check.C) {

 		c.Errorf("--net=none should've disabled the network; the container shouldn't have been able to ping 8.8.8.8")

 	}

-	out, exitCode, err = dockerCmdWithError(c, "run", "-n=false", "busybox", "ping", "-c", "1", "8.8.8.8")

+	out, exitCode, err = dockerCmdWithError("run", "-n=false", "busybox", "ping", "-c", "1", "8.8.8.8")

 	if err != nil && exitCode != 1 {

 		c.Fatal(out, err)

 	}

@@ -219,7 +219,7 @@ func (s *DockerSuite) TestRunLinksContainerWithContainerId(c *check.C) {

 // Issue 9677.

 func (s *DockerSuite) TestRunWithDaemonFlags(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "--selinux-enabled", "run", "-i", "-t", "busybox", "true")

+	out, _, err := dockerCmdWithError("--selinux-enabled", "run", "-i", "-t", "busybox", "true")

 	if err != nil {

 		if !strings.Contains(out, "must follow the 'docker daemon' command") && // daemon

 			!strings.Contains(out, "flag provided but not defined: --selinux-enabled") { // no daemon (client-only)

@@ -269,7 +269,7 @@ func (s *DockerSuite) TestRunCreateVolumesInSymlinkDir(c *check.C) {

 }

 func (s *DockerSuite) TestRunVolumesMountedAsReadonly(c *check.C) {

-	if _, code, err := dockerCmdWithError(c, "run", "-v", "/test:/test:ro", "busybox", "touch", "/test/somefile"); err == nil || code == 0 {

+	if _, code, err := dockerCmdWithError("run", "-v", "/test:/test:ro", "busybox", "touch", "/test/somefile"); err == nil || code == 0 {

 		c.Fatalf("run should fail because volume is ro: exit code %d", code)

 	}

 }

@@ -277,7 +277,7 @@ func (s *DockerSuite) TestRunVolumesMountedAsReadonly(c *check.C) {

 func (s *DockerSuite) TestRunVolumesFromInReadonlyMode(c *check.C) {

 	dockerCmd(c, "run", "--name", "parent", "-v", "/test", "busybox", "true")

-	if _, code, err := dockerCmdWithError(c, "run", "--volumes-from", "parent:ro", "busybox", "touch", "/test/file"); err == nil || code == 0 {

+	if _, code, err := dockerCmdWithError("run", "--volumes-from", "parent:ro", "busybox", "touch", "/test/file"); err == nil || code == 0 {

 		c.Fatalf("run should fail because volume is ro: exit code %d", code)

 	}

 }

@@ -287,7 +287,7 @@ func (s *DockerSuite) TestRunVolumesFromInReadWriteMode(c *check.C) {

 	dockerCmd(c, "run", "--name", "parent", "-v", "/test", "busybox", "true")

 	dockerCmd(c, "run", "--volumes-from", "parent:rw", "busybox", "touch", "/test/file")

-	if out, _, err := dockerCmdWithError(c, "run", "--volumes-from", "parent:bar", "busybox", "touch", "/test/file"); err == nil || !strings.Contains(out, "invalid mode for volumes-from: bar") {

+	if out, _, err := dockerCmdWithError("run", "--volumes-from", "parent:bar", "busybox", "touch", "/test/file"); err == nil || !strings.Contains(out, "invalid mode for volumes-from: bar") {

 		c.Fatalf("running --volumes-from foo:bar should have failed with invalid mount mode: %q", out)

 	}

@@ -298,14 +298,14 @@ func (s *DockerSuite) TestVolumesFromGetsProperMode(c *check.C) {

 	dockerCmd(c, "run", "--name", "parent", "-v", "/test:/test:ro", "busybox", "true")

 	// Expect this "rw" mode to be be ignored since the inherited volume is "ro"

-	if _, _, err := dockerCmdWithError(c, "run", "--volumes-from", "parent:rw", "busybox", "touch", "/test/file"); err == nil {

+	if _, _, err := dockerCmdWithError("run", "--volumes-from", "parent:rw", "busybox", "touch", "/test/file"); err == nil {

 		c.Fatal("Expected volumes-from to inherit read-only volume even when passing in `rw`")

 	}

 	dockerCmd(c, "run", "--name", "parent2", "-v", "/test:/test:ro", "busybox", "true")

 	// Expect this to be read-only since both are "ro"

-	if _, _, err := dockerCmdWithError(c, "run", "--volumes-from", "parent2:ro", "busybox", "touch", "/test/file"); err == nil {

+	if _, _, err := dockerCmdWithError("run", "--volumes-from", "parent2:ro", "busybox", "touch", "/test/file"); err == nil {

 		c.Fatal("Expected volumes-from to inherit read-only volume even when passing in `ro`")

 	}

 }

@@ -315,7 +315,7 @@ func (s *DockerSuite) TestRunNoDupVolumes(c *check.C) {

 	mountstr1 := randomUnixTmpDirPath("test1") + ":/someplace"

 	mountstr2 := randomUnixTmpDirPath("test2") + ":/someplace"

-	if out, _, err := dockerCmdWithError(c, "run", "-v", mountstr1, "-v", mountstr2, "busybox", "true"); err == nil {

+	if out, _, err := dockerCmdWithError("run", "-v", mountstr1, "-v", mountstr2, "busybox", "true"); err == nil {

 		c.Fatal("Expected error about duplicate volume definitions")

 	} else {

 		if !strings.Contains(out, "Duplicate bind mount") {

@@ -338,7 +338,7 @@ func (s *DockerSuite) TestRunMultipleVolumesFrom(c *check.C) {

 // this tests verifies the ID format for the container

 func (s *DockerSuite) TestRunVerifyContainerID(c *check.C) {

-	out, exit, err := dockerCmdWithError(c, "run", "-d", "busybox", "true")

+	out, exit, err := dockerCmdWithError("run", "-d", "busybox", "true")

 	if err != nil {

 		c.Fatal(err)

 	}

@@ -374,7 +374,7 @@ func (s *DockerSuite) TestRunCreateVolumeWithSymlink(c *check.C) {

 		c.Fatalf("could not build '%s': %v", image, err)

 	}

-	_, exitCode, err := dockerCmdWithError(c, "run", "-v", "/bar/foo", "--name", "test-createvolumewithsymlink", image, "sh", "-c", "mount | grep -q /home/foo")

+	_, exitCode, err := dockerCmdWithError("run", "-v", "/bar/foo", "--name", "test-createvolumewithsymlink", image, "sh", "-c", "mount | grep -q /home/foo")

 	if err != nil || exitCode != 0 {

 		c.Fatalf("[run] err: %v, exitcode: %d", err, exitCode)

 	}

@@ -384,7 +384,7 @@ func (s *DockerSuite) TestRunCreateVolumeWithSymlink(c *check.C) {

 		c.Fatalf("[inspect] err: %v", err)

 	}

-	_, exitCode, err = dockerCmdWithError(c, "rm", "-v", "test-createvolumewithsymlink")

+	_, exitCode, err = dockerCmdWithError("rm", "-v", "test-createvolumewithsymlink")

 	if err != nil || exitCode != 0 {

 		c.Fatalf("[rm] err: %v, exitcode: %d", err, exitCode)

 	}

@@ -409,19 +409,19 @@ func (s *DockerSuite) TestRunVolumesFromSymlinkPath(c *check.C) {

 		c.Fatalf("could not build 'docker-test-volumesfromsymlinkpath': %v", err)

 	}

-	_, exitCode, err := dockerCmdWithError(c, "run", "--name", "test-volumesfromsymlinkpath", name)

+	_, exitCode, err := dockerCmdWithError("run", "--name", "test-volumesfromsymlinkpath", name)

 	if err != nil || exitCode != 0 {

 		c.Fatalf("[run] (volume) err: %v, exitcode: %d", err, exitCode)

 	}

-	_, exitCode, err = dockerCmdWithError(c, "run", "--volumes-from", "test-volumesfromsymlinkpath", "busybox", "sh", "-c", "ls /foo | grep -q bar")

+	_, exitCode, err = dockerCmdWithError("run", "--volumes-from", "test-volumesfromsymlinkpath", "busybox", "sh", "-c", "ls /foo | grep -q bar")

 	if err != nil || exitCode != 0 {

 		c.Fatalf("[run] err: %v, exitcode: %d", err, exitCode)

 	}

 }

 func (s *DockerSuite) TestRunExitCode(c *check.C) {

-	_, exit, err := dockerCmdWithError(c, "run", "busybox", "/bin/sh", "-c", "exit 72")

+	_, exit, err := dockerCmdWithError("run", "busybox", "/bin/sh", "-c", "exit 72")

 	if err == nil {

 		c.Fatal("should not have a non nil error")

 	}

@@ -452,7 +452,7 @@ func (s *DockerSuite) TestRunUserByID(c *check.C) {

 }

 func (s *DockerSuite) TestRunUserByIDBig(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "-u", "2147483648", "busybox", "id")

+	out, _, err := dockerCmdWithError("run", "-u", "2147483648", "busybox", "id")

 	if err == nil {

 		c.Fatal("No error, but must be.", out)

 	}

@@ -462,7 +462,7 @@ func (s *DockerSuite) TestRunUserByIDBig(c *check.C) {

 }

 func (s *DockerSuite) TestRunUserByIDNegative(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "-u", "-1", "busybox", "id")

+	out, _, err := dockerCmdWithError("run", "-u", "-1", "busybox", "id")

 	if err == nil {

 		c.Fatal("No error, but must be.", out)

 	}

@@ -472,7 +472,7 @@ func (s *DockerSuite) TestRunUserByIDNegative(c *check.C) {

 }

 func (s *DockerSuite) TestRunUserByIDZero(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "-u", "0", "busybox", "id")

+	out, _, err := dockerCmdWithError("run", "-u", "0", "busybox", "id")

 	if err != nil {

 		c.Fatal(err, out)

 	}

@@ -482,7 +482,7 @@ func (s *DockerSuite) TestRunUserByIDZero(c *check.C) {

 }

 func (s *DockerSuite) TestRunUserNotFound(c *check.C) {

-	_, _, err := dockerCmdWithError(c, "run", "-u", "notme", "busybox", "id")

+	_, _, err := dockerCmdWithError("run", "-u", "notme", "busybox", "id")

 	if err == nil {

 		c.Fatal("unknown user should cause container to fail")

 	}

@@ -496,7 +496,7 @@ func (s *DockerSuite) TestRunTwoConcurrentContainers(c *check.C) {

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

 		go func() {

 			defer group.Done()

-			_, _, err := dockerCmdWithError(c, "run", "busybox", "sleep", "2")

+			_, _, err := dockerCmdWithError("run", "busybox", "sleep", "2")

 			errChan <- err

 		}()

 	}

@@ -632,7 +632,7 @@ func (s *DockerSuite) TestRunContainerNetwork(c *check.C) {

 func (s *DockerSuite) TestRunNetHostNotAllowedWithLinks(c *check.C) {

 	dockerCmd(c, "run", "--name", "linked", "busybox", "true")

-	_, _, err := dockerCmdWithError(c, "run", "--net=host", "--link", "linked:linked", "busybox", "true")

+	_, _, err := dockerCmdWithError("run", "--net=host", "--link", "linked:linked", "busybox", "true")

 	if err == nil {

 		c.Fatal("Expected error")

 	}

@@ -665,14 +665,14 @@ func (s *DockerSuite) TestRunUnprivilegedCanMknod(c *check.C) {

 }

 func (s *DockerSuite) TestRunCapDropInvalid(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "--cap-drop=CHPASS", "busybox", "ls")

+	out, _, err := dockerCmdWithError("run", "--cap-drop=CHPASS", "busybox", "ls")

 	if err == nil {

 		c.Fatal(err, out)

 	}

 }

 func (s *DockerSuite) TestRunCapDropCannotMknod(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "--cap-drop=MKNOD", "busybox", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok")

+	out, _, err := dockerCmdWithError("run", "--cap-drop=MKNOD", "busybox", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok")

 	if err == nil {

 		c.Fatal(err, out)

@@ -683,7 +683,7 @@ func (s *DockerSuite) TestRunCapDropCannotMknod(c *check.C) {

 }

 func (s *DockerSuite) TestRunCapDropCannotMknodLowerCase(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "--cap-drop=mknod", "busybox", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok")

+	out, _, err := dockerCmdWithError("run", "--cap-drop=mknod", "busybox", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok")

 	if err == nil {

 		c.Fatal(err, out)

@@ -694,7 +694,7 @@ func (s *DockerSuite) TestRunCapDropCannotMknodLowerCase(c *check.C) {

 }

 func (s *DockerSuite) TestRunCapDropALLCannotMknod(c *check.C) {

-	out, _, err := dockerCmdWithError(c, "run", "--cap-drop=ALL", "--cap-add=SETGID", "busybox", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok")

+	out, _, err := dockerCmdWithError("run", "--cap-drop=ALL", "--cap-add=SETGID", "busybox", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok")

 	if err == nil {

 		c.Fatal(err, out)

 	}

@@ -712,7 +712,7 @@ func (s *DockerSuite) TestRunCapDropALLAddMknodCanMknod(c *check.C) {