@@ -2,7 +2,6 @@ package main

 import (

 	"encoding/json"

-	"fmt"

 	"os/exec"

 	"testing"

 )

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

 func TestInspectApiContainerResponse(t *testing.T) {

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

 	out, _, err := runCommandWithOutput(runCmd)

-	errorOut(err, t, fmt.Sprintf("failed to create a container: %v %v", out, err))

+	if err != nil {

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

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

@@ -20,7 +20,9 @@ func TestBuildOnBuildForbiddenMaintainerInSourceImage(t *testing.T) {

 	defer deleteImages(name)

 	createCmd := exec.Command(dockerBinary, "create", "busybox", "true")

 	out, _, _, err := runCommandWithStdoutStderr(createCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

@@ -49,7 +51,9 @@ func TestBuildOnBuildForbiddenFromInSourceImage(t *testing.T) {

 	defer deleteImages(name)

 	createCmd := exec.Command(dockerBinary, "create", "busybox", "true")

 	out, _, _, err := runCommandWithStdoutStderr(createCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

@@ -78,7 +82,9 @@ func TestBuildOnBuildForbiddenChainedInSourceImage(t *testing.T) {

 	defer deleteImages(name)

 	createCmd := exec.Command(dockerBinary, "create", "busybox", "true")

 	out, _, _, err := runCommandWithStdoutStderr(createCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

@@ -299,11 +305,8 @@ RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio'

 func TestBuildCopyAddMultipleFiles(t *testing.T) {

 	buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")

-	out, exitCode, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testaddimg", "MultipleFiles")

-	errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testaddimg", "MultipleFiles"); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testaddimg")

@@ -620,11 +623,8 @@ func TestBuildCopySingleFileToRoot(t *testing.T) {

 		t.Fatal(err)

 	}

 	f.Close()

-	out, exitCode, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", ".")

-	errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "."); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testcopyimg")

@@ -650,9 +650,8 @@ func TestBuildCopySingleFileToWorkdir(t *testing.T) {

 		t.Fatal(err)

 	}

 	f.Close()

-	_, exitCode, err := dockerCmdInDirWithTimeout(5*time.Second, buildDirectory, "build", "-t", "testcopyimg", ".")

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

-		t.Fatalf("build failed: %s", err)

+	if out, _, err := dockerCmdInDirWithTimeout(5*time.Second, buildDirectory, "build", "-t", "testcopyimg", "."); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testcopyimg")

@@ -662,11 +661,8 @@ func TestBuildCopySingleFileToWorkdir(t *testing.T) {

 func TestBuildCopySingleFileToExistDir(t *testing.T) {

 	buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")

-	out, exitCode, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "SingleFileToExistDir")

-	errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "SingleFileToExistDir"); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testcopyimg")

@@ -676,11 +672,8 @@ func TestBuildCopySingleFileToExistDir(t *testing.T) {

 func TestBuildCopySingleFileToNonExistDir(t *testing.T) {

 	buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")

-	out, exitCode, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "SingleFileToNonExistDir")

-	errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "SingleFileToNonExistDir"); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testcopyimg")

@@ -690,11 +683,8 @@ func TestBuildCopySingleFileToNonExistDir(t *testing.T) {

 func TestBuildCopyDirContentToRoot(t *testing.T) {

 	buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")

-	out, exitCode, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "DirContentToRoot")

-	errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "DirContentToRoot"); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testcopyimg")

@@ -704,11 +694,8 @@ func TestBuildCopyDirContentToRoot(t *testing.T) {

 func TestBuildCopyDirContentToExistDir(t *testing.T) {

 	buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")

-	out, exitCode, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "DirContentToExistDir")

-	errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "DirContentToExistDir"); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testcopyimg")

@@ -737,11 +724,8 @@ func TestBuildCopyWholeDirToRoot(t *testing.T) {

 		t.Fatal(err)

 	}

 	f.Close()

-	out, exitCode, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", ".")

-	errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "."); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testcopyimg")

@@ -751,11 +735,8 @@ func TestBuildCopyWholeDirToRoot(t *testing.T) {

 func TestBuildCopyEtcToRoot(t *testing.T) {

 	buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")

-	out, exitCode, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "EtcToRoot")

-	errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := dockerCmdInDir(t, buildDirectory, "build", "-t", "testcopyimg", "EtcToRoot"); err != nil {

+		t.Fatalf("build failed to complete: %s, %v", out, err)

 	}

 	deleteImages("testcopyimg")

@@ -766,9 +747,7 @@ func TestBuildCopyDisallowRemote(t *testing.T) {

 	buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")

 	buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", "DisallowRemote")

 	buildCmd.Dir = buildDirectory

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

-

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

+	if out, _, err := runCommandWithOutput(buildCmd); err == nil {

 		t.Fatalf("building the image should've failed; output: %s", out)

 	}

@@ -790,14 +769,16 @@ func TestBuildWithInaccessibleFilesInContext(t *testing.T) {

 		// This is used to ensure we detect inaccessible files early during build in the cli client

 		pathToFileWithoutReadAccess := filepath.Join(ctx.Dir, "fileWithoutReadAccess")

-		err = os.Chown(pathToFileWithoutReadAccess, 0, 0)

-		errorOut(err, t, fmt.Sprintf("failed to chown file to root: %s", err))

-		err = os.Chmod(pathToFileWithoutReadAccess, 0700)

-		errorOut(err, t, fmt.Sprintf("failed to chmod file to 700: %s", err))

+		if err = os.Chown(pathToFileWithoutReadAccess, 0, 0); err != nil {

+			t.Fatalf("failed to chown file to root: %s", err)

+		}

+		if err = os.Chmod(pathToFileWithoutReadAccess, 0700); err != nil {

+			t.Fatalf("failed to chmod file to 700: %s", err)

+		}

 		buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))

 		buildCmd.Dir = ctx.Dir

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

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

+		out, _, err := runCommandWithOutput(buildCmd)

+		if err == nil {

 			t.Fatalf("build should have failed: %s %s", err, out)

 		}

@@ -822,17 +803,20 @@ func TestBuildWithInaccessibleFilesInContext(t *testing.T) {

 		pathToDirectoryWithoutReadAccess := filepath.Join(ctx.Dir, "directoryWeCantStat")

 		pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")

-		err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0)

-		errorOut(err, t, fmt.Sprintf("failed to chown directory to root: %s", err))

-		err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444)

-		errorOut(err, t, fmt.Sprintf("failed to chmod directory to 755: %s", err))

-		err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700)

-		errorOut(err, t, fmt.Sprintf("failed to chmod file to 444: %s", err))

+		if err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {

+			t.Fatalf("failed to chown directory to root: %s", err)

+		}

+		if err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {

+			t.Fatalf("failed to chmod directory to 755: %s", err)

+		}

+		if err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {

+			t.Fatalf("failed to chmod file to 444: %s", err)

+		}

 		buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))

 		buildCmd.Dir = ctx.Dir

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

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

+		out, _, err := runCommandWithOutput(buildCmd)

+		if err == nil {

 			t.Fatalf("build should have failed: %s %s", err, out)

 		}

@@ -878,17 +862,19 @@ func TestBuildWithInaccessibleFilesInContext(t *testing.T) {

 		// This is used to ensure we don't try to add inaccessible files when they are ignored by a .dockerignore pattern

 		pathToDirectoryWithoutReadAccess := filepath.Join(ctx.Dir, "directoryWeCantStat")

 		pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")

-		err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0)

-		errorOut(err, t, fmt.Sprintf("failed to chown directory to root: %s", err))

-		err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444)

-		errorOut(err, t, fmt.Sprintf("failed to chmod directory to 755: %s", err))

-		err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700)

-		errorOut(err, t, fmt.Sprintf("failed to chmod file to 444: %s", err))

+		if err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {

+			t.Fatalf("failed to chown directory to root: %s", err)

+		}

+		if err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {

+			t.Fatalf("failed to chmod directory to 755: %s", err)

+		}

+		if err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {

+			t.Fatalf("failed to chmod file to 444: %s", err)

+		}

 		buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))

 		buildCmd.Dir = ctx.Dir

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

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

