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

 	"syscall"

 	"time"

-	"github.com/docker/libcontainer"

 	"github.com/docker/libcontainer/configs"

 	"github.com/docker/libcontainer/devices"

 	"github.com/docker/libcontainer/label"

@@ -1020,14 +1019,6 @@ func (container *Container) Exposes(p nat.Port) bool {

 	return exists

 }

-func (container *Container) GetPtyMaster() (libcontainer.Console, error) {

-	ttyConsole, ok := container.command.ProcessConfig.Terminal.(execdriver.TtyTerminal)

-	if !ok {

-		return nil, ErrNoTTY

-	}

-	return ttyConsole.Master(), nil

-}

-

 func (container *Container) HostConfig() *runconfig.HostConfig {

 	container.Lock()

 	res := container.hostConfig

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

 package main

 import (

+	"bufio"

 	"io"

 	"os/exec"

 	"strings"

@@ -134,3 +135,51 @@ func TestAttachTtyWithoutStdin(t *testing.T) {

 	logDone("attach - forbid piped stdin to tty enabled container")

 }

+

+func TestAttachDisconnect(t *testing.T) {

+	defer deleteAllContainers()

+	out, _, _ := dockerCmd(t, "run", "-di", "busybox", "/bin/cat")

+	id := strings.TrimSpace(out)

+

+	cmd := exec.Command(dockerBinary, "attach", id)

+	stdin, err := cmd.StdinPipe()

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer stdin.Close()

+	stdout, err := cmd.StdoutPipe()

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer stdout.Close()

+	if err := cmd.Start(); err != nil {

+		t.Fatal(err)

+	}

+	defer cmd.Process.Kill()

+

+	if _, err := stdin.Write([]byte("hello\n")); err != nil {

+		t.Fatal(err)

+	}

+	out, err = bufio.NewReader(stdout).ReadString('\n')

+	if err != nil {

+		t.Fatal(err)

+	}

+	if strings.TrimSpace(out) != "hello" {

+		t.Fatalf("exepected 'hello', got %q", out)

+	}

+

+	if err := stdin.Close(); err != nil {

+		t.Fatal(err)

+	}

+

+	// Expect container to still be running after stdin is closed

+	running, err := inspectField(id, "State.Running")

+	if err != nil {

+		t.Fatal(err)

+	}

+	if running != "true" {

+		t.Fatal("exepected container to still be running")

+	}

+

+	logDone("attach - disconnect")

+}

@@ -3,11 +3,13 @@

 package main

 import (

+	"bufio"

 	"os/exec"

 	"strings"

 	"testing"

 	"time"

+	"github.com/docker/docker/pkg/stringid"

 	"github.com/kr/pty"

 )

@@ -137,3 +139,150 @@ func TestAttachAfterDetach(t *testing.T) {

 	logDone("attach - reconnect after detaching")

 }

+

+// TestAttachDetach checks that attach in tty mode can be detached using the long container ID

+func TestAttachDetach(t *testing.T) {

+	out, _, _ := dockerCmd(t, "run", "-itd", "busybox", "cat")

+	id := strings.TrimSpace(out)

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

+		t.Fatal(err)

+	}

+

+	cpty, tty, err := pty.Open()

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer cpty.Close()

+

+	cmd := exec.Command(dockerBinary, "attach", id)

+	cmd.Stdin = tty

+	stdout, err := cmd.StdoutPipe()

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer stdout.Close()

+	if err := cmd.Start(); err != nil {

+		t.Fatal(err)

+	}

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

+		t.Fatalf("error waiting for container to start: %v", err)

+	}

+

+	if _, err := cpty.Write([]byte("hello\n")); err != nil {

+		t.Fatal(err)

+	}

+	out, err = bufio.NewReader(stdout).ReadString('\n')

+	if err != nil {

+		t.Fatal(err)

+	}

+	if strings.TrimSpace(out) != "hello" {

+		t.Fatalf("exepected 'hello', got %q", out)

+	}

+

+	// escape sequence

+	if _, err := cpty.Write([]byte{16}); err != nil {

+		t.Fatal(err)

+	}

+	time.Sleep(100 * time.Millisecond)

+	if _, err := cpty.Write([]byte{17}); err != nil {

+		t.Fatal(err)

+	}

+

+	ch := make(chan struct{})

+	go func() {

+		cmd.Wait()

+		ch <- struct{}{}

+	}()

+

+	running, err := inspectField(id, "State.Running")

+	if err != nil {

+		t.Fatal(err)

+	}

+	if running != "true" {

+		t.Fatal("exepected container to still be running")

+	}

+

+	go func() {

+		dockerCmd(t, "kill", id)

+	}()

+

+	select {

+	case <-ch:

+	case <-time.After(10 * time.Millisecond):

+		t.Fatal("timed out waiting for container to exit")

+	}

+

+	logDone("attach - detach")

+}

