@@ -27,49 +27,29 @@ import (

 )

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

-	name := "testbuildjsonemptyrun"

-

-	_, err := buildImage(

-		name,

-		`

+	buildImageSuccessfully(c, "testbuildjsonemptyrun", withDockerfile(`

     FROM busybox

     RUN []

-    `,

-		true)

-

-	if err != nil {

-		c.Fatal("error when dealing with a RUN statement with empty JSON array")

-	}

-

+    `))

 }

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

 	name := "testbuildshcmdjsonentrypoint"

+	expected := "/bin/sh -c echo test"

+	if daemonPlatform == "windows" {

+		expected = "cmd /S /C echo test"

+	}

-	_, err := buildImage(

-		name,

-		`

+	buildImageSuccessfully(c, name, withDockerfile(`

     FROM busybox

     ENTRYPOINT ["echo"]

     CMD echo test

-    `,

-		true)

-	if err != nil {

-		c.Fatal(err)

-	}

-

+    `))

 	out, _ := dockerCmd(c, "run", "--rm", name)

-	if daemonPlatform == "windows" {

-		if !strings.Contains(out, "cmd /S /C echo test") {

-			c.Fatalf("CMD did not contain cmd /S /C echo test : %q", out)

-		}

-	} else {

-		if strings.TrimSpace(out) != "/bin/sh -c echo test" {

-			c.Fatalf("CMD did not contain /bin/sh -c : %q", out)

-		}

+	if strings.TrimSpace(out) != expected {

+		c.Fatalf("CMD did not contain %q : %q", expected, out)

 	}

-

 }

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

@@ -77,21 +57,16 @@ func (s *DockerSuite) TestBuildEnvironmentReplacementUser(c *check.C) {

 	testRequires(c, DaemonIsLinux)

 	name := "testbuildenvironmentreplacement"

-	_, err := buildImage(name, `

+	buildImageSuccessfully(c, name, withDockerfile(`

   FROM scratch

   ENV user foo

   USER ${user}

-  `, true)

-	if err != nil {

-		c.Fatal(err)

-	}

-

+  `))

 	res := inspectFieldJSON(c, name, "Config.User")

 	if res != `"foo"` {

 		c.Fatal("User foo from environment not in Config.User on image")

 	}

-

 }

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

@@ -105,23 +80,14 @@ func (s *DockerSuite) TestBuildEnvironmentReplacementVolume(c *check.C) {

 		volumePath = "/quux"

 	}

-	_, err := buildImage(name, `

+	buildImageSuccessfully(c, name, withDockerfile(`

   FROM `+minimalBaseImage()+`

   ENV volume `+volumePath+`

   VOLUME ${volume}

-  `, true)

-	if err != nil {

-		c.Fatal(err)

-	}

-

-	res := inspectFieldJSON(c, name, "Config.Volumes")

+  `))

 	var volumes map[string]interface{}

-

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

-		c.Fatal(err)

-	}

-

+	inspectFieldAndUnmarshall(c, name, "Config.Volumes", &volumes)

 	if _, ok := volumes[volumePath]; !ok {

 		c.Fatal("Volume " + volumePath + " from environment not in Config.Volumes on image")

 	}

@@ -133,27 +99,17 @@ func (s *DockerSuite) TestBuildEnvironmentReplacementExpose(c *check.C) {

 	testRequires(c, DaemonIsLinux)

 	name := "testbuildenvironmentreplacement"

-	_, err := buildImage(name, `

+	buildImageSuccessfully(c, name, withDockerfile(`

   FROM scratch

   ENV port 80

   EXPOSE ${port}

   ENV ports "  99   100 "

   EXPOSE ${ports}

-  `, true)

-	if err != nil {

-		c.Fatal(err)

-	}

-

-	res := inspectFieldJSON(c, name, "Config.ExposedPorts")

+  `))

 	var exposedPorts map[string]interface{}

-

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

