@@ -4,27 +4,136 @@ import (

 	"fmt"

 	"net/http/httptest"

 	"os"

+	"os/exec"

 	"path/filepath"

+	"strings"

 	"sync"

 	"syscall"

 	"testing"

+	"github.com/docker/docker/api/types/container"

 	"github.com/docker/docker/api/types/swarm"

 	cliconfig "github.com/docker/docker/cli/config"

 	"github.com/docker/docker/integration-cli/daemon"

+	"github.com/docker/docker/integration-cli/environment"

 	"github.com/docker/docker/pkg/reexec"

 	"github.com/go-check/check"

 )

-func Test(t *testing.T) {

+const (

+	// the private registry to use for tests

+	privateRegistryURL = "127.0.0.1:5000"

+

+	// path to containerd's ctr binary

+	ctrBinary = "docker-containerd-ctr"

+

+	// the docker daemon binary to use

+	dockerdBinary = "dockerd"

+)

+

+var (

+	testEnv *environment.Execution

+

+	// FIXME(vdemeester) remove these and use environmentdaemonPid

+	protectedImages = map[string]struct{}{}

+

+	// the docker client binary to use

+	dockerBinary = "docker"

+

+	// isLocalDaemon is true if the daemon under test is on the same

+	// host as the CLI.

+	isLocalDaemon bool

+	// daemonPlatform is held globally so that tests can make intelligent

+	// decisions on how to configure themselves according to the platform

+	// of the daemon. This is initialized in docker_utils by sending

+	// a version call to the daemon and examining the response header.

+	daemonPlatform string

+

+	// WindowsBaseImage is the name of the base image for Windows testing

+	// Environment variable WINDOWS_BASE_IMAGE can override this

+	WindowsBaseImage string

+

+	// For a local daemon on Linux, these values will be used for testing

+	// user namespace support as the standard graph path(s) will be

+	// appended with the root remapped uid.gid prefix

+	dockerBasePath       string

+	volumesConfigPath    string

+	containerStoragePath string

+

+	// daemonStorageDriver is held globally so that tests can know the storage

+	// driver of the daemon. This is initialized in docker_utils by sending

+	// a version call to the daemon and examining the response header.

+	daemonStorageDriver string

+

+	// isolation is the isolation mode of the daemon under test

+	isolation container.Isolation

+

+	// experimentalDaemon tell whether the main daemon has

+	// experimental features enabled or not

+	experimentalDaemon bool

+

+	daemonKernelVersion string

+)

+

+func init() {

+	var err error

+

 	reexec.Init() // This is required for external graphdriver tests

+	testEnv, err = environment.New()

+	if err != nil {

+		fmt.Println(err)

+		os.Exit(1)

+	}

+

+	assignGlobalVariablesFromTestEnv(testEnv)

+}

+

+// FIXME(vdemeester) remove this and use environment

+func assignGlobalVariablesFromTestEnv(testEnv *environment.Execution) {

+	isLocalDaemon = testEnv.LocalDaemon()

+	daemonPlatform = testEnv.DaemonPlatform()

+	dockerBasePath = testEnv.DockerBasePath()

+	volumesConfigPath = testEnv.VolumesConfigPath()

+	containerStoragePath = testEnv.ContainerStoragePath()

+	daemonStorageDriver = testEnv.DaemonStorageDriver()

+	isolation = testEnv.Isolation()

+	experimentalDaemon = testEnv.ExperimentalDaemon()

+	daemonKernelVersion = testEnv.DaemonKernelVersion()

+	WindowsBaseImage = testEnv.MinimalBaseImage()

+}

+

+func TestMain(m *testing.M) {

+	var err error

+	if dockerBin := os.Getenv("DOCKER_BINARY"); dockerBin != "" {

+		dockerBinary = dockerBin

+	}

+	dockerBinary, err = exec.LookPath(dockerBinary)

+	if err != nil {

+		fmt.Printf("ERROR: couldn't resolve full path to the Docker binary (%v)\n", err)

+		os.Exit(1)

+	}

+

+	cmd := exec.Command(dockerBinary, "images", "-f", "dangling=false", "--format", "{{.Repository}}:{{.Tag}}")

+	cmd.Env = appendBaseEnv(true)

+	out, err := cmd.CombinedOutput()

+	if err != nil {

+		panic(fmt.Errorf("err=%v\nout=%s\n", err, out))

+	}

+	images := strings.Split(strings.TrimSpace(string(out)), "\n")

+	for _, img := range images {

+		protectedImages[img] = struct{}{}

+	}

 	if !isLocalDaemon {

 		fmt.Println("INFO: Testing against a remote daemon")

 	} else {

 		fmt.Println("INFO: Testing against a local daemon")

 	}

+	exitCode := m.Run()

+	os.Exit(exitCode)

+}

+func Test(t *testing.T) {

 	if daemonPlatform == "linux" {

 		ensureFrozenImagesLinux(t)

 	}

@@ -39,8 +148,8 @@ type DockerSuite struct {

 }

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

-	if daemonPid > 0 && isLocalDaemon {

-		daemon.SignalDaemonDump(daemonPid)

+	if testEnv.DaemonPID() > 0 && isLocalDaemon {

+		daemon.SignalDaemonDump(testEnv.DaemonPID())

 	}

 }

@@ -324,7 +324,7 @@ func (d *Daemon) StartWithLogFile(out *os.File, providedArgs ...string) error {

 func (d *Daemon) StartWithBusybox(t testingT, arg ...string) {

 	d.Start(t, arg...)

 	if err := d.LoadBusybox(); err != nil {

-		t.Fatalf("Error loading busybox image to current daeom: %s", d.id)

+		t.Fatalf("Error loading busybox image to current daemon: %s\n%v", d.id, err)

 	}

 }

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

 	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/container"

+	"github.com/docker/docker/integration-cli/environment"

 	"github.com/docker/docker/pkg/integration/checker"

 	icmd "github.com/docker/docker/pkg/integration/cmd"

 	"github.com/go-check/check"

@@ -212,7 +213,7 @@ func (s *DockerSuite) TestInspectBindMountPoint(c *check.C) {

 	if daemonPlatform == "windows" {

 		modifier = ""

 		// TODO Windows: Temporary check - remove once TP5 support is dropped

-		if windowsDaemonKV < 14350 {

+		if environment.WindowsKernelVersion(testEnv.DaemonKernelVersion()) < 14350 {

 			c.Skip("Needs later Windows build for RO volumes")

 		}

 		// Linux creates the host directory if it doesn't exist. Windows does not.

deleted file mode 100644

@@ -1,142 +0,0 @@

-package main

-

-import (

-	"encoding/json"

-	"fmt"

-	"io/ioutil"

-	"os"

-	"os/exec"

-	"path/filepath"

-	"strconv"

-

-	"github.com/docker/docker/api/types/container"

-	"github.com/docker/docker/pkg/reexec"

-)

-

-const (

-	// the private registry to use for tests

-	privateRegistryURL = "127.0.0.1:5000"

-

-	// the docker daemon binary to use

-	dockerdBinary = "dockerd"

-)

-

-var (

-	// the docker client binary to use

-	dockerBinary = "docker"

-

-	// path to containerd's ctr binary

-	ctrBinary = "docker-containerd-ctr"

-

-	// isLocalDaemon is true if the daemon under test is on the same

-	// host as the CLI.

-	isLocalDaemon bool

-

-	// daemonPlatform is held globally so that tests can make intelligent

-	// decisions on how to configure themselves according to the platform

-	// of the daemon. This is initialized in docker_utils by sending

-	// a version call to the daemon and examining the response header.

-	daemonPlatform string

-

-	// windowsDaemonKV is used on Windows to distinguish between different

-	// versions. This is necessary to enable certain tests based on whether

-	// the platform supports it. For example, Windows Server 2016 TP3 did

-	// not support volumes, but TP4 did.

-	windowsDaemonKV int

-

-	// For a local daemon on Linux, these values will be used for testing

-	// user namespace support as the standard graph path(s) will be

-	// appended with the root remapped uid.gid prefix

-	dockerBasePath       string

-	volumesConfigPath    string

-	containerStoragePath string

-

-	// experimentalDaemon tell whether the main daemon has

-	// experimental features enabled or not

-	experimentalDaemon bool

-

-	// daemonStorageDriver is held globally so that tests can know the storage

-	// driver of the daemon. This is initialized in docker_utils by sending

-	// a version call to the daemon and examining the response header.

-	daemonStorageDriver string

-

-	// WindowsBaseImage is the name of the base image for Windows testing

-	// Environment variable WINDOWS_BASE_IMAGE can override this

-	WindowsBaseImage = "microsoft/windowsservercore"

-

-	// isolation is the isolation mode of the daemon under test

-	isolation container.Isolation

-

-	// daemonPid is the pid of the main test daemon

-	daemonPid int

-

-	daemonKernelVersion string

-)

-

-func init() {

-	reexec.Init()

-	if dockerBin := os.Getenv("DOCKER_BINARY"); dockerBin != "" {

-		dockerBinary = dockerBin

-	}

-	var err error

-	dockerBinary, err = exec.LookPath(dockerBinary)

-	if err != nil {

-		fmt.Printf("ERROR: couldn't resolve full path to the Docker binary (%v)\n", err)

-		os.Exit(1)

-	}

-

-	// Deterministically working out the environment in which CI is running

-	// to evaluate whether the daemon is local or remote is not possible through

-	// a build tag.

-	//

-	// For example Windows to Linux CI under Jenkins tests the 64-bit

-	// Windows binary build with the daemon build tag, but calls a remote

-	// Linux daemon.

-	//

-	// We can't just say if Windows then assume the daemon is local as at

-	// some point, we will be testing the Windows CLI against a Windows daemon.

-	//

-	// Similarly, it will be perfectly valid to also run CLI tests from

-	// a Linux CLI (built with the daemon tag) against a Windows daemon.

-	if len(os.Getenv("DOCKER_REMOTE_DAEMON")) > 0 {

-		isLocalDaemon = false

-	} else {

-		isLocalDaemon = true

-	}

-

-	// TODO Windows CI. This are incorrect and need fixing into

-	// platform specific pieces.

-	// This is only used for a tests with local daemon true (Linux-only today)

-	// default is "/var/lib/docker", but we'll try and ask the

-	// /info endpoint for the specific root dir

-	dockerBasePath = "/var/lib/docker"

-	type Info struct {

-		DockerRootDir     string

-		ExperimentalBuild bool

-		KernelVersion     string

-	}

-	var i Info

-	status, b, err := sockRequest("GET", "/info", nil)

-	if err == nil && status == 200 {

-		if err = json.Unmarshal(b, &i); err == nil {

-			dockerBasePath = i.DockerRootDir

-			experimentalDaemon = i.ExperimentalBuild

-			daemonKernelVersion = i.KernelVersion

-		}

-	}

-	volumesConfigPath = dockerBasePath + "/volumes"

-	containerStoragePath = dockerBasePath + "/containers"

-

-	if len(os.Getenv("WINDOWS_BASE_IMAGE")) > 0 {

-		WindowsBaseImage = os.Getenv("WINDOWS_BASE_IMAGE")

-		fmt.Println("INFO: Windows Base image is ", WindowsBaseImage)

-	}

-

-	dest := os.Getenv("DEST")

-	b, err = ioutil.ReadFile(filepath.Join(dest, "docker.pid"))

-	if err == nil {

-		if p, err := strconv.ParseInt(string(b), 10, 32); err == nil {

-			daemonPid = int(p)

-		}

-	}

-}

deleted file mode 100644

@@ -1,1368 +0,0 @@

-package main

-

-import (

-	"bufio"

-	"bytes"

-	"encoding/json"

-	"errors"

-	"fmt"

-	"io"

-	"io/ioutil"

-	"net"

-	"net/http"

-	"net/http/httptest"

-	"net/http/httputil"

-	"net/url"

-	"os"

-	"os/exec"

-	"path"

-	"path/filepath"

-	"strconv"

-	"strings"

-	"time"

-

-	"github.com/docker/docker/api/types"

-	volumetypes "github.com/docker/docker/api/types/volume"

-	"github.com/docker/docker/integration-cli/daemon"

-	"github.com/docker/docker/opts"

-	"github.com/docker/docker/pkg/httputils"

-	"github.com/docker/docker/pkg/integration"

-	"github.com/docker/docker/pkg/integration/checker"

-	icmd "github.com/docker/docker/pkg/integration/cmd"

-	"github.com/docker/docker/pkg/ioutils"

-	"github.com/docker/docker/pkg/stringutils"

-	"github.com/go-check/check"

-)

-

-func init() {

-	cmd := exec.Command(dockerBinary, "images", "-f", "dangling=false", "--format", "{{.Repository}}:{{.Tag}}")

-	cmd.Env = appendBaseEnv(true)

-	out, err := cmd.CombinedOutput()

-	if err != nil {

-		panic(fmt.Errorf("err=%v\nout=%s\n", err, out))

-	}

-	images := strings.Split(strings.TrimSpace(string(out)), "\n")

-	for _, img := range images {

-		protectedImages[img] = struct{}{}

-	}

-

-	res, body, err := sockRequestRaw("GET", "/info", nil, "application/json")

-	if err != nil {

-		panic(fmt.Errorf("Init failed to get /info: %v", err))

-	}

-	defer body.Close()

-	if res.StatusCode != http.StatusOK {

-		panic(fmt.Errorf("Init failed to get /info. Res=%v", res))

-	}

-

-	svrHeader, _ := httputils.ParseServerHeader(res.Header.Get("Server"))

-	daemonPlatform = svrHeader.OS

-	if daemonPlatform != "linux" && daemonPlatform != "windows" {

-		panic("Cannot run tests against platform: " + daemonPlatform)

-	}

-

-	// Now we know the daemon platform, can set paths used by tests.

-	var info types.Info

-	err = json.NewDecoder(body).Decode(&info)

-	if err != nil {

-		panic(fmt.Errorf("Init failed to unmarshal docker info: %v", err))

-	}

-

-	daemonStorageDriver = info.Driver

-	dockerBasePath = info.DockerRootDir

-	volumesConfigPath = filepath.Join(dockerBasePath, "volumes")

-	containerStoragePath = filepath.Join(dockerBasePath, "containers")

-	// Make sure in context of daemon, not the local platform. Note we can't

-	// use filepath.FromSlash or ToSlash here as they are a no-op on Unix.

-	if daemonPlatform == "windows" {

-		volumesConfigPath = strings.Replace(volumesConfigPath, `/`, `\`, -1)

-		containerStoragePath = strings.Replace(containerStoragePath, `/`, `\`, -1)

-		// On Windows, extract out the version as we need to make selective

-		// decisions during integration testing as and when features are implemented.

-		// e.g. in "10.0 10550 (10550.1000.amd64fre.branch.date-time)" we want 10550

-		windowsDaemonKV, _ = strconv.Atoi(strings.Split(info.KernelVersion, " ")[1])

-	} else {

-		volumesConfigPath = strings.Replace(volumesConfigPath, `\`, `/`, -1)

-		containerStoragePath = strings.Replace(containerStoragePath, `\`, `/`, -1)

-	}

-	isolation = info.Isolation

-}

-

-func daemonHost() string {

-	daemonURLStr := "unix://" + opts.DefaultUnixSocket

-	if daemonHostVar := os.Getenv("DOCKER_HOST"); daemonHostVar != "" {

-		daemonURLStr = daemonHostVar

-	}

-	return daemonURLStr

-}

-

-// FIXME(vdemeester) should probably completely move to daemon struct/methods

-func sockConn(timeout time.Duration, daemonStr string) (net.Conn, error) {

-	if daemonStr == "" {

-		daemonStr = daemonHost()

-	}

-	return daemon.SockConn(timeout, daemonStr)

-}

-

-func sockRequest(method, endpoint string, data interface{}) (int, []byte, error) {

-	jsonData := bytes.NewBuffer(nil)

-	if err := json.NewEncoder(jsonData).Encode(data); err != nil {

-		return -1, nil, err

-	}

-

-	res, body, err := sockRequestRaw(method, endpoint, jsonData, "application/json")

-	if err != nil {

-		return -1, nil, err

-	}

-	b, err := integration.ReadBody(body)

-	return res.StatusCode, b, err

-}

-

-func sockRequestRaw(method, endpoint string, data io.Reader, ct string) (*http.Response, io.ReadCloser, error) {

-	return sockRequestRawToDaemon(method, endpoint, data, ct, "")

-}

-

-func sockRequestRawToDaemon(method, endpoint string, data io.Reader, ct, daemon string) (*http.Response, io.ReadCloser, error) {

-	req, client, err := newRequestClient(method, endpoint, data, ct, daemon)

-	if err != nil {

-		return nil, nil, err

-	}

-

-	resp, err := client.Do(req)

-	if err != nil {

-		client.Close()

-		return nil, nil, err

-	}

-	body := ioutils.NewReadCloserWrapper(resp.Body, func() error {

-		defer resp.Body.Close()

-		return client.Close()

-	})

-

-	return resp, body, nil

-}

-

-func sockRequestHijack(method, endpoint string, data io.Reader, ct string) (net.Conn, *bufio.Reader, error) {

-	req, client, err := newRequestClient(method, endpoint, data, ct, "")

-	if err != nil {

-		return nil, nil, err

-	}

-

-	client.Do(req)

-	conn, br := client.Hijack()

-	return conn, br, nil

-}

-

-func newRequestClient(method, endpoint string, data io.Reader, ct, daemon string) (*http.Request, *httputil.ClientConn, error) {

-	c, err := sockConn(time.Duration(10*time.Second), daemon)

-	if err != nil {

-		return nil, nil, fmt.Errorf("could not dial docker daemon: %v", err)

-	}

-

-	client := httputil.NewClientConn(c, nil)

-

-	req, err := http.NewRequest(method, endpoint, data)

-	if err != nil {

-		client.Close()

-		return nil, nil, fmt.Errorf("could not create new request: %v", err)

-	}

-

-	if ct != "" {

-		req.Header.Set("Content-Type", ct)

-	}

-	return req, client, nil

-}

-

-func deleteContainer(container ...string) error {

-	result := icmd.RunCommand(dockerBinary, append([]string{"rm", "-fv"}, container...)...)

-	return result.Compare(icmd.Success)

-}

-

-func getAllContainers() (string, error) {

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

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

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

-		err = fmt.Errorf("failed to get a list of containers: %v\n", out)

-	}

-

-	return out, err

-}

-

-func deleteAllContainers(c *check.C) {

-	containers, err := getAllContainers()

-	c.Assert(err, checker.IsNil, check.Commentf("containers: %v", containers))

-

-	if containers != "" {

-		err = deleteContainer(strings.Split(strings.TrimSpace(containers), "\n")...)

-		c.Assert(err, checker.IsNil)

-	}

-}

-

-func deleteAllNetworks(c *check.C) {

-	networks, err := getAllNetworks()

-	c.Assert(err, check.IsNil)

-	var errs []string

-	for _, n := range networks {

-		if n.Name == "bridge" || n.Name == "none" || n.Name == "host" {

-			continue

-		}

-		if daemonPlatform == "windows" && strings.ToLower(n.Name) == "nat" {

-			// nat is a pre-defined network on Windows and cannot be removed

-			continue

-		}

-		status, b, err := sockRequest("DELETE", "/networks/"+n.Name, nil)

-		if err != nil {

-			errs = append(errs, err.Error())

-			continue

-		}

-		if status != http.StatusNoContent {

-			errs = append(errs, fmt.Sprintf("error deleting network %s: %s", n.Name, string(b)))

-		}

-	}

-	c.Assert(errs, checker.HasLen, 0, check.Commentf(strings.Join(errs, "\n")))

-}

-

-func getAllNetworks() ([]types.NetworkResource, error) {

-	var networks []types.NetworkResource

-	_, b, err := sockRequest("GET", "/networks", nil)

-	if err != nil {

-		return nil, err

-	}

-	if err := json.Unmarshal(b, &networks); err != nil {

-		return nil, err

-	}

-	return networks, nil

-}

-

-func deleteAllPlugins(c *check.C) {

-	plugins, err := getAllPlugins()

-	c.Assert(err, checker.IsNil)

-	var errs []string

-	for _, p := range plugins {

-		pluginName := p.Name

-		status, b, err := sockRequest("DELETE", "/plugins/"+pluginName+"?force=1", nil)

-		if err != nil {

-			errs = append(errs, err.Error())

-			continue

-		}

-		if status != http.StatusOK {

-			errs = append(errs, fmt.Sprintf("error deleting plugin %s: %s", p.Name, string(b)))

-		}

-	}

-	c.Assert(errs, checker.HasLen, 0, check.Commentf(strings.Join(errs, "\n")))

-}

-

-func getAllPlugins() (types.PluginsListResponse, error) {

-	var plugins types.PluginsListResponse

-	_, b, err := sockRequest("GET", "/plugins", nil)

-	if err != nil {

-		return nil, err

-	}

-	if err := json.Unmarshal(b, &plugins); err != nil {

-		return nil, err

-	}

-	return plugins, nil

-}

-

-func deleteAllVolumes(c *check.C) {

-	volumes, err := getAllVolumes()

-	c.Assert(err, checker.IsNil)

-	var errs []string

-	for _, v := range volumes {

-		status, b, err := sockRequest("DELETE", "/volumes/"+v.Name, nil)

-		if err != nil {

-			errs = append(errs, err.Error())

-			continue

-		}

-		if status != http.StatusNoContent {

-			errs = append(errs, fmt.Sprintf("error deleting volume %s: %s", v.Name, string(b)))

-		}

-	}

-	c.Assert(errs, checker.HasLen, 0, check.Commentf(strings.Join(errs, "\n")))

-}

-

-func getAllVolumes() ([]*types.Volume, error) {

-	var volumes volumetypes.VolumesListOKBody

-	_, b, err := sockRequest("GET", "/volumes", nil)

-	if err != nil {

-		return nil, err

-	}

-	if err := json.Unmarshal(b, &volumes); err != nil {

-		return nil, err

-	}

-	return volumes.Volumes, nil

-}

-

-var protectedImages = map[string]struct{}{}

-

-func deleteAllImages(c *check.C) {

-	cmd := exec.Command(dockerBinary, "images", "--digests")

-	cmd.Env = appendBaseEnv(true)

-	out, err := cmd.CombinedOutput()

-	c.Assert(err, checker.IsNil)

-	lines := strings.Split(string(out), "\n")[1:]

-	imgMap := map[string]struct{}{}

-	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>" || fields[1] == "<none>" {

-				if fields[2] != "<none>" {

-					imgMap[fields[0]+"@"+fields[2]] = struct{}{}

-				} else {

-					imgMap[fields[3]] = struct{}{}

-				}

-				// continue

-			} else {

-				imgMap[imgTag] = struct{}{}

-			}

-		}

-	}

-	if len(imgMap) != 0 {

-		imgs := make([]string, 0, len(imgMap))

-		for k := range imgMap {

-			imgs = append(imgs, k)

-		}

-		dockerCmd(c, append([]string{"rmi", "-f"}, imgs...)...)

-	}

-}

-

-func getPausedContainers() ([]string, error) {

-	getPausedContainersCmd := exec.Command(dockerBinary, "ps", "-f", "status=paused", "-q", "-a")

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

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

-		err = fmt.Errorf("failed to get a list of paused containers: %v\n", out)

-	}

-	if err != nil {

-		return nil, err

-	}

-

-	return strings.Fields(out), nil

-}

-

-func unpauseContainer(c *check.C, container string) {

-	dockerCmd(c, "unpause", container)

-}

-

-func unpauseAllContainers(c *check.C) {

-	containers, err := getPausedContainers()

-	c.Assert(err, checker.IsNil, check.Commentf("containers: %v", containers))

-	for _, value := range containers {

-		unpauseContainer(c, value)

-	}

-}

-

-func deleteImages(images ...string) error {

-	args := []string{dockerBinary, "rmi", "-f"}

-	return icmd.RunCmd(icmd.Cmd{Command: append(args, images...)}).Error

-}

-

-func dockerCmdWithError(args ...string) (string, int, error) {

-	if err := validateArgs(args...); err != nil {

-		return "", 0, err

-	}

-	result := icmd.RunCommand(dockerBinary, args...)

-	if result.Error != nil {

-		return result.Combined(), result.ExitCode, result.Compare(icmd.Success)

-	}

-	return result.Combined(), result.ExitCode, result.Error

-}

-

-func dockerCmdWithStdoutStderr(c *check.C, args ...string) (string, string, int) {

-	if err := validateArgs(args...); err != nil {

-		c.Fatalf(err.Error())

-	}

-

-	result := icmd.RunCommand(dockerBinary, args...)

-	c.Assert(result, icmd.Matches, icmd.Success)

-	return result.Stdout(), result.Stderr(), result.ExitCode

-}

-

-func dockerCmd(c *check.C, args ...string) (string, int) {

-	if err := validateArgs(args...); err != nil {

-		c.Fatalf(err.Error())

-	}

-	result := icmd.RunCommand(dockerBinary, args...)

-	c.Assert(result, icmd.Matches, icmd.Success)

-	return result.Combined(), result.ExitCode

-}

-

-func dockerCmdWithResult(args ...string) *icmd.Result {

-	return icmd.RunCommand(dockerBinary, args...)

-}

-

-func binaryWithArgs(args ...string) []string {

-	return append([]string{dockerBinary}, args...)

-}

-

-// execute a docker command with a timeout

-func dockerCmdWithTimeout(timeout time.Duration, args ...string) *icmd.Result {

-	if err := validateArgs(args...); err != nil {

-		return &icmd.Result{Error: err}

-	}

-	return icmd.RunCmd(icmd.Cmd{Command: binaryWithArgs(args...), Timeout: timeout})

-}

-

-// execute a docker command in a directory

-func dockerCmdInDir(c *check.C, path string, args ...string) (string, int, error) {

-	if err := validateArgs(args...); err != nil {

-		c.Fatalf(err.Error())

-	}

-	result := icmd.RunCmd(icmd.Cmd{Command: binaryWithArgs(args...), Dir: path})

-	return result.Combined(), result.ExitCode, result.Error

-}

-

-// validateArgs is a checker to ensure tests are not running commands which are

-// not supported on platforms. Specifically on Windows this is 'busybox top'.

-func validateArgs(args ...string) error {

-	if daemonPlatform != "windows" {

-		return nil

-	}

-	foundBusybox := -1

-	for key, value := range args {

-		if strings.ToLower(value) == "busybox" {

-			foundBusybox = key

-		}

-		if (foundBusybox != -1) && (key == foundBusybox+1) && (strings.ToLower(value) == "top") {

-			return errors.New("cannot use 'busybox top' in tests on Windows. Use runSleepingContainer()")

-		}

-	}

-	return nil

-}

-

-// find the State.ExitCode in container metadata

-func findContainerExitCode(c *check.C, name string, vargs ...string) string {

-	args := append(vargs, "inspect", "--format='{{ .State.ExitCode }} {{ .State.Error }}'", name)

-	cmd := exec.Command(dockerBinary, args...)

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

-	if err != nil {

-		c.Fatal(err, out)

-	}

-	return out

-}

-

-func findContainerIP(c *check.C, id string, network string) string {

-	out, _ := dockerCmd(c, "inspect", fmt.Sprintf("--format='{{ .NetworkSettings.Networks.%s.IPAddress }}'", network), id)

-	return strings.Trim(out, " \r\n'")

-}

-

-func getContainerCount() (int, error) {

-	const containers = "Containers:"

-

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

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

-	if err != nil {

-		return 0, err

-	}

-

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

-	for _, line := range lines {

-		if strings.Contains(line, containers) {

-			output := strings.TrimSpace(line)

-			output = strings.TrimLeft(output, containers)

-			output = strings.Trim(output, " ")

-			containerCount, err := strconv.Atoi(output)

-			if err != nil {

-				return 0, err

-			}

-			return containerCount, nil

-		}

-	}

-	return 0, fmt.Errorf("couldn't find the Container count in the output")

-}

-

-// FakeContext creates directories that can be used as a build context

-type FakeContext struct {

-	Dir string

-}

-

-// Add a file at a path, creating directories where necessary

-func (f *FakeContext) Add(file, content string) error {

-	return f.addFile(file, []byte(content))

-}

-

-func (f *FakeContext) addFile(file string, content []byte) error {

-	fp := filepath.Join(f.Dir, filepath.FromSlash(file))

-	dirpath := filepath.Dir(fp)

-	if dirpath != "." {

-		if err := os.MkdirAll(dirpath, 0755); err != nil {

-			return err

-		}

-	}

-	return ioutil.WriteFile(fp, content, 0644)

-

-}

-

-// Delete a file at a path

-func (f *FakeContext) Delete(file string) error {

-	fp := filepath.Join(f.Dir, filepath.FromSlash(file))

-	return os.RemoveAll(fp)

-}

-

-// Close deletes the context

-func (f *FakeContext) Close() error {

-	return os.RemoveAll(f.Dir)

-}

-

-func fakeContextFromNewTempDir() (*FakeContext, error) {

-	tmp, err := ioutil.TempDir("", "fake-context")

-	if err != nil {

-		return nil, err

-	}

-	if err := os.Chmod(tmp, 0755); err != nil {

-		return nil, err

-	}

-	return fakeContextFromDir(tmp), nil

-}

-

-func fakeContextFromDir(dir string) *FakeContext {

-	return &FakeContext{dir}

-}

-

-func fakeContextWithFiles(files map[string]string) (*FakeContext, error) {

-	ctx, err := fakeContextFromNewTempDir()

-	if err != nil {

-		return nil, err

-	}

-	for file, content := range files {

-		if err := ctx.Add(file, content); err != nil {

-			ctx.Close()

-			return nil, err

-		}

-	}

-	return ctx, nil

-}

-

-func fakeContextAddDockerfile(ctx *FakeContext, dockerfile string) error {

-	if err := ctx.Add("Dockerfile", dockerfile); err != nil {

-		ctx.Close()

-		return err

-	}

-	return nil

-}