+

+// TestAttachDetachTruncatedID checks that attach in tty mode can be detached

+func TestAttachDetachTruncatedID(t *testing.T) {

+	out, _, _ := dockerCmd(t, "run", "-itd", "busybox", "cat")

+	id := stringid.TruncateID(strings.TrimSpace(out))

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

+		t.Fatal(err)

+	}

+

+	cpty, tty, err := pty.Open()

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer cpty.Close()

+

+	cmd := exec.Command(dockerBinary, "attach", id)

+	cmd.Stdin = tty

+	stdout, err := cmd.StdoutPipe()

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer stdout.Close()

+	if err := cmd.Start(); err != nil {

+		t.Fatal(err)

+	}

+

+	if _, err := cpty.Write([]byte("hello\n")); err != nil {

+		t.Fatal(err)

+	}

+	out, err = bufio.NewReader(stdout).ReadString('\n')

+	if err != nil {

+		t.Fatal(err)

+	}

+	if strings.TrimSpace(out) != "hello" {

+		t.Fatalf("exepected 'hello', got %q", out)

+	}

+

+	// escape sequence

+	if _, err := cpty.Write([]byte{16}); err != nil {

+		t.Fatal(err)

+	}

+	time.Sleep(100 * time.Millisecond)

+	if _, err := cpty.Write([]byte{17}); err != nil {

+		t.Fatal(err)

+	}

+

+	ch := make(chan struct{})

+	go func() {

+		cmd.Wait()

+		ch <- struct{}{}

+	}()

+

+	running, err := inspectField(id, "State.Running")

+	if err != nil {

+		t.Fatal(err)

+	}

+	if running != "true" {

+		t.Fatal("exepected container to still be running")

+	}

+

+	go func() {

+		dockerCmd(t, "kill", id)

+	}()

+

+	select {

+	case <-ch:

+	case <-time.After(10 * time.Millisecond):

+		t.Fatal("timed out waiting for container to exit")

+	}

+

+	logDone("attach - detach truncated ID")

+}