-		c.Fatal(err)

-	}

-

+	inspectFieldAndUnmarshall(c, name, "Config.ExposedPorts", &exposedPorts)

 	exp := []int{80, 99, 100}

-

 	for _, p := range exp {

 		tmp := fmt.Sprintf("%d/tcp", p)

 		if _, ok := exposedPorts[tmp]; !ok {

@@ -166,23 +122,28 @@ func (s *DockerSuite) TestBuildEnvironmentReplacementExpose(c *check.C) {

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

 	name := "testbuildenvironmentreplacement"

-	_, err := buildImage(name, `

+	buildImageSuccessfully(c, name, withDockerfile(`

   FROM busybox

   ENV MYWORKDIR /work

   RUN mkdir ${MYWORKDIR}

   WORKDIR ${MYWORKDIR}

-  `, true)

+  `))

+	res := inspectFieldJSON(c, name, "Config.WorkingDir")

-	if err != nil {

-		c.Fatal(err)

+	expected := `"/work"`

+	if daemonPlatform == "windows" {

+		expected = `"C:\\work"`

+	}

+	if res != expected {

+		c.Fatalf("Workdir /workdir from environment not in Config.WorkingDir on image: %s", res)

 	}

-

 }

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

 	name := "testbuildenvironmentreplacement"

-	ctx, err := fakeContext(`

+	buildImageSuccessfully(c, name, withBuildContext(c,

+		withFile("Dockerfile", `

   FROM `+minimalBaseImage()+`

   ENV baz foo

   ENV quux bar

@@ -194,23 +155,12 @@ func (s *DockerSuite) TestBuildEnvironmentReplacementAddCopy(c *check.C) {

   COPY ${quux} ${dot}

   ADD ${zzz:-${fee}} ${dot}

   COPY ${zzz:-${gee}} ${dot}

-  `,

-		map[string]string{

-			"foo": "test1",

-			"bar": "test2",

-			"fff": "test3",

-			"ggg": "test4",

-		})

-

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

-

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

-	}

-

+  `),

+		withFile("foo", "test1"),

+		withFile("bar", "test2"),

+		withFile("fff", "test3"),

+		withFile("ggg", "test4"),

+	))

 }

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

