@@ -1276,13 +1276,12 @@ func pingContainers(c *check.C, d *Daemon, expectFailure bool) {

 	}

 	args := append(dargs, "run", "-d", "--name", "container1", "busybox", "top")

-	_, err := runCommand(exec.Command(dockerBinary, args...))

-	c.Assert(err, check.IsNil)

+	dockerCmd(c, args...)

 	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 = runCommand(exec.Command(dockerBinary, args...))

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

 	if expectFailure {

 		c.Assert(err, check.NotNil)

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

 	}

 	args = append(dargs, "rm", "-f", "container1")

-	runCommand(exec.Command(dockerBinary, args...))

+	dockerCmd(c, args...)

 }

 func (s *DockerDaemonSuite) TestDaemonRestartWithSocketAsVolume(c *check.C) {

@@ -1,7 +1,6 @@

 package main

 import (

-	"os/exec"

 	"strings"

 	"github.com/go-check/check"

@@ -10,19 +9,10 @@ import (

 // ensure that an added file shows up in docker diff

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

 	containerCmd := `echo foo > /root/bar`

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "sh", "-c", containerCmd)

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

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

-	}

+	out, _ := dockerCmd(c, "run", "-d", "busybox", "sh", "-c", containerCmd)

 	cleanCID := strings.TrimSpace(out)

-

-	diffCmd := exec.Command(dockerBinary, "diff", cleanCID)

-	out, _, err = runCommandWithOutput(diffCmd)

-	if err != nil {

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

-	}

+	out, _ = dockerCmd(c, "diff", cleanCID)

 	found := false

 	for _, line := range strings.Split(out, "\n") {

@@ -45,20 +35,10 @@ func (s *DockerSuite) TestDiffEnsureDockerinitFilesAreIgnored(c *check.C) {

 	// we might not run into this problem from the first run, so start a few containers

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

 		containerCmd := `echo foo > /root/bar`

-		runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "sh", "-c", containerCmd)

-		out, _, err := runCommandWithOutput(runCmd)

-

-		if err != nil {

-			c.Fatal(out, err)

-		}

+		out, _ := dockerCmd(c, "run", "-d", "busybox", "sh", "-c", containerCmd)

 		cleanCID := strings.TrimSpace(out)

-

-		diffCmd := exec.Command(dockerBinary, "diff", cleanCID)

-		out, _, err = runCommandWithOutput(diffCmd)

-		if err != nil {

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

-		}

+		out, _ = dockerCmd(c, "diff", cleanCID)

 		for _, filename := range dockerinitFiles {

 			if strings.Contains(out, filename) {

@@ -69,19 +49,10 @@ func (s *DockerSuite) TestDiffEnsureDockerinitFilesAreIgnored(c *check.C) {

 }

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

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "sleep", "0")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

+	out, _ := dockerCmd(c, "run", "-d", "busybox", "sleep", "0")

 	cleanCID := strings.TrimSpace(out)

-

-	diffCmd := exec.Command(dockerBinary, "diff", cleanCID)

-	out, _, err = runCommandWithOutput(diffCmd)

-	if err != nil {

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

-	}

+	out, _ = dockerCmd(c, "diff", cleanCID)

 	expected := map[string]bool{

 		"C /dev":         true,

@@ -111,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 := runCommandWithOutput(exec.Command(dockerBinary, "diff", ""))

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

 	c.Assert(err, check.NotNil)

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

 }

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

 	// --since=$start must contain only the 'untag' event

 	for _, f := range []func(time.Time) string{unixTs, rfc3339, duration} {

 		since, until := f(start), f(end)

-		cmd := exec.Command(dockerBinary, "events", "--since="+since, "--until="+until)

-		out, _, err := runCommandWithOutput(cmd)

-		if err != nil {

-			c.Fatalf("docker events cmd failed: %v\nout=%s", err, out)

-		}

+		out, _ := dockerCmd(c, "events", "--since="+since, "--until="+until)

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

 		if len(events) != 2 {

 			c.Fatalf("unexpected events, was expecting only 2 events tag/untag (since=%s, until=%s) out=%s", since, until, out)

@@ -77,12 +73,11 @@ func (s *DockerSuite) TestEventsContainerFailStartDie(c *check.C) {

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

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

-	if err := exec.Command(dockerBinary, "run", "--name", "testeventdie", image, "blerg").Run(); err == nil {

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

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

 	}

-	eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

-	out, _, _ = runCommandWithOutput(eventsCmd)

+	out, _ = dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

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

 	if len(events) <= 1 {

 		c.Fatalf("Missing expected event")

@@ -123,8 +118,7 @@ func (s *DockerSuite) TestEventsLimit(c *check.C) {

 		}

 	}

-	eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

-	out, _, _ := runCommandWithOutput(eventsCmd)

+	out, _ := dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

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

 	nEvents := len(events) - 1

 	if nEvents != 64 {

@@ -134,11 +128,7 @@ func (s *DockerSuite) TestEventsLimit(c *check.C) {

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

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

-	eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

-	out, exitCode, err := runCommandWithOutput(eventsCmd)

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

-		c.Fatalf("Failed to get events with exit code %d: %s", exitCode, err)

-	}

+	out, _ := dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

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

 	events = events[:len(events)-1]

 	if len(events) < 5 {

@@ -171,12 +161,8 @@ func (s *DockerSuite) TestEventsContainerEventsSinceUnixEpoch(c *check.C) {

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

 	timeBeginning := time.Unix(0, 0).Format(time.RFC3339Nano)

 	timeBeginning = strings.Replace(timeBeginning, "Z", ".000000000Z", -1)

-	eventsCmd := exec.Command(dockerBinary, "events", fmt.Sprintf("--since='%s'", timeBeginning),

+	out, _ := dockerCmd(c, "events", fmt.Sprintf("--since='%s'", timeBeginning),

 		fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

-	out, exitCode, err := runCommandWithOutput(eventsCmd)

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

-		c.Fatalf("Failed to get events with exit code %d: %s", exitCode, err)

-	}

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

 	events = events[:len(events)-1]

 	if len(events) < 5 {

@@ -217,11 +203,7 @@ func (s *DockerSuite) TestEventsImageUntagDelete(c *check.C) {

 	if err := deleteImages(name); err != nil {

 		c.Fatal(err)

 	}

-	eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

-	out, exitCode, err := runCommandWithOutput(eventsCmd)

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

-		c.Fatalf("Failed to get events with exit code %d: %s", exitCode, err)

-	}

+	out, _ := dockerCmd(c, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

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

 	events = events[:len(events)-1]

@@ -244,11 +226,9 @@ func (s *DockerSuite) TestEventsImageTag(c *check.C) {

 	image := "testimageevents:tag"

 	dockerCmd(c, "tag", "busybox", image)

-	eventsCmd := exec.Command(dockerBinary, "events",

+	out, _ := dockerCmd(c, "events",

 		fmt.Sprintf("--since=%d", since),

 		fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

-	out, _, err := runCommandWithOutput(eventsCmd)

-	c.Assert(err, check.IsNil)

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

 	if len(events) != 1 {

@@ -267,15 +247,11 @@ func (s *DockerSuite) TestEventsImagePull(c *check.C) {

 	since := daemonTime(c).Unix()

 	testRequires(c, Network)

-	pullCmd := exec.Command(dockerBinary, "pull", "hello-world")

-	if out, _, err := runCommandWithOutput(pullCmd); err != nil {

-		c.Fatalf("pulling the hello-world image from has failed: %s, %v", out, err)

-	}

+	dockerCmd(c, "pull", "hello-world")

-	eventsCmd := exec.Command(dockerBinary, "events",

+	out, _ := dockerCmd(c, "events",

 		fmt.Sprintf("--since=%d", since),

 		fmt.Sprintf("--until=%d", daemonTime(c).Unix()))

-	out, _, _ := runCommandWithOutput(eventsCmd)

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

 	event := strings.TrimSpace(events[len(events)-1])

@@ -313,11 +289,7 @@ func (s *DockerSuite) TestEventsImageImport(c *check.C) {

 		}

 	}()

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "true")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatal("failed to create a container", out, err)

-	}

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

 	cleanedContainerID := strings.TrimSpace(out)

 	out, _, err = runCommandPipelineWithOutput(

@@ -352,24 +324,12 @@ func (s *DockerSuite) TestEventsFilters(c *check.C) {

 	}

 	since := daemonTime(c).Unix()

-	out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "--rm", "busybox", "true"))

-	if err != nil {

-		c.Fatal(out, err)

-	}

-	out, _, err = runCommandWithOutput(exec.Command(dockerBinary, "run", "--rm", "busybox", "true"))

-	if err != nil {

-		c.Fatal(out, err)

-	}

-	out, _, err = runCommandWithOutput(exec.Command(dockerBinary, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", "event=die"))

-	if err != nil {

-		c.Fatalf("Failed to get events: %s", err)

-	}

+	dockerCmd(c, "run", "--rm", "busybox", "true")

+	dockerCmd(c, "run", "--rm", "busybox", "true")

+	out, _ := dockerCmd(c, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", "event=die")

 	parseEvents(out, "die")

-	out, _, err = runCommandWithOutput(exec.Command(dockerBinary, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", "event=die", "--filter", "event=start"))

-	if err != nil {

-		c.Fatalf("Failed to get events: %s", err)

-	}

+	out, _ = dockerCmd(c, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", "event=die", "--filter", "event=start")

 	parseEvents(out, "((die)|(start))")

 	// make sure we at least got 2 start events

@@ -383,24 +343,14 @@ func (s *DockerSuite) TestEventsFilters(c *check.C) {

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

 	since := daemonTime(c).Unix()

-	out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "--name", "container_1", "-d", "busybox:latest", "true"))

-	if err != nil {

-		c.Fatal(out, err)

-	}

+	out, _ := dockerCmd(c, "run", "--name", "container_1", "-d", "busybox:latest", "true")

 	container1 := strings.TrimSpace(out)

-	out, _, err = runCommandWithOutput(exec.Command(dockerBinary, "run", "--name", "container_2", "-d", "busybox", "true"))

-	if err != nil {

-		c.Fatal(out, err)

-	}

+	out, _ = dockerCmd(c, "run", "--name", "container_2", "-d", "busybox", "true")

 	container2 := strings.TrimSpace(out)

 	name := "busybox"

-	eventsCmd := exec.Command(dockerBinary, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", fmt.Sprintf("image=%s", name))

-	out, _, err = runCommandWithOutput(eventsCmd)

-	if err != nil {

-		c.Fatalf("Failed to get events, error: %s(%s)", err, out)

-	}

+	out, _ = dockerCmd(c, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", daemonTime(c).Unix()), "--filter", fmt.Sprintf("image=%s", name))

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

 	events = events[:len(events)-1]

 	if len(events) == 0 {

@@ -427,10 +377,7 @@ func (s *DockerSuite) TestEventsFilterContainer(c *check.C) {

 	nameID := make(map[string]string)

 	for _, name := range []string{"container_1", "container_2"} {

-		out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "--name", name, "busybox", "true"))

-		if err != nil {

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

-		}

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

 		id, err := inspectField(name, "Id")

 		if err != nil {

 			c.Fatal(err)

@@ -461,30 +408,19 @@ func (s *DockerSuite) TestEventsFilterContainer(c *check.C) {

 	for name, ID := range nameID {

 		// filter by names

-		eventsCmd := exec.Command(dockerBinary, "events", "--since", since, "--until", until, "--filter", "container="+name)

-		out, _, err := runCommandWithOutput(eventsCmd)

-		if err != nil {

-			c.Fatal(err)

-		}

-

+		out, _ := dockerCmd(c, "events", "--since", since, "--until", until, "--filter", "container="+name)

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

 		if err := checkEvents(ID, events); err != nil {

 			c.Fatal(err)

 		}

 		// filter by ID's

-		eventsCmd = exec.Command(dockerBinary, "events", "--since", since, "--until", until, "--filter", "container="+ID)

-		out, _, err = runCommandWithOutput(eventsCmd)

-		if err != nil {

-			c.Fatal(err)

-		}

-

+		out, _ = dockerCmd(c, "events", "--since", since, "--until", until, "--filter", "container="+ID)

 		events = strings.Split(strings.TrimSuffix(out, "\n"), "\n")

 		if err := checkEvents(ID, events); err != nil {

 			c.Fatal(err)

 		}

 	}

-

 }

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

@@ -529,11 +465,7 @@ func (s *DockerSuite) TestEventsStreaming(c *check.C) {

 		}

 	}()

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox:latest", "true")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

+	out, _ := dockerCmd(c, "run", "-d", "busybox:latest", "true")

 	cleanedContainerID := strings.TrimSpace(out)

 	id <- cleanedContainerID

@@ -558,11 +490,7 @@ func (s *DockerSuite) TestEventsStreaming(c *check.C) {

 		// ignore, done

 	}

-	rmCmd := exec.Command(dockerBinary, "rm", cleanedContainerID)

-	out, _, err = runCommandWithOutput(rmCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

+	dockerCmd(c, "rm", cleanedContainerID)

 	select {

 	case <-time.After(5 * time.Second):

@@ -575,32 +503,14 @@ func (s *DockerSuite) TestEventsStreaming(c *check.C) {

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

 	since := daemonTime(c).Unix()

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "top")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatalf("Couldn't run top: %s\n%q", out, err)

-	}

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

 	cID := strings.TrimSpace(out)

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

-	cmd := exec.Command(dockerBinary, "commit", "-m", "test", cID)

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't commit: %s\n%q", out, err)

-	}

-

-	cmd = exec.Command(dockerBinary, "stop", cID)

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't stop: %s\n%q", out, err)

-	}

-

-	cmd = exec.Command(dockerBinary, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since)))

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't get events: %s\n%q", out, err)

-	}

+	dockerCmd(c, "commit", "-m", "test", cID)

+	dockerCmd(c, "stop", cID)

+	out, _ = dockerCmd(c, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since)))

 	if !strings.Contains(out, " commit\n") {

 		c.Fatalf("Missing 'commit' log event\n%s", out)

 	}

@@ -616,24 +526,10 @@ func (s *DockerSuite) TestEventsCopy(c *check.C) {

 		c.Fatalf("Couldn't create image: %q", err)

 	}

-	runCmd := exec.Command(dockerBinary, "run", "--name=cptest", id, "true")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatalf("Couldn't run top: %s\n%q", out, err)

-	}

-

-	cmd := exec.Command(dockerBinary, "cp", "cptest:/tmp/file", "-")

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Failed getting file:%q\n%q", out, err)

-	}

-

-	cmd = exec.Command(dockerBinary, "events", "--since=0", "-f", "container=cptest", "--until="+strconv.Itoa(int(since)))

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't get events: %s\n%q", out, err)

-	}

+	dockerCmd(c, "run", "--name=cptest", id, "true")

+	dockerCmd(c, "cp", "cptest:/tmp/file", "-")

+	out, _ := dockerCmd(c, "events", "--since=0", "-f", "container=cptest", "--until="+strconv.Itoa(int(since)))

 	if !strings.Contains(out, " copy\n") {

 		c.Fatalf("Missing 'copy' log event\n%s", out)

 	}

@@ -642,11 +538,7 @@ func (s *DockerSuite) TestEventsCopy(c *check.C) {

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

 	since := daemonTime(c).Unix()

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "top")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatalf("Couldn't run top: %s\n%q", out, err)

-	}

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

 	cID := strings.TrimSpace(out)

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

@@ -655,18 +547,9 @@ func (s *DockerSuite) TestEventsResize(c *check.C) {

 	c.Assert(status, check.Equals, http.StatusOK)

 	c.Assert(err, check.IsNil)

-	cmd := exec.Command(dockerBinary, "stop", cID)

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't stop: %s\n%q", out, err)

-	}

-

-	cmd = exec.Command(dockerBinary, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since)))

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't get events: %s\n%q", out, err)

-	}

+	dockerCmd(c, "stop", cID)

+	out, _ = dockerCmd(c, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since)))

 	if !strings.Contains(out, " resize\n") {

 		c.Fatalf("Missing 'resize' log event\n%s", out)

 	}

@@ -700,18 +583,9 @@ func (s *DockerSuite) TestEventsAttach(c *check.C) {

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

-	cmd = exec.Command(dockerBinary, "stop", cID)

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't stop: %s\n%q", out, err)

-	}

-

-	cmd = exec.Command(dockerBinary, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since)))

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't get events: %s\n%q", out, err)

-	}

+	dockerCmd(c, "stop", cID)

+	out, _ = dockerCmd(c, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since)))

 	if !strings.Contains(out, " attach\n") {

 		c.Fatalf("Missing 'attach' log event\n%s", out)

 	}

@@ -720,24 +594,10 @@ func (s *DockerSuite) TestEventsAttach(c *check.C) {

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

 	since := daemonTime(c).Unix()

-	runCmd := exec.Command(dockerBinary, "run", "--name", "oldName", "busybox", "true")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatalf("Couldn't run true: %s\n%q", out, err)

-	}

-

-	renameCmd := exec.Command(dockerBinary, "rename", "oldName", "newName")

-	out, _, err = runCommandWithOutput(renameCmd)

-	if err != nil {

-		c.Fatalf("Couldn't rename: %s\n%q", out, err)

-	}

-

-	cmd := exec.Command(dockerBinary, "events", "--since=0", "-f", "container=newName", "--until="+strconv.Itoa(int(since)))

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't get events: %s\n%q", out, err)

-	}

+	dockerCmd(c, "run", "--name", "oldName", "busybox", "true")

+	dockerCmd(c, "rename", "oldName", "newName")

+	out, _ := dockerCmd(c, "events", "--since=0", "-f", "container=newName", "--until="+strconv.Itoa(int(since)))

 	if !strings.Contains(out, " rename\n") {

 		c.Fatalf("Missing 'rename' log event\n%s", out)

 	}

@@ -746,32 +606,14 @@ func (s *DockerSuite) TestEventsRename(c *check.C) {

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

 	since := daemonTime(c).Unix()

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "top")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatalf("Couldn't run true: %s\n%q", out, err)

-	}

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

 	cID := strings.TrimSpace(out)

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