@@ -3,6 +3,7 @@

 package main

 import (

+	"bufio"

 	"fmt"

 	"io/ioutil"

 	"os"

@@ -201,3 +202,73 @@ func TestRunDeviceDirectory(t *testing.T) {

 	logDone("run - test --device directory mounts all internal devices")

 }

+

+// TestRunDetach checks attaching and detaching with the escape sequence.

+func TestRunAttachDetach(t *testing.T) {

+	defer deleteAllContainers()

+	name := "attach-detach"

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

+	stdout, err := cmd.StdoutPipe()

+	if err != nil {

+		t.Fatal(err)

+	}

+	cpty, tty, err := pty.Open()

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer cpty.Close()

+	cmd.Stdin = tty

+	if err := cmd.Start(); err != nil {

+		t.Fatal(err)

+	}

+	if err := waitRun(name); err != nil {

+		t.Fatal(err)

+	}

+

+	if _, err := cpty.Write([]byte("hello\n")); err != nil {

+		t.Fatal(err)

+	}

+

+	out, err := bufio.NewReader(stdout).ReadString('\n')

+	if err != nil {

+		t.Fatal(err)

+	}

+	if strings.TrimSpace(out) != "hello" {

+		t.Fatalf("exepected 'hello', got %q", out)

+	}

+

+	// escape sequence

+	if _, err := cpty.Write([]byte{16}); err != nil {

+		t.Fatal(err)

+	}

+	time.Sleep(100 * time.Millisecond)

+	if _, err := cpty.Write([]byte{17}); err != nil {

+		t.Fatal(err)

+	}

+

+	ch := make(chan struct{})

+	go func() {

+		cmd.Wait()

+		ch <- struct{}{}

+	}()

+

+	running, err := inspectField(name, "State.Running")

+	if err != nil {

+		t.Fatal(err)

+	}

+	if running != "true" {

+		t.Fatal("exepected container to still be running")

+	}

+

+	go func() {

+		dockerCmd(t, "kill", name)

+	}()

+

+	select {

+	case <-ch:

+	case <-time.After(10 * time.Millisecond):

+		t.Fatal("timed out waiting for container to exit")

+	}

+

+	logDone("run - attach detach")

+}

@@ -213,7 +213,16 @@ func waitInspect(name, expr, expected string, timeout int) error {

 		cmd := exec.Command(dockerBinary, "inspect", "-f", expr, name)

 		out, _, err := runCommandWithOutput(cmd)

 		if err != nil {

-			return fmt.Errorf("error executing docker inspect: %v", err)

+			if !strings.Contains(out, "No such") {

+				return fmt.Errorf("error executing docker inspect: %v\n%s", err, out)

+			}

+			select {

+			case <-after:

+				return err

+			default:

+				time.Sleep(10 * time.Millisecond)

+				continue

+			}

 		}

 		out = strings.TrimSpace(out)

deleted file mode 100644

@@ -1,436 +0,0 @@

-package docker

-

-import (

-	"bufio"

-	"fmt"

-	"io"

-	"io/ioutil"

-	"strings"

-	"testing"

-	"time"

-

-	"github.com/Sirupsen/logrus"

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

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

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

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

-	"github.com/kr/pty"

-)

-

-func closeWrap(args ...io.Closer) error {

-	e := false

-	ret := fmt.Errorf("Error closing elements")

-	for _, c := range args {

-		if err := c.Close(); err != nil {

-			e = true

-			ret = fmt.Errorf("%s\n%s", ret, err)

-		}

-	}

-	if e {

-		return ret

-	}

-	return nil

-}

-

-func setRaw(t *testing.T, c *daemon.Container) *term.State {

-	pty, err := c.GetPtyMaster()

-	if err != nil {

-		t.Fatal(err)

-	}

-	state, err := term.MakeRaw(pty.Fd())

-	if err != nil {

-		t.Fatal(err)

-	}

-	return state

-}

-

-func unsetRaw(t *testing.T, c *daemon.Container, state *term.State) {

-	pty, err := c.GetPtyMaster()

-	if err != nil {

-		t.Fatal(err)

-	}

-	term.RestoreTerminal(pty.Fd(), state)

-}

-

-func waitContainerStart(t *testing.T, timeout time.Duration) *daemon.Container {

-	var container *daemon.Container

-

-	setTimeout(t, "Waiting for the container to be started timed out", timeout, func() {

-		for {

-			l := globalDaemon.List()

-			if len(l) == 1 && l[0].IsRunning() {

-				container = l[0]

-				break

-			}

-			time.Sleep(10 * time.Millisecond)

-		}

-	})

-

-	if container == nil {

-		t.Fatal("An error occured while waiting for the container to start")

-	}

-

-	return container

-}

-

-func setTimeout(t *testing.T, msg string, d time.Duration, f func()) {

-	c := make(chan bool)

-

-	// Make sure we are not too long

-	go func() {

-		time.Sleep(d)

-		c <- true

-	}()

-	go func() {

-		f()

-		c <- false

-	}()

-	if <-c && msg != "" {

-		t.Fatal(msg)

-	}

-}

-

-func expectPipe(expected string, r io.Reader) error {

-	o, err := bufio.NewReader(r).ReadString('\n')

-	if err != nil {

-		return err

-	}

-	if strings.Trim(o, " \r\n") != expected {

-		return fmt.Errorf("Unexpected output. Expected [%s], received [%s]", expected, o)

-	}

-	return nil

-}

-

-func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error {

-	for i := 0; i < count; i++ {

-		if _, err := w.Write([]byte(input)); err != nil {

-			return err

-		}

-		if err := expectPipe(output, r); err != nil {

-			return err

-		}

-	}

-	return nil

-}

-

-// TestRunDetach checks attaching and detaching with the escape sequence.

-func TestRunDetach(t *testing.T) {

-	stdout, stdoutPipe := io.Pipe()

-	cpty, tty, err := pty.Open()

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	cli := client.NewDockerCli(tty, stdoutPipe, ioutil.Discard, "", testDaemonProto, testDaemonAddr, nil)

-	defer cleanup(globalEngine, t)

-

-	ch := make(chan struct{})

-	go func() {

-		defer close(ch)

-		cli.CmdRun("-i", "-t", unitTestImageID, "cat")

-	}()

-

-	container := waitContainerStart(t, 10*time.Second)

-

-	state := setRaw(t, container)

-	defer unsetRaw(t, container, state)

-

-	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {

-		if err := assertPipe("hello\n", "hello", stdout, cpty, 150); err != nil {

-			t.Fatal(err)

-		}

-	})

-

-	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {

-		cpty.Write([]byte{16})

-		time.Sleep(100 * time.Millisecond)

-		cpty.Write([]byte{17})

-	})

-

-	// wait for CmdRun to return

-	setTimeout(t, "Waiting for CmdRun timed out", 15*time.Second, func() {

-		<-ch

-	})

-	closeWrap(cpty, stdout, stdoutPipe)

-

-	time.Sleep(500 * time.Millisecond)

-	if !container.IsRunning() {

-		t.Fatal("The detached container should be still running")

-	}

-

-	setTimeout(t, "Waiting for container to die timed out", 20*time.Second, func() {

-		container.Kill()

-	})

-}