@@ -218,8 +168,7 @@ func (s *DockerSuite) TestBuildEnvironmentReplacementEnv(c *check.C) {

 	testRequires(c, DaemonIsLinux)

 	name := "testbuildenvironmentreplacement"

-	_, err := buildImage(name,

-		`

+	buildImageSuccessfully(c, name, withDockerfile(`

   FROM busybox

   ENV foo zzz

   ENV bar ${foo}

@@ -232,20 +181,10 @@ func (s *DockerSuite) TestBuildEnvironmentReplacementEnv(c *check.C) {

   RUN [ "$abc3" = '$foo' ] && (echo "$abc3" | grep -q foo)

   ENV abc4 "\$foo"

   RUN [ "$abc4" = '$foo' ] && (echo "$abc4" | grep -q foo)

-  `, true)

-

-	if err != nil {

-		c.Fatal(err)

-	}

-

-	res := inspectFieldJSON(c, name, "Config.Env")

+  `))

 	envResult := []string{}

-

-	if err = json.Unmarshal([]byte(res), &envResult); err != nil {

-		c.Fatal(err)

-	}

-

+	inspectFieldAndUnmarshall(c, name, "Config.Env", &envResult)

 	found := false

 	envCount := 0

@@ -279,114 +218,70 @@ func (s *DockerSuite) TestBuildEnvironmentReplacementEnv(c *check.C) {

 }

-func (s *DockerSuite) TestBuildHandleEscapes(c *check.C) {

+func (s *DockerSuite) TestBuildHandleEscapesInVolume(c *check.C) {

 	// The volume paths used in this test are invalid on Windows

 	testRequires(c, DaemonIsLinux)

 	name := "testbuildhandleescapes"

-	_, err := buildImage(name,

-		`

-  FROM scratch

-  ENV FOO bar

-  VOLUME ${FOO}

-  `, true)

-

-	if err != nil {

-		c.Fatal(err)

-	}

-

-	var result map[string]map[string]struct{}

-

-	res := inspectFieldJSON(c, name, "Config.Volumes")

-

-	if err = json.Unmarshal([]byte(res), &result); err != nil {

-		c.Fatal(err)

-	}

-

-	if _, ok := result["bar"]; !ok {

-		c.Fatalf("Could not find volume bar set from env foo in volumes table, got %q", result)

-	}

-

-	deleteImages(name)

-

-	_, err = buildImage(name,

-		`

-  FROM scratch

-  ENV FOO bar

-  VOLUME \${FOO}

-  `, true)

-

-	if err != nil {

-		c.Fatal(err)

-	}

-

-	res = inspectFieldJSON(c, name, "Config.Volumes")

-

-	if err = json.Unmarshal([]byte(res), &result); err != nil {

-		c.Fatal(err)

-	}

-

-	if _, ok := result["${FOO}"]; !ok {

-		c.Fatalf("Could not find volume ${FOO} set from env foo in volumes table, got %q", result)

+	testCases := []struct {

+		volumeValue string

+		expected    string

+	}{

+		{

+			volumeValue: "${FOO}",

+			expected:    "bar",

+		},

+		{

+			volumeValue: `\${FOO}`,

+			expected:    "${FOO}",

+		},

+		// this test in particular provides *7* backslashes and expects 6 to come back.

+		// Like above, the first escape is swallowed and the rest are treated as

+		// literals, this one is just less obvious because of all the character noise.

+		{

+			volumeValue: `\\\\\\\${FOO}`,

+			expected:    `\\\${FOO}`,

+		},

 	}

-	deleteImages(name)

-

-	// this test in particular provides *7* backslashes and expects 6 to come back.

-	// Like above, the first escape is swallowed and the rest are treated as

-	// literals, this one is just less obvious because of all the character noise.

-

-	_, err = buildImage(name,

-		`

+	for _, tc := range testCases {

+		buildImageSuccessfully(c, name, withDockerfile(fmt.Sprintf(`

   FROM scratch

   ENV FOO bar

-  VOLUME \\\\\\\${FOO}

-  `, true)

-

-	if err != nil {

-		c.Fatal(err)

-	}

+  VOLUME %s

+  `, tc.volumeValue)))

-	res = inspectFieldJSON(c, name, "Config.Volumes")

-

-	if err = json.Unmarshal([]byte(res), &result); err != nil {

-		c.Fatal(err)

-	}

+		var result map[string]map[string]struct{}

+		inspectFieldAndUnmarshall(c, name, "Config.Volumes", &result)

+		if _, ok := result[tc.expected]; !ok {

+			c.Fatalf("Could not find volume %s set from env foo in volumes table, got %q", tc.expected, result)

+		}

-	if _, ok := result[`\\\${FOO}`]; !ok {

-		c.Fatalf(`Could not find volume \\\${FOO} set from env foo in volumes table, got %q`, result)

+		// Remove the image for the next iteration

+		dockerCmd(c, "rmi", name)

 	}

-

 }

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

 	name := "testbuildonbuildlowercase"

 	name2 := "testbuildonbuildlowercase2"

-	_, err := buildImage(name,

-		`

+	buildImageSuccessfully(c, name, withDockerfile(`

   FROM busybox

   onbuild run echo quux

-  `, true)

+  `))

-	if err != nil {

-		c.Fatal(err)

-	}

-

-	_, out, err := buildImageWithOut(name2, fmt.Sprintf(`

+	result := buildImageNew(name2, withDockerfile(fmt.Sprintf(`

   FROM %s

-  `, name), true)

+  `, name)))

+	result.Assert(c, icmd.Success)