-	cmd := exec.Command(dockerBinary, "top", cID)

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't run docker top: %s\n%q", out, err)

-	}

-

-	cmd = exec.Command(dockerBinary, "stop", cID)

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't stop: %s\n%q", out, err)

-	}

-

-	cmd = exec.Command(dockerBinary, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since)))

-	out, _, err = runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("Couldn't get events: %s\n%q", out, err)

-	}

+	dockerCmd(c, "top", cID)

+	dockerCmd(c, "stop", cID)

+	out, _ = dockerCmd(c, "events", "--since=0", "-f", "container="+cID, "--until="+strconv.Itoa(int(since)))

 	if !strings.Contains(out, " top\n") {

 		c.Fatalf("Missing 'top' log event\n%s", out)

 	}

@@ -790,9 +632,7 @@ func (s *DockerRegistrySuite) TestEventsImageFilterPush(c *check.C) {

 	since := daemonTime(c).Unix()

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

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "top")

-	out, _, err := runCommandWithOutput(runCmd)

-	c.Assert(err, check.IsNil)

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

 	cID := strings.TrimSpace(out)

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

@@ -800,10 +640,7 @@ func (s *DockerRegistrySuite) TestEventsImageFilterPush(c *check.C) {

 	dockerCmd(c, "stop", cID)

 	dockerCmd(c, "push", repoName)

-	cmd := exec.Command(dockerBinary, "events", "--since=0", "-f", "image="+repoName, "-f", "event=push", "--until="+strconv.Itoa(int(since)))

-	out, _, err = runCommandWithOutput(cmd)

-	c.Assert(err, check.IsNil)

-

+	out, _ = dockerCmd(c, "events", "--since=0", "-f", "image="+repoName, "-f", "event=push", "--until="+strconv.Itoa(int(since)))

 	if !strings.Contains(out, repoName+": push\n") {

 		c.Fatalf("Missing 'push' log event for image %s\n%s", repoName, out)

 	}

@@ -19,32 +19,18 @@ import (

 )

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

+	dockerCmd(c, "run", "-d", "--name", "testing", "busybox", "sh", "-c", "echo test > /tmp/file && top")

-	runCmd := exec.Command(dockerBinary, "run", "-d", "--name", "testing", "busybox", "sh", "-c", "echo test > /tmp/file && top")

-	if out, _, _, err := runCommandWithStdoutStderr(runCmd); err != nil {

-		c.Fatal(out, err)

-	}

-

-	execCmd := exec.Command(dockerBinary, "exec", "testing", "cat", "/tmp/file")

-	out, _, err := runCommandWithOutput(execCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-

+	out, _ := dockerCmd(c, "exec", "testing", "cat", "/tmp/file")

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

-

-	if expected := "test"; out != expected {

-		c.Errorf("container exec should've printed %q but printed %q", expected, out)

+	if out != "test" {

+		c.Errorf("container exec should've printed test but printed %q", out)

 	}

 }

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

-

-	runCmd := exec.Command(dockerBinary, "run", "-d", "--name", "testing", "busybox", "sh", "-c", "echo test > /tmp/file && top")

-	if out, _, _, err := runCommandWithStdoutStderr(runCmd); err != nil {

-		c.Fatal(out, err)

-	}

+	dockerCmd(c, "run", "-d", "--name", "testing", "busybox", "sh", "-c", "echo test > /tmp/file && top")

 	execCmd := exec.Command(dockerBinary, "exec", "-i", "testing", "sh")

 	stdin, err := execCmd.StdinPipe()

@@ -90,31 +76,15 @@ func (s *DockerSuite) TestExecInteractive(c *check.C) {

 }

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

-

-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "top")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-

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

 	cleanedContainerID := strings.TrimSpace(out)

+	dockerCmd(c, "restart", cleanedContainerID)

-	runCmd = exec.Command(dockerBinary, "restart", cleanedContainerID)

-	if out, _, err = runCommandWithOutput(runCmd); err != nil {

-		c.Fatal(out, err)

-	}

-

-	runCmd = exec.Command(dockerBinary, "exec", cleanedContainerID, "echo", "hello")

-	out, _, err = runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-

+	out, _ = dockerCmd(c, "exec", cleanedContainerID, "echo", "hello")

 	outStr := strings.TrimSpace(out)

 	if outStr != "hello" {

 		c.Errorf("container should've printed hello, instead printed %q", outStr)

 	}

-

 }

 func (s *DockerDaemonSuite) TestExecAfterDaemonRestart(c *check.C) {

@@ -149,65 +119,36 @@ func (s *DockerDaemonSuite) TestExecAfterDaemonRestart(c *check.C) {

 // Regression test for #9155, #9044

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

-

-	runCmd := exec.Command(dockerBinary, "run",

-		"-e", "LALA=value1",

-		"-e", "LALA=value2",

+	dockerCmd(c, "run", "-e", "LALA=value1", "-e", "LALA=value2",

 		"-d", "--name", "testing", "busybox", "top")

-	if out, _, _, err := runCommandWithStdoutStderr(runCmd); err != nil {

-		c.Fatal(out, err)

-	}

-

-	execCmd := exec.Command(dockerBinary, "exec", "testing", "env")

-	out, _, err := runCommandWithOutput(execCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

+	out, _ := dockerCmd(c, "exec", "testing", "env")

 	if strings.Contains(out, "LALA=value1") ||

 		!strings.Contains(out, "LALA=value2") ||

 		!strings.Contains(out, "HOME=/root") {

 		c.Errorf("exec env(%q), expect %q, %q", out, "LALA=value2", "HOME=/root")

 	}

-

 }

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

-

-	runCmd := exec.Command(dockerBinary, "run", "-d", "--name", "top", "busybox", "top")

-	if out, _, _, err := runCommandWithStdoutStderr(runCmd); err != nil {

-		c.Fatal(out, err)

-	}

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

 	// Test normal (non-detached) case first

 	cmd := exec.Command(dockerBinary, "exec", "top", "sh", "-c", "exit 23")

 	ec, _ := runCommand(cmd)

-

 	if ec != 23 {

 		c.Fatalf("Should have had an ExitCode of 23, not: %d", ec)

 	}

-

 }

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

 	defer unpauseAllContainers()

-	runCmd := exec.Command(dockerBinary, "run", "-d", "--name", "testing", "busybox", "top")

-	out, _, err := runCommandWithOutput(runCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-

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

 	ContainerID := strings.TrimSpace(out)

-	pausedCmd := exec.Command(dockerBinary, "pause", "testing")

-	out, _, _, err = runCommandWithStdoutStderr(pausedCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-

-	execCmd := exec.Command(dockerBinary, "exec", "-i", "-t", ContainerID, "echo", "hello")

-	out, _, err = runCommandWithOutput(execCmd)

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

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

 	if err == nil {

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

 	}

@@ -216,18 +157,13 @@ func (s *DockerSuite) TestExecPausedContainer(c *check.C) {

 	if !strings.Contains(out, expected) {

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

 	}

-

 }

 // regression test for #9476

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

+	dockerCmd(c, "run", "-d", "-it", "--name", "exec_tty_stdin", "busybox")

-	cmd := exec.Command(dockerBinary, "run", "-d", "-it", "--name", "exec_tty_stdin", "busybox")

-	if out, _, err := runCommandWithOutput(cmd); err != nil {

-		c.Fatal(out, err)

-	}

-

-	cmd = exec.Command(dockerBinary, "exec", "-i", "exec_tty_stdin", "cat")

+	cmd := exec.Command(dockerBinary, "exec", "-i", "exec_tty_stdin", "cat")

 	stdinRw, err := cmd.StdinPipe()

 	if err != nil {

 		c.Fatal(err)

@@ -240,42 +176,22 @@ func (s *DockerSuite) TestExecTtyCloseStdin(c *check.C) {

 		c.Fatal(out, err)

 	}

-	cmd = exec.Command(dockerBinary, "top", "exec_tty_stdin")

-	out, _, err := runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-

+	out, _ := dockerCmd(c, "top", "exec_tty_stdin")

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

 	if len(outArr) > 3 || strings.Contains(out, "nsenter-exec") {

-		// This is the really bad part

-		if out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "rm", "-f", "exec_tty_stdin")); err != nil {

-			c.Fatal(out, err)

-		}

-

 		c.Fatalf("exec process left running\n\t %s", out)

 	}

-

 }

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

-

-	cmd := exec.Command(dockerBinary, "run", "-d", "-ti", "busybox")

-	out, _, err := runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatalf("failed to start container: %v (%v)", out, err)

-	}

-

+	out, _ := dockerCmd(c, "run", "-d", "-ti", "busybox")

 	id := strings.TrimSpace(out)

 	if err := waitRun(id); err != nil {

 		c.Fatal(err)

 	}

 	defer func() {

-		cmd := exec.Command(dockerBinary, "kill", id)

-		if out, _, err := runCommandWithOutput(cmd); err != nil {

-			c.Fatalf("failed to kill container: %v (%v)", out, err)

-		}

+		dockerCmd(c, "kill", id)

 	}()

 	errChan := make(chan error)

@@ -304,15 +220,10 @@ func (s *DockerSuite) TestExecTtyWithoutStdin(c *check.C) {

 	case <-time.After(3 * time.Second):

 		c.Fatal("exec is running but should have failed")

 	}

-

 }

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