+		if out, _, err := runCommandWithOutput(buildCmd); err != nil {

 			t.Fatalf("build should have worked: %s %s", err, out)

 		}

@@ -913,10 +899,8 @@ func TestBuildForceRm(t *testing.T) {

 	buildCmd := exec.Command(dockerBinary, "build", "-t", name, "--force-rm", ".")

 	buildCmd.Dir = ctx.Dir

-	_, exitCode, err := runCommandWithOutput(buildCmd)

-

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

-		t.Fatal("failed to build the image")

+	if out, _, err := runCommandWithOutput(buildCmd); err == nil {

+		t.Fatal("failed to build the image: %s, %v", out, err)

 	}

 	containerCountAfter, err := getContainerCount()

@@ -945,9 +929,9 @@ func TestBuildRm(t *testing.T) {

 			t.Fatalf("failed to get the container count: %s", err)

 		}

-		out, exitCode, err := dockerCmdInDir(t, ctx.Dir, "build", "--rm", "-t", name, ".")

+		out, _, err := dockerCmdInDir(t, ctx.Dir, "build", "--rm", "-t", name, ".")

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

+		if err != nil {

 			t.Fatal("failed to build the image", out)

 		}

@@ -968,9 +952,9 @@ func TestBuildRm(t *testing.T) {

 			t.Fatalf("failed to get the container count: %s", err)

 		}

-		out, exitCode, err := dockerCmdInDir(t, ctx.Dir, "build", "-t", name, ".")

+		out, _, err := dockerCmdInDir(t, ctx.Dir, "build", "-t", name, ".")

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

+		if err != nil {

 			t.Fatal("failed to build the image", out)

 		}

@@ -991,9 +975,9 @@ func TestBuildRm(t *testing.T) {

 			t.Fatalf("failed to get the container count: %s", err)

 		}

-		out, exitCode, err := dockerCmdInDir(t, ctx.Dir, "build", "--rm=false", "-t", name, ".")

+		out, _, err := dockerCmdInDir(t, ctx.Dir, "build", "--rm=false", "-t", name, ".")

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

+		if err != nil {

 			t.Fatal("failed to build the image", out)

 		}

@@ -1335,7 +1319,9 @@ func TestBuildOnBuildLimitedInheritence(t *testing.T) {

 		}

 		out1, _, err := dockerCmdInDir(t, ctx.Dir, "build", "-t", name1, ".")

-		errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out1, err))