-	if err != nil {

-		c.Fatal(err)

+	if !strings.Contains(result.Combined(), "quux") {

+		c.Fatalf("Did not receive the expected echo text, got %s", result.Combined())

 	}

-	if !strings.Contains(out, "quux") {

-		c.Fatalf("Did not receive the expected echo text, got %s", out)

-	}

-

-	if strings.Contains(out, "ONBUILD ONBUILD") {

-		c.Fatalf("Got an ONBUILD ONBUILD error with no error: got %s", out)

+	if strings.Contains(result.Combined(), "ONBUILD ONBUILD") {

+		c.Fatalf("Got an ONBUILD ONBUILD error with no error: got %s", result.Combined())

 	}

 }

@@ -395,20 +290,13 @@ func (s *DockerSuite) TestBuildEnvEscapes(c *check.C) {

 	// ENV expansions work differently in Windows

 	testRequires(c, DaemonIsLinux)

 	name := "testbuildenvescapes"

-	_, err := buildImage(name,

-		`

+	buildImageSuccessfully(c, name, withDockerfile(`

     FROM busybox

     ENV TEST foo

     CMD echo \$

-    `,

-		true)

-

-	if err != nil {

-		c.Fatal(err)

-	}

+    `))

 	out, _ := dockerCmd(c, "run", "-t", name)

-

 	if strings.TrimSpace(out) != "$" {

 		c.Fatalf("Env TEST was not overwritten with bar when foo was supplied to dockerfile: was %q", strings.TrimSpace(out))

 	}

@@ -419,77 +307,51 @@ func (s *DockerSuite) TestBuildEnvOverwrite(c *check.C) {

 	// ENV expansions work differently in Windows

 	testRequires(c, DaemonIsLinux)

 	name := "testbuildenvoverwrite"

-

-	_, err := buildImage(name,

-		`

+	buildImageSuccessfully(c, name, withDockerfile(`

     FROM busybox

     ENV TEST foo

     CMD echo ${TEST}

-    `,

-		true)

-

-	if err != nil {

-		c.Fatal(err)

-	}

+    `))

 	out, _ := dockerCmd(c, "run", "-e", "TEST=bar", "-t", name)

-

 	if strings.TrimSpace(out) != "bar" {

 		c.Fatalf("Env TEST was not overwritten with bar when foo was supplied to dockerfile: was %q", strings.TrimSpace(out))

 	}

 }

+// FIXME(vdemeester) why we disabled cache here ?

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

 	name1 := "onbuildcmd"

 	name2 := "onbuildgenerated"

-	_, err := buildImage(name1, `

+	buildImageSuccessfully(c, name1, withDockerfile(`

 FROM busybox

 ONBUILD CMD ["hello world"]

 ONBUILD ENTRYPOINT ["echo"]

-ONBUILD RUN ["true"]`,

-		false)

-

-	if err != nil {

-		c.Fatal(err)

-	}

-

-	_, err = buildImage(name2, fmt.Sprintf(`FROM %s`, name1), false)

+ONBUILD RUN ["true"]`))

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name2, withDockerfile(fmt.Sprintf(`FROM %s`, name1)))

 	out, _ := dockerCmd(c, "run", name2)

-

 	if !regexp.MustCompile(`(?m)^hello world`).MatchString(out) {

 		c.Fatalf("did not get echo output from onbuild. Got: %q", out)

 	}

 }

+// FIXME(vdemeester) why we disabled cache here ?

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

 	name1 := "onbuildcmd"

 	name2 := "onbuildgenerated"

-	_, err := buildImage(name1, `

+	buildImageSuccessfully(c, name1, withDockerfile(`

 FROM busybox

-ONBUILD ENTRYPOINT ["echo"]`,

-		false)

+ONBUILD ENTRYPOINT ["echo"]`))

-	if err != nil {

-		c.Fatal(err)

-	}

-