-

-// TestAttachDetach checks that attach in tty mode can be detached using the long container ID

-func TestAttachDetach(t *testing.T) {

-	stdout, stdoutPipe := io.Pipe()

-	cpty, tty, err := pty.Open()

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	cli := client.NewDockerCli(tty, stdoutPipe, ioutil.Discard, "", testDaemonProto, testDaemonAddr, nil)

-	defer cleanup(globalEngine, t)

-

-	ch := make(chan struct{})

-	go func() {

-		defer close(ch)

-		if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil {

-			t.Fatal(err)

-		}

-	}()

-

-	container := waitContainerStart(t, 10*time.Second)

-

-	setTimeout(t, "Reading container's id timed out", 10*time.Second, func() {

-		buf := make([]byte, 1024)

-		n, err := stdout.Read(buf)

-		if err != nil {

-			t.Fatal(err)

-		}

-

-		if strings.Trim(string(buf[:n]), " \r\n") != container.ID {

-			t.Fatalf("Wrong ID received. Expect %s, received %s", container.ID, buf[:n])

-		}

-	})

-	setTimeout(t, "Starting container timed out", 10*time.Second, func() {

-		<-ch

-	})

-

-	state := setRaw(t, container)

-	defer unsetRaw(t, container, state)

-

-	stdout, stdoutPipe = io.Pipe()

-	cpty, tty, err = pty.Open()

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	cli = client.NewDockerCli(tty, stdoutPipe, ioutil.Discard, "", testDaemonProto, testDaemonAddr, nil)

-

-	ch = make(chan struct{})

-	go func() {

-		defer close(ch)

-		if err := cli.CmdAttach(container.ID); err != nil {

-			if err != io.ErrClosedPipe {

-				t.Fatal(err)

-			}

-		}

-	}()

-

-	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {

-		if err := assertPipe("hello\n", "hello", stdout, cpty, 150); err != nil {

-			if err != io.ErrClosedPipe {

-				t.Fatal(err)

-			}

-		}

-	})

-

-	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {

-		cpty.Write([]byte{16})

-		time.Sleep(100 * time.Millisecond)

-		cpty.Write([]byte{17})

-	})

-

-	// wait for CmdRun to return

-	setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() {

-		<-ch

-	})

-

-	closeWrap(cpty, stdout, stdoutPipe)

-

-	time.Sleep(500 * time.Millisecond)

