Merge branch 'master' of github.com:docker/docker into kill

Docker-DCO-1.1-Signed-off-by: Dan Walsh <dwalsh@redhat.com> (github: rhatdan)

integration-cli/check_test.go

@@ -24,13 +24,58 @@ func (s *TimerSuite) TearDownTest(c *check.C) {
 	fmt.Printf("%-60s%.2f\n", c.TestName(), time.Since(s.start).Seconds())
 }
 
+func init() {
+	check.Suite(&DockerSuite{})
+}
+
 type DockerSuite struct {
 	TimerSuite
 }
 
 func (s *DockerSuite) TearDownTest(c *check.C) {
 	deleteAllContainers()
+	deleteAllImages()
 	s.TimerSuite.TearDownTest(c)
 }
 
-var _ = check.Suite(&DockerSuite{})
+func init() {
+	check.Suite(&DockerRegistrySuite{
+		ds: &DockerSuite{},
+	})
+}
+
+type DockerRegistrySuite struct {
+	ds  *DockerSuite
+	reg *testRegistryV2
+}
+
+func (s *DockerRegistrySuite) SetUpTest(c *check.C) {
+	s.reg = setupRegistry(c)
+	s.ds.SetUpTest(c)
+}
+
+func (s *DockerRegistrySuite) TearDownTest(c *check.C) {
+	s.reg.Close()
+	s.ds.TearDownTest(c)
+}
+
+func init() {
+	check.Suite(&DockerDaemonSuite{
+		ds: &DockerSuite{},
+	})
+}
+
+type DockerDaemonSuite struct {
+	ds *DockerSuite
+	d  *Daemon
+}
+
+func (s *DockerDaemonSuite) SetUpTest(c *check.C) {
+	s.d = NewDaemon(c)
+	s.ds.SetUpTest(c)
+}
+
+func (s *DockerDaemonSuite) TearDownTest(c *check.C) {
+	s.d.Stop()
+	s.ds.TearDownTest(c)
+}

integration-cli/docker_api_attach_test.go