-	_, err = buildImage(name2, fmt.Sprintf("FROM %s\nCMD [\"hello world\"]\n", name1), false)

-

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name2, withDockerfile(fmt.Sprintf("FROM %s\nCMD [\"hello world\"]\n", name1)))

 	out, _ := dockerCmd(c, "run", name2)

-

 	if !regexp.MustCompile(`(?m)^hello world`).MatchString(out) {

 		c.Fatal("got malformed output from onbuild", out)

 	}

@@ -626,8 +488,8 @@ ADD folder/file /test/changetarget`,

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

 	testRequires(c, DaemonIsLinux) // Linux specific test

-	name := "testaddimg"

-	ctx, err := fakeContext(fmt.Sprintf(`FROM busybox

+	buildImageSuccessfully(c, "testaddimg", withBuildContext(c,

+		withFile("Dockerfile", fmt.Sprintf(`FROM busybox

 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

 RUN echo 'dockerio:x:1001:' >> /etc/group

 RUN touch /exists

@@ -635,18 +497,8 @@ RUN chown dockerio.dockerio /exists

 ADD test_file /

 RUN [ $(ls -l /test_file | awk '{print $3":"$4}') = 'root:root' ]

 RUN [ $(ls -l /test_file | awk '{print $1}') = '%s' ]

-RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`, expectedFileChmod),

-		map[string]string{

-			"test_file": "test1",

-		})

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

-

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

-	}

+RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`, expectedFileChmod)),

+		withFile("test_file", "test1")))

 }

 // Issue #3960: "ADD src ." hangs

@@ -678,8 +530,8 @@ ADD test_file .`,

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

 	testRequires(c, DaemonIsLinux) // Linux specific test

-	name := "testaddsinglefiletoexistdir"

-	ctx, err := fakeContext(`FROM busybox

+	buildImageSuccessfully(c, "testaddsinglefiletoexistdir", withBuildContext(c,

+		withFile("Dockerfile", `FROM busybox

 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

 RUN echo 'dockerio:x:1001:' >> /etc/group

 RUN mkdir /exists

@@ -688,18 +540,8 @@ RUN chown -R dockerio.dockerio /exists

 ADD test_file /exists/

 RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]

 RUN [ $(ls -l /exists/test_file | awk '{print $3":"$4}') = 'root:root' ]

-RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,

-		map[string]string{

-			"test_file": "test1",

-		})

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

-

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

-	}

+RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`),

+		withFile("test_file", "test1")))

 }

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

@@ -712,8 +554,8 @@ func (s *DockerSuite) TestBuildCopyAddMultipleFiles(c *check.C) {

 	}

 	defer server.Close()

-	name := "testcopymultiplefilestofile"

-	ctx, err := fakeContext(fmt.Sprintf(`FROM busybox

+	buildImageSuccessfully(c, "testcopymultiplefilestofile", withBuildContext(c,

+		withFile("Dockerfile", fmt.Sprintf(`FROM busybox

 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

 RUN echo 'dockerio:x:1001:' >> /etc/group

 RUN mkdir /exists

@@ -724,141 +566,75 @@ ADD test_file3 test_file4 %s/robots.txt /exists/

 RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]

 RUN [ $(ls -l /exists/test_file1 | awk '{print $3":"$4}') = 'root:root' ]

 RUN [ $(ls -l /exists/test_file2 | awk '{print $3":"$4}') = 'root:root' ]

-

 RUN [ $(ls -l /exists/test_file3 | awk '{print $3":"$4}') = 'root:root' ]

 RUN [ $(ls -l /exists/test_file4 | awk '{print $3":"$4}') = 'root:root' ]

 RUN [ $(ls -l /exists/robots.txt | awk '{print $3":"$4}') = 'root:root' ]

-

 RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]

-`, server.URL()),

-		map[string]string{

-			"test_file1": "test1",

-			"test_file2": "test2",

-			"test_file3": "test3",

-			"test_file4": "test4",

-		})

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

-

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

-	}

-}