+		if err != nil {

+			t.Fatalf("build failed to complete: %s, %v", out1, err)

+		}

 		defer deleteImages(name1)

 	}

 	{

@@ -1349,7 +1335,9 @@ func TestBuildOnBuildLimitedInheritence(t *testing.T) {

 		}

 		out2, _, err = dockerCmdInDir(t, ctx.Dir, "build", "-t", name2, ".")

-		errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out2, err))

+		if err != nil {

+			t.Fatalf("build failed to complete: %s, %v", out2, err)

+		}

 		defer deleteImages(name2)

 	}

 	{

@@ -1363,7 +1351,10 @@ func TestBuildOnBuildLimitedInheritence(t *testing.T) {

 		}

 		out3, _, err = dockerCmdInDir(t, ctx.Dir, "build", "-t", name3, ".")

-		errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out3, err))

+		if err != nil {

+			t.Fatalf("build failed to complete: %s, %v", out3, err)

+		}

+

 		defer deleteImages(name3)

 	}

@@ -1763,8 +1754,7 @@ CMD ["cat", "/foo"]`,

 	defer deleteImages(name)

 	buildCmd.Stdin = context

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

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

+	if out, _, err := runCommandWithOutput(buildCmd); err != nil {

 		t.Fatalf("build failed to complete: %v %v", out, err)

 	}

 	logDone(fmt.Sprintf("build - build an image with a context tar, compression: %v", compression))

@@ -1782,13 +1772,11 @@ func TestBuildNoContext(t *testing.T) {

 	buildCmd := exec.Command(dockerBinary, "build", "-t", "nocontext", "-")

 	buildCmd.Stdin = strings.NewReader("FROM busybox\nCMD echo ok\n")

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

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

+	if out, _, err := runCommandWithOutput(buildCmd); err != nil {

 		t.Fatalf("build failed to complete: %v %v", out, err)

 	}

-	out, exitCode, err = cmd(t, "run", "nocontext")

-	if out != "ok\n" {

+	if out, _, err := cmd(t, "run", "nocontext"); out != "ok\n" || err != nil {

 		t.Fatalf("run produced invalid output: %q, expected %q", out, "ok")

 	}

@@ -2717,7 +2705,7 @@ func TestBuildExoticShellInterpolation(t *testing.T) {

 	_, err := buildImage(name, `

 		FROM busybox