-	if !container.IsRunning() {

-		t.Fatal("The detached container should be still running")

-	}

-

-	setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() {

-		container.Kill()

-	})

-}

-

-// TestAttachDetachTruncatedID checks that attach in tty mode can be detached

-func TestAttachDetachTruncatedID(t *testing.T) {

-	stdout, stdoutPipe := io.Pipe()

-	cpty, tty, err := pty.Open()

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	cli := client.NewDockerCli(tty, stdoutPipe, ioutil.Discard, "", testDaemonProto, testDaemonAddr, nil)

-	defer cleanup(globalEngine, t)

-

-	// Discard the CmdRun output

-	go stdout.Read(make([]byte, 1024))

-	setTimeout(t, "Starting container timed out", 2*time.Second, func() {

-		if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil {

-			t.Fatal(err)

-		}

-	})

-

-	container := waitContainerStart(t, 10*time.Second)

-

-	state := setRaw(t, container)

-	defer unsetRaw(t, container, state)

-

-	stdout, stdoutPipe = io.Pipe()

-	cpty, tty, err = pty.Open()

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	cli = client.NewDockerCli(tty, stdoutPipe, ioutil.Discard, "", testDaemonProto, testDaemonAddr, nil)

-

-	ch := make(chan struct{})

-	go func() {

-		defer close(ch)

-		if err := cli.CmdAttach(stringid.TruncateID(container.ID)); err != nil {

-			if err != io.ErrClosedPipe {

-				t.Fatal(err)

-			}

-		}

-	}()

-

-	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {

-		if err := assertPipe("hello\n", "hello", stdout, cpty, 150); err != nil {

-			if err != io.ErrClosedPipe {

-				t.Fatal(err)

-			}

-		}

-	})

-

-	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {

-		cpty.Write([]byte{16})

-		time.Sleep(100 * time.Millisecond)

-		cpty.Write([]byte{17})

-	})

-

-	// wait for CmdRun to return

-	setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() {

-		<-ch

-	})

-	closeWrap(cpty, stdout, stdoutPipe)

-

-	time.Sleep(500 * time.Millisecond)

-	if !container.IsRunning() {

-		t.Fatal("The detached container should be still running")

-	}

-

-	setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() {

-		container.Kill()

-	})

-}

-

-// Expected behaviour, the process stays alive when the client disconnects

-func TestAttachDisconnect(t *testing.T) {

-	stdout, stdoutPipe := io.Pipe()

-	cpty, tty, err := pty.Open()

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	cli := client.NewDockerCli(tty, stdoutPipe, ioutil.Discard, "", testDaemonProto, testDaemonAddr, nil)

-	defer cleanup(globalEngine, t)

-

-	go func() {

-		// Start a process in daemon mode

-		if err := cli.CmdRun("-d", "-i", unitTestImageID, "/bin/cat"); err != nil {

-			logrus.Debugf("Error CmdRun: %s", err)

-		}

-	}()

-

-	setTimeout(t, "Waiting for CmdRun timed out", 10*time.Second, func() {

-		if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil {

-			t.Fatal(err)

-		}

-	})

-

-	setTimeout(t, "Waiting for the container to be started timed out", 10*time.Second, func() {

-		for {

-			l := globalDaemon.List()

-			if len(l) == 1 && l[0].IsRunning() {

-				break

-			}

-			time.Sleep(10 * time.Millisecond)

-		}

-	})

-

-	container := globalDaemon.List()[0]

-

-	// Attach to it

-	c1 := make(chan struct{})

-	go func() {

-		// We're simulating a disconnect so the return value doesn't matter. What matters is the

-		// fact that CmdAttach returns.

-		cli.CmdAttach(container.ID)

-		close(c1)

-	}()

-

-	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {

-		if err := assertPipe("hello\n", "hello", stdout, cpty, 150); err != nil {

-			t.Fatal(err)

-		}

-	})

-	// Close pipes (client disconnects)

-	if err := closeWrap(cpty, stdout, stdoutPipe); err != nil {

-		t.Fatal(err)

-	}

-

-	// Wait for attach to finish, the client disconnected, therefore, Attach finished his job