-

-// This test is mainly for user namespaces to verify that new directories

-// are created as the remapped root uid/gid pair

-func (s *DockerSuite) TestBuildAddToNewDestination(c *check.C) {

-	testRequires(c, DaemonIsLinux) // Linux specific test

-	name := "testaddtonewdest"

-	ctx, err := fakeContext(`FROM busybox

-ADD . /new_dir

-RUN ls -l /

-RUN [ $(ls -l / | grep new_dir | awk '{print $3":"$4}') = 'root:root' ]`,

-		map[string]string{

-			"test_dir/test_file": "test file",

-		})

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

-

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

-	}

+`, server.URL())),

+		withFile("test_file1", "test1"),

+		withFile("test_file2", "test2"),

+		withFile("test_file3", "test3"),

+		withFile("test_file3", "test3"),

+		withFile("test_file4", "test4")))

 }

-// This test is mainly for user namespaces to verify that new directories

+// These tests are mainly for user namespaces to verify that new directories

 // are created as the remapped root uid/gid pair

-func (s *DockerSuite) TestBuildCopyToNewParentDirectory(c *check.C) {

-	testRequires(c, DaemonIsLinux) // Linux specific test

-	name := "testcopytonewdir"

-	ctx, err := fakeContext(`FROM busybox

-COPY test_dir /new_dir

-RUN ls -l /new_dir

-RUN [ $(ls -l / | grep new_dir | awk '{print $3":"$4}') = 'root:root' ]`,

-		map[string]string{

-			"test_dir/test_file": "test file",

-		})

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

-

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

+func (s *DockerSuite) TestBuildUsernamespaceValidateRemappedRoot(c *check.C) {

+	testRequires(c, DaemonIsLinux)

+	testCases := []string{

+		"ADD . /new_dir",

+		"COPY test_dir /new_dir",

+		"WORKDIR /new_dir",

 	}

-}

+	name := "testbuildusernamespacevalidateremappedroot"

+	for _, tc := range testCases {

+		buildImageSuccessfully(c, name, withBuildContext(c,

+			withFile("Dockerfile", fmt.Sprintf(`FROM busybox

+%s

+RUN [ $(ls -l / | grep new_dir | awk '{print $3":"$4}') = 'root:root' ]`, tc)),

+			withFile("test_dir/test_file", "test file")))

-// This test is mainly for user namespaces to verify that new directories

-// are created as the remapped root uid/gid pair

-func (s *DockerSuite) TestBuildWorkdirIsContainerRoot(c *check.C) {

-	testRequires(c, DaemonIsLinux) // Linux specific test

-	name := "testworkdirownership"

-	if _, err := buildImage(name, `FROM busybox

-WORKDIR /new_dir

-RUN ls -l /

-RUN [ $(ls -l / | grep new_dir | awk '{print $3":"$4}') = 'root:root' ]`, true); err != nil {

-		c.Fatal(err)

+		dockerCmd(c, "rmi", name)

 	}

 }

-func (s *DockerSuite) TestBuildAddFileWithWhitespace(c *check.C) {

+func (s *DockerSuite) TestBuildAddAndCopyFileWithWhitespace(c *check.C) {

 	testRequires(c, DaemonIsLinux) // Not currently passing on Windows

 	name := "testaddfilewithwhitespace"

-	ctx, err := fakeContext(`FROM busybox

+