-

+		

 		ENV SOME_VAR a.b.c

 		RUN [ "$SOME_VAR"       = 'a.b.c' ]

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

 package main

 import (

-	"fmt"

 	"os/exec"

 	"strings"

 	"testing"

@@ -10,23 +9,29 @@ import (

 func TestCommitAfterContainerIsDone(t *testing.T) {

 	runCmd := exec.Command(dockerBinary, "run", "-i", "-a", "stdin", "busybox", "echo", "foo")

 	out, _, _, err := runCommandWithStdoutStderr(runCmd)

-	errorOut(err, t, fmt.Sprintf("failed to run container: %v %v", out, err))

+	if err != nil {

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

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

 	waitCmd := exec.Command(dockerBinary, "wait", cleanedContainerID)

-	_, _, err = runCommandWithOutput(waitCmd)

-	errorOut(err, t, fmt.Sprintf("error thrown while waiting for container: %s", out))

+	if _, _, err = runCommandWithOutput(waitCmd); err != nil {

+		t.Fatalf("error thrown while waiting for container: %s, %v", out, err)

+	}

 	commitCmd := exec.Command(dockerBinary, "commit", cleanedContainerID)

 	out, _, err = runCommandWithOutput(commitCmd)

-	errorOut(err, t, fmt.Sprintf("failed to commit container to image: %v %v", out, err))

+	if err != nil {

+		t.Fatalf("failed to commit container to image: %s, %v", out, err)

+	}

 	cleanedImageID := stripTrailingCharacters(out)

 	inspectCmd := exec.Command(dockerBinary, "inspect", cleanedImageID)

-	out, _, err = runCommandWithOutput(inspectCmd)

-	errorOut(err, t, fmt.Sprintf("failed to inspect image: %v %v", out, err))

+	if out, _, err = runCommandWithOutput(inspectCmd); err != nil {

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

+	}

 	deleteContainer(cleanedContainerID)

 	deleteImages(cleanedImageID)

@@ -37,23 +42,29 @@ func TestCommitAfterContainerIsDone(t *testing.T) {

 func TestCommitWithoutPause(t *testing.T) {

 	runCmd := exec.Command(dockerBinary, "run", "-i", "-a", "stdin", "busybox", "echo", "foo")

 	out, _, _, err := runCommandWithStdoutStderr(runCmd)

-	errorOut(err, t, fmt.Sprintf("failed to run container: %v %v", out, err))

+	if err != nil {

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

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

 	waitCmd := exec.Command(dockerBinary, "wait", cleanedContainerID)

-	_, _, err = runCommandWithOutput(waitCmd)

-	errorOut(err, t, fmt.Sprintf("error thrown while waiting for container: %s", out))

+	if _, _, err = runCommandWithOutput(waitCmd); err != nil {

+		t.Fatalf("error thrown while waiting for container: %s, %v", out, err)

+	}

 	commitCmd := exec.Command(dockerBinary, "commit", "-p=false", cleanedContainerID)

 	out, _, err = runCommandWithOutput(commitCmd)

-	errorOut(err, t, fmt.Sprintf("failed to commit container to image: %v %v", out, err))

+	if err != nil {

+		t.Fatalf("failed to commit container to image: %s, %v", out, err)

+	}

 	cleanedImageID := stripTrailingCharacters(out)

 	inspectCmd := exec.Command(dockerBinary, "inspect", cleanedImageID)

-	out, _, err = runCommandWithOutput(inspectCmd)

-	errorOut(err, t, fmt.Sprintf("failed to inspect image: %v %v", out, err))

+	if out, _, err = runCommandWithOutput(inspectCmd); err != nil {

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

+	}

 	deleteContainer(cleanedContainerID)

 	deleteImages(cleanedImageID)

@@ -81,7 +92,7 @@ func TestCommitNewFile(t *testing.T) {

 		t.Fatal(err, out)

 	}

 	if actual := strings.Trim(out, "\r\n"); actual != "koye" {

-		t.Fatalf("expected output koye received %s", actual)

+		t.Fatalf("expected output koye received %q", actual)

 	}

 	deleteAllContainers()

@@ -92,7 +103,6 @@ func TestCommitNewFile(t *testing.T) {

 func TestCommitTTY(t *testing.T) {

 	cmd := exec.Command(dockerBinary, "run", "-t", "--name", "tty", "busybox", "/bin/ls")

-

 	if _, err := runCommand(cmd); err != nil {

 		t.Fatal(err)

 	}

@@ -105,7 +115,6 @@ func TestCommitTTY(t *testing.T) {

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

 	cmd = exec.Command(dockerBinary, "run", "ttytest", "/bin/ls")

-

 	if _, err := runCommand(cmd); err != nil {

 		t.Fatal(err)

 	}

@@ -124,6 +133,7 @@ func TestCommitWithHostBindMount(t *testing.T) {

 	if err != nil {

 		t.Fatal(imageID, err)

 	}

+

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

 	cmd = exec.Command(dockerBinary, "run", "bindtest", "true")

@@ -2,7 +2,6 @@ package main

 import (

 	"encoding/json"

-	"fmt"

 	"os/exec"

 	"testing"

 	"time"

@@ -12,13 +11,17 @@ import (

 func TestCreateArgs(t *testing.T) {

 	runCmd := exec.Command(dockerBinary, "create", "busybox", "command", "arg1", "arg2", "arg with space")

 	out, _, _, err := runCommandWithStdoutStderr(runCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

 	inspectCmd := exec.Command(dockerBinary, "inspect", cleanedContainerID)

-	inspectOut, _, err := runCommandWithOutput(inspectCmd)

-	errorOut(err, t, fmt.Sprintf("out should've been a container id: %v %v", inspectOut, err))

+	out, _, err = runCommandWithOutput(inspectCmd)

+	if err != nil {

+		t.Fatalf("out should've been a container id: %s, %v", out, err)

+	}

 	containers := []struct {

 		ID      string

@@ -27,7 +30,7 @@ func TestCreateArgs(t *testing.T) {

 		Args    []string

 		Image   string

 	}{}

-	if err := json.Unmarshal([]byte(inspectOut), &containers); err != nil {

+	if err := json.Unmarshal([]byte(out), &containers); err != nil {

 		t.Fatalf("Error inspecting the container: %s", err)

 	}

 	if len(containers) != 1 {

@@ -60,20 +63,24 @@ func TestCreateArgs(t *testing.T) {

 func TestCreateHostConfig(t *testing.T) {

 	runCmd := exec.Command(dockerBinary, "create", "-P", "busybox", "echo")

 	out, _, _, err := runCommandWithStdoutStderr(runCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

 	inspectCmd := exec.Command(dockerBinary, "inspect", cleanedContainerID)

-	inspectOut, _, err := runCommandWithOutput(inspectCmd)

-	errorOut(err, t, fmt.Sprintf("out should've been a container id: %v %v", inspectOut, err))

+	out, _, err = runCommandWithOutput(inspectCmd)

+	if err != nil {

+		t.Fatalf("out should've been a container id: %s, %v", out, err)

+	}

 	containers := []struct {

 		HostConfig *struct {

 			PublishAllPorts bool

 		}

 	}{}

-	if err := json.Unmarshal([]byte(inspectOut), &containers); err != nil {

+	if err := json.Unmarshal([]byte(out), &containers); err != nil {

 		t.Fatalf("Error inspecting the container: %s", err)

 	}

 	if len(containers) != 1 {

@@ -98,13 +105,17 @@ func TestCreateHostConfig(t *testing.T) {

 func TestCreateEchoStdout(t *testing.T) {

 	runCmd := exec.Command(dockerBinary, "create", "busybox", "echo", "test123")

 	out, _, _, err := runCommandWithStdoutStderr(runCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

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

 	out, _, _, err = runCommandWithStdoutStderr(runCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	if out != "test123\n" {

 		t.Errorf("container should've printed 'test123', got %q", out)

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

 package main

 import (

-	"fmt"

 	"os/exec"

 	"strings"

 	"testing"

@@ -11,14 +10,18 @@ import (

 func TestDiffFilenameShownInOutput(t *testing.T) {

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

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

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

-	errorOut(err, t, fmt.Sprintf("failed to start the container: %v", err))

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

+	if err != nil {

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

+	}

-	cleanCID := stripTrailingCharacters(cid)

+	cleanCID := stripTrailingCharacters(out)

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

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

-	errorOut(err, t, fmt.Sprintf("failed to run diff: %v %v", out, err))

+	out, _, err = runCommandWithOutput(diffCmd)

+	if err != nil {

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

+	}

 	found := false

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

@@ -44,14 +47,18 @@ func TestDiffEnsureDockerinitFilesAreIgnored(t *testing.T) {

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

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

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

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

-		errorOut(err, t, fmt.Sprintf("%s", err))

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

+		if err != nil {

+			t.Fatal(out, err)

+		}

-		cleanCID := stripTrailingCharacters(cid)

+		cleanCID := stripTrailingCharacters(out)

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

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

-		errorOut(err, t, fmt.Sprintf("failed to run diff: %v %v", out, err))

+		out, _, err = runCommandWithOutput(diffCmd)

+		if err != nil {

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

+		}

 		deleteContainer(cleanCID)

@@ -67,13 +74,18 @@ func TestDiffEnsureDockerinitFilesAreIgnored(t *testing.T) {

 func TestDiffEnsureOnlyKmsgAndPtmx(t *testing.T) {

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

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

-	errorOut(err, t, fmt.Sprintf("%s", err))

-	cleanCID := stripTrailingCharacters(cid)

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

+	if err != nil {

+		t.Fatal(out, err)

+	}

+

+	cleanCID := stripTrailingCharacters(out)

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

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

-	errorOut(err, t, fmt.Sprintf("failed to run diff: %v %v", out, err))

+	out, _, err = runCommandWithOutput(diffCmd)

+	if err != nil {

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

+	}

 	deleteContainer(cleanCID)

 	expected := map[string]bool{

@@ -10,13 +10,15 @@ import (

 func TestExec(t *testing.T) {

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

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

-	errorOut(err, t, out)

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

+		t.Fatal(out, err)

+	}

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

-

-	out, _, err = runCommandWithOutput(execCmd)

-	errorOut(err, t, out)

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

+	if err != nil {

+		t.Fatal(out, err)

+	}

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

@@ -31,8 +33,9 @@ func TestExec(t *testing.T) {

 func TestExecInteractive(t *testing.T) {

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

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

-	errorOut(err, t, out)

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

+		t.Fatal(out, err)

+	}

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

 	stdin, err := execCmd.StdinPipe()

@@ -84,17 +87,22 @@ func TestExecInteractive(t *testing.T) {

 func TestExecAfterContainerRestart(t *testing.T) {

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

 	out, _, err := runCommandWithOutput(runCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

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

-	out, _, err = runCommandWithOutput(runCmd)

-	errorOut(err, t, out)

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

+		t.Fatal(out, err)

+	}

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

 	out, _, err = runCommandWithOutput(runCmd)

-	errorOut(err, t, out)

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	outStr := strings.TrimSpace(out)

 	if outStr != "hello" {

@@ -26,19 +26,23 @@ func TestExportContainerAndImportImage(t *testing.T) {

 	exportCmdTemplate := `%v export %v > /tmp/testexp.tar`

 	exportCmdFinal := fmt.Sprintf(exportCmdTemplate, dockerBinary, cleanedContainerID)

 	exportCmd := exec.Command("bash", "-c", exportCmdFinal)

-	out, _, err = runCommandWithOutput(exportCmd)

-	errorOut(err, t, fmt.Sprintf("failed to export container: %v %v", out, err))

+	if out, _, err = runCommandWithOutput(exportCmd); err != nil {

+		t.Fatalf("failed to export container: %s, %v", out, err)

+	}

 	importCmdFinal := `cat /tmp/testexp.tar | docker import - repo/testexp:v1`

 	importCmd := exec.Command("bash", "-c", importCmdFinal)

 	out, _, err = runCommandWithOutput(importCmd)

-	errorOut(err, t, fmt.Sprintf("failed to import image: %v %v", out, err))

+	if err != nil {

+		t.Fatalf("failed to import image: %s, %v", out, err)

+	}

 	cleanedImageID := stripTrailingCharacters(out)

 	inspectCmd = exec.Command(dockerBinary, "inspect", cleanedImageID)

-	out, _, err = runCommandWithOutput(inspectCmd)

-	errorOut(err, t, fmt.Sprintf("output should've been an image id: %v %v", out, err))

+	if out, _, err = runCommandWithOutput(inspectCmd); err != nil {

+		t.Fatalf("output should've been an image id: %s, %v", out, err)

+	}

 	deleteContainer(cleanedContainerID)

 	deleteImages("repo/testexp:v1")

@@ -46,9 +46,8 @@ RUN echo "Z"`,

 	}

 	out, exitCode, err := runCommandWithOutput(exec.Command(dockerBinary, "history", "testbuildhistory"))

-	errorOut(err, t, fmt.Sprintf("image history failed: %v %v", out, err))

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

-		t.Fatal("failed to get image history")

+		t.Fatal("failed to get image history: %s, %v", out, err)

 	}

 	actualValues := strings.Split(out, "\n")[1:27]

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

 package main

 import (

-	"fmt"

 	"os/exec"

 	"strings"

 	"testing"

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

 func TestImagesEnsureImageIsListed(t *testing.T) {

 	imagesCmd := exec.Command(dockerBinary, "images")

 	out, _, err := runCommandWithOutput(imagesCmd)

-	errorOut(err, t, fmt.Sprintf("listing images failed with errors: %v", err))

+	if err != nil {

+		t.Fatalf("listing images failed with errors: %s, %v", out, err)

+	}

 	if !strings.Contains(out, "busybox") {

 		t.Fatal("images should've listed busybox")

@@ -46,7 +47,9 @@ func TestImagesOrderedByCreationDate(t *testing.T) {

 	}

 	out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "images", "-q", "--no-trunc"))

-	errorOut(err, t, fmt.Sprintf("listing images failed with errors: %v", err))

+	if err != nil {

+		t.Fatalf("listing images failed with errors: %s, %v", out, err)

+	}

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

 	if imgs[0] != id3 {

 		t.Fatalf("First image must be %s, got %s", id3, imgs[0])

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

 package main

 import (

-	"fmt"

 	"os/exec"

 	"strings"

 	"testing"

@@ -11,10 +10,8 @@ import (

 func TestInfoEnsureSucceeds(t *testing.T) {

 	versionCmd := exec.Command(dockerBinary, "info")

 	out, exitCode, err := runCommandWithOutput(versionCmd)

-	errorOut(err, t, fmt.Sprintf("encountered error while running docker info: %v", err))

-

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

-		t.Fatal("failed to execute docker info")

+		t.Fatal("failed to execute docker info: %s, %v", out, err)

 	}

 	stringsToCheck := []string{"Containers:", "Execution Driver:", "Kernel Version:"}

@@ -10,13 +10,14 @@ func TestInspectImage(t *testing.T) {

 	imageTest := "scratch"

 	imageTestID := "511136ea3c5a64f264b78b5433614aec563103b4d4702f3ba7d4d2698e22c158"

 	imagesCmd := exec.Command(dockerBinary, "inspect", "--format='{{.Id}}'", imageTest)

-

 	out, exitCode, err := runCommandWithOutput(imagesCmd)

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

-		t.Fatalf("failed to inspect image")

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

 	}

+

 	if id := strings.TrimSuffix(out, "\n"); id != imageTestID {

 		t.Fatalf("Expected id: %s for image: %s but received id: %s", imageTestID, imageTest, id)

 	}

+

 	logDone("inspect - inspect an image")

 }

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

 package main

 import (

-	"fmt"

 	"os/exec"

 	"strings"

 	"testing"

@@ -10,21 +9,27 @@ import (

 func TestKillContainer(t *testing.T) {

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

 	out, _, err := runCommandWithOutput(runCmd)

-	errorOut(err, t, fmt.Sprintf("run failed with errors: %v", err))

+	if err != nil {

+		t.Fatal(out, err)

+	}

 	cleanedContainerID := stripTrailingCharacters(out)

 	inspectCmd := exec.Command(dockerBinary, "inspect", cleanedContainerID)

-	inspectOut, _, err := runCommandWithOutput(inspectCmd)

-	errorOut(err, t, fmt.Sprintf("out should've been a container id: %v %v", inspectOut, err))

+	if out, _, err = runCommandWithOutput(inspectCmd); err != nil {

+		t.Fatalf("out should've been a container id: %s, %v", out, err)

+	}

 	killCmd := exec.Command(dockerBinary, "kill", cleanedContainerID)

-	out, _, err = runCommandWithOutput(killCmd)

-	errorOut(err, t, fmt.Sprintf("failed to kill container: %v %v", out, err))

+	if out, _, err = runCommandWithOutput(killCmd); err != nil {

+		t.Fatalf("failed to kill container: %s, %v", out, err)

+	}

 	listRunningContainersCmd := exec.Command(dockerBinary, "ps", "-q")

 	out, _, err = runCommandWithOutput(listRunningContainersCmd)

-	errorOut(err, t, fmt.Sprintf("failed to list running containers: %v", err))

+	if err != nil {

+		t.Fatalf("failed to list running containers: %s, %v", out, err)

+	}

 	if strings.Contains(out, cleanedContainerID) {

 		t.Fatal("killed container is still running")

@@ -38,21 +43,27 @@ func TestKillContainer(t *testing.T) {

 func TestKillDifferentUserContainer(t *testing.T) {

 	runCmd := exec.Command(dockerBinary, "run", "-u", "daemon", "-d", "busybox", "sh", "-c", "sleep 10")

 	out, _, err := runCommandWithOutput(runCmd)

-	errorOut(err, t, fmt.Sprintf("run failed with errors: %v", err))