@@ -40,24 +40,38 @@ func (s *DockerSuite) TestGetContainersAttachWebsocket(c *check.C) {
 
 	expected := []byte("hello")
 	actual := make([]byte, len(expected))
-	outChan := make(chan string)
+
+	outChan := make(chan error)
 	go func() {
-		if _, err := ws.Read(actual); err != nil {
-			c.Fatal(err)
-		}
-		outChan <- "done"
+		_, err := ws.Read(actual)
+		outChan <- err
+		close(outChan)
 	}()
 
-	inChan := make(chan string)
+	inChan := make(chan error)
 	go func() {
-		if _, err := ws.Write(expected); err != nil {
-			c.Fatal(err)
-		}
-		inChan <- "done"
+		_, err := ws.Write(expected)
+		inChan <- err
+		close(inChan)
 	}()
 
-	<-inChan
-	<-outChan
+	select {
+	case err := <-inChan:
+		if err != nil {
+			c.Fatal(err)
+		}
+	case <-time.After(5 * time.Second):
+		c.Fatal("Timeout writing to ws")
+	}
+
+	select {
+	case err := <-outChan:
+		if err != nil {
+			c.Fatal(err)
+		}
+	case <-time.After(5 * time.Second):
+		c.Fatal("Timeout reading from ws")
+	}
 
 	if !bytes.Equal(expected, actual) {
 		c.Fatal("Expected output on websocket to match input")

integration-cli/docker_api_containers_test.go

@@ -176,7 +176,7 @@ func (s *DockerSuite) TestContainerApiStartVolumesFrom(c *check.C) {
 		c.Fatal(out, err)
 	}
 
-	name := "testing"
+	name := "TestContainerApiStartDupVolumeBinds"
 	config := map[string]interface{}{
 		"Image":   "busybox",
 		"Volumes": map[string]struct{}{volPath: {}},
@@ -260,15 +260,14 @@ func (s *DockerSuite) TestGetContainerStats(c *check.C) {
 		c.Fatalf("Error on container creation: %v, output: %q", err, out)
 	}
 	type b struct {
-		body []byte
-		err  error
+		status int
+		body   []byte
+		err    error
 	}
 	bc := make(chan b, 1)
 	go func() {
 		status, body, err := sockRequest("GET", "/containers/"+name+"/stats", nil)
-		c.Assert(status, check.Equals, http.StatusOK)
-		c.Assert(err, check.IsNil)
-		bc <- b{body, err}
+		bc <- b{status, body, err}
 	}()
 
 	// allow some time to stream the stats from the container
@@ -283,9 +282,8 @@ func (s *DockerSuite) TestGetContainerStats(c *check.C) {
 	case <-time.After(2 * time.Second):
 		c.Fatal("stream was not closed after container was removed")
 	case sr := <-bc:
-		if sr.err != nil {
-			c.Fatal(sr.err)
-		}
+		c.Assert(sr.err, check.IsNil)
+		c.Assert(sr.status, check.Equals, http.StatusOK)
 
 		dec := json.NewDecoder(bytes.NewBuffer(sr.body))
 		var s *types.Stats
@@ -297,6 +295,7 @@ func (s *DockerSuite) TestGetContainerStats(c *check.C) {
 }
 
 func (s *DockerSuite) TestGetStoppedContainerStats(c *check.C) {
+	// TODO: this test does nothing because we are c.Assert'ing in goroutine
 	var (
 		name   = "statscontainer"
 		runCmd = exec.Command(dockerBinary, "create", "--name", name, "busybox", "top")
@@ -339,8 +338,8 @@ func (s *DockerSuite) TestBuildApiDockerfilePath(c *check.C) {
 		c.Fatalf("failed to close tar archive: %v", err)
 	}
 
-	status, body, err := sockRequestRaw("POST", "/build?dockerfile=../Dockerfile", buffer, "application/x-tar")
-	c.Assert(status, check.Equals, http.StatusInternalServerError)
+	res, body, err := sockRequestRaw("POST", "/build?dockerfile=../Dockerfile", buffer, "application/x-tar")
+	c.Assert(res.StatusCode, check.Equals, http.StatusInternalServerError)
 	c.Assert(err, check.IsNil)
 
 	out, err := readBody(body)
@@ -365,8 +364,8 @@ RUN find /tmp/`,
 	}
 	defer server.Close()
 
-	status, body, err := sockRequestRaw("POST", "/build?dockerfile=baz&remote="+server.URL()+"/testD", nil, "application/json")
-	c.Assert(status, check.Equals, http.StatusOK)
+	res, body, err := sockRequestRaw("POST", "/build?dockerfile=baz&remote="+server.URL()+"/testD", nil, "application/json")
+	c.Assert(res.StatusCode, check.Equals, http.StatusOK)
 	c.Assert(err, check.IsNil)
 
 	buf, err := readBody(body)
@@ -393,8 +392,8 @@ RUN echo from dockerfile`,
 	}
 	defer git.Close()
 
-	status, body, err := sockRequestRaw("POST", "/build?remote="+git.RepoURL, nil, "application/json")
-	c.Assert(status, check.Equals, http.StatusOK)
+	res, body, err := sockRequestRaw("POST", "/build?remote="+git.RepoURL, nil, "application/json")
+	c.Assert(res.StatusCode, check.Equals, http.StatusOK)
 	c.Assert(err, check.IsNil)
 
 	buf, err := readBody(body)
@@ -421,8 +420,8 @@ RUN echo from Dockerfile`,
 	defer git.Close()
 
 	// Make sure it tries to 'dockerfile' query param value
-	status, body, err := sockRequestRaw("POST", "/build?dockerfile=baz&remote="+git.RepoURL, nil, "application/json")
-	c.Assert(status, check.Equals, http.StatusOK)
+	res, body, err := sockRequestRaw("POST", "/build?dockerfile=baz&remote="+git.RepoURL, nil, "application/json")
+	c.Assert(res.StatusCode, check.Equals, http.StatusOK)
 	c.Assert(err, check.IsNil)
 
 	buf, err := readBody(body)
@@ -450,8 +449,8 @@ RUN echo from dockerfile`,
 	defer git.Close()
 
 	// Make sure it tries to 'dockerfile' query param value
-	status, body, err := sockRequestRaw("POST", "/build?remote="+git.RepoURL, nil, "application/json")
-	c.Assert(status, check.Equals, http.StatusOK)
+	res, body, err := sockRequestRaw("POST", "/build?remote="+git.RepoURL, nil, "application/json")
+	c.Assert(res.StatusCode, check.Equals, http.StatusOK)
 	c.Assert(err, check.IsNil)
 
 	buf, err := readBody(body)
@@ -483,8 +482,8 @@ func (s *DockerSuite) TestBuildApiDockerfileSymlink(c *check.C) {
 		c.Fatalf("failed to close tar archive: %v", err)
 	}
 
-	status, body, err := sockRequestRaw("POST", "/build", buffer, "application/x-tar")
-	c.Assert(status, check.Equals, http.StatusInternalServerError)
+	res, body, err := sockRequestRaw("POST", "/build", buffer, "application/x-tar")
+	c.Assert(res.StatusCode, check.Equals, http.StatusInternalServerError)
 	c.Assert(err, check.IsNil)
 
 	out, err := readBody(body)
@@ -614,14 +613,14 @@ func (s *DockerSuite) TestContainerApiTop(c *check.C) {
 }
 
 func (s *DockerSuite) TestContainerApiCommit(c *check.C) {
-	out, err := exec.Command(dockerBinary, "run", "-d", "busybox", "/bin/sh", "-c", "touch /test").CombinedOutput()
+	cName := "testapicommit"
+	out, err := exec.Command(dockerBinary, "run", "--name="+cName, "busybox", "/bin/sh", "-c", "touch /test").CombinedOutput()
 	if err != nil {
 		c.Fatal(err, out)
 	}
-	id := strings.TrimSpace(string(out))
 
-	name := "testcommit" + stringid.GenerateRandomID()
-	status, b, err := sockRequest("POST", "/commit?repo="+name+"&testtag=tag&container="+id, nil)
+	name := "TestContainerApiCommit"
+	status, b, err := sockRequest("POST", "/commit?repo="+name+"&testtag=tag&container="+cName, nil)
 	c.Assert(status, check.Equals, http.StatusCreated)
 	c.Assert(err, check.IsNil)
 
@@ -632,7 +631,6 @@ func (s *DockerSuite) TestContainerApiCommit(c *check.C) {
 	if err := json.Unmarshal(b, &img); err != nil {
 		c.Fatal(err)
 	}
-	defer deleteImages(img.Id)
 
 	cmd, err := inspectField(img.Id, "Config.Cmd")
 	if err != nil {
@@ -644,7 +642,7 @@ func (s *DockerSuite) TestContainerApiCommit(c *check.C) {
 	// sanity check, make sure the image is what we think it is
 	out, err = exec.Command(dockerBinary, "run", img.Id, "ls", "/test").CombinedOutput()
 	if err != nil {
-		c.Fatalf("error checking commited image: %v - %q", err, string(out))
+		c.Fatalf("error checking committed image: %v - %q", err, string(out))
 	}
 }
 
@@ -721,7 +719,7 @@ func (s *DockerSuite) TestContainerApiVerifyHeader(c *check.C) {
 		"Image": "busybox",
 	}
 
-	create := func(ct string) (int, io.ReadCloser, error) {
+	create := func(ct string) (*http.Response, io.ReadCloser, error) {
 		jsonData := bytes.NewBuffer(nil)
 		if err := json.NewEncoder(jsonData).Encode(config); err != nil {
 			c.Fatal(err)
@@ -730,21 +728,21 @@ func (s *DockerSuite) TestContainerApiVerifyHeader(c *check.C) {
 	}
 
 	// Try with no content-type
-	status, body, err := create("")
-	c.Assert(status, check.Equals, http.StatusInternalServerError)
+	res, body, err := create("")
 	c.Assert(err, check.IsNil)
+	c.Assert(res.StatusCode, check.Equals, http.StatusInternalServerError)
 	body.Close()
 
 	// Try with wrong content-type
-	status, body, err = create("application/xml")
-	c.Assert(status, check.Equals, http.StatusInternalServerError)
+	res, body, err = create("application/xml")
 	c.Assert(err, check.IsNil)
+	c.Assert(res.StatusCode, check.Equals, http.StatusInternalServerError)
 	body.Close()
 
 	// now application/json
-	status, body, err = create("application/json")
-	c.Assert(status, check.Equals, http.StatusCreated)
+	res, body, err = create("application/json")
 	c.Assert(err, check.IsNil)
+	c.Assert(res.StatusCode, check.Equals, http.StatusCreated)
 	body.Close()
 }
 
@@ -775,8 +773,8 @@ func (s *DockerSuite) TestContainerApiPostCreateNull(c *check.C) {
 		"NetworkDisabled":false,
 		"OnBuild":null}`
 
-	status, body, err := sockRequestRaw("POST", "/containers/create", strings.NewReader(config), "application/json")
-	c.Assert(status, check.Equals, http.StatusCreated)
+	res, body, err := sockRequestRaw("POST", "/containers/create", strings.NewReader(config), "application/json")
+	c.Assert(res.StatusCode, check.Equals, http.StatusCreated)
 	c.Assert(err, check.IsNil)
 
 	b, err := readBody(body)
@@ -809,13 +807,13 @@ func (s *DockerSuite) TestCreateWithTooLowMemoryLimit(c *check.C) {
 		"Memory":    524287
 	}`
 
-	status, body, _ := sockRequestRaw("POST", "/containers/create", strings.NewReader(config), "application/json")
+	res, body, _ := sockRequestRaw("POST", "/containers/create", strings.NewReader(config), "application/json")
 	b, err2 := readBody(body)
 	if err2 != nil {
 		c.Fatal(err2)
 	}
 
-	c.Assert(status, check.Equals, http.StatusInternalServerError)
+	c.Assert(res.StatusCode, check.Equals, http.StatusInternalServerError)
 	c.Assert(strings.Contains(string(b), "Minimum memory limit allowed is 4MB"), check.Equals, true)
 }
 
@@ -832,12 +830,31 @@ func (s *DockerSuite) TestStartWithTooLowMemoryLimit(c *check.C) {
                 "Memory":    524287
         }`
 
-	status, body, _ := sockRequestRaw("POST", "/containers/"+containerID+"/start", strings.NewReader(config), "application/json")
+	res, body, _ := sockRequestRaw("POST", "/containers/"+containerID+"/start", strings.NewReader(config), "application/json")
 	b, err2 := readBody(body)
 	if err2 != nil {
 		c.Fatal(err2)
 	}
 
-	c.Assert(status, check.Equals, http.StatusInternalServerError)
+	c.Assert(res.StatusCode, check.Equals, http.StatusInternalServerError)
 	c.Assert(strings.Contains(string(b), "Minimum memory limit allowed is 4MB"), check.Equals, true)
 }
+
+func (s *DockerSuite) TestContainerApiRename(c *check.C) {
+	runCmd := exec.Command(dockerBinary, "run", "--name", "TestContainerApiRename", "-d", "busybox", "sh")
+	out, _, err := runCommandWithOutput(runCmd)
+	c.Assert(err, check.IsNil)
+
+	containerID := strings.TrimSpace(out)
+	newName := "TestContainerApiRenameNew"
+	statusCode, _, err := sockRequest("POST", "/containers/"+containerID+"/rename?name="+newName, nil)
+
+	// 204 No Content is expected, not 200
+	c.Assert(statusCode, check.Equals, http.StatusNoContent)
+	c.Assert(err, check.IsNil)
+
+	name, err := inspectField(containerID, "Name")
+	if name != "/"+newName {
+		c.Fatalf("Failed to rename container, expected %v, got %v. Container rename API failed", newName, name)
+	}
+}

integration-cli/docker_api_images_test.go

@@ -30,7 +30,6 @@ func (s *DockerSuite) TestApiImagesFilter(c *check.C) {
 	name := "utest:tag1"
 	name2 := "utest/docker:tag2"
 	name3 := "utest:5000/docker:tag3"
-	defer deleteImages(name, name2, name3)
 	for _, n := range []string{name, name2, name3} {
 		if out, err := exec.Command(dockerBinary, "tag", "busybox", n).CombinedOutput(); err != nil {
 			c.Fatal(err, out)
@@ -74,11 +73,10 @@ func (s *DockerSuite) TestApiImagesSaveAndLoad(c *check.C) {
 		c.Fatal(err)
 	}
 	id := strings.TrimSpace(out)
-	defer deleteImages("saveandload")
 
-	status, body, err := sockRequestRaw("GET", "/images/"+id+"/get", nil, "")
-	c.Assert(status, check.Equals, http.StatusOK)
+	res, body, err := sockRequestRaw("GET", "/images/"+id+"/get", nil, "")
 	c.Assert(err, check.IsNil)
+	c.Assert(res.StatusCode, check.Equals, http.StatusOK)
 
 	defer body.Close()
 
@@ -86,9 +84,9 @@ func (s *DockerSuite) TestApiImagesSaveAndLoad(c *check.C) {
 		c.Fatal(err, out)
 	}
 
-	status, loadBody, err := sockRequestRaw("POST", "/images/load", body, "application/x-tar")
-	c.Assert(status, check.Equals, http.StatusOK)
+	res, loadBody, err := sockRequestRaw("POST", "/images/load", body, "application/x-tar")
 	c.Assert(err, check.IsNil)
+	c.Assert(res.StatusCode, check.Equals, http.StatusOK)
 
 	defer loadBody.Close()
 

integration-cli/docker_api_logs_test.go

@@ -1,28 +1,46 @@
 package main
 
 import (
+	"bufio"
 	"bytes"
 	"fmt"
 	"net/http"
 	"os/exec"
+	"strings"
+	"time"
 
 	"github.com/go-check/check"
 )
 
 func (s *DockerSuite) TestLogsApiWithStdout(c *check.C) {
-	name := "logs_test"
-
-	runCmd := exec.Command(dockerBinary, "run", "-d", "-t", "--name", name, "busybox", "bin/sh", "-c", "sleep 10 && echo "+name)
-	if out, _, err := runCommandWithOutput(runCmd); err != nil {
-		c.Fatal(out, err)
+	out, _ := dockerCmd(c, "run", "-d", "-t", "busybox", "/bin/sh", "-c", "while true; do echo hello; sleep 1; done")
+	id := strings.TrimSpace(out)
+	if err := waitRun(id); err != nil {
+		c.Fatal(err)
 	}
 
-	status, body, err := sockRequest("GET", fmt.Sprintf("/containers/%s/logs?follow=1&stdout=1&timestamps=1", name), nil)
-	c.Assert(status, check.Equals, http.StatusOK)
-	c.Assert(err, check.IsNil)
+	type logOut struct {
+		out string
+		res *http.Response
+		err error
+	}
+	chLog := make(chan logOut)
 
-	if !bytes.Contains(body, []byte(name)) {
-		c.Fatalf("Expected %s, got %s", name, string(body[:]))
+	go func() {
+		res, body, err := sockRequestRaw("GET", fmt.Sprintf("/containers/%s/logs?follow=1&stdout=1&timestamps=1", id), nil, "")
+		out, _ := bufio.NewReader(body).ReadString('\n')
+		chLog <- logOut{strings.TrimSpace(out), res, err}
+	}()
+
+	select {
+	case l := <-chLog:
+		c.Assert(l.err, check.IsNil)
+		c.Assert(l.res.StatusCode, check.Equals, http.StatusOK)
+		if !strings.HasSuffix(l.out, "hello") {
+			c.Fatalf("expected log output to container 'hello', but it does not")
+		}
+	case <-time.After(2 * time.Second):
+		c.Fatal("timeout waiting for logs to exit")
 	}
 }
 

integration-cli/docker_cli_attach_test.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bufio"
+	"fmt"
 	"io"
 	"os/exec"
 	"strings"
@@ -89,7 +90,6 @@ func (s *DockerSuite) TestAttachMultipleAndRestart(c *check.C) {
 }
 
 func (s *DockerSuite) TestAttachTtyWithoutStdin(c *check.C) {
-
 	cmd := exec.Command(dockerBinary, "run", "-d", "-ti", "busybox")
 	out, _, err := runCommandWithOutput(cmd)
 	if err != nil {
@@ -108,29 +108,32 @@ func (s *DockerSuite) TestAttachTtyWithoutStdin(c *check.C) {
 		}
 	}()
 
-	done := make(chan struct{})
+	done := make(chan error)
 	go func() {
 		defer close(done)
 
 		cmd := exec.Command(dockerBinary, "attach", id)
 		if _, err := cmd.StdinPipe(); err != nil {
-			c.Fatal(err)
+			done <- err
+			return
 		}
 
 		expected := "cannot enable tty mode"
 		if out, _, err := runCommandWithOutput(cmd); err == nil {
-			c.Fatal("attach should have failed")
+			done <- fmt.Errorf("attach should have failed")
+			return
 		} else if !strings.Contains(out, expected) {
-			c.Fatalf("attach failed with error %q: expected %q", out, expected)
+			done <- fmt.Errorf("attach failed with error %q: expected %q", out, expected)
+			return
 		}
 	}()
 
 	select {
-	case <-done:
+	case err := <-done:
+		c.Assert(err, check.IsNil)
 	case <-time.After(attachWait):
 		c.Fatal("attach is running but should have failed")
 	}
-
 }
 
 func (s *DockerSuite) TestAttachDisconnect(c *check.C) {
@@ -161,7 +164,7 @@ func (s *DockerSuite) TestAttachDisconnect(c *check.C) {
 		c.Fatal(err)
 	}
 	if strings.TrimSpace(out) != "hello" {
-		c.Fatalf("exepected 'hello', got %q", out)
+		c.Fatalf("expected 'hello', got %q", out)
 	}
 
 	if err := stdin.Close(); err != nil {
@@ -174,7 +177,7 @@ func (s *DockerSuite) TestAttachDisconnect(c *check.C) {
 		c.Fatal(err)
 	}
 	if running != "true" {
-		c.Fatal("exepected container to still be running")
+		c.Fatal("expected container to still be running")
 	}
 
 }

integration-cli/docker_cli_attach_unix_test.go

@@ -27,14 +27,14 @@ func (s *DockerSuite) TestAttachClosedOnContainerStop(c *check.C) {
 		c.Fatal(err)
 	}
 
-	done := make(chan struct{})
-
+	errChan := make(chan error)
 	go func() {
-		defer close(done)
+		defer close(errChan)
 
 		_, tty, err := pty.Open()
 		if err != nil {
-			c.Fatalf("could not open pty: %v", err)
+			errChan <- err
+			return
 		}
 		attachCmd := exec.Command(dockerBinary, "attach", id)
 		attachCmd.Stdin = tty
@@ -42,7 +42,8 @@ func (s *DockerSuite) TestAttachClosedOnContainerStop(c *check.C) {
 		attachCmd.Stderr = tty
 
 		if err := attachCmd.Run(); err != nil {
-			c.Fatalf("attach returned error %s", err)
+			errChan <- err
+			return
 		}
 	}()
 
@@ -51,7 +52,8 @@ func (s *DockerSuite) TestAttachClosedOnContainerStop(c *check.C) {
 		c.Fatalf("error thrown while waiting for container: %s, %v", out, err)
 	}
 	select {
-	case <-done:
+	case err := <-errChan:
+		c.Assert(err, check.IsNil)
 	case <-time.After(attachWait):
 		c.Fatal("timed out without attach returning")
 	}
@@ -71,12 +73,10 @@ func (s *DockerSuite) TestAttachAfterDetach(c *check.C) {
 	cmd.Stdout = tty
 	cmd.Stderr = tty
 
-	detached := make(chan struct{})
+	errChan := make(chan error)
 	go func() {
-		if err := cmd.Run(); err != nil {
-			c.Fatalf("attach returned error %s", err)
-		}
-		close(detached)
+		errChan <- cmd.Run()
+		close(errChan)
 	}()
 
 	time.Sleep(500 * time.Millisecond)
@@ -87,7 +87,12 @@ func (s *DockerSuite) TestAttachAfterDetach(c *check.C) {
 	time.Sleep(100 * time.Millisecond)
 	cpty.Write([]byte{17})
 
-	<-detached
+	select {
+	case err := <-errChan:
+		c.Assert(err, check.IsNil)
+	case <-time.After(5 * time.Second):
+		c.Fatal("timeout while detaching")
+	}
 
 	cpty, tty, err = pty.Open()
 	if err != nil {
@@ -119,9 +124,7 @@ func (s *DockerSuite) TestAttachAfterDetach(c *check.C) {
 
 	select {
 	case err := <-readErr:
-		if err != nil {
-			c.Fatal(err)
-		}
+		c.Assert(err, check.IsNil)
 	case <-time.After(2 * time.Second):
 		c.Fatal("timeout waiting for attach read")
 	}
@@ -172,7 +175,7 @@ func (s *DockerSuite) TestAttachDetach(c *check.C) {
 		c.Fatal(err)
 	}
 	if strings.TrimSpace(out) != "hello" {
-		c.Fatalf("exepected 'hello', got %q", out)
+		c.Fatalf("expected 'hello', got %q", out)
 	}
 
 	// escape sequence
@@ -195,7 +198,7 @@ func (s *DockerSuite) TestAttachDetach(c *check.C) {
 		c.Fatal(err)
 	}
 	if running != "true" {
-		c.Fatal("exepected container to still be running")
+		c.Fatal("expected container to still be running")
 	}
 
 	go func() {
@@ -243,7 +246,7 @@ func (s *DockerSuite) TestAttachDetachTruncatedID(c *check.C) {
 		c.Fatal(err)
 	}
 	if strings.TrimSpace(out) != "hello" {
-		c.Fatalf("exepected 'hello', got %q", out)
+		c.Fatalf("expected 'hello', got %q", out)
 	}
 
 	// escape sequence
@@ -266,7 +269,7 @@ func (s *DockerSuite) TestAttachDetachTruncatedID(c *check.C) {
 		c.Fatal(err)
 	}
 	if running != "true" {
-		c.Fatal("exepected container to still be running")
+		c.Fatal("expected container to still be running")
 	}
 
 	go func() {

integration-cli/docker_cli_by_digest_test.go

@@ -33,7 +33,6 @@ func setupImageWithTag(tag string) (string, error) {
 	if out, _, err := runCommandWithOutput(cmd); err != nil {
 		return "", fmt.Errorf("image tagging failed: %s, %v", out, err)
 	}
-	defer deleteImages(repoAndTag)
 
 	// delete the container as we don't need it any more
 	if err := deleteContainer(containerName); err != nil {
@@ -63,9 +62,7 @@ func setupImageWithTag(tag string) (string, error) {
 	return pushDigest, nil
 }
 
-func (s *DockerSuite) TestPullByTagDisplaysDigest(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestPullByTagDisplaysDigest(c *check.C) {
 	pushDigest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -77,7 +74,6 @@ func (s *DockerSuite) TestPullByTagDisplaysDigest(c *check.C) {
 	if err != nil {
 		c.Fatalf("error pulling by tag: %s, %v", out, err)
 	}
-	defer deleteImages(repoName)
 
 	// the pull output includes "Digest: <digest>", so find that
 	matches := digestRegex.FindStringSubmatch(out)
@@ -90,12 +86,9 @@ func (s *DockerSuite) TestPullByTagDisplaysDigest(c *check.C) {
 	if pushDigest != pullDigest {
 		c.Fatalf("push digest %q didn't match pull digest %q", pushDigest, pullDigest)
 	}
-
 }
 
-func (s *DockerSuite) TestPullByDigest(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestPullByDigest(c *check.C) {
 	pushDigest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -108,7 +101,6 @@ func (s *DockerSuite) TestPullByDigest(c *check.C) {
 	if err != nil {
 		c.Fatalf("error pulling by digest: %s, %v", out, err)
 	}
-	defer deleteImages(imageReference)
 
 	// the pull output includes "Digest: <digest>", so find that
 	matches := digestRegex.FindStringSubmatch(out)
@@ -121,12 +113,9 @@ func (s *DockerSuite) TestPullByDigest(c *check.C) {
 	if pushDigest != pullDigest {
 		c.Fatalf("push digest %q didn't match pull digest %q", pushDigest, pullDigest)
 	}
-
 }
 
-func (s *DockerSuite) TestCreateByDigest(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestCreateByDigest(c *check.C) {
 	pushDigest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -148,12 +137,9 @@ func (s *DockerSuite) TestCreateByDigest(c *check.C) {
 	if res != imageReference {
 		c.Fatalf("unexpected Config.Image: %s (expected %s)", res, imageReference)
 	}
-
 }
 
-func (s *DockerSuite) TestRunByDigest(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestRunByDigest(c *check.C) {
 	pushDigest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -184,12 +170,9 @@ func (s *DockerSuite) TestRunByDigest(c *check.C) {
 	if res != imageReference {
 		c.Fatalf("unexpected Config.Image: %s (expected %s)", res, imageReference)
 	}
-
 }
 
-func (s *DockerSuite) TestRemoveImageByDigest(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestRemoveImageByDigest(c *check.C) {
 	digest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -220,12 +203,9 @@ func (s *DockerSuite) TestRemoveImageByDigest(c *check.C) {
 	} else if !strings.Contains(err.Error(), "No such image") {
 		c.Fatalf("expected 'No such image' output, got %v", err)
 	}
-
 }
 
-func (s *DockerSuite) TestBuildByDigest(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestBuildByDigest(c *check.C) {
 	digest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -248,7 +228,6 @@ func (s *DockerSuite) TestBuildByDigest(c *check.C) {
 
 	// do the build
 	name := "buildbydigest"
-	defer deleteImages(name)
 	_, err = buildImage(name, fmt.Sprintf(
 		`FROM %s
      CMD ["/bin/echo", "Hello World"]`, imageReference),
@@ -266,12 +245,9 @@ func (s *DockerSuite) TestBuildByDigest(c *check.C) {
 	if res != imageID {
 		c.Fatalf("Image %s, expected %s", res, imageID)
 	}
-
 }
 
-func (s *DockerSuite) TestTagByDigest(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestTagByDigest(c *check.C) {
 	digest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -306,12 +282,9 @@ func (s *DockerSuite) TestTagByDigest(c *check.C) {
 	if tagID != expectedID {
 		c.Fatalf("expected image id %q, got %q", expectedID, tagID)
 	}
-
 }
 
-func (s *DockerSuite) TestListImagesWithoutDigests(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestListImagesWithoutDigests(c *check.C) {
 	digest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -338,9 +311,7 @@ func (s *DockerSuite) TestListImagesWithoutDigests(c *check.C) {
 
 }
 
-func (s *DockerSuite) TestListImagesWithDigests(c *check.C) {
-	defer setupRegistry(c)()
-	defer deleteImages(repoName+":tag1", repoName+":tag2")
+func (s *DockerRegistrySuite) TestListImagesWithDigests(c *check.C) {
 
 	// setup image1
 	digest1, err := setupImageWithTag("tag1")
@@ -348,7 +319,6 @@ func (s *DockerSuite) TestListImagesWithDigests(c *check.C) {
 		c.Fatalf("error setting up image: %v", err)
 	}
 	imageReference1 := fmt.Sprintf("%s@%s", repoName, digest1)
-	defer deleteImages(imageReference1)
 	c.Logf("imageReference1 = %s", imageReference1)
 
 	// pull image1 by digest
@@ -377,7 +347,6 @@ func (s *DockerSuite) TestListImagesWithDigests(c *check.C) {
 		c.Fatalf("error setting up image: %v", err)
 	}
 	imageReference2 := fmt.Sprintf("%s@%s", repoName, digest2)
-	defer deleteImages(imageReference2)
 	c.Logf("imageReference2 = %s", imageReference2)
 
 	// pull image1 by digest
@@ -489,12 +458,9 @@ func (s *DockerSuite) TestListImagesWithDigests(c *check.C) {
 	if !busyboxRe.MatchString(out) {
 		c.Fatalf("expected %q: %s", busyboxRe.String(), out)
 	}
-
 }
 
-func (s *DockerSuite) TestDeleteImageByIDOnlyPulledByDigest(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestDeleteImageByIDOnlyPulledByDigest(c *check.C) {
 	pushDigest, err := setupImage()
 	if err != nil {
 		c.Fatalf("error setting up image: %v", err)
@@ -508,7 +474,6 @@ func (s *DockerSuite) TestDeleteImageByIDOnlyPulledByDigest(c *check.C) {
 		c.Fatalf("error pulling by digest: %s, %v", out, err)
 	}
 	// just in case...
-	defer deleteImages(imageReference)
 
 	imageID, err := inspectField(imageReference, ".Id")
 	if err != nil {
@@ -519,5 +484,4 @@ func (s *DockerSuite) TestDeleteImageByIDOnlyPulledByDigest(c *check.C) {
 	if _, err := runCommand(cmd); err != nil {
 		c.Fatalf("error deleting image by id: %v", err)
 	}
-
 }

integration-cli/docker_cli_commit_test.go

@@ -33,10 +33,6 @@ func (s *DockerSuite) TestCommitAfterContainerIsDone(c *check.C) {
 	if out, _, err = runCommandWithOutput(inspectCmd); err != nil {
 		c.Fatalf("failed to inspect image: %s, %v", out, err)
 	}
-
-	deleteContainer(cleanedContainerID)
-	deleteImages(cleanedImageID)
-
 }
 
 func (s *DockerSuite) TestCommitWithoutPause(c *check.C) {
@@ -65,10 +61,6 @@ func (s *DockerSuite) TestCommitWithoutPause(c *check.C) {
 	if out, _, err = runCommandWithOutput(inspectCmd); err != nil {
 		c.Fatalf("failed to inspect image: %s, %v", out, err)
 	}
-
-	deleteContainer(cleanedContainerID)
-	deleteImages(cleanedImageID)
-
 }
 
 //test commit a paused container should not unpause it after commit
@@ -92,8 +84,6 @@ func (s *DockerSuite) TestCommitPausedContainer(c *check.C) {
 	if err != nil {
 		c.Fatalf("failed to commit container to image: %s, %v", out, err)
 	}
-	cleanedImageID := strings.TrimSpace(out)
-	defer deleteImages(cleanedImageID)
 
 	cmd = exec.Command(dockerBinary, "inspect", "-f", "{{.State.Paused}}", cleanedContainerID)
 	out, _, _, err = runCommandWithStdoutStderr(cmd)
@@ -120,7 +110,6 @@ func (s *DockerSuite) TestCommitNewFile(c *check.C) {
 		c.Fatal(err)
 	}
 	imageID = strings.Trim(imageID, "\r\n")
-	defer deleteImages(imageID)
 
 	cmd = exec.Command(dockerBinary, "run", imageID, "cat", "/foo")
 
@@ -161,7 +150,6 @@ func (s *DockerSuite) TestCommitHardlink(c *check.C) {
 		c.Fatal(imageID, err)
 	}
 	imageID = strings.Trim(imageID, "\r\n")
-	defer deleteImages(imageID)
 
 	cmd = exec.Command(dockerBinary, "run", "-t", "hardlinks", "ls", "-di", "file1", "file2")
 	secondOuput, _, err := runCommandWithOutput(cmd)
@@ -185,7 +173,6 @@ func (s *DockerSuite) TestCommitHardlink(c *check.C) {
 }
 
 func (s *DockerSuite) TestCommitTTY(c *check.C) {
-	defer deleteImages("ttytest")
 
 	cmd := exec.Command(dockerBinary, "run", "-t", "--name", "tty", "busybox", "/bin/ls")
 	if _, err := runCommand(cmd); err != nil {
@@ -220,7 +207,6 @@ func (s *DockerSuite) TestCommitWithHostBindMount(c *check.C) {
 	}
 
 	imageID = strings.Trim(imageID, "\r\n")
-	defer deleteImages(imageID)
 
 	cmd = exec.Command(dockerBinary, "run", "bindtest", "true")
 
@@ -248,7 +234,6 @@ func (s *DockerSuite) TestCommitChange(c *check.C) {
 		c.Fatal(imageId, err)
 	}
 	imageId = strings.Trim(imageId, "\r\n")
-	defer deleteImages(imageId)
 
 	expected := map[string]string{
 		"Config.ExposedPorts": "map[8080/tcp:{}]",
@@ -274,11 +259,10 @@ func (s *DockerSuite) TestCommitMergeConfigRun(c *check.C) {
 	id := strings.TrimSpace(out)
 
 	dockerCmd(c, "commit", `--run={"Cmd": ["cat", "/tmp/foo"]}`, id, "commit-test")
-	defer deleteImages("commit-test")
 
 	out, _ = dockerCmd(c, "run", "--name", name, "commit-test")
 	if strings.TrimSpace(out) != "testing" {
-		c.Fatal("run config in commited container was not merged")
+		c.Fatal("run config in committed container was not merged")
 	}
 
 	type cfg struct {

integration-cli/docker_cli_create_test.go

@@ -259,7 +259,6 @@ func (s *DockerSuite) TestCreateLabels(c *check.C) {
 
 func (s *DockerSuite) TestCreateLabelFromImage(c *check.C) {
 	imageName := "testcreatebuildlabel"
-	defer deleteImages(imageName)
 	_, err := buildImage(imageName,
 		`FROM busybox
 		LABEL k1=v1 k2=v2`,

integration-cli/docker_cli_daemon_test.go

@@ -16,25 +16,23 @@ import (
 	"github.com/go-check/check"
 )
 
-func (s *DockerSuite) TestDaemonRestartWithRunningContainersPorts(c *check.C) {
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonRestartWithRunningContainersPorts(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
-	if out, err := d.Cmd("run", "-d", "--name", "top1", "-p", "1234:80", "--restart", "always", "busybox:latest", "top"); err != nil {
+	if out, err := s.d.Cmd("run", "-d", "--name", "top1", "-p", "1234:80", "--restart", "always", "busybox:latest", "top"); err != nil {
 		c.Fatalf("Could not run top1: err=%v\n%s", err, out)
 	}
 	// --restart=no by default
-	if out, err := d.Cmd("run", "-d", "--name", "top2", "-p", "80", "busybox:latest", "top"); err != nil {
+	if out, err := s.d.Cmd("run", "-d", "--name", "top2", "-p", "80", "busybox:latest", "top"); err != nil {
 		c.Fatalf("Could not run top2: err=%v\n%s", err, out)
 	}
 
 	testRun := func(m map[string]bool, prefix string) {
 		var format string
 		for cont, shouldRun := range m {
-			out, err := d.Cmd("ps")
+			out, err := s.d.Cmd("ps")
 			if err != nil {
 				c.Fatalf("Could not run ps: err=%v\n%q", err, out)
 			}
@@ -51,34 +49,30 @@ func (s *DockerSuite) TestDaemonRestartWithRunningContainersPorts(c *check.C) {
 
 	testRun(map[string]bool{"top1": true, "top2": true}, "")
 
-	if err := d.Restart(); err != nil {
+	if err := s.d.Restart(); err != nil {
 		c.Fatalf("Could not restart daemon: %v", err)
 	}
-
 	testRun(map[string]bool{"top1": true, "top2": false}, "After daemon restart: ")
-
 }
 
-func (s *DockerSuite) TestDaemonRestartWithVolumesRefs(c *check.C) {
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonRestartWithVolumesRefs(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
-	if out, err := d.Cmd("run", "-d", "--name", "volrestarttest1", "-v", "/foo", "busybox"); err != nil {
+	if out, err := s.d.Cmd("run", "-d", "--name", "volrestarttest1", "-v", "/foo", "busybox"); err != nil {
 		c.Fatal(err, out)
 	}
-	if err := d.Restart(); err != nil {
+	if err := s.d.Restart(); err != nil {
 		c.Fatal(err)
 	}
-	if _, err := d.Cmd("run", "-d", "--volumes-from", "volrestarttest1", "--name", "volrestarttest2", "busybox", "top"); err != nil {
+	if _, err := s.d.Cmd("run", "-d", "--volumes-from", "volrestarttest1", "--name", "volrestarttest2", "busybox", "top"); err != nil {
 		c.Fatal(err)
 	}
-	if out, err := d.Cmd("rm", "-fv", "volrestarttest2"); err != nil {
+	if out, err := s.d.Cmd("rm", "-fv", "volrestarttest2"); err != nil {
 		c.Fatal(err, out)
 	}
-	v, err := d.Cmd("inspect", "--format", "{{ json .Volumes }}", "volrestarttest1")
+	v, err := s.d.Cmd("inspect", "--format", "{{ json .Volumes }}", "volrestarttest1")
 	if err != nil {
 		c.Fatal(err)
 	}
@@ -87,30 +81,25 @@ func (s *DockerSuite) TestDaemonRestartWithVolumesRefs(c *check.C) {
 	if _, err := os.Stat(volumes["/foo"]); err != nil {
 		c.Fatalf("Expected volume to exist: %s - %s", volumes["/foo"], err)
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonStartIptablesFalse(c *check.C) {
-	d := NewDaemon(c)
-	if err := d.Start("--iptables=false"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonStartIptablesFalse(c *check.C) {
+	if err := s.d.Start("--iptables=false"); err != nil {
 		c.Fatalf("we should have been able to start the daemon with passing iptables=false: %v", err)
 	}
-	d.Stop()
-
 }
 
 // Issue #8444: If docker0 bridge is modified (intentionally or unintentionally) and
 // no longer has an IP associated, we should gracefully handle that case and associate
 // an IP with it rather than fail daemon start
-func (s *DockerSuite) TestDaemonStartBridgeWithoutIPAssociation(c *check.C) {
-	d := NewDaemon(c)
+func (s *DockerDaemonSuite) TestDaemonStartBridgeWithoutIPAssociation(c *check.C) {
 	// rather than depending on brctl commands to verify docker0 is created and up
 	// let's start the daemon and stop it, and then make a modification to run the
 	// actual test
-	if err := d.Start(); err != nil {
+	if err := s.d.Start(); err != nil {
 		c.Fatalf("Could not start daemon: %v", err)
 	}
-	if err := d.Stop(); err != nil {
+	if err := s.d.Stop(); err != nil {
 		c.Fatalf("Could not stop daemon: %v", err)
 	}
 
@@ -121,27 +110,18 @@ func (s *DockerSuite) TestDaemonStartBridgeWithoutIPAssociation(c *check.C) {
 		c.Fatalf("failed to remove docker0 IP association: %v, stdout: %q, stderr: %q", err, stdout, stderr)
 	}
 
-	if err := d.Start(); err != nil {
+	if err := s.d.Start(); err != nil {
 		warning := "**WARNING: Docker bridge network in bad state--delete docker0 bridge interface to fix"
 		c.Fatalf("Could not start daemon when docker0 has no IP address: %v\n%s", err, warning)
 	}
-
-	// cleanup - stop the daemon if test passed
-	if err := d.Stop(); err != nil {
-		c.Fatalf("Could not stop daemon: %v", err)
-	}
-
 }
 
-func (s *DockerSuite) TestDaemonIptablesClean(c *check.C) {
-
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonIptablesClean(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
-	if out, err := d.Cmd("run", "-d", "--name", "top", "-p", "80", "busybox:latest", "top"); err != nil {
+	if out, err := s.d.Cmd("run", "-d", "--name", "top", "-p", "80", "busybox:latest", "top"); err != nil {
 		c.Fatalf("Could not run top: %s, %v", out, err)
 	}
 
@@ -157,7 +137,7 @@ func (s *DockerSuite) TestDaemonIptablesClean(c *check.C) {
 		c.Fatalf("iptables output should have contained %q, but was %q", ipTablesSearchString, out)
 	}
 
-	if err := d.Stop(); err != nil {
+	if err := s.d.Stop(); err != nil {
 		c.Fatalf("Could not stop daemon: %v", err)
 	}
 
@@ -171,18 +151,14 @@ func (s *DockerSuite) TestDaemonIptablesClean(c *check.C) {
 	if strings.Contains(out, ipTablesSearchString) {
 		c.Fatalf("iptables output should not have contained %q, but was %q", ipTablesSearchString, out)
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonIptablesCreate(c *check.C) {
-
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonIptablesCreate(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
-	if out, err := d.Cmd("run", "-d", "--name", "top", "--restart=always", "-p", "80", "busybox:latest", "top"); err != nil {
+	if out, err := s.d.Cmd("run", "-d", "--name", "top", "--restart=always", "-p", "80", "busybox:latest", "top"); err != nil {
 		c.Fatalf("Could not run top: %s, %v", out, err)
 	}
 
@@ -198,12 +174,12 @@ func (s *DockerSuite) TestDaemonIptablesCreate(c *check.C) {
 		c.Fatalf("iptables output should have contained %q, but was %q", ipTablesSearchString, out)
 	}
 
-	if err := d.Restart(); err != nil {
+	if err := s.d.Restart(); err != nil {
 		c.Fatalf("Could not restart daemon: %v", err)
 	}
 
 	// make sure the container is not running
-	runningOut, err := d.Cmd("inspect", "--format='{{.State.Running}}'", "top")
+	runningOut, err := s.d.Cmd("inspect", "--format='{{.State.Running}}'", "top")
 	if err != nil {
 		c.Fatalf("Could not inspect on container: %s, %v", out, err)
 	}
@@ -221,69 +197,64 @@ func (s *DockerSuite) TestDaemonIptablesCreate(c *check.C) {
 	if !strings.Contains(out, ipTablesSearchString) {
 		c.Fatalf("iptables output after restart should have contained %q, but was %q", ipTablesSearchString, out)
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonLoggingLevel(c *check.C) {
-	d := NewDaemon(c)
+func (s *DockerDaemonSuite) TestDaemonLogLevelWrong(c *check.C) {
+	c.Assert(s.d.Start("--log-level=bogus"), check.NotNil, check.Commentf("Daemon shouldn't start with wrong log level"))
+}
 
-	if err := d.Start("--log-level=bogus"); err == nil {
-		c.Fatal("Daemon should not have been able to start")
-	}
-
-	d = NewDaemon(c)
-	if err := d.Start("--log-level=debug"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonLogLevelDebug(c *check.C) {
+	if err := s.d.Start("--log-level=debug"); err != nil {
 		c.Fatal(err)
 	}
-	d.Stop()
-	content, _ := ioutil.ReadFile(d.logFile.Name())
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
 	if !strings.Contains(string(content), `level=debug`) {
 		c.Fatalf(`Missing level="debug" in log file:\n%s`, string(content))
 	}
+}
 
-	d = NewDaemon(c)
-	if err := d.Start("--log-level=fatal"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonLogLevelFatal(c *check.C) {
+	// we creating new daemons to create new logFile
+	if err := s.d.Start("--log-level=fatal"); err != nil {
 		c.Fatal(err)
 	}
-	d.Stop()
-	content, _ = ioutil.ReadFile(d.logFile.Name())
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
 	if strings.Contains(string(content), `level=debug`) {
 		c.Fatalf(`Should not have level="debug" in log file:\n%s`, string(content))
 	}
+}
 
-	d = NewDaemon(c)
-	if err := d.Start("-D"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonFlagD(c *check.C) {
+	if err := s.d.Start("-D"); err != nil {
 		c.Fatal(err)
 	}
-	d.Stop()
-	content, _ = ioutil.ReadFile(d.logFile.Name())
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
 	if !strings.Contains(string(content), `level=debug`) {
 		c.Fatalf(`Missing level="debug" in log file using -D:\n%s`, string(content))
 	}
+}
 
-	d = NewDaemon(c)
-	if err := d.Start("--debug"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonFlagDebug(c *check.C) {
+	if err := s.d.Start("--debug"); err != nil {
 		c.Fatal(err)
 	}
-	d.Stop()
-	content, _ = ioutil.ReadFile(d.logFile.Name())
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
 	if !strings.Contains(string(content), `level=debug`) {
 		c.Fatalf(`Missing level="debug" in log file using --debug:\n%s`, string(content))
 	}
+}
 
-	d = NewDaemon(c)
-	if err := d.Start("--debug", "--log-level=fatal"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonFlagDebugLogLevelFatal(c *check.C) {
+	if err := s.d.Start("--debug", "--log-level=fatal"); err != nil {
 		c.Fatal(err)
 	}
-	d.Stop()
-	content, _ = ioutil.ReadFile(d.logFile.Name())
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
 	if !strings.Contains(string(content), `level=debug`) {
 		c.Fatalf(`Missing level="debug" in log file when using both --debug and --log-level=fatal:\n%s`, string(content))
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonAllocatesListeningPort(c *check.C) {
+func (s *DockerDaemonSuite) TestDaemonAllocatesListeningPort(c *check.C) {
 	listeningPorts := [][]string{
 		{"0.0.0.0", "0.0.0.0", "5678"},
 		{"127.0.0.1", "127.0.0.1", "1234"},
@@ -295,31 +266,25 @@ func (s *DockerSuite) TestDaemonAllocatesListeningPort(c *check.C) {
 		cmdArgs = append(cmdArgs, "--host", fmt.Sprintf("tcp://%s:%s", hostDirective[0], hostDirective[2]))
 	}
 
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(cmdArgs...); err != nil {
+	if err := s.d.StartWithBusybox(cmdArgs...); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
 	for _, hostDirective := range listeningPorts {
-		output, err := d.Cmd("run", "-p", fmt.Sprintf("%s:%s:80", hostDirective[1], hostDirective[2]), "busybox", "true")
+		output, err := s.d.Cmd("run", "-p", fmt.Sprintf("%s:%s:80", hostDirective[1], hostDirective[2]), "busybox", "true")
 		if err == nil {
 			c.Fatalf("Container should not start, expected port already allocated error: %q", output)
 		} else if !strings.Contains(output, "port is already allocated") {
 			c.Fatalf("Expected port is already allocated error: %q", output)
 		}
 	}
-
 }
 
 // #9629
-func (s *DockerSuite) TestDaemonVolumesBindsRefs(c *check.C) {
-	d := NewDaemon(c)
-
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonVolumesBindsRefs(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
 	tmp, err := ioutil.TempDir(os.TempDir(), "")
 	if err != nil {
@@ -331,28 +296,26 @@ func (s *DockerSuite) TestDaemonVolumesBindsRefs(c *check.C) {
 		c.Fatal(err)
 	}
 
-	if out, err := d.Cmd("create", "-v", tmp+":/foo", "--name=voltest", "busybox"); err != nil {
+	if out, err := s.d.Cmd("create", "-v", tmp+":/foo", "--name=voltest", "busybox"); err != nil {
 		c.Fatal(err, out)
 	}
 
-	if err := d.Restart(); err != nil {
+	if err := s.d.Restart(); err != nil {
 		c.Fatal(err)
 	}
 
-	if out, err := d.Cmd("run", "--volumes-from=voltest", "--name=consumer", "busybox", "/bin/sh", "-c", "[ -f /foo/test ]"); err != nil {
+	if out, err := s.d.Cmd("run", "--volumes-from=voltest", "--name=consumer", "busybox", "/bin/sh", "-c", "[ -f /foo/test ]"); err != nil {
 		c.Fatal(err, out)
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonKeyGeneration(c *check.C) {
+func (s *DockerDaemonSuite) TestDaemonKeyGeneration(c *check.C) {
 	// TODO: skip or update for Windows daemon
 	os.Remove("/etc/docker/key.json")
-	d := NewDaemon(c)
-	if err := d.Start(); err != nil {
+	if err := s.d.Start(); err != nil {
 		c.Fatalf("Could not start daemon: %v", err)
 	}
-	d.Stop()
+	s.d.Stop()
 
 	k, err := libtrust.LoadKeyFile("/etc/docker/key.json")
 	if err != nil {
@@ -363,10 +326,9 @@ func (s *DockerSuite) TestDaemonKeyGeneration(c *check.C) {
 	if len(kid) != 59 {
 		c.Fatalf("Bad key ID: %s", kid)
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonKeyMigration(c *check.C) {
+func (s *DockerDaemonSuite) TestDaemonKeyMigration(c *check.C) {
 	// TODO: skip or update for Windows daemon
 	os.Remove("/etc/docker/key.json")
 	k1, err := libtrust.GenerateECP256PrivateKey()
@@ -380,11 +342,10 @@ func (s *DockerSuite) TestDaemonKeyMigration(c *check.C) {
 		c.Fatalf("Error saving private key: %s", err)
 	}
 
-	d := NewDaemon(c)
-	if err := d.Start(); err != nil {
+	if err := s.d.Start(); err != nil {
 		c.Fatalf("Could not start daemon: %v", err)
 	}
-	d.Stop()
+	s.d.Stop()
 
 	k2, err := libtrust.LoadKeyFile("/etc/docker/key.json")
 	if err != nil {
@@ -393,29 +354,25 @@ func (s *DockerSuite) TestDaemonKeyMigration(c *check.C) {
 	if k1.KeyID() != k2.KeyID() {
 		c.Fatalf("Key not migrated")
 	}
-
 }
 
 // Simulate an older daemon (pre 1.3) coming up with volumes specified in containers
 //	without corresponding volume json
-func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
-	d := NewDaemon(c)
-
+func (s *DockerDaemonSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
 	graphDir := filepath.Join(os.TempDir(), "docker-test")
 	defer os.RemoveAll(graphDir)
-	if err := d.StartWithBusybox("-g", graphDir); err != nil {
+	if err := s.d.StartWithBusybox("-g", graphDir); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
 	tmpDir := filepath.Join(os.TempDir(), "test")
 	defer os.RemoveAll(tmpDir)
 
-	if out, err := d.Cmd("create", "-v", tmpDir+":/foo", "--name=test", "busybox"); err != nil {
+	if out, err := s.d.Cmd("create", "-v", tmpDir+":/foo", "--name=test", "busybox"); err != nil {
 		c.Fatal(err, out)
 	}
 
-	if err := d.Stop(); err != nil {
+	if err := s.d.Stop(); err != nil {
 		c.Fatal(err)
 	}
 
@@ -430,7 +387,7 @@ func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
 		c.Fatal(err)
 	}
 
-	if err := d.Start("-g", graphDir); err != nil {
+	if err := s.d.Start("-g", graphDir); err != nil {
 		c.Fatal(err)
 	}
 
@@ -447,7 +404,7 @@ func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
 	}
 
 	// Now with just removing the volume config and not the volume data
-	if err := d.Stop(); err != nil {
+	if err := s.d.Stop(); err != nil {
 		c.Fatal(err)
 	}
 
@@ -455,7 +412,7 @@ func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
 		c.Fatal(err)
 	}
 
-	if err := d.Start("-g", graphDir); err != nil {
+	if err := s.d.Start("-g", graphDir); err != nil {
 		c.Fatal(err)
 	}
 
@@ -467,45 +424,37 @@ func (s *DockerSuite) TestDaemonUpgradeWithVolumes(c *check.C) {
 	if len(dir) == 0 {
 		c.Fatalf("expected volumes config dir to contain data for new volume")
 	}
-
 }
 
 // GH#11320 - verify that the daemon exits on failure properly
 // Note that this explicitly tests the conflict of {-b,--bridge} and {--bip} options as the means
 // to get a daemon init failure; no other tests for -b/--bip conflict are therefore required
-func (s *DockerSuite) TestDaemonExitOnFailure(c *check.C) {
-	d := NewDaemon(c)
-	defer d.Stop()
-
+func (s *DockerDaemonSuite) TestDaemonExitOnFailure(c *check.C) {
 	//attempt to start daemon with incorrect flags (we know -b and --bip conflict)
-	if err := d.Start("--bridge", "nosuchbridge", "--bip", "1.1.1.1"); err != nil {
+	if err := s.d.Start("--bridge", "nosuchbridge", "--bip", "1.1.1.1"); err != nil {
 		//verify we got the right error
 		if !strings.Contains(err.Error(), "Daemon exited and never started") {
 			c.Fatalf("Expected daemon not to start, got %v", err)
 		}
 		// look in the log and make sure we got the message that daemon is shutting down
-		runCmd := exec.Command("grep", "Error starting daemon", d.LogfileName())
+		runCmd := exec.Command("grep", "Error starting daemon", s.d.LogfileName())
 		if out, _, err := runCommandWithOutput(runCmd); err != nil {
 			c.Fatalf("Expected 'Error starting daemon' message; but doesn't exist in log: %q, err: %v", out, err)
 		}
 	} else {
 		//if we didn't get an error and the daemon is running, this is a failure
-		d.Stop()
 		c.Fatal("Conflicting options should cause the daemon to error out with a failure")
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonUlimitDefaults(c *check.C) {
+func (s *DockerDaemonSuite) TestDaemonUlimitDefaults(c *check.C) {
 	testRequires(c, NativeExecDriver)
-	d := NewDaemon(c)
 
-	if err := d.StartWithBusybox("--default-ulimit", "nofile=42:42", "--default-ulimit", "nproc=1024:1024"); err != nil {
+	if err := s.d.StartWithBusybox("--default-ulimit", "nofile=42:42", "--default-ulimit", "nproc=1024:1024"); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
-	out, err := d.Cmd("run", "--ulimit", "nproc=2048", "--name=test", "busybox", "/bin/sh", "-c", "echo $(ulimit -n); echo $(ulimit -p)")
+	out, err := s.d.Cmd("run", "--ulimit", "nproc=2048", "--name=test", "busybox", "/bin/sh", "-c", "echo $(ulimit -n); echo $(ulimit -p)")
 	if err != nil {
 		c.Fatal(out, err)
 	}
@@ -525,11 +474,11 @@ func (s *DockerSuite) TestDaemonUlimitDefaults(c *check.C) {
 	}
 
 	// Now restart daemon with a new default
-	if err := d.Restart("--default-ulimit", "nofile=43"); err != nil {
+	if err := s.d.Restart("--default-ulimit", "nofile=43"); err != nil {
 		c.Fatal(err)
 	}
 
-	out, err = d.Cmd("start", "-a", "test")
+	out, err = s.d.Cmd("start", "-a", "test")
 	if err != nil {
 		c.Fatal(err)
 	}
@@ -547,53 +496,46 @@ func (s *DockerSuite) TestDaemonUlimitDefaults(c *check.C) {
 	if nproc != "2048" {
 		c.Fatalf("exepcted `ulimit -p` to be 2048, got: %s", nproc)
 	}
-
 }
 
 // #11315
-func (s *DockerSuite) TestDaemonRestartRenameContainer(c *check.C) {
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(); err != nil {
-		c.Fatal(err)
-	}
-	defer d.Stop()
-
-	if out, err := d.Cmd("run", "--name=test", "busybox"); err != nil {
-		c.Fatal(err, out)
-	}
-
-	if out, err := d.Cmd("rename", "test", "test2"); err != nil {
-		c.Fatal(err, out)
-	}
-
-	if err := d.Restart(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonRestartRenameContainer(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatal(err)
 	}
 
-	if out, err := d.Cmd("start", "test2"); err != nil {
+	if out, err := s.d.Cmd("run", "--name=test", "busybox"); err != nil {
 		c.Fatal(err, out)
 	}
 
+	if out, err := s.d.Cmd("rename", "test", "test2"); err != nil {
+		c.Fatal(err, out)
+	}
+
+	if err := s.d.Restart(); err != nil {
+		c.Fatal(err)
+	}
+
+	if out, err := s.d.Cmd("start", "test2"); err != nil {
+		c.Fatal(err, out)
+	}
 }
 
-func (s *DockerSuite) TestDaemonLoggingDriverDefault(c *check.C) {
-	d := NewDaemon(c)
-
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverDefault(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
-	out, err := d.Cmd("run", "-d", "busybox", "echo", "testline")
+	out, err := s.d.Cmd("run", "-d", "busybox", "echo", "testline")
 	if err != nil {
 		c.Fatal(out, err)
 	}
 	id := strings.TrimSpace(out)
 
-	if out, err := d.Cmd("wait", id); err != nil {
+	if out, err := s.d.Cmd("wait", id); err != nil {
 		c.Fatal(out, err)
 	}
-	logPath := filepath.Join(d.folder, "graph", "containers", id, id+"-json.log")
+	logPath := filepath.Join(s.d.folder, "graph", "containers", id, id+"-json.log")
 
 	if _, err := os.Stat(logPath); err != nil {
 		c.Fatal(err)
@@ -621,72 +563,63 @@ func (s *DockerSuite) TestDaemonLoggingDriverDefault(c *check.C) {
 	}
 }
 
-func (s *DockerSuite) TestDaemonLoggingDriverDefaultOverride(c *check.C) {
-	d := NewDaemon(c)
-
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverDefaultOverride(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
-	out, err := d.Cmd("run", "-d", "--log-driver=none", "busybox", "echo", "testline")
+	out, err := s.d.Cmd("run", "-d", "--log-driver=none", "busybox", "echo", "testline")
 	if err != nil {
 		c.Fatal(out, err)
 	}
 	id := strings.TrimSpace(out)
 
-	if out, err := d.Cmd("wait", id); err != nil {
+	if out, err := s.d.Cmd("wait", id); err != nil {
 		c.Fatal(out, err)
 	}
-	logPath := filepath.Join(d.folder, "graph", "containers", id, id+"-json.log")
+	logPath := filepath.Join(s.d.folder, "graph", "containers", id, id+"-json.log")
 
 	if _, err := os.Stat(logPath); err == nil || !os.IsNotExist(err) {
 		c.Fatalf("%s shouldn't exits, error on Stat: %s", logPath, err)
 	}
 }
 
-func (s *DockerSuite) TestDaemonLoggingDriverNone(c *check.C) {
-	d := NewDaemon(c)
-
-	if err := d.StartWithBusybox("--log-driver=none"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverNone(c *check.C) {
+	if err := s.d.StartWithBusybox("--log-driver=none"); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
-	out, err := d.Cmd("run", "-d", "busybox", "echo", "testline")
+	out, err := s.d.Cmd("run", "-d", "busybox", "echo", "testline")
 	if err != nil {
 		c.Fatal(out, err)
 	}
 	id := strings.TrimSpace(out)
-	if out, err := d.Cmd("wait", id); err != nil {
+	if out, err := s.d.Cmd("wait", id); err != nil {
 		c.Fatal(out, err)
 	}
 
-	logPath := filepath.Join(d.folder, "graph", "containers", id, id+"-json.log")
+	logPath := filepath.Join(s.d.folder, "graph", "containers", id, id+"-json.log")
 
 	if _, err := os.Stat(logPath); err == nil || !os.IsNotExist(err) {
 		c.Fatalf("%s shouldn't exits, error on Stat: %s", logPath, err)
 	}
 }
 
-func (s *DockerSuite) TestDaemonLoggingDriverNoneOverride(c *check.C) {
-	d := NewDaemon(c)
-
-	if err := d.StartWithBusybox("--log-driver=none"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverNoneOverride(c *check.C) {
+	if err := s.d.StartWithBusybox("--log-driver=none"); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
-	out, err := d.Cmd("run", "-d", "--log-driver=json-file", "busybox", "echo", "testline")
+	out, err := s.d.Cmd("run", "-d", "--log-driver=json-file", "busybox", "echo", "testline")
 	if err != nil {
 		c.Fatal(out, err)
 	}
 	id := strings.TrimSpace(out)
 
-	if out, err := d.Cmd("wait", id); err != nil {
+	if out, err := s.d.Cmd("wait", id); err != nil {
 		c.Fatal(out, err)
 	}
-	logPath := filepath.Join(d.folder, "graph", "containers", id, id+"-json.log")
+	logPath := filepath.Join(s.d.folder, "graph", "containers", id, id+"-json.log")
 
 	if _, err := os.Stat(logPath); err != nil {
 		c.Fatal(err)
@@ -714,20 +647,17 @@ func (s *DockerSuite) TestDaemonLoggingDriverNoneOverride(c *check.C) {
 	}
 }
 
-func (s *DockerSuite) TestDaemonLoggingDriverNoneLogsError(c *check.C) {
-	d := NewDaemon(c)
-
-	if err := d.StartWithBusybox("--log-driver=none"); err != nil {
+func (s *DockerDaemonSuite) TestDaemonLoggingDriverNoneLogsError(c *check.C) {
+	if err := s.d.StartWithBusybox("--log-driver=none"); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
-	out, err := d.Cmd("run", "-d", "busybox", "echo", "testline")
+	out, err := s.d.Cmd("run", "-d", "busybox", "echo", "testline")
 	if err != nil {
 		c.Fatal(out, err)
 	}
 	id := strings.TrimSpace(out)
-	out, err = d.Cmd("logs", id)
+	out, err = s.d.Cmd("logs", id)
 	if err == nil {
 		c.Fatalf("Logs should fail with \"none\" driver")
 	}
@@ -736,54 +666,50 @@ func (s *DockerSuite) TestDaemonLoggingDriverNoneLogsError(c *check.C) {
 	}
 }
 
-func (s *DockerSuite) TestDaemonDots(c *check.C) {
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonDots(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
 	// Now create 4 containers
-	if _, err := d.Cmd("create", "busybox"); err != nil {
+	if _, err := s.d.Cmd("create", "busybox"); err != nil {
 		c.Fatalf("Error creating container: %q", err)
 	}
-	if _, err := d.Cmd("create", "busybox"); err != nil {
+	if _, err := s.d.Cmd("create", "busybox"); err != nil {
 		c.Fatalf("Error creating container: %q", err)
 	}
-	if _, err := d.Cmd("create", "busybox"); err != nil {
+	if _, err := s.d.Cmd("create", "busybox"); err != nil {
 		c.Fatalf("Error creating container: %q", err)
 	}
-	if _, err := d.Cmd("create", "busybox"); err != nil {
+	if _, err := s.d.Cmd("create", "busybox"); err != nil {
 		c.Fatalf("Error creating container: %q", err)
 	}
 
-	d.Stop()
+	s.d.Stop()
 
-	d.Start("--log-level=debug")
-	d.Stop()
-	content, _ := ioutil.ReadFile(d.logFile.Name())
+	s.d.Start("--log-level=debug")
+	s.d.Stop()
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
 	if strings.Contains(string(content), "....") {
 		c.Fatalf("Debug level should not have ....\n%s", string(content))
 	}
 
-	d.Start("--log-level=error")
-	d.Stop()
-	content, _ = ioutil.ReadFile(d.logFile.Name())
+	s.d.Start("--log-level=error")
+	s.d.Stop()
+	content, _ = ioutil.ReadFile(s.d.logFile.Name())
 	if strings.Contains(string(content), "....") {
 		c.Fatalf("Error level should not have ....\n%s", string(content))
 	}
 
-	d.Start("--log-level=info")
-	d.Stop()
-	content, _ = ioutil.ReadFile(d.logFile.Name())
+	s.d.Start("--log-level=info")
+	s.d.Stop()
+	content, _ = ioutil.ReadFile(s.d.logFile.Name())
 	if !strings.Contains(string(content), "....") {
 		c.Fatalf("Info level should have ....\n%s", string(content))
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonUnixSockCleanedUp(c *check.C) {
-	d := NewDaemon(c)
+func (s *DockerDaemonSuite) TestDaemonUnixSockCleanedUp(c *check.C) {
 	dir, err := ioutil.TempDir("", "socket-cleanup-test")
 	if err != nil {
 		c.Fatal(err)
@@ -791,26 +717,24 @@ func (s *DockerSuite) TestDaemonUnixSockCleanedUp(c *check.C) {
 	defer os.RemoveAll(dir)
 
 	sockPath := filepath.Join(dir, "docker.sock")
-	if err := d.Start("--host", "unix://"+sockPath); err != nil {
+	if err := s.d.Start("--host", "unix://"+sockPath); err != nil {
 		c.Fatal(err)
 	}
-	defer d.Stop()
 
 	if _, err := os.Stat(sockPath); err != nil {
 		c.Fatal("socket does not exist")
 	}
 
-	if err := d.Stop(); err != nil {
+	if err := s.d.Stop(); err != nil {
 		c.Fatal(err)
 	}
 
 	if _, err := os.Stat(sockPath); err == nil || !os.IsNotExist(err) {
 		c.Fatal("unix socket is not cleaned up")
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonwithwrongkey(c *check.C) {
+func (s *DockerDaemonSuite) TestDaemonwithwrongkey(c *check.C) {
 	type Config struct {
 		Crv string `json:"crv"`
 		D   string `json:"d"`
@@ -821,12 +745,11 @@ func (s *DockerSuite) TestDaemonwithwrongkey(c *check.C) {
 	}
 
 	os.Remove("/etc/docker/key.json")
-	d := NewDaemon(c)
-	if err := d.Start(); err != nil {
+	if err := s.d.Start(); err != nil {
 		c.Fatalf("Failed to start daemon: %v", err)
 	}
 
-	if err := d.Stop(); err != nil {
+	if err := s.d.Stop(); err != nil {
 		c.Fatalf("Could not stop daemon: %v", err)
 	}
 
@@ -855,46 +778,41 @@ func (s *DockerSuite) TestDaemonwithwrongkey(c *check.C) {
 		c.Fatalf("Error ioutil.WriteFile: %s", err)
 	}
 
-	d1 := NewDaemon(c)
 	defer os.Remove("/etc/docker/key.json")
 
-	if err := d1.Start(); err == nil {
-		d1.Stop()
-		c.Fatalf("It should not be succssful to start daemon with wrong key: %v", err)
+	if err := s.d.Start(); err == nil {
+		c.Fatalf("It should not be successful to start daemon with wrong key: %v", err)
 	}
 
-	content, _ := ioutil.ReadFile(d1.logFile.Name())
+	content, _ := ioutil.ReadFile(s.d.logFile.Name())
 
 	if !strings.Contains(string(content), "Public Key ID does not match") {
 		c.Fatal("Missing KeyID message from daemon logs")
 	}
-
 }
 
-func (s *DockerSuite) TestDaemonRestartKillWait(c *check.C) {
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(); err != nil {
+func (s *DockerDaemonSuite) TestDaemonRestartKillWait(c *check.C) {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
-	out, err := d.Cmd("run", "-id", "busybox", "/bin/cat")
+	out, err := s.d.Cmd("run", "-id", "busybox", "/bin/cat")
 	if err != nil {
 		c.Fatalf("Could not run /bin/cat: err=%v\n%s", err, out)
 	}
 	containerID := strings.TrimSpace(out)
 
-	if out, err := d.Cmd("kill", containerID); err != nil {
+	if out, err := s.d.Cmd("kill", containerID); err != nil {
 		c.Fatalf("Could not kill %s: err=%v\n%s", containerID, err, out)
 	}
 
-	if err := d.Restart(); err != nil {
+	if err := s.d.Restart(); err != nil {
 		c.Fatalf("Could not restart daemon: %v", err)
 	}
 
 	errchan := make(chan error)
 	go func() {
-		if out, err := d.Cmd("wait", containerID); err != nil {
+		if out, err := s.d.Cmd("wait", containerID); err != nil {
 			errchan <- fmt.Errorf("%v:\n%s", err, out)
 		}
 		close(errchan)
@@ -908,26 +826,23 @@ func (s *DockerSuite) TestDaemonRestartKillWait(c *check.C) {
 			c.Fatal(err)
 		}
 	}
-
 }
 
 // TestHttpsInfo connects via two-way authenticated HTTPS to the info endpoint
-func (s *DockerSuite) TestHttpsInfo(c *check.C) {
+func (s *DockerDaemonSuite) TestHttpsInfo(c *check.C) {
 	const (
 		testDaemonHttpsAddr = "localhost:4271"
 	)
 
-	d := NewDaemon(c)
-	if err := d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
+	if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
 		"--tlskey", "fixtures/https/server-key.pem", "-H", testDaemonHttpsAddr); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
 	//force tcp protocol
 	host := fmt.Sprintf("tcp://%s", testDaemonHttpsAddr)
 	daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-cert.pem", "--tlskey", "fixtures/https/client-key.pem"}
-	out, err := d.CmdWithArgs(daemonArgs, "info")
+	out, err := s.d.CmdWithArgs(daemonArgs, "info")
 	if err != nil {
 		c.Fatalf("Error Occurred: %s and output: %s", err, out)
 	}
@@ -935,22 +850,20 @@ func (s *DockerSuite) TestHttpsInfo(c *check.C) {
 
 // TestHttpsInfoRogueCert connects via two-way authenticated HTTPS to the info endpoint
 // by using a rogue client certificate and checks that it fails with the expected error.
-func (s *DockerSuite) TestHttpsInfoRogueCert(c *check.C) {
+func (s *DockerDaemonSuite) TestHttpsInfoRogueCert(c *check.C) {
 	const (
 		errBadCertificate   = "remote error: bad certificate"
 		testDaemonHttpsAddr = "localhost:4271"
 	)
-	d := NewDaemon(c)
-	if err := d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
+	if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
 		"--tlskey", "fixtures/https/server-key.pem", "-H", testDaemonHttpsAddr); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
 	//force tcp protocol
 	host := fmt.Sprintf("tcp://%s", testDaemonHttpsAddr)
 	daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-rogue-cert.pem", "--tlskey", "fixtures/https/client-rogue-key.pem"}
-	out, err := d.CmdWithArgs(daemonArgs, "info")
+	out, err := s.d.CmdWithArgs(daemonArgs, "info")
 	if err == nil || !strings.Contains(out, errBadCertificate) {
 		c.Fatalf("Expected err: %s, got instead: %s and output: %s", errBadCertificate, err, out)
 	}
@@ -958,22 +871,20 @@ func (s *DockerSuite) TestHttpsInfoRogueCert(c *check.C) {
 
 // TestHttpsInfoRogueServerCert connects via two-way authenticated HTTPS to the info endpoint
 // which provides a rogue server certificate and checks that it fails with the expected error
-func (s *DockerSuite) TestHttpsInfoRogueServerCert(c *check.C) {
+func (s *DockerDaemonSuite) TestHttpsInfoRogueServerCert(c *check.C) {
 	const (
 		errCaUnknown             = "x509: certificate signed by unknown authority"
 		testDaemonRogueHttpsAddr = "localhost:4272"
 	)
-	d := NewDaemon(c)
-	if err := d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-rogue-cert.pem",
+	if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-rogue-cert.pem",
 		"--tlskey", "fixtures/https/server-rogue-key.pem", "-H", testDaemonRogueHttpsAddr); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
 	//force tcp protocol
 	host := fmt.Sprintf("tcp://%s", testDaemonRogueHttpsAddr)
 	daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-rogue-cert.pem", "--tlskey", "fixtures/https/client-rogue-key.pem"}
-	out, err := d.CmdWithArgs(daemonArgs, "info")
+	out, err := s.d.CmdWithArgs(daemonArgs, "info")
 	if err == nil || !strings.Contains(out, errCaUnknown) {
 		c.Fatalf("Expected err: %s, got instead: %s and output: %s", errCaUnknown, err, out)
 	}

integration-cli/docker_cli_events_test.go

@@ -7,6 +7,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/go-check/check"
@@ -65,9 +66,28 @@ func (s *DockerSuite) TestEventsContainerFailStartDie(c *check.C) {
 }
 
 func (s *DockerSuite) TestEventsLimit(c *check.C) {
-	for i := 0; i < 30; i++ {
-		dockerCmd(c, "run", "busybox", "echo", strconv.Itoa(i))
+
+	var waitGroup sync.WaitGroup
+	errChan := make(chan error, 17)
+
+	args := []string{"run", "--rm", "busybox", "true"}
+	for i := 0; i < 17; i++ {
+		waitGroup.Add(1)
+		go func() {
+			defer waitGroup.Done()
+			errChan <- exec.Command(dockerBinary, args...).Run()
+		}()
 	}
+
+	waitGroup.Wait()
+	close(errChan)
+
+	for err := range errChan {
+		if err != nil {
+			c.Fatalf("%q failed with error: %v", strings.Join(args, " "), err)
+		}
+	}
+
 	eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()))
 	out, _, _ := runCommandWithOutput(eventsCmd)
 	events := strings.Split(out, "\n")
@@ -144,7 +164,6 @@ func (s *DockerSuite) TestEventsContainerEventsSinceUnixEpoch(c *check.C) {
 
 func (s *DockerSuite) TestEventsImageUntagDelete(c *check.C) {
 	name := "testimageevents"
-	defer deleteImages(name)
 	_, err := buildImage(name,
 		`FROM scratch
 		MAINTAINER "docker"`,
@@ -180,8 +199,6 @@ func (s *DockerSuite) TestEventsImagePull(c *check.C) {
 	since := daemonTime(c).Unix()
 	testRequires(c, Network)
 
-	defer deleteImages("hello-world")
-
 	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)
@@ -211,8 +228,7 @@ func (s *DockerSuite) TestEventsImageImport(c *check.C) {
 	if err != nil {
 		c.Fatal(err)
 	}
-	err = eventsCmd.Start()
-	if err != nil {
+	if err := eventsCmd.Start(); err != nil {
 		c.Fatal(err)
 	}
 	defer eventsCmd.Process.Kill()
@@ -343,12 +359,15 @@ 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", "-d", "--name", name, "busybox", "true"))
+		out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "--name", name, "busybox", "true"))
+		if err != nil {
+			c.Fatalf("Error: %v, Output: %s", err, out)
+		}
+		id, err := inspectField(name, "Id")
 		if err != nil {
 			c.Fatal(err)
 		}
-		nameID[name] = strings.TrimSpace(out)
-		waitInspect(name, "{{.State.Runing }}", "false", 5)
+		nameID[name] = id
 	}
 
 	until := fmt.Sprintf("%d", daemonTime(c).Unix())
@@ -403,30 +422,23 @@ func (s *DockerSuite) TestEventsFilterContainer(c *check.C) {
 func (s *DockerSuite) TestEventsStreaming(c *check.C) {
 	start := daemonTime(c).Unix()
 
-	finish := make(chan struct{})
-	defer close(finish)
 	id := make(chan string)
 	eventCreate := make(chan struct{})
 	eventStart := make(chan struct{})
 	eventDie := make(chan struct{})
 	eventDestroy := make(chan struct{})
 
+	eventsCmd := exec.Command(dockerBinary, "events", "--since", strconv.FormatInt(start, 10))
+	stdout, err := eventsCmd.StdoutPipe()
+	if err != nil {
+		c.Fatal(err)
+	}
+	if err := eventsCmd.Start(); err != nil {
+		c.Fatalf("failed to start 'docker events': %s", err)
+	}
+	defer eventsCmd.Process.Kill()
+
 	go func() {
-		eventsCmd := exec.Command(dockerBinary, "events", "--since", strconv.FormatInt(start, 10))
-		stdout, err := eventsCmd.StdoutPipe()
-		if err != nil {
-			c.Fatal(err)
-		}
-		err = eventsCmd.Start()
-		if err != nil {
-			c.Fatalf("failed to start 'docker events': %s", err)
-		}
-
-		go func() {
-			<-finish
-			eventsCmd.Process.Kill()
-		}()
-
 		containerID := <-id
 
 		matchCreate := regexp.MustCompile(containerID + `: \(from busybox:latest\) create$`)
@@ -447,11 +459,6 @@ func (s *DockerSuite) TestEventsStreaming(c *check.C) {
 				close(eventDestroy)
 			}
 		}
-
-		err = eventsCmd.Wait()
-		if err != nil && !IsKilled(err) {
-			c.Fatalf("docker events had bad exit status: %s", err)
-		}
 	}()
 
 	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox:latest", "true")
@@ -495,5 +502,4 @@ func (s *DockerSuite) TestEventsStreaming(c *check.C) {
 	case <-eventDestroy:
 		// ignore, done
 	}
-
 }

integration-cli/docker_cli_exec_test.go

@@ -74,15 +74,14 @@ func (s *DockerSuite) TestExecInteractive(c *check.C) {
 	if err := stdin.Close(); err != nil {
 		c.Fatal(err)
 	}
-	finish := make(chan struct{})
+	errChan := make(chan error)
 	go func() {
-		if err := execCmd.Wait(); err != nil {
-			c.Fatal(err)
-		}
-		close(finish)
+		errChan <- execCmd.Wait()
+		close(errChan)
 	}()
 	select {
-	case <-finish:
+	case err := <-errChan:
+		c.Assert(err, check.IsNil)
 	case <-time.After(1 * time.Second):
 		c.Fatal("docker exec failed to exit on stdin close")
 	}
@@ -117,28 +116,26 @@ func (s *DockerSuite) TestExecAfterContainerRestart(c *check.C) {
 
 }
 
-func (s *DockerSuite) TestExecAfterDaemonRestart(c *check.C) {
+func (s *DockerDaemonSuite) TestExecAfterDaemonRestart(c *check.C) {
 	testRequires(c, SameHostDaemon)
 
-	d := NewDaemon(c)
-	if err := d.StartWithBusybox(); err != nil {
+	if err := s.d.StartWithBusybox(); err != nil {
 		c.Fatalf("Could not start daemon with busybox: %v", err)
 	}
-	defer d.Stop()
 
-	if out, err := d.Cmd("run", "-d", "--name", "top", "-p", "80", "busybox:latest", "top"); err != nil {
+	if out, err := s.d.Cmd("run", "-d", "--name", "top", "-p", "80", "busybox:latest", "top"); err != nil {
 		c.Fatalf("Could not run top: err=%v\n%s", err, out)
 	}
 
-	if err := d.Restart(); err != nil {
+	if err := s.d.Restart(); err != nil {
 		c.Fatalf("Could not restart daemon: %v", err)
 	}
 
-	if out, err := d.Cmd("start", "top"); err != nil {
+	if out, err := s.d.Cmd("start", "top"); err != nil {
 		c.Fatalf("Could not start top after daemon restart: err=%v\n%s", err, out)
 	}
 
-	out, err := d.Cmd("exec", "top", "echo", "hello")
+	out, err := s.d.Cmd("exec", "top", "echo", "hello")
 	if err != nil {
 		c.Fatalf("Could not exec on container top: err=%v\n%s", err, out)
 	}
@@ -147,7 +144,6 @@ func (s *DockerSuite) TestExecAfterDaemonRestart(c *check.C) {
 	if outStr != "hello" {
 		c.Errorf("container should've printed hello, instead printed %q", outStr)
 	}
-
 }
 
 // Regression test for #9155, #9044
@@ -281,25 +277,29 @@ func (s *DockerSuite) TestExecTtyWithoutStdin(c *check.C) {
 		}
 	}()
 
-	done := make(chan struct{})
+	errChan := make(chan error)
 	go func() {
-		defer close(done)
+		defer close(errChan)
 
 		cmd := exec.Command(dockerBinary, "exec", "-ti", id, "true")
 		if _, err := cmd.StdinPipe(); err != nil {
-			c.Fatal(err)
+			errChan <- err
+			return
 		}
 
 		expected := "cannot enable tty mode"
 		if out, _, err := runCommandWithOutput(cmd); err == nil {
-			c.Fatal("exec should have failed")
+			errChan <- fmt.Errorf("exec should have failed")
+			return
 		} else if !strings.Contains(out, expected) {
-			c.Fatalf("exec failed with error %q: expected %q", out, expected)
+			errChan <- fmt.Errorf("exec failed with error %q: expected %q", out, expected)
+			return
 		}
 	}()
 
 	select {
-	case <-done:
+	case err := <-errChan:
+		c.Assert(err, check.IsNil)
 	case <-time.After(3 * time.Second):
 		c.Fatal("exec is running but should have failed")
 	}
@@ -329,17 +329,22 @@ func (s *DockerSuite) TestExecStopNotHanging(c *check.C) {
 		c.Fatal(err)
 	}
 
-	wait := make(chan struct{})
+	type dstop struct {
+		out []byte
+		err error
+	}
+
+	ch := make(chan dstop)
 	go func() {
-		if out, err := exec.Command(dockerBinary, "stop", "testing").CombinedOutput(); err != nil {
-			c.Fatal(out, err)
-		}
-		close(wait)
+		out, err := exec.Command(dockerBinary, "stop", "testing").CombinedOutput()
+		ch <- dstop{out, err}
+		close(ch)
 	}()
 	select {
 	case <-time.After(3 * time.Second):
 		c.Fatal("Container stop timed out")
-	case <-wait:
+	case s := <-ch:
+		c.Assert(s.err, check.IsNil)
 	}
 }
 
@@ -362,6 +367,7 @@ func (s *DockerSuite) TestExecCgroup(c *check.C) {
 	var wg sync.WaitGroup
 	var mu sync.Mutex
 	execCgroups := []sort.StringSlice{}
+	errChan := make(chan error)
 	// exec a few times concurrently to get consistent failure
 	for i := 0; i < 5; i++ {
 		wg.Add(1)
@@ -369,7 +375,8 @@ func (s *DockerSuite) TestExecCgroup(c *check.C) {
 			cmd := exec.Command(dockerBinary, "exec", "testing", "cat", "/proc/self/cgroup")
 			out, _, err := runCommandWithOutput(cmd)
 			if err != nil {
-				c.Fatal(out, err)
+				errChan <- err
+				return
 			}
 			cg := sort.StringSlice(strings.Split(string(out), "\n"))
 
@@ -380,6 +387,11 @@ func (s *DockerSuite) TestExecCgroup(c *check.C) {
 		}()
 	}
 	wg.Wait()
+	close(errChan)
+
+	for err := range errChan {
+		c.Assert(err, check.IsNil)
+	}
 
 	for _, cg := range execCgroups {
 		if !reflect.DeepEqual(cg, containerCgroups) {

integration-cli/docker_cli_export_import_test.go

@@ -12,8 +12,6 @@ import (
 func (s *DockerSuite) TestExportContainerAndImportImage(c *check.C) {
 	containerID := "testexportcontainerandimportimage"
 
-	defer deleteImages("repo/testexp:v1")
-
 	runCmd := exec.Command(dockerBinary, "run", "-d", "--name", containerID, "busybox", "true")
 	out, _, err := runCommandWithOutput(runCmd)
 	if err != nil {
@@ -51,8 +49,6 @@ func (s *DockerSuite) TestExportContainerAndImportImage(c *check.C) {
 func (s *DockerSuite) TestExportContainerWithOutputAndImportImage(c *check.C) {
 	containerID := "testexportcontainerwithoutputandimportimage"
 
-	defer deleteImages("repo/testexp:v1")
-
 	runCmd := exec.Command(dockerBinary, "run", "-d", "--name", containerID, "busybox", "true")
 	out, _, err := runCommandWithOutput(runCmd)
 	if err != nil {

integration-cli/docker_cli_history_test.go

@@ -14,7 +14,6 @@ import (
 // sort is not predictable it doesn't always fail.
 func (s *DockerSuite) TestBuildHistory(c *check.C) {
 	name := "testbuildhistory"
-	defer deleteImages(name)
 	_, err := buildImage(name, `FROM busybox
 RUN echo "A"
 RUN echo "B"
@@ -85,7 +84,6 @@ func (s *DockerSuite) TestHistoryNonExistentImage(c *check.C) {
 
 func (s *DockerSuite) TestHistoryImageWithComment(c *check.C) {
 	name := "testhistoryimagewithcomment"
-	defer deleteImages(name)
 
 	// make a image through docker commit <container id> [ -m messages ]
 	//runCmd := exec.Command(dockerBinary, "run", "-i", "-a", "stdin", "busybox", "echo", "foo")

integration-cli/docker_cli_images_test.go

@@ -26,9 +26,6 @@ func (s *DockerSuite) TestImagesEnsureImageIsListed(c *check.C) {
 }
 
 func (s *DockerSuite) TestImagesOrderedByCreationDate(c *check.C) {
-	defer deleteImages("order:test_a")
-	defer deleteImages("order:test_c")
-	defer deleteImages("order:test_b")
 	id1, err := buildImage("order:test_a",
 		`FROM scratch
 		MAINTAINER dockerio1`, true)
@@ -80,9 +77,6 @@ func (s *DockerSuite) TestImagesFilterLabel(c *check.C) {
 	imageName1 := "images_filter_test1"
 	imageName2 := "images_filter_test2"
 	imageName3 := "images_filter_test3"
-	defer deleteImages(imageName1)
-	defer deleteImages(imageName2)
-	defer deleteImages(imageName3)
 	image1ID, err := buildImage(imageName1,
 		`FROM scratch
 		 LABEL match me`, true)
@@ -130,7 +124,6 @@ func (s *DockerSuite) TestImagesFilterLabel(c *check.C) {
 
 func (s *DockerSuite) TestImagesFilterSpaceTrimCase(c *check.C) {
 	imageName := "images_filter_test"
-	defer deleteImages(imageName)
 	buildImage(imageName,
 		`FROM scratch
 		 RUN touch /test/foo
@@ -189,7 +182,6 @@ func (s *DockerSuite) TestImagesEnsureDanglingImageOnlyListedOnce(c *check.C) {
 		c.Fatalf("error tagging foobox: %s", err)
 	}
 	imageId := stringid.TruncateID(strings.TrimSpace(out))
-	defer deleteImages(imageId)
 
 	// overwrite the tag, making the previous image dangling
 	cmd = exec.Command(dockerBinary, "tag", "-f", "busybox", "foobox")
@@ -197,7 +189,6 @@ func (s *DockerSuite) TestImagesEnsureDanglingImageOnlyListedOnce(c *check.C) {
 	if err != nil {
 		c.Fatalf("error tagging foobox: %s", err)
 	}
-	defer deleteImages("foobox")
 
 	cmd = exec.Command(dockerBinary, "images", "-q", "-f", "dangling=true")
 	out, _, err = runCommandWithOutput(cmd)

integration-cli/docker_cli_import_test.go

@@ -27,7 +27,6 @@ func (s *DockerSuite) TestImportDisplay(c *check.C) {
 		c.Fatalf("display is messed up: %d '\\n' instead of 1:\n%s", n, out)
 	}
 	image := strings.TrimSpace(out)
-	defer deleteImages(image)
 
 	runCmd = exec.Command(dockerBinary, "run", "--rm", image, "true")
 	out, _, err = runCommandWithOutput(runCmd)

integration-cli/docker_cli_links_test.go

@@ -310,3 +310,24 @@ func (s *DockerSuite) TestLinksUpdateOnRestart(c *check.C) {
 		c.Fatalf("For 'onetwo' alias expected IP: %s, got: %s", realIP, ip)
 	}
 }
+
+func (s *DockerSuite) TestLinksEnvs(c *check.C) {
+	runCmd := exec.Command(dockerBinary, "run", "-d", "-e", "e1=", "-e", "e2=v2", "-e", "e3=v3=v3", "--name=first", "busybox", "top")
+	out, _, _, err := runCommandWithStdoutStderr(runCmd)
+	if err != nil {
+		c.Fatalf("Run of first failed: %s\n%s", out, err)
+	}
+
+	runCmd = exec.Command(dockerBinary, "run", "--name=second", "--link=first:first", "busybox", "env")
+
+	out, stde, rc, err := runCommandWithStdoutStderr(runCmd)
+	if err != nil || rc != 0 {
+		c.Fatalf("run of 2nd failed: rc: %d, out: %s\n err: %s", rc, out, stde)
+	}
+
+	if !strings.Contains(out, "FIRST_ENV_e1=\n") ||
+		!strings.Contains(out, "FIRST_ENV_e2=v2") ||
+		!strings.Contains(out, "FIRST_ENV_e3=v3=v3") {
+		c.Fatalf("Incorrect output: %s", out)
+	}
+}

integration-cli/docker_cli_logs_test.go

@@ -260,16 +260,15 @@ func (s *DockerSuite) TestLogsFollowStopped(c *check.C) {
 		c.Fatal(err)
 	}
 
-	ch := make(chan struct{})
+	errChan := make(chan error)
 	go func() {
-		if err := logsCmd.Wait(); err != nil {
-			c.Fatal(err)
-		}
-		close(ch)
+		errChan <- logsCmd.Wait()
+		close(errChan)
 	}()
 
 	select {
-	case <-ch:
+	case err := <-errChan:
+		c.Assert(err, check.IsNil)
 	case <-time.After(1 * time.Second):
 		c.Fatal("Following logs is hanged")
 	}
@@ -298,9 +297,7 @@ func (s *DockerSuite) TestLogsFollowSlowStdoutConsumer(c *check.C) {
 	logCmd := exec.Command(dockerBinary, "logs", "-f", cleanedContainerID)
 
 	stdout, err := logCmd.StdoutPipe()
-	if err != nil {
-		c.Fatal(err)
-	}
+	c.Assert(err, check.IsNil)
 
 	if err := logCmd.Start(); err != nil {
 		c.Fatal(err)
@@ -308,15 +305,11 @@ func (s *DockerSuite) TestLogsFollowSlowStdoutConsumer(c *check.C) {
 
 	// First read slowly
 	bytes1, err := consumeWithSpeed(stdout, 10, 50*time.Millisecond, stopSlowRead)
-	if err != nil {
-		c.Fatal(err)
-	}
+	c.Assert(err, check.IsNil)
 
 	// After the container has finished we can continue reading fast
 	bytes2, err := consumeWithSpeed(stdout, 32*1024, 0, nil)
-	if err != nil {
-		c.Fatal(err)
-	}
+	c.Assert(err, check.IsNil)
 
 	actual := bytes1 + bytes2
 	expected := 200000

integration-cli/docker_cli_proxy_test.go

@@ -22,7 +22,7 @@ func (s *DockerSuite) TestCliProxyDisableProxyUnixSock(c *check.C) {
 
 // Can't use localhost here since go has a special case to not use proxy if connecting to localhost
 // See https://golang.org/pkg/net/http/#ProxyFromEnvironment
-func (s *DockerSuite) TestCliProxyProxyTCPSock(c *check.C) {
+func (s *DockerDaemonSuite) TestCliProxyProxyTCPSock(c *check.C) {
 	testRequires(c, SameHostDaemon)
 	// get the IP to use to connect since we can't use localhost
 	addrs, err := net.InterfaceAddrs()
@@ -43,8 +43,7 @@ func (s *DockerSuite) TestCliProxyProxyTCPSock(c *check.C) {
 		c.Fatal("could not find ip to connect to")
 	}
 
-	d := NewDaemon(c)
-	if err := d.Start("-H", "tcp://"+ip+":2375"); err != nil {
+	if err := s.d.Start("-H", "tcp://"+ip+":2375"); err != nil {
 		c.Fatal(err)
 	}
 

integration-cli/docker_cli_ps_test.go

@@ -255,7 +255,6 @@ func assertContainerList(out string, expected []string) bool {
 }
 
 func (s *DockerSuite) TestPsListContainersSize(c *check.C) {
-
 	cmd := exec.Command(dockerBinary, "run", "-d", "busybox", "echo", "hello")
 	runCommandWithOutput(cmd)
 	cmd = exec.Command(dockerBinary, "ps", "-s", "-n=1")
@@ -547,7 +546,7 @@ func (s *DockerSuite) TestPsListContainersFilterExited(c *check.C) {
 	}
 	ids = strings.Split(strings.TrimSpace(out), "\n")
 	if len(ids) != 2 {
-		c.Fatalf("Should be 2 zero exited containerst got %d", len(ids))
+		c.Fatalf("Should be 2 zero exited containers got %d", len(ids))
 	}
 	if ids[0] != secondNonZero {
 		c.Fatalf("First in list should be %q, got %q", secondNonZero, ids[0])
@@ -560,7 +559,6 @@ func (s *DockerSuite) TestPsListContainersFilterExited(c *check.C) {
 
 func (s *DockerSuite) TestPsRightTagName(c *check.C) {
 	tag := "asybox:shmatest"
-	defer deleteImages(tag)
 	if out, err := exec.Command(dockerBinary, "tag", "busybox", tag).CombinedOutput(); err != nil {
 		c.Fatalf("Failed to tag image: %s, out: %q", err, out)
 	}

integration-cli/docker_cli_pull_test.go

@@ -9,11 +9,8 @@ import (
 )
 
 // See issue docker/docker#8141
-func (s *DockerSuite) TestPullImageWithAliases(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestPullImageWithAliases(c *check.C) {
 	repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)
-	defer deleteImages(repoName)
 
 	repos := []string{}
 	for _, tag := range []string{"recent", "fresh"} {
@@ -25,7 +22,6 @@ func (s *DockerSuite) TestPullImageWithAliases(c *check.C) {
 		if out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "tag", "busybox", repo)); err != nil {
 			c.Fatalf("Failed to tag image %v: error %v, output %q", repos, err, out)
 		}
-		defer deleteImages(repo)
 		if out, err := exec.Command(dockerBinary, "push", repo).CombinedOutput(); err != nil {
 			c.Fatalf("Failed to push image %v: error %v, output %q", repo, err, string(out))
 		}
@@ -50,7 +46,6 @@ func (s *DockerSuite) TestPullImageWithAliases(c *check.C) {
 			c.Fatalf("Image %v shouldn't have been pulled down", repo)
 		}
 	}
-
 }
 
 // pulling library/hello-world should show verified message
@@ -61,7 +56,6 @@ func (s *DockerSuite) TestPullVerified(c *check.C) {
 	// unless keychain is manually updated to contain the daemon's sign key.
 
 	verifiedName := "hello-world"
-	defer deleteImages(verifiedName)
 
 	// pull it
 	expected := "The image you are pulling has been verified"
@@ -88,8 +82,6 @@ func (s *DockerSuite) TestPullVerified(c *check.C) {
 func (s *DockerSuite) TestPullImageFromCentralRegistry(c *check.C) {
 	testRequires(c, Network)
 
-	defer deleteImages("hello-world")
-
 	pullCmd := exec.Command(dockerBinary, "pull", "hello-world")
 	if out, _, err := runCommandWithOutput(pullCmd); err != nil {
 		c.Fatalf("pulling the hello-world image from the registry has failed: %s, %v", out, err)

integration-cli/docker_cli_push_test.go

@@ -13,16 +13,13 @@ import (
 )
 
 // pulling an image from the central registry should work
-func (s *DockerSuite) TestPushBusyboxImage(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestPushBusyboxImage(c *check.C) {
 	repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)
 	// tag the image to upload it to the private registry
 	tagCmd := exec.Command(dockerBinary, "tag", "busybox", repoName)
 	if out, _, err := runCommandWithOutput(tagCmd); err != nil {
 		c.Fatalf("image tagging failed: %s, %v", out, err)
 	}
-	defer deleteImages(repoName)
 
 	pushCmd := exec.Command(dockerBinary, "push", repoName)
 	if out, _, err := runCommandWithOutput(pushCmd); err != nil {
@@ -38,37 +35,31 @@ func (s *DockerSuite) TestPushUnprefixedRepo(c *check.C) {
 	}
 }
 
-func (s *DockerSuite) TestPushUntagged(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestPushUntagged(c *check.C) {
 	repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)
 
 	expected := "Repository does not exist"
 	pushCmd := exec.Command(dockerBinary, "push", repoName)
 	if out, _, err := runCommandWithOutput(pushCmd); err == nil {
-		c.Fatalf("pushing the image to the private registry should have failed: outuput %q", out)
+		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)
 	}
 }
 
-func (s *DockerSuite) TestPushBadTag(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestPushBadTag(c *check.C) {
 	repoName := fmt.Sprintf("%v/dockercli/busybox:latest", privateRegistryURL)
 
 	expected := "does not exist"
 	pushCmd := exec.Command(dockerBinary, "push", repoName)
 	if out, _, err := runCommandWithOutput(pushCmd); err == nil {
-		c.Fatalf("pushing the image to the private registry should have failed: outuput %q", out)
+		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)
 	}
 }
 
-func (s *DockerSuite) TestPushMultipleTags(c *check.C) {
-	defer setupRegistry(c)()
-
+func (s *DockerRegistrySuite) TestPushMultipleTags(c *check.C) {
 	repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)
 	repoTag1 := fmt.Sprintf("%v/dockercli/busybox:t1", privateRegistryURL)
 	repoTag2 := fmt.Sprintf("%v/dockercli/busybox:t2", privateRegistryURL)
@@ -77,12 +68,10 @@ func (s *DockerSuite) TestPushMultipleTags(c *check.C) {
 	if out, _, err := runCommandWithOutput(tagCmd1); err != nil {
 		c.Fatalf("image tagging failed: %s, %v", out, err)
 	}
-	defer deleteImages(repoTag1)
 	tagCmd2 := exec.Command(dockerBinary, "tag", "busybox", repoTag2)
 	if out, _, err := runCommandWithOutput(tagCmd2); err != nil {
 		c.Fatalf("image tagging failed: %s, %v", out, err)
 	}
-	defer deleteImages(repoTag2)
 
 	pushCmd := exec.Command(dockerBinary, "push", repoName)
 	if out, _, err := runCommandWithOutput(pushCmd); err != nil {
@@ -90,14 +79,12 @@ func (s *DockerSuite) TestPushMultipleTags(c *check.C) {
 	}
 }
 
-func (s *DockerSuite) TestPushInterrupt(c *check.C) {
-	defer setupRegistry(c)()
+func (s *DockerRegistrySuite) TestPushInterrupt(c *check.C) {
 	repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)
 	// tag the image and upload it to the private registry
 	if out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "tag", "busybox", repoName)); err != nil {
 		c.Fatalf("image tagging failed: %s, %v", out, err)
 	}
-	defer deleteImages(repoName)
 
 	pushCmd := exec.Command(dockerBinary, "push", repoName)
 	if err := pushCmd.Start(); err != nil {
@@ -122,8 +109,7 @@ func (s *DockerSuite) TestPushInterrupt(c *check.C) {
 	}
 }
 
-func (s *DockerSuite) TestPushEmptyLayer(c *check.C) {
-	defer setupRegistry(c)()
+func (s *DockerRegistrySuite) TestPushEmptyLayer(c *check.C) {
 	repoName := fmt.Sprintf("%v/dockercli/emptylayer", privateRegistryURL)
 	emptyTarball, err := ioutil.TempFile("", "empty_tarball")
 	if err != nil {

integration-cli/docker_cli_rm_test.go

@@ -87,7 +87,6 @@ func (s *DockerSuite) TestRmContainerOrphaning(c *check.C) {
 
 	// build first dockerfile
 	img1, err := buildImage(img, dockerfile1, true)
-	defer deleteImages(img1)
 	if err != nil {
 		c.Fatalf("Could not build image %s: %v", img, err)
 	}

integration-cli/docker_cli_rmi_test.go

@@ -108,7 +108,7 @@ func (s *DockerSuite) TestRmiImgIDForce(c *check.C) {
 	runCmd = exec.Command(dockerBinary, "rmi", imgID)
 	out, _, err = runCommandWithOutput(runCmd)
 	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 mutiple repos should have failed without force:%s, %v", out, err)
+		c.Fatalf("rmi tagged in multiple repos should have failed without force:%s, %v", out, err)
 	}
 
 	dockerCmd(c, "rmi", "-f", imgID)

integration-cli/docker_cli_run_test.go

@@ -329,7 +329,7 @@ func (s *DockerSuite) TestRunLinksContainerWithContainerId(c *check.C) {
 	cmd = exec.Command(dockerBinary, "inspect", "-f", "{{.NetworkSettings.IPAddress}}", cID)
 	ip, _, _, err := runCommandWithStdoutStderr(cmd)
 	if err != nil {
-		c.Fatalf("faild to inspect container: %v, output: %q", err, ip)
+		c.Fatalf("failed to inspect container: %v, output: %q", err, ip)
 	}
 	ip = strings.TrimSpace(ip)
 	cmd = exec.Command(dockerBinary, "run", "--link", cID+":test", "busybox", "/bin/cat", "/etc/hosts")
@@ -447,7 +447,6 @@ func (s *DockerSuite) TestRunCreateVolumesInSymlinkDir(c *check.C) {
 	if _, err := buildImage(name, dockerFile, false); err != nil {
 		c.Fatal(err)
 	}
-	defer deleteImages(name)
 
 	out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-v", "/test/test", name))
 	if err != nil {
@@ -604,7 +603,6 @@ func (s *DockerSuite) TestRunCreateVolume(c *check.C) {
 // Note that this bug happens only with symlinks with a target that starts with '/'.
 func (s *DockerSuite) TestRunCreateVolumeWithSymlink(c *check.C) {
 	image := "docker-test-createvolumewithsymlink"
-	defer deleteImages(image)
 
 	buildCmd := exec.Command(dockerBinary, "build", "-t", image, "-")
 	buildCmd.Stdin = strings.NewReader(`FROM busybox
@@ -644,7 +642,6 @@ func (s *DockerSuite) TestRunCreateVolumeWithSymlink(c *check.C) {
 // Tests that a volume path that has a symlink exists in a container mounting it with `--volumes-from`.
 func (s *DockerSuite) TestRunVolumesFromSymlinkPath(c *check.C) {
 	name := "docker-test-volumesfromsymlinkpath"
-	defer deleteImages(name)
 
 	buildCmd := exec.Command(dockerBinary, "build", "-t", name, "-")
 	buildCmd.Stdin = strings.NewReader(`FROM busybox
@@ -759,17 +756,22 @@ func (s *DockerSuite) TestRunTwoConcurrentContainers(c *check.C) {
 	group := sync.WaitGroup{}
 	group.Add(2)
 
+	errChan := make(chan error, 2)
 	for i := 0; i < 2; i++ {
 		go func() {
 			defer group.Done()
 			cmd := exec.Command(dockerBinary, "run", "busybox", "sleep", "2")
-			if _, err := runCommand(cmd); err != nil {
-				c.Fatal(err)
-			}
+			_, err := runCommand(cmd)
+			errChan <- err
 		}()
 	}
 
 	group.Wait()
+	close(errChan)
+
+	for err := range errChan {
+		c.Assert(err, check.IsNil)
+	}
 }
 
 func (s *DockerSuite) TestRunEnvironment(c *check.C) {
@@ -1746,7 +1748,6 @@ func (s *DockerSuite) TestRunState(c *check.C) {
 // Test for #1737
 func (s *DockerSuite) TestRunCopyVolumeUidGid(c *check.C) {
 	name := "testrunvolumesuidgid"
-	defer deleteImages(name)
 	_, err := buildImage(name,
 		`FROM busybox
 		RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
@@ -1772,7 +1773,6 @@ func (s *DockerSuite) TestRunCopyVolumeUidGid(c *check.C) {
 // Test for #1582
 func (s *DockerSuite) TestRunCopyVolumeContent(c *check.C) {
 	name := "testruncopyvolumecontent"
-	defer deleteImages(name)
 	_, err := buildImage(name,
 		`FROM busybox
 		RUN mkdir -p /hello/local && echo hello > /hello/local/world`,
@@ -1794,7 +1794,6 @@ func (s *DockerSuite) TestRunCopyVolumeContent(c *check.C) {
 
 func (s *DockerSuite) TestRunCleanupCmdOnEntrypoint(c *check.C) {
 	name := "testrunmdcleanuponentrypoint"
-	defer deleteImages(name)
 	if _, err := buildImage(name,
 		`FROM busybox
 		ENTRYPOINT ["echo"]
@@ -1857,22 +1856,20 @@ func (s *DockerSuite) TestRunExitOnStdinClose(c *check.C) {
 	if err := stdin.Close(); err != nil {
 		c.Fatal(err)
 	}
-	finish := make(chan struct{})
+	finish := make(chan error)
 	go func() {
-		if err := runCmd.Wait(); err != nil {
-			c.Fatal(err)
-		}
+		finish <- runCmd.Wait()
 		close(finish)
 	}()
 	select {
-	case <-finish:
+	case err := <-finish:
+		c.Assert(err, check.IsNil)
 	case <-time.After(1 * time.Second):
 		c.Fatal("docker run failed to exit on stdin close")
 	}
 	state, err := inspectField(name, "State.Running")
-	if err != nil {
-		c.Fatal(err)
-	}
+	c.Assert(err, check.IsNil)
+
 	if state != "false" {
 		c.Fatal("Container must be stopped after stdin closing")
 	}
@@ -2073,7 +2070,7 @@ func (s *DockerSuite) TestRunCidFileCleanupIfEmpty(c *check.C) {
 	if err == nil {
 		c.Fatalf("Run without command must fail. out=%s", out)
 	} else if !strings.Contains(out, "No command specified") {
-		c.Fatalf("Run without command failed with wrong outpuc. out=%s\nerr=%v", out, err)
+		c.Fatalf("Run without command failed with wrong output. out=%s\nerr=%v", out, err)
 	}
 
 	if _, err := os.Stat(tmpCidFile); err == nil {
@@ -2349,7 +2346,6 @@ func (s *DockerSuite) TestRunCreateVolumeEtc(c *check.C) {
 }
 
 func (s *DockerSuite) TestVolumesNoCopyData(c *check.C) {
-	defer deleteImages("dataimage")
 	if _, err := buildImage("dataimage",
 		`FROM busybox
 		 RUN mkdir -p /foo
@@ -2430,7 +2426,6 @@ func (s *DockerSuite) TestRunVolumesCleanPaths(c *check.C) {
 		true); err != nil {
 		c.Fatal(err)
 	}
-	defer deleteImages("run_volumes_clean_paths")
 
 	cmd := exec.Command(dockerBinary, "run", "-v", "/foo", "-v", "/bar/", "--name", "dark_helmet", "run_volumes_clean_paths")
 	if out, _, err := runCommandWithOutput(cmd); err != nil {
@@ -2665,6 +2660,14 @@ func (s *DockerSuite) TestContainerNetworkMode(c *check.C) {
 	}
 }
 
+func (s *DockerSuite) TestContainerNetworkModeToSelf(c *check.C) {
+	cmd := exec.Command(dockerBinary, "run", "--name=me", "--net=container:me", "busybox", "true")
+	out, _, err := runCommandWithOutput(cmd)
+	if err == nil || !strings.Contains(out, "cannot join own network") {
+		c.Fatalf("using container net mode to self should result in an error")
+	}
+}
+
 func (s *DockerSuite) TestRunModePidHost(c *check.C) {
 	testRequires(c, NativeExecDriver, SameHostDaemon)
 
@@ -2762,25 +2765,29 @@ func (s *DockerSuite) TestRunPortFromDockerRangeInUse(c *check.C) {
 }
 
 func (s *DockerSuite) TestRunTtyWithPipe(c *check.C) {
-	done := make(chan struct{})
+	errChan := make(chan error)
 	go func() {
-		defer close(done)
+		defer close(errChan)
 
 		cmd := exec.Command(dockerBinary, "run", "-ti", "busybox", "true")
 		if _, err := cmd.StdinPipe(); err != nil {
-			c.Fatal(err)
+			errChan <- err
+			return
 		}
 
 		expected := "cannot enable tty mode"
 		if out, _, err := runCommandWithOutput(cmd); err == nil {
-			c.Fatal("run should have failed")
+			errChan <- fmt.Errorf("run should have failed")
+			return
 		} else if !strings.Contains(out, expected) {
-			c.Fatalf("run failed with error %q: expected %q", out, expected)
+			errChan <- fmt.Errorf("run failed with error %q: expected %q", out, expected)
+			return
 		}
 	}()
 
 	select {
-	case <-done:
+	case err := <-errChan:
+		c.Assert(err, check.IsNil)
 	case <-time.After(3 * time.Second):
 		c.Fatal("container is running but should have failed")
 	}
@@ -2875,19 +2882,19 @@ func (s *DockerSuite) TestRunAllowPortRangeThroughPublish(c *check.C) {
 }
 
 func (s *DockerSuite) TestRunOOMExitCode(c *check.C) {
-	done := make(chan struct{})
+	errChan := make(chan error)
 	go func() {
-		defer close(done)
-
+		defer close(errChan)
 		runCmd := exec.Command(dockerBinary, "run", "-m", "4MB", "busybox", "sh", "-c", "x=a; while true; do x=$x$x$x$x; done")
 		out, exitCode, _ := runCommandWithOutput(runCmd)
 		if expected := 137; exitCode != expected {
-			c.Fatalf("wrong exit code for OOM container: expected %d, got %d (output: %q)", expected, exitCode, out)
+			errChan <- fmt.Errorf("wrong exit code for OOM container: expected %d, got %d (output: %q)", expected, exitCode, out)
 		}
 	}()
 
 	select {
-	case <-done:
+	case err := <-errChan:
+		c.Assert(err, check.IsNil)
 	case <-time.After(30 * time.Second):
 		c.Fatal("Timeout waiting for container to die on OOM")
 	}
@@ -3030,9 +3037,7 @@ func (s *DockerSuite) TestRunPidHostWithChildIsKillable(c *check.C) {
 	}()
 	select {
 	case err := <-errchan:
-		if err != nil {
-			c.Fatal(err)
-		}
+		c.Assert(err, check.IsNil)
 	case <-time.After(5 * time.Second):
 		c.Fatal("Kill container timed out")
 	}

integration-cli/docker_cli_run_unix_test.go

@@ -29,21 +29,22 @@ func (s *DockerSuite) TestRunRedirectStdout(c *check.C) {
 		cmd.Stdin = tty
 		cmd.Stdout = tty
 		cmd.Stderr = tty
-		ch := make(chan struct{})
 		if err := cmd.Start(); err != nil {
 			c.Fatalf("start err: %v", err)
 		}
+		ch := make(chan error)
 		go func() {
-			if err := cmd.Wait(); err != nil {
-				c.Fatalf("wait err=%v", err)
-			}
+			ch <- cmd.Wait()
 			close(ch)
 		}()
 
 		select {
 		case <-time.After(10 * time.Second):
 			c.Fatal("command timeout")
-		case <-ch:
+		case err := <-ch:
+			if err != nil {
+				c.Fatalf("wait err=%v", err)
+			}
 		}
 	}
 
@@ -213,7 +214,7 @@ func (s *DockerSuite) TestRunAttachDetach(c *check.C) {
 		c.Fatal(err)
 	}
 	if strings.TrimSpace(out) != "hello" {
-		c.Fatalf("exepected 'hello', got %q", out)
+		c.Fatalf("expected 'hello', got %q", out)
 	}
 
 	// escape sequence
@@ -236,7 +237,7 @@ func (s *DockerSuite) TestRunAttachDetach(c *check.C) {
 		c.Fatal(err)
 	}
 	if running != "true" {
-		c.Fatal("exepected container to still be running")
+		c.Fatal("expected container to still be running")
 	}
 
 	go func() {

integration-cli/docker_cli_save_load_test.go

@@ -131,7 +131,6 @@ func (s *DockerSuite) TestSaveSingleTag(c *check.C) {
 	repoName := "foobar-save-single-tag-test"
 
 	tagCmd := exec.Command(dockerBinary, "tag", "busybox:latest", fmt.Sprintf("%v:latest", repoName))
-	defer deleteImages(repoName)
 	if out, _, err := runCommandWithOutput(tagCmd); err != nil {
 		c.Fatalf("failed to tag repo: %s, %v", out, err)
 	}
@@ -157,7 +156,6 @@ func (s *DockerSuite) TestSaveImageId(c *check.C) {
 	repoName := "foobar-save-image-id-test"
 
 	tagCmd := exec.Command(dockerBinary, "tag", "emptyfs:latest", fmt.Sprintf("%v:latest", repoName))
-	defer deleteImages(repoName)
 	if out, _, err := runCommandWithOutput(tagCmd); err != nil {
 		c.Fatalf("failed to tag repo: %s, %v", out, err)
 	}
@@ -264,7 +262,6 @@ func (s *DockerSuite) TestSaveMultipleNames(c *check.C) {
 	if out, _, err := runCommandWithOutput(tagCmd); err != nil {
 		c.Fatalf("failed to tag repo: %s, %v", out, err)
 	}
-	defer deleteImages(repoName + "-one")
 
 	// Make two images
 	tagCmd = exec.Command(dockerBinary, "tag", "emptyfs:latest", fmt.Sprintf("%v-two:latest", repoName))
@@ -272,7 +269,6 @@ func (s *DockerSuite) TestSaveMultipleNames(c *check.C) {
 	if err != nil {
 		c.Fatalf("failed to tag repo: %s, %v", out, err)
 	}
-	defer deleteImages(repoName + "-two")
 
 	out, _, err = runCommandPipelineWithOutput(
 		exec.Command(dockerBinary, "save", fmt.Sprintf("%v-one", repoName), fmt.Sprintf("%v-two:latest", repoName)),
@@ -311,9 +307,7 @@ func (s *DockerSuite) TestSaveRepoWithMultipleImages(c *check.C) {
 	tagBar := repoName + ":bar"
 
 	idFoo := makeImage("busybox:latest", tagFoo)
-	defer deleteImages(idFoo)
 	idBar := makeImage("busybox:latest", tagBar)
-	defer deleteImages(idBar)
 
 	deleteImages(repoName)
 
@@ -339,7 +333,7 @@ func (s *DockerSuite) TestSaveRepoWithMultipleImages(c *check.C) {
 	sort.Strings(actual)
 	sort.Strings(expected)
 	if !reflect.DeepEqual(expected, actual) {
-		c.Fatalf("achive does not contains the right layers: got %v, expected %v", actual, expected)
+		c.Fatalf("archive does not contains the right layers: got %v, expected %v", actual, expected)
 	}
 
 }
@@ -358,7 +352,6 @@ func (s *DockerSuite) TestSaveDirectoryPermissions(c *check.C) {
 	os.Mkdir(extractionDirectory, 0777)
 
 	defer os.RemoveAll(tmpDir)
-	defer deleteImages(name)
 	_, err = buildImage(name,
 		`FROM busybox
 	RUN adduser -D user && mkdir -p /opt/a/b && chown -R user:user /opt/a

integration-cli/docker_cli_start_test.go

@@ -20,18 +20,19 @@ func (s *DockerSuite) TestStartAttachReturnsOnError(c *check.C) {
 		c.Fatal("Expected error but got none")
 	}
 
-	ch := make(chan struct{})
+	ch := make(chan error)
 	go func() {
 		// Attempt to start attached to the container that won't start
 		// This should return an error immediately since the container can't be started
 		if _, err := runCommand(exec.Command(dockerBinary, "start", "-a", "test2")); err == nil {
-			c.Fatal("Expected error but got none")
+			ch <- fmt.Errorf("Expected error but got none")
 		}
 		close(ch)
 	}()
 
 	select {
-	case <-ch:
+	case err := <-ch:
+		c.Assert(err, check.IsNil)
 	case <-time.After(time.Second):
 		c.Fatalf("Attach did not exit properly")
 	}
@@ -205,7 +206,7 @@ func (s *DockerSuite) TestStartMultipleContainers(c *check.C) {
 		c.Fatal("Container should be stopped")
 	}
 
-	// start all the three containers, container `child_first` start first which should be faild
+	// start all the three containers, container `child_first` start first which should be failed
 	// container 'parent' start second and then start container 'child_second'
 	cmd = exec.Command(dockerBinary, "start", "child_first", "parent", "child_second")
 	out, _, err = runCommandWithOutput(cmd)

integration-cli/docker_cli_tag_test.go

@@ -18,9 +18,6 @@ func (s *DockerSuite) TestTagUnprefixedRepoByName(c *check.C) {
 	if out, _, err := runCommandWithOutput(tagCmd); err != nil {
 		c.Fatal(out, err)
 	}
-
-	deleteImages("testfoobarbaz")
-
 }
 
 // tagging an image by ID in a new unprefixed repo should work
@@ -36,9 +33,6 @@ func (s *DockerSuite) TestTagUnprefixedRepoByID(c *check.C) {
 	if out, _, err = runCommandWithOutput(tagCmd); err != nil {
 		c.Fatal(out, err)
 	}
-
-	deleteImages("testfoobarbaz")
-
 }
 
 // ensure we don't allow the use of invalid repository names; these tag operations should fail
@@ -104,8 +98,6 @@ func (s *DockerSuite) TestTagExistedNameWithoutForce(c *check.C) {
 	if err == nil || !strings.Contains(out, "Conflict: Tag test is already set to image") {
 		c.Fatal("tag busybox busybox:test should have failed,because busybox:test is existed")
 	}
-	deleteImages("busybox:test")
-
 }
 
 // tag an image with an existed tag name with -f option should work
@@ -122,8 +114,6 @@ func (s *DockerSuite) TestTagExistedNameWithForce(c *check.C) {
 	if out, _, err := runCommandWithOutput(tagCmd); err != nil {
 		c.Fatal(out, err)
 	}
-	deleteImages("busybox:test")
-
 }
 
 // ensure tagging using official names works

integration-cli/docker_cli_wait_test.go

@@ -44,19 +44,29 @@ func (s *DockerSuite) TestWaitNonBlockedExitZero(c *check.C) {
 
 // blocking wait with 0 exit code
 func (s *DockerSuite) TestWaitBlockedExitZero(c *check.C) {
-
-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "sh", "-c", "sleep 10")
-	out, _, err := runCommandWithOutput(runCmd)
-	if err != nil {
-		c.Fatal(out, err)
-	}
+	out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "trap 'exit 0' SIGTERM; while true; do sleep 0.01; done")
 	containerID := strings.TrimSpace(out)
 
-	runCmd = exec.Command(dockerBinary, "wait", containerID)
-	out, _, err = runCommandWithOutput(runCmd)
+	if err := waitRun(containerID); err != nil {
+		c.Fatal(err)
+	}
 
-	if err != nil || strings.TrimSpace(out) != "0" {
-		c.Fatal("failed to set up container", out, err)
+	chWait := make(chan string)
+	go func() {
+		out, _, _ := runCommandWithOutput(exec.Command(dockerBinary, "wait", containerID))
+		chWait <- out
+	}()
+
+	time.Sleep(100 * time.Millisecond)
+	dockerCmd(c, "stop", containerID)
+
+	select {
+	case status := <-chWait:
+		if strings.TrimSpace(status) != "0" {
+			c.Fatalf("expected exit 0, got %s", status)
+		}
+	case <-time.After(2 * time.Second):
+		c.Fatal("timeout waiting for `docker wait` to exit")
 	}
 
 }
@@ -97,19 +107,30 @@ func (s *DockerSuite) TestWaitNonBlockedExitRandom(c *check.C) {
 
 // blocking wait with random exit code
 func (s *DockerSuite) TestWaitBlockedExitRandom(c *check.C) {
-
-	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "sh", "-c", "sleep 10; exit 99")
-	out, _, err := runCommandWithOutput(runCmd)
-	if err != nil {
-		c.Fatal(out, err)
-	}
+	out, _ := dockerCmd(c, "run", "-d", "busybox", "sh", "-c", "trap 'exit 99' SIGTERM; while true; do sleep 0.01; done")
 	containerID := strings.TrimSpace(out)
-
-	runCmd = exec.Command(dockerBinary, "wait", containerID)
-	out, _, err = runCommandWithOutput(runCmd)
-
-	if err != nil || strings.TrimSpace(out) != "99" {
-		c.Fatal("failed to set up container", out, err)
+	if err := waitRun(containerID); err != nil {
+		c.Fatal(err)
+	}
+	if err := waitRun(containerID); err != nil {
+		c.Fatal(err)
 	}
 
+	chWait := make(chan string)
+	go func() {
+		out, _, _ := runCommandWithOutput(exec.Command(dockerBinary, "wait", containerID))
+		chWait <- out
+	}()
+
+	time.Sleep(100 * time.Millisecond)
+	dockerCmd(c, "stop", containerID)
+
+	select {
+	case status := <-chWait:
+		if strings.TrimSpace(status) != "99" {
+			c.Fatalf("expected exit 99, got %s", status)
+		}
+	case <-time.After(2 * time.Second):
+		c.Fatal("timeout waiting for `docker wait` to exit")
+	}
 }

integration-cli/docker_utils.go

@@ -313,20 +313,20 @@ func sockRequest(method, endpoint string, data interface{}) (int, []byte, error)
 		return -1, nil, err
 	}
 
-	status, body, err := sockRequestRaw(method, endpoint, jsonData, "application/json")
+	res, body, err := sockRequestRaw(method, endpoint, jsonData, "application/json")
 	if err != nil {
 		b, _ := ioutil.ReadAll(body)
-		return status, b, err
+		return -1, b, err
 	}
 	var b []byte
 	b, err = readBody(body)
-	return status, b, err
+	return res.StatusCode, b, err
 }
 
-func sockRequestRaw(method, endpoint string, data io.Reader, ct string) (int, io.ReadCloser, error) {
+func sockRequestRaw(method, endpoint string, data io.Reader, ct string) (*http.Response, io.ReadCloser, error) {
 	c, err := sockConn(time.Duration(10 * time.Second))
 	if err != nil {
-		return -1, nil, fmt.Errorf("could not dial docker daemon: %v", err)
+		return nil, nil, fmt.Errorf("could not dial docker daemon: %v", err)
 	}
 
 	client := httputil.NewClientConn(c, nil)
@@ -334,7 +334,7 @@ func sockRequestRaw(method, endpoint string, data io.Reader, ct string) (int, io
 	req, err := http.NewRequest(method, endpoint, data)
 	if err != nil {
 		client.Close()
-		return -1, nil, fmt.Errorf("could not create new request: %v", err)
+		return nil, nil, fmt.Errorf("could not create new request: %v", err)
 	}
 
 	if ct != "" {
@@ -344,14 +344,14 @@ func sockRequestRaw(method, endpoint string, data io.Reader, ct string) (int, io
 	resp, err := client.Do(req)
 	if err != nil {
 		client.Close()
-		return -1, nil, fmt.Errorf("could not perform request: %v", err)
+		return nil, nil, fmt.Errorf("could not perform request: %v", err)
 	}
 	body := ioutils.NewReadCloserWrapper(resp.Body, func() error {
 		defer client.Close()
 		return resp.Body.Close()
 	})
 
-	return resp.StatusCode, body, err
+	return resp, body, nil
 }
 
 func readBody(b io.ReadCloser) ([]byte, error) {
@@ -361,9 +361,7 @@ func readBody(b io.ReadCloser) ([]byte, error) {
 
 func deleteContainer(container string) error {
 	container = strings.TrimSpace(strings.Replace(container, "\n", " ", -1))
-	killArgs := strings.Split(fmt.Sprintf("kill %v", container), " ")
-	runCommand(exec.Command(dockerBinary, killArgs...))
-	rmArgs := strings.Split(fmt.Sprintf("rm -v %v", container), " ")
+	rmArgs := strings.Split(fmt.Sprintf("rm -fv %v", container), " ")
 	exitCode, err := runCommand(exec.Command(dockerBinary, rmArgs...))
 	// set error manually if not set
 	if exitCode != 0 && err == nil {
@@ -396,6 +394,58 @@ func deleteAllContainers() error {
 	return nil
 }
 
+var protectedImages = map[string]struct{}{}
+
+func init() {
+	out, err := exec.Command(dockerBinary, "images").CombinedOutput()
+	if err != nil {
+		panic(err)
+	}
+	lines := strings.Split(string(out), "\n")[1:]
+	for _, l := range lines {
+		if l == "" {
+			continue
+		}
+		fields := strings.Fields(l)
+		imgTag := fields[0] + ":" + fields[1]
+		// just for case if we have dangling images in tested daemon
+		if imgTag != "<none>:<none>" {
+			protectedImages[imgTag] = struct{}{}
+		}
+	}
+}
+
+func deleteAllImages() error {
+	out, err := exec.Command(dockerBinary, "images").CombinedOutput()
+	if err != nil {
+		return err
+	}
+	lines := strings.Split(string(out), "\n")[1:]
+	var imgs []string
+	for _, l := range lines {
+		if l == "" {
+			continue
+		}
+		fields := strings.Fields(l)
+		imgTag := fields[0] + ":" + fields[1]
+		if _, ok := protectedImages[imgTag]; !ok {
+			if fields[0] == "<none>" {
+				imgs = append(imgs, fields[2])
+				continue
+			}
+			imgs = append(imgs, imgTag)
+		}
+	}
+	if len(imgs) == 0 {
+		return nil
+	}
+	args := append([]string{"rmi", "-f"}, imgs...)
+	if err := exec.Command(dockerBinary, args...).Run(); err != nil {
+		return err
+	}
+	return nil
+}
+
 func getPausedContainers() (string, error) {
 	getPausedContainersCmd := exec.Command(dockerBinary, "ps", "-f", "status=paused", "-q", "-a")
 	out, exitCode, err := runCommandWithOutput(getPausedContainersCmd)
@@ -1078,7 +1128,7 @@ func daemonTime(c *check.C) time.Time {
 	return dt
 }
 
-func setupRegistry(c *check.C) func() {
+func setupRegistry(c *check.C) *testRegistryV2 {
 	testRequires(c, RegistryHosting)
 	reg, err := newTestRegistryV2(c)
 	if err != nil {
@@ -1096,8 +1146,7 @@ func setupRegistry(c *check.C) func() {
 	if err != nil {
 		c.Fatal("Timeout waiting for test registry to become available")
 	}
-
-	return func() { reg.Close() }
+	return reg
 }
 
 // appendBaseEnv appends the minimum set of environment variables to exec the

integration-cli/utils.go

@@ -169,8 +169,7 @@ func runCommandPipelineWithOutput(cmds ...*exec.Cmd) (output string, exitCode in
 }
 
 func unmarshalJSON(data []byte, result interface{}) error {
-	err := json.Unmarshal(data, result)
-	if err != nil {
+	if err := json.Unmarshal(data, result); err != nil {
 		return err
 	}