+	for _, command := range []string{"ADD", "COPY"} {

+		buildImageSuccessfully(c, name, withBuildContext(c,

+			withFile("Dockerfile", fmt.Sprintf(`FROM busybox

 RUN mkdir "/test dir"

 RUN mkdir "/test_dir"

-ADD [ "test file1", "/test_file1" ]

-ADD [ "test_file2", "/test file2" ]

-ADD [ "test file3", "/test file3" ]

-ADD [ "test dir/test_file4", "/test_dir/test_file4" ]

-ADD [ "test_dir/test_file5", "/test dir/test_file5" ]

-ADD [ "test dir/test_file6", "/test dir/test_file6" ]

+%s [ "test file1", "/test_file1" ]

+%s [ "test_file2", "/test file2" ]

+%s [ "test file3", "/test file3" ]

+%s [ "test dir/test_file4", "/test_dir/test_file4" ]

+%s [ "test_dir/test_file5", "/test dir/test_file5" ]

+%s [ "test dir/test_file6", "/test dir/test_file6" ]

 RUN [ $(cat "/test_file1") = 'test1' ]

 RUN [ $(cat "/test file2") = 'test2' ]

 RUN [ $(cat "/test file3") = 'test3' ]

 RUN [ $(cat "/test_dir/test_file4") = 'test4' ]

 RUN [ $(cat "/test dir/test_file5") = 'test5' ]

-RUN [ $(cat "/test dir/test_file6") = 'test6' ]`,

-		map[string]string{

-			"test file1":          "test1",

-			"test_file2":          "test2",

-			"test file3":          "test3",

-			"test dir/test_file4": "test4",

-			"test_dir/test_file5": "test5",

-			"test dir/test_file6": "test6",

-		})

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

+RUN [ $(cat "/test dir/test_file6") = 'test6' ]`, command, command, command, command, command, command)),

+			withFile("test file1", "test1"),

+			withFile("test_file2", "test2"),

+			withFile("test file3", "test3"),

+			withFile("test dir/test_file4", "test4"),

+			withFile("test_dir/test_file5", "test5"),

+			withFile("test dir/test_file6", "test6"),

+		))

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

+		dockerCmd(c, "rmi", name)

 	}

 }

-func (s *DockerSuite) TestBuildCopyFileWithWhitespace(c *check.C) {

-	dockerfile := `FROM busybox

-RUN mkdir "/test dir"

-RUN mkdir "/test_dir"

-COPY [ "test file1", "/test_file1" ]

-COPY [ "test_file2", "/test file2" ]

-COPY [ "test file3", "/test file3" ]

-COPY [ "test dir/test_file4", "/test_dir/test_file4" ]

-COPY [ "test_dir/test_file5", "/test dir/test_file5" ]

-COPY [ "test dir/test_file6", "/test dir/test_file6" ]

-RUN [ $(cat "/test_file1") = 'test1' ]

-RUN [ $(cat "/test file2") = 'test2' ]

-RUN [ $(cat "/test file3") = 'test3' ]

-RUN [ $(cat "/test_dir/test_file4") = 'test4' ]

-RUN [ $(cat "/test dir/test_file5") = 'test5' ]

-RUN [ $(cat "/test dir/test_file6") = 'test6' ]`

-

-	if daemonPlatform == "windows" {

-		dockerfile = `FROM ` + WindowsBaseImage + `

+func (s *DockerSuite) TestBuildCopyFileWithWhitespaceOnWindows(c *check.C) {

+	testRequires(c, DaemonIsWindows)

+	dockerfile := `FROM ` + WindowsBaseImage + `

 RUN mkdir "C:/test dir"

 RUN mkdir "C:/test_dir"

 COPY [ "test file1", "/test_file1" ]

@@ -873,26 +649,17 @@ RUN find "test3" "C:/test file3"

 RUN find "test4" "C:/test_dir/test_file4"

 RUN find "test5" "C:/test dir/test_file5"

 RUN find "test6" "C:/test dir/test_file6"`

-	}

 	name := "testcopyfilewithwhitespace"

-	ctx, err := fakeContext(dockerfile,

-		map[string]string{

-			"test file1":          "test1",

-			"test_file2":          "test2",

-			"test file3":          "test3",

-			"test dir/test_file4": "test4",

-			"test_dir/test_file5": "test5",

-			"test dir/test_file6": "test6",

-		})

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

-

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name, withBuildContext(c,

+		withFile("Dockerfile", dockerfile),

+		withFile("test file1", "test1"),

+		withFile("test_file2", "test2"),

+		withFile("test file3", "test3"),

+		withFile("test dir/test_file4", "test4"),

+		withFile("test_dir/test_file5", "test5"),

+		withFile("test dir/test_file6", "test6"),

+	))

 }

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

@@ -946,27 +713,23 @@ func (s *DockerSuite) TestBuildCopyWildcard(c *check.C) {

 }

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

-	name := "testcopywildcardinname"

-	ctx, err := fakeContext(`FROM busybox

+	// Run this only on Linux

+	// Below is the original comment (that I don't agree with — vdemeester)

+	// Normally we would do c.Fatal(err) here but given that

+	// the odds of this failing are so rare, it must be because

+	// the OS we're running the client on doesn't support * in

+	// filenames (like windows).  So, instead of failing the test

+	// just let it pass. Then we don't need to explicitly

+	// say which OSs this works on or not.

+	testRequires(c, DaemonIsLinux)

+

+	buildImageSuccessfully(c, "testcopywildcardinname", withBuildContext(c,

+		withFile("Dockerfile", `FROM busybox

 	COPY *.txt /tmp/

 	RUN [ "$(cat /tmp/\*.txt)" = 'hi there' ]

-	`, map[string]string{"*.txt": "hi there"})

-

-	if err != nil {

-		// Normally we would do c.Fatal(err) here but given that

-		// the odds of this failing are so rare, it must be because

-		// the OS we're running the client on doesn't support * in

-		// filenames (like windows).  So, instead of failing the test

-		// just let it pass. Then we don't need to explicitly

-		// say which OSs this works on or not.

-		return

-	}

-	defer ctx.Close()

-

-	_, err = buildImageFromContext(name, ctx, true)

-	if err != nil {

-		c.Fatalf("should have built: %q", err)

-	}

+	`),

+		withFile("*.txt", "hi there"),

+	))

 }

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

