@@ -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)

@@ -113,56 +113,6 @@ func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error

 	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()