-

-	runCmd := exec.Command(dockerBinary, "run", "-d", "--name", "top", "busybox", "top")

-	if out, _, err := runCommandWithOutput(runCmd); err != nil {

-		c.Fatal(out, err)

-	}

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

 	// Test normal (non-detached) case first

 	cmd := exec.Command(dockerBinary, "exec", "top")

@@ -322,10 +233,7 @@ func (s *DockerSuite) TestExecParseError(c *check.C) {

 }

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

-	runCmd := exec.Command(dockerBinary, "run", "-d", "--name", "testing", "busybox", "top")

-	if out, _, err := runCommandWithOutput(runCmd); err != nil {

-		c.Fatal(out, err)

-	}

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

 	if err := exec.Command(dockerBinary, "exec", "testing", "top").Start(); err != nil {

 		c.Fatal(err)

@@ -351,20 +259,10 @@ func (s *DockerSuite) TestExecStopNotHanging(c *check.C) {

 }

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

-	var cmd *exec.Cmd

-

-	cmd = exec.Command(dockerBinary, "run", "-d", "--name", "testing", "busybox", "top")

-	_, err := runCommand(cmd)

-	if err != nil {

-		c.Fatal(err)

-	}

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

-	cmd = exec.Command(dockerBinary, "exec", "testing", "cat", "/proc/1/cgroup")

-	out, _, err := runCommandWithOutput(cmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-	containerCgroups := sort.StringSlice(strings.Split(string(out), "\n"))

+	out, _ := dockerCmd(c, "exec", "testing", "cat", "/proc/1/cgroup")

+	containerCgroups := sort.StringSlice(strings.Split(out, "\n"))

 	var wg sync.WaitGroup

 	var mu sync.Mutex

@@ -374,13 +272,12 @@ func (s *DockerSuite) TestExecCgroup(c *check.C) {

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

 		wg.Add(1)

 		go func() {

-			cmd := exec.Command(dockerBinary, "exec", "testing", "cat", "/proc/self/cgroup")

-			out, _, err := runCommandWithOutput(cmd)

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

 			if err != nil {

 				errChan <- err

 				return

 			}

-			cg := sort.StringSlice(strings.Split(string(out), "\n"))

+			cg := sort.StringSlice(strings.Split(out, "\n"))

 			mu.Lock()

 			execCgroups = append(execCgroups, cg)

@@ -409,18 +306,13 @@ func (s *DockerSuite) TestExecCgroup(c *check.C) {

 			c.Fatal("cgroups mismatched")

 		}

 	}

-

 }

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

-

-	out, exitCode, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-d", "busybox", "top"))

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

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

-	}

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

 	id := strings.TrimSuffix(out, "\n")

-	out, err = inspectField(id, "ExecIDs")

+	out, err := inspectField(id, "ExecIDs")

 	if err != nil {

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

 	}

@@ -496,29 +388,15 @@ func (s *DockerSuite) TestLinksPingLinkedContainersOnRename(c *check.C) {

 		c.Fatal(out, "id should not be nil")

 	}

-	execCmd := exec.Command(dockerBinary, "exec", "container2", "ping", "-c", "1", "alias1", "-W", "1")

-	out, _, err := runCommandWithOutput(execCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-

+	dockerCmd(c, "exec", "container2", "ping", "-c", "1", "alias1", "-W", "1")

 	dockerCmd(c, "rename", "container1", "container_new")

-

-	execCmd = exec.Command(dockerBinary, "exec", "container2", "ping", "-c", "1", "alias1", "-W", "1")

-	out, _, err = runCommandWithOutput(execCmd)

-	if err != nil {

-		c.Fatal(out, err)

-	}

-

+	dockerCmd(c, "exec", "container2", "ping", "-c", "1", "alias1", "-W", "1")