@@ -1004,8 +767,8 @@ func (s *DockerSuite) TestBuildCopyWildcardCache(c *check.C) {

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

 	testRequires(c, DaemonIsLinux) // Linux specific test

-	name := "testaddsinglefiletononexistingdir"

-	ctx, err := fakeContext(`FROM busybox

+	buildImageSuccessfully(c, "testaddsinglefiletononexistingdir", withBuildContext(c,

+		withFile("Dockerfile", `FROM busybox

 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

 RUN echo 'dockerio:x:1001:' >> /etc/group

 RUN touch /exists

@@ -1013,49 +776,28 @@ RUN chown dockerio.dockerio /exists

 ADD test_file /test_dir/

 RUN [ $(ls -l / | grep test_dir | awk '{print $3":"$4}') = 'root:root' ]

 RUN [ $(ls -l /test_dir/test_file | awk '{print $3":"$4}') = 'root:root' ]

-RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,

-		map[string]string{

-			"test_file": "test1",

-		})

-	if err != nil {

-		c.Fatal(err)

-	}

-	defer ctx.Close()

-

-	if _, err := buildImageFromContext(name, ctx, true); err != nil {

-		c.Fatal(err)

-	}

-

+RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`),

+		withFile("test_file", "test1")))

 }

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

 	testRequires(c, DaemonIsLinux) // Linux specific test

-	name := "testadddircontenttoroot"

-	ctx, err := fakeContext(`FROM busybox

+	buildImageSuccessfully(c, "testadddircontenttoroot", withBuildContext(c,

+		withFile("Dockerfile", `FROM busybox

 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

 RUN echo 'dockerio:x:1001:' >> /etc/group

 RUN touch /exists

 RUN chown dockerio.dockerio exists

 ADD test_dir /

 RUN [ $(ls -l /test_file | awk '{print $3":"$4}') = 'root:root' ]

-RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,