-	setTimeout(t, "Waiting for CmdAttach timed out", 2*time.Second, func() {

-		<-c1

-	})

-

-	// We closed stdin, expect /bin/cat to still be running

-	// Wait a little bit to make sure container.monitor() did his thing

-	_, err = container.WaitStop(500 * time.Millisecond)

-	if err == nil || !container.IsRunning() {

-		t.Fatalf("/bin/cat is not running after closing stdin")

-	}

-

-	// Try to avoid the timeout in destroy. Best effort, don't check error

-	cStdin := container.StdinPipe()

-	cStdin.Close()

-	container.WaitStop(-1 * time.Second)

-}

-

-// Expected behaviour: container gets deleted automatically after exit

-func TestRunAutoRemove(t *testing.T) {

-	t.Skip("Fixme. Skipping test for now, race condition")

-	stdout, stdoutPipe := io.Pipe()

-

-	cli := client.NewDockerCli(nil, stdoutPipe, ioutil.Discard, "", testDaemonProto, testDaemonAddr, nil)

-	defer cleanup(globalEngine, t)

-

-	c := make(chan struct{})

-	go func() {

-		defer close(c)

-		if err := cli.CmdRun("--rm", unitTestImageID, "hostname"); err != nil {

-			t.Fatal(err)

-		}

-	}()

-

-	var temporaryContainerID string

-	setTimeout(t, "Reading command output time out", 2*time.Second, func() {

-		cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')

-		if err != nil {

-			t.Fatal(err)

-		}

-		temporaryContainerID = cmdOutput

-		if err := closeWrap(stdout, stdoutPipe); err != nil {

-			t.Fatal(err)

-		}

-	})

-

-	setTimeout(t, "CmdRun timed out", 10*time.Second, func() {

-		<-c

-	})

-

-	time.Sleep(500 * time.Millisecond)

-

-	if len(globalDaemon.List()) > 0 {

-		t.Fatalf("failed to remove container automatically: container %s still exists", temporaryContainerID)

-	}

-}

new file mode 100644

@@ -0,0 +1,88 @@

+package docker

+

+import (

+	"bufio"

+	"fmt"

+	"io"

+	"strings"

+	"testing"

+	"time"

+

+	"github.com/docker/docker/daemon"

+)

+

+func closeWrap(args ...io.Closer) error {

+	e := false

+	ret := fmt.Errorf("Error closing elements")

+	for _, c := range args {

+		if err := c.Close(); err != nil {

+			e = true

+			ret = fmt.Errorf("%s\n%s", ret, err)

+		}

+	}

+	if e {

+		return ret

+	}

+	return nil

+}

+

+func waitContainerStart(t *testing.T, timeout time.Duration) *daemon.Container {

+	var container *daemon.Container

+

+	setTimeout(t, "Waiting for the container to be started timed out", timeout, func() {

+		for {

+			l := globalDaemon.List()

+			if len(l) == 1 && l[0].IsRunning() {

+				container = l[0]

+				break

+			}

+			time.Sleep(10 * time.Millisecond)

+		}

+	})

+

+	if container == nil {

+		t.Fatal("An error occured while waiting for the container to start")

+	}

+

+	return container

+}

+

+func setTimeout(t *testing.T, msg string, d time.Duration, f func()) {

+	c := make(chan bool)

+

+	// Make sure we are not too long

+	go func() {

+		time.Sleep(d)

+		c <- true

+	}()

+	go func() {

+		f()

+		c <- false

+	}()

+	if <-c && msg != "" {

+		t.Fatal(msg)

+	}

+}

+

+func expectPipe(expected string, r io.Reader) error {

+	o, err := bufio.NewReader(r).ReadString('\n')

+	if err != nil {

+		return err

+	}

+	if strings.Trim(o, " \r\n") != expected {

+		return fmt.Errorf("Unexpected output. Expected [%s], received [%s]", expected, o)

+	}

+	return nil

+}

+

+func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error {

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

+		if _, err := w.Write([]byte(input)); err != nil {

+			return err

+		}

+		if err := expectPipe(output, r); err != nil {

+			return err

+		}

+	}

+	return nil

+}