package main
 
 import (

 	"archive/tar"

 	"bufio"

 	"bytes"

 	"encoding/json"

 	"fmt"

 	"io/ioutil"

 	"os"

 	"os/exec"
 	"path/filepath"

 	"reflect"

 	"regexp"

 	"runtime"

 	"strconv"

 	"strings"

 	"text/template"

 	"time"

 	"github.com/docker/docker/builder/command"

 	"github.com/docker/docker/pkg/archive"

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

 	"github.com/go-check/check"

 )
 

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

 	name := "testbuildjsonemptyrun"
 
 	_, err := buildImage(
 		name,
 		`
     FROM busybox
     RUN []
     `,
 		true)
 
 	if err != nil {

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

 	}
 
 }
 

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

 	name := "testbuildemptywhitespace"
 
 	_, err := buildImage(
 		name,
 		`
     FROM busybox

     COPY

       quux \
       bar
     `,
 		true)
 
 	if err == nil {

 		c.Fatal("no error when dealing with a COPY statement with no content on the same line")

 	}
 
 }
 

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

 	name := "testbuildshcmdjsonentrypoint"
 
 	_, err := buildImage(
 		name,
 		`
     FROM busybox
     ENTRYPOINT ["/bin/echo"]
     CMD echo test
     `,
 		true)
 
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	out, _, err := runCommandWithOutput(
 		exec.Command(
 			dockerBinary,
 			"run",

 			"--rm",

 			name))
 
 	if err != nil {

 		c.Fatal(err)

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

 		c.Fatal("CMD did not contain /bin/sh -c")

 	}
 
 }
 

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

 	name := "testbuildenvironmentreplacement"
 
 	_, err := buildImage(name, `
   FROM scratch
   ENV user foo
   USER ${user}
   `, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	res, err := inspectFieldJSON(name, "Config.User")
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	if res != `"foo"` {

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

 	}
 
 }
 

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

 	name := "testbuildenvironmentreplacement"
 
 	_, err := buildImage(name, `
   FROM scratch
   ENV volume /quux
   VOLUME ${volume}
   `, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	res, err := inspectFieldJSON(name, "Config.Volumes")
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	var volumes map[string]interface{}
 
 	if err := json.Unmarshal([]byte(res), &volumes); err != nil {

 		c.Fatal(err)

 	}
 
 	if _, ok := volumes["/quux"]; !ok {

 		c.Fatal("Volume /quux from environment not in Config.Volumes on image")

 	}
 
 }
 

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

 	name := "testbuildenvironmentreplacement"
 
 	_, err := buildImage(name, `
   FROM scratch
   ENV port 80
   EXPOSE ${port}
   `, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	res, err := inspectFieldJSON(name, "Config.ExposedPorts")
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	var exposedPorts map[string]interface{}
 
 	if err := json.Unmarshal([]byte(res), &exposedPorts); err != nil {

 		c.Fatal(err)

 	}
 
 	if _, ok := exposedPorts["80/tcp"]; !ok {

 		c.Fatal("Exposed port 80 from environment not in Config.ExposedPorts on image")

 	}
 
 }
 

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

 	name := "testbuildenvironmentreplacement"
 
 	_, err := buildImage(name, `
   FROM busybox
   ENV MYWORKDIR /work
   RUN mkdir ${MYWORKDIR}
   WORKDIR ${MYWORKDIR}
   `, true)
 
 	if err != nil {

 		c.Fatal(err)

 	}
 
 }
 

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

 	name := "testbuildenvironmentreplacement"
 
 	ctx, err := fakeContext(`
   FROM scratch
   ENV baz foo
   ENV quux bar
   ENV dot .

   ENV fee fff
   ENV gee ggg

 
   ADD ${baz} ${dot}
   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)

 	}
 
 }
 

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

 	name := "testbuildenvironmentreplacement"
 
 	_, err := buildImage(name,
 		`

   FROM busybox
   ENV foo zzz

   ENV bar ${foo}

   ENV abc1='$foo'
   ENV env1=$foo env2=${foo} env3="$foo" env4="${foo}"
   RUN [ "$abc1" = '$foo' ] && (echo "$abc1" | grep -q foo)
   ENV abc2="\$foo"
   RUN [ "$abc2" = '$foo' ] && (echo "$abc2" | grep -q foo)
   ENV abc3 '$foo'
   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, err := inspectFieldJSON(name, "Config.Env")
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	envResult := []string{}
 
 	if err = unmarshalJSON([]byte(res), &envResult); err != nil {

 		c.Fatal(err)

 	}
 
 	found := false

 	envCount := 0

 
 	for _, env := range envResult {
 		parts := strings.SplitN(env, "=", 2)
 		if parts[0] == "bar" {
 			found = true

 			if parts[1] != "zzz" {

 				c.Fatalf("Could not find replaced var for env `bar`: got %q instead of `zzz`", parts[1])

 			}
 		} else if strings.HasPrefix(parts[0], "env") {
 			envCount++
 			if parts[1] != "zzz" {

 				c.Fatalf("%s should be 'foo' but instead its %q", parts[0], parts[1])

 			}

 		} else if strings.HasPrefix(parts[0], "env") {
 			envCount++
 			if parts[1] != "foo" {

 				c.Fatalf("%s should be 'foo' but instead its %q", parts[0], parts[1])

 			}

 		}
 	}
 
 	if !found {

 		c.Fatal("Never found the `bar` env variable")

 	}
 

 	if envCount != 4 {

 		c.Fatalf("Didn't find all env vars - only saw %d\n%s", envCount, envResult)

 	}
 

 }
 

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

 	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, err := inspectFieldJSON(name, "Config.Volumes")
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	if err = unmarshalJSON([]byte(res), &result); err != nil {

 		c.Fatal(err)

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

 		c.Fatal("Could not find volume bar set from env foo in volumes table")

 	}
 

 	deleteImages(name)
 

 	_, err = buildImage(name,
 		`
   FROM scratch
   ENV FOO bar
   VOLUME \${FOO}
   `, true)
 
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	res, err = inspectFieldJSON(name, "Config.Volumes")
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	if err = unmarshalJSON([]byte(res), &result); err != nil {

 		c.Fatal(err)

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

 		c.Fatal("Could not find volume ${FOO} set from env foo in volumes table")

 	}
 

 	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,
 		`
   FROM scratch
   ENV FOO bar
   VOLUME \\\\\\\${FOO}
   `, true)
 
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	res, err = inspectFieldJSON(name, "Config.Volumes")
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	if err = unmarshalJSON([]byte(res), &result); err != nil {

 		c.Fatal(err)

 	}
 

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

 		c.Fatal(`Could not find volume \\\${FOO} set from env foo in volumes table`, result)

 	}
 
 }
 

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

 	name := "testbuildonbuildlowercase"
 	name2 := "testbuildonbuildlowercase2"
 
 	_, err := buildImage(name,
 		`
   FROM busybox
   onbuild run echo quux
   `, true)
 
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	_, out, err := buildImageWithOut(name2, fmt.Sprintf(`
   FROM %s
   `, name), true)
 
 	if err != nil {

 		c.Fatal(err)

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

 	}
 
 }
 

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

 	name := "testbuildenvescapes"
 	_, err := buildImage(name,
 		`
     FROM busybox
     ENV TEST foo
     CMD echo \$
     `,
 		true)
 
 	out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-t", name))
 
 	if err != nil {

 		c.Fatal(err)

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

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

 	}
 
 }
 

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

 	name := "testbuildenvoverwrite"
 
 	_, err := buildImage(name,
 		`
     FROM busybox
     ENV TEST foo

     CMD echo ${TEST}

     `,
 		true)
 
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-e", "TEST=bar", "-t", name))
 
 	if err != nil {

 		c.Fatal(err)

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

 	}
 
 }
 

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

 	name := "testbuildonbuildforbiddenmaintainerinsourceimage"

 	createCmd := exec.Command(dockerBinary, "create", "busybox", "true")
 	out, _, _, err := runCommandWithStdoutStderr(createCmd)

 	if err != nil {

 		c.Fatal(out, err)

 	}

 	cleanedContainerID := strings.TrimSpace(out)

 
 	commitCmd := exec.Command(dockerBinary, "commit", "--run", "{\"OnBuild\":[\"MAINTAINER docker.io\"]}", cleanedContainerID, "onbuild")
 
 	if _, err := runCommand(commitCmd); err != nil {

 		c.Fatal(err)

 	}
 
 	_, err = buildImage(name,
 		`FROM onbuild`,
 		true)
 	if err != nil {
 		if !strings.Contains(err.Error(), "maintainer isn't allowed as an ONBUILD trigger") {

 			c.Fatalf("Wrong error %v, must be about MAINTAINER and ONBUILD in source image", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 
 }
 

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

 	name := "testbuildonbuildforbiddenfrominsourceimage"

 	createCmd := exec.Command(dockerBinary, "create", "busybox", "true")
 	out, _, _, err := runCommandWithStdoutStderr(createCmd)

 	if err != nil {

 		c.Fatal(out, err)

 	}

 	cleanedContainerID := strings.TrimSpace(out)

 
 	commitCmd := exec.Command(dockerBinary, "commit", "--run", "{\"OnBuild\":[\"FROM busybox\"]}", cleanedContainerID, "onbuild")
 
 	if _, err := runCommand(commitCmd); err != nil {

 		c.Fatal(err)

 	}
 
 	_, err = buildImage(name,
 		`FROM onbuild`,
 		true)
 	if err != nil {
 		if !strings.Contains(err.Error(), "from isn't allowed as an ONBUILD trigger") {

 			c.Fatalf("Wrong error %v, must be about FROM and ONBUILD in source image", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 
 }
 

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

 	name := "testbuildonbuildforbiddenchainedinsourceimage"

 	createCmd := exec.Command(dockerBinary, "create", "busybox", "true")
 	out, _, _, err := runCommandWithStdoutStderr(createCmd)

 	if err != nil {

 		c.Fatal(out, err)

 	}

 	cleanedContainerID := strings.TrimSpace(out)

 
 	commitCmd := exec.Command(dockerBinary, "commit", "--run", "{\"OnBuild\":[\"ONBUILD RUN ls\"]}", cleanedContainerID, "onbuild")
 
 	if _, err := runCommand(commitCmd); err != nil {

 		c.Fatal(err)

 	}
 
 	_, err = buildImage(name,
 		`FROM onbuild`,
 		true)
 	if err != nil {
 		if !strings.Contains(err.Error(), "Chaining ONBUILD via `ONBUILD ONBUILD` isn't allowed") {

 			c.Fatalf("Wrong error %v, must be about chaining ONBUILD in source image", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 
 }
 

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

 	name1 := "onbuildcmd"
 	name2 := "onbuildgenerated"
 
 	_, err := buildImage(name1, `
 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)
 
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-t", name2))
 	if err != nil {

 		c.Fatal(err)

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

 		c.Fatal("did not get echo output from onbuild", out)

 	}
 
 }
 

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

 	name1 := "onbuildcmd"
 	name2 := "onbuildgenerated"
 
 	_, err := buildImage(name1, `
 FROM busybox
 ONBUILD ENTRYPOINT ["echo"]`,
 		false)
 
 	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)

 	}
 
 	out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-t", name2))
 	if err != nil {

 		c.Fatal(err)

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

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

 	}
 
 }
 

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

 	name := "testbuildtwoimageswithadd"
 	server, err := fakeStorage(map[string]string{
 		"robots.txt": "hello",
 		"index.html": "world",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer server.Close()

 	if _, err := buildImage(name,
 		fmt.Sprintf(`FROM scratch

 		ADD %s/robots.txt /`, server.URL()),

 		true); err != nil {

 		c.Fatal(err)

 	}

 	if err != nil {

 		c.Fatal(err)

 	}
 	deleteImages(name)

 	_, out, err := buildImageWithOut(name,

 		fmt.Sprintf(`FROM scratch

 		ADD %s/index.html /`, server.URL()),

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	if strings.Contains(out, "Using cache") {

 		c.Fatal("2nd build used cache on ADD, it shouldn't")

 	}
 
 }
 

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

 	name := "testbuildlastmodified"
 
 	server, err := fakeStorage(map[string]string{
 		"file": "hello",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()
 
 	var out, out2 string
 
 	dFmt := `FROM busybox
 ADD %s/file /
 RUN ls -le /file`
 

 	dockerfile := fmt.Sprintf(dFmt, server.URL())

 
 	if _, out, err = buildImageWithOut(name, dockerfile, false); err != nil {

 		c.Fatal(err)

 	}
 
 	originMTime := regexp.MustCompile(`root.*/file.*\n`).FindString(out)
 	// Make sure our regexp is correct
 	if strings.Index(originMTime, "/file") < 0 {

 		c.Fatalf("Missing ls info on 'file':\n%s", out)

 	}
 
 	// Build it again and make sure the mtime of the file didn't change.
 	// Wait a few seconds to make sure the time changed enough to notice
 	time.Sleep(2 * time.Second)
 
 	if _, out2, err = buildImageWithOut(name, dockerfile, false); err != nil {

 		c.Fatal(err)

 	}
 
 	newMTime := regexp.MustCompile(`root.*/file.*\n`).FindString(out2)
 	if newMTime != originMTime {

 		c.Fatalf("MTime changed:\nOrigin:%s\nNew:%s", originMTime, newMTime)

 	}
 
 	// Now 'touch' the file and make sure the timestamp DID change this time
 	// Create a new fakeStorage instead of just using Add() to help windows
 	server, err = fakeStorage(map[string]string{
 		"file": "hello",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()
 

 	dockerfile = fmt.Sprintf(dFmt, server.URL())

 
 	if _, out2, err = buildImageWithOut(name, dockerfile, false); err != nil {

 		c.Fatal(err)

 	}
 
 	newMTime = regexp.MustCompile(`root.*/file.*\n`).FindString(out2)
 	if newMTime == originMTime {

 		c.Fatalf("MTime didn't change:\nOrigin:%s\nNew:%s", originMTime, newMTime)

 	}
 
 }
 

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

 	name := "foobuildsixtysteps"
 	ctx, err := fakeContext("FROM scratch\n"+strings.Repeat("ADD foo /\n", 60),
 		map[string]string{
 			"foo": "test1",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testaddimg"

 	ctx, err := fakeContext(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
 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)

 	}
 }
 

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

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

 	name := "testaddsinglefiletoworkdir"
 	ctx, err := fakeContext(`FROM busybox
 ADD test_file .`,
 		map[string]string{
 			"test_file": "test1",
 		})

 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

 	errChan := make(chan error)

 	go func() {

 		_, err := buildImageFromContext(name, ctx, true)
 		errChan <- err
 		close(errChan)

 	}()
 	select {
 	case <-time.After(5 * time.Second):

 		c.Fatal("Build with adding to workdir timed out")

 	case err := <-errChan:
 		c.Assert(err, check.IsNil)

 	}
 }
 

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

 	name := "testaddsinglefiletoexistdir"
 	ctx, err := fakeContext(`FROM busybox
 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
 RUN echo 'dockerio:x:1001:' >> /etc/group
 RUN mkdir /exists
 RUN touch /exists/exists_file
 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)

 	}
 }
 

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

 	server, err := fakeStorage(map[string]string{
 		"robots.txt": "hello",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()
 

 	name := "testcopymultiplefilestofile"

 	ctx, err := fakeContext(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
 RUN touch /exists/exists_file
 RUN chown -R dockerio.dockerio /exists
 COPY test_file1 test_file2 /exists/

 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",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

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

 		c.Fatal(err)

 	}

 }
 

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

 	name := "testaddmultiplefilestofile"
 	ctx, err := fakeContext(`FROM scratch
 	ADD file1.txt file2.txt test

 	`,

 		map[string]string{
 			"file1.txt": "test1",
 			"file2.txt": "test1",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	expected := "When using ADD with more than one source file, the destination must be a directory and end with a /"
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain %q) got:\n%v", expected, err)

 	}
 
 }
 

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

 	name := "testjsonaddmultiplefilestofile"
 	ctx, err := fakeContext(`FROM scratch
 	ADD ["file1.txt", "file2.txt", "test"]
 	`,
 		map[string]string{
 			"file1.txt": "test1",
 			"file2.txt": "test1",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	expected := "When using ADD with more than one source file, the destination must be a directory and end with a /"
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain %q) got:\n%v", expected, err)

 	}
 
 }
 

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

 	name := "testaddmultiplefilestofilewild"
 	ctx, err := fakeContext(`FROM scratch
 	ADD file*.txt test

 	`,

 		map[string]string{
 			"file1.txt": "test1",
 			"file2.txt": "test1",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	expected := "When using ADD with more than one source file, the destination must be a directory and end with a /"
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain %q) got:\n%v", expected, err)

 	}
 
 }
 

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

 	name := "testjsonaddmultiplefilestofilewild"
 	ctx, err := fakeContext(`FROM scratch
 	ADD ["file*.txt", "test"]
 	`,
 		map[string]string{
 			"file1.txt": "test1",
 			"file2.txt": "test1",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	expected := "When using ADD with more than one source file, the destination must be a directory and end with a /"
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain %q) got:\n%v", expected, err)

 	}
 
 }
 

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

 	name := "testcopymultiplefilestofile"
 	ctx, err := fakeContext(`FROM scratch
 	COPY file1.txt file2.txt test

 	`,

 		map[string]string{
 			"file1.txt": "test1",
 			"file2.txt": "test1",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	expected := "When using COPY with more than one source file, the destination must be a directory and end with a /"
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain %q) got:\n%v", expected, err)

 	}
 
 }
 

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

 	name := "testjsoncopymultiplefilestofile"
 	ctx, err := fakeContext(`FROM scratch
 	COPY ["file1.txt", "file2.txt", "test"]
 	`,
 		map[string]string{
 			"file1.txt": "test1",
 			"file2.txt": "test1",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	expected := "When using COPY with more than one source file, the destination must be a directory and end with a /"
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain %q) got:\n%v", expected, err)

 	}
 
 }
 

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

 	name := "testaddfilewithwhitespace"
 	ctx, err := fakeContext(`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" ]
 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",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testcopyfilewithwhitespace"
 	ctx, err := fakeContext(`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' ]`,
 		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",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testaddmultiplefilestofilewithwhitespace"
 	ctx, err := fakeContext(`FROM busybox
 	ADD [ "test file1", "test file2", "test" ]

     `,

 		map[string]string{
 			"test file1": "test1",
 			"test file2": "test2",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	expected := "When using ADD with more than one source file, the destination must be a directory and end with a /"
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain %q) got:\n%v", expected, err)

 	}
 
 }
 

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

 	name := "testcopymultiplefilestofilewithwhitespace"
 	ctx, err := fakeContext(`FROM busybox
 	COPY [ "test file1", "test file2", "test" ]
         `,
 		map[string]string{
 			"test file1": "test1",
 			"test file2": "test2",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	expected := "When using COPY with more than one source file, the destination must be a directory and end with a /"
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain %q) got:\n%v", expected, err)

 	}
 
 }
 

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

 	name := "testcopywildcard"
 	server, err := fakeStorage(map[string]string{
 		"robots.txt": "hello",
 		"index.html": "world",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()

 	ctx, err := fakeContext(fmt.Sprintf(`FROM busybox
 	COPY file*.txt /tmp/
 	RUN ls /tmp/file1.txt /tmp/file2.txt
 	RUN mkdir /tmp1
 	COPY dir* /tmp1/
 	RUN ls /tmp1/dirt /tmp1/nested_file /tmp1/nested_dir/nest_nest_file
 	RUN mkdir /tmp2
         ADD dir/*dir %s/robots.txt /tmp2/
 	RUN ls /tmp2/nest_nest_file /tmp2/robots.txt

 	`, server.URL()),

 		map[string]string{
 			"file1.txt":                     "test1",
 			"file2.txt":                     "test2",
 			"dir/nested_file":               "nested file",
 			"dir/nested_dir/nest_nest_file": "2 times nested",
 			"dirt": "dirty",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()

 
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	// Now make sure we use a cache the 2nd time
 	id2, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	if id1 != id2 {

 		c.Fatal("didn't use the cache")

 	}
 
 }
 

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

 	name := "testcopywildcardnofind"
 	ctx, err := fakeContext(`FROM busybox
 	COPY file*.txt /tmp/
 	`, nil)
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	_, err = buildImageFromContext(name, ctx, true)
 	if err == nil {

 		c.Fatal("should have failed to find a file")

 	}
 	if !strings.Contains(err.Error(), "No source files were specified") {

 		c.Fatalf("Wrong error %v, must be about no source files", err)

 	}
 
 }
 

 func (s *DockerSuite) TestBuildCopyWildcardInName(c *check.C) {
 	name := "testcopywildcardinname"
 	defer deleteImages(name)
 	ctx, err := fakeContext(`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)
 	}
 }
 

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

 	name := "testcopywildcardcache"
 	ctx, err := fakeContext(`FROM busybox

 	COPY file1.txt /tmp/`,

 		map[string]string{
 			"file1.txt": "test1",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 

 	// Now make sure we use a cache the 2nd time even with wild cards.
 	// Use the same context so the file is the same and the checksum will match
 	ctx.Add("Dockerfile", `FROM busybox
 	COPY file*.txt /tmp/`)

 	id2, err := buildImageFromContext(name, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 
 	if id1 != id2 {

 		c.Fatal("didn't use the cache")

 	}
 
 }
 

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

 	name := "testaddsinglefiletononexistingdir"

 	ctx, err := fakeContext(`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_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)

 	}

 }
 

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

 	name := "testadddircontenttoroot"
 	ctx, err := fakeContext(`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' ]`,
 		map[string]string{
 			"test_dir/test_file": "test1",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testadddircontenttoexistingdir"

 	ctx, err := fakeContext(`FROM busybox
 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
 RUN echo 'dockerio:x:1001:' >> /etc/group
 RUN mkdir /exists
 RUN touch /exists/exists_file
 RUN chown -R dockerio.dockerio /exists
 ADD test_dir/ /exists/
 RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
 RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
 RUN [ $(ls -l /exists/test_file | awk '{print $3":"$4}') = 'root:root' ]`,
 		map[string]string{
 			"test_dir/test_file": "test1",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testaddwholedirtoroot"

 	ctx, err := fakeContext(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
 RUN chown dockerio.dockerio exists
 ADD test_dir /test_dir
 RUN [ $(ls -l / | grep test_dir | awk '{print $3":"$4}') = 'root:root' ]
 RUN [ $(ls -l / | grep test_dir | awk '{print $1}') = 'drwxr-xr-x' ]
 RUN [ $(ls -l /test_dir/test_file | awk '{print $3":"$4}') = 'root:root' ]

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

 		map[string]string{
 			"test_dir/test_file": "test1",
 		})

 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}

 }
 

 // Testing #5941

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

 	name := "testaddetctoroot"
 	ctx, err := fakeContext(`FROM scratch
 ADD . /`,
 		map[string]string{
 			"etc/test_file": "test1",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}
 }
 

 // Testing #9401

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

 	name := "testaddpreservesfilesspecialbits"
 	ctx, err := fakeContext(`FROM busybox
 ADD suidbin /usr/bin/suidbin
 RUN chmod 4755 /usr/bin/suidbin
 RUN [ $(ls -l /usr/bin/suidbin | awk '{print $1}') = '-rwsr-xr-x' ]
 ADD ./data/ /
 RUN [ $(ls -l /usr/bin/suidbin | awk '{print $1}') = '-rwsr-xr-x' ]`,
 		map[string]string{
 			"suidbin":             "suidbin",
 			"/data/usr/test_file": "test1",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()
 
 	if _, err := buildImageFromContext(name, ctx, true); err != nil {

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testcopysinglefiletoroot"

 	ctx, err := fakeContext(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
 RUN chown dockerio.dockerio /exists
 COPY 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)

 	}
 }
 
 // Issue #3960: "ADD src ." hangs - adapted for COPY

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

 	name := "testcopysinglefiletoworkdir"
 	ctx, err := fakeContext(`FROM busybox
 COPY test_file .`,
 		map[string]string{
 			"test_file": "test1",
 		})

 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

 	errChan := make(chan error)

 	go func() {

 		_, err := buildImageFromContext(name, ctx, true)
 		errChan <- err
 		close(errChan)

 	}()
 	select {
 	case <-time.After(5 * time.Second):

 		c.Fatal("Build with adding to workdir timed out")

 	case err := <-errChan:
 		c.Assert(err, check.IsNil)

 	}
 }
 

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

 	name := "testcopysinglefiletoexistdir"
 	ctx, err := fakeContext(`FROM busybox
 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
 RUN echo 'dockerio:x:1001:' >> /etc/group
 RUN mkdir /exists
 RUN touch /exists/exists_file
 RUN chown -R dockerio.dockerio /exists
 COPY 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)

 	}
 }
 

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

 	name := "testcopysinglefiletononexistdir"
 	ctx, err := fakeContext(`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
 COPY 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)

 	}
 }
 

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

 	name := "testcopydircontenttoroot"
 	ctx, err := fakeContext(`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
 COPY test_dir /
 RUN [ $(ls -l /test_file | awk '{print $3":"$4}') = 'root:root' ]
 RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
 		map[string]string{
 			"test_dir/test_file": "test1",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testcopydircontenttoexistdir"
 	ctx, err := fakeContext(`FROM busybox
 RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
 RUN echo 'dockerio:x:1001:' >> /etc/group
 RUN mkdir /exists
 RUN touch /exists/exists_file
 RUN chown -R dockerio.dockerio /exists
 COPY test_dir/ /exists/
 RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
 RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
 RUN [ $(ls -l /exists/test_file | awk '{print $3":"$4}') = 'root:root' ]`,
 		map[string]string{
 			"test_dir/test_file": "test1",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testcopywholedirtoroot"

 	ctx, err := fakeContext(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
 RUN chown dockerio.dockerio exists
 COPY test_dir /test_dir
 RUN [ $(ls -l / | grep test_dir | awk '{print $3":"$4}') = 'root:root' ]
 RUN [ $(ls -l / | grep test_dir | awk '{print $1}') = 'drwxr-xr-x' ]
 RUN [ $(ls -l /test_dir/test_file | awk '{print $3":"$4}') = 'root:root' ]

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

 		map[string]string{
 			"test_dir/test_file": "test1",
 		})

 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testcopyetctoroot"
 	ctx, err := fakeContext(`FROM scratch
 COPY . /`,
 		map[string]string{
 			"etc/test_file": "test1",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}

 	defer ctx.Close()
 

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

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testcopydisallowremote"
 	_, out, err := buildImageWithOut(name, `FROM scratch
 COPY https://index.docker.io/robots.txt /`,
 		true)
 	if err == nil || !strings.Contains(out, "Source can't be a URL for COPY") {

 		c.Fatalf("Error should be about disallowed remote source, got err: %s, out: %q", err, out)

 	}
 }
 

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

 	const (
 		dockerfile = `
 			FROM scratch
 			ADD links.tar /
 			ADD foo.txt /symlink/
 			`
 		targetFile = "foo.txt"
 	)
 	var (
 		name = "test-link-absolute"
 	)
 	ctx, err := fakeContext(dockerfile, nil)
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()
 
 	tempDir, err := ioutil.TempDir("", "test-link-absolute-temp-")
 	if err != nil {

 		c.Fatalf("failed to create temporary directory: %s", tempDir)

 	}
 	defer os.RemoveAll(tempDir)
 

 	var symlinkTarget string
 	if runtime.GOOS == "windows" {
 		var driveLetter string
 		if abs, err := filepath.Abs(tempDir); err != nil {

 			c.Fatal(err)

 		} else {
 			driveLetter = abs[:1]
 		}
 		tempDirWithoutDrive := tempDir[2:]
 		symlinkTarget = fmt.Sprintf(`%s:\..\..\..\..\..\..\..\..\..\..\..\..%s`, driveLetter, tempDirWithoutDrive)
 	} else {
 		symlinkTarget = fmt.Sprintf("/../../../../../../../../../../../..%s", tempDir)
 	}
 

 	tarPath := filepath.Join(ctx.Dir, "links.tar")
 	nonExistingFile := filepath.Join(tempDir, targetFile)
 	fooPath := filepath.Join(ctx.Dir, targetFile)
 
 	tarOut, err := os.Create(tarPath)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	tarWriter := tar.NewWriter(tarOut)
 
 	header := &tar.Header{
 		Name:     "symlink",
 		Typeflag: tar.TypeSymlink,
 		Linkname: symlinkTarget,
 		Mode:     0755,
 		Uid:      0,
 		Gid:      0,
 	}
 
 	err = tarWriter.WriteHeader(header)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	tarWriter.Close()
 	tarOut.Close()
 
 	foo, err := os.Create(fooPath)
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer foo.Close()
 
 	if _, err := foo.WriteString("test"); err != nil {

 		c.Fatal(err)

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

 		c.Fatal(err)

 	}
 
 	if _, err := os.Stat(nonExistingFile); err == nil || err != nil && !os.IsNotExist(err) {

 		c.Fatalf("%s shouldn't have been written and it shouldn't exist", nonExistingFile)

 	}
 
 }
 

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

 	const (
 		dockerfileTemplate = `
 		FROM busybox
 		RUN ln -s /../../../../../../../../%s /x
 		VOLUME /x
 		ADD foo.txt /x/`
 		targetFile = "foo.txt"
 	)
 	var (
 		name       = "test-link-absolute-volume"
 		dockerfile = ""
 	)
 
 	tempDir, err := ioutil.TempDir("", "test-link-absolute-volume-temp-")
 	if err != nil {

 		c.Fatalf("failed to create temporary directory: %s", tempDir)

 	}
 	defer os.RemoveAll(tempDir)
 
 	dockerfile = fmt.Sprintf(dockerfileTemplate, tempDir)
 	nonExistingFile := filepath.Join(tempDir, targetFile)
 
 	ctx, err := fakeContext(dockerfile, nil)
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()
 	fooPath := filepath.Join(ctx.Dir, targetFile)
 
 	foo, err := os.Create(fooPath)
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer foo.Close()
 
 	if _, err := foo.WriteString("test"); err != nil {

 		c.Fatal(err)

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

 		c.Fatal(err)

 	}
 
 	if _, err := os.Stat(nonExistingFile); err == nil || err != nil && !os.IsNotExist(err) {

 		c.Fatalf("%s shouldn't have been written and it shouldn't exist", nonExistingFile)

 	}
 
 }
 

 // Issue #5270 - ensure we throw a better error than "unexpected EOF"
 // when we can't access files in the context.

 func (s *DockerSuite) TestBuildWithInaccessibleFilesInContext(c *check.C) {
 	testRequires(c, UnixCli) // test uses chown/chmod: not available on windows

 	{

 		name := "testbuildinaccessiblefiles"
 		ctx, err := fakeContext("FROM scratch\nADD . /foo/", map[string]string{"fileWithoutReadAccess": "foo"})
 		if err != nil {

 			c.Fatal(err)

 		}
 		defer ctx.Close()

 		// This is used to ensure we detect inaccessible files early during build in the cli client

 		pathToFileWithoutReadAccess := filepath.Join(ctx.Dir, "fileWithoutReadAccess")

 		if err = os.Chown(pathToFileWithoutReadAccess, 0, 0); err != nil {

 			c.Fatalf("failed to chown file to root: %s", err)

 		}
 		if err = os.Chmod(pathToFileWithoutReadAccess, 0700); err != nil {

 			c.Fatalf("failed to chmod file to 700: %s", err)

 		}

 		buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))
 		buildCmd.Dir = ctx.Dir

 		out, _, err := runCommandWithOutput(buildCmd)
 		if err == nil {

 			c.Fatalf("build should have failed: %s %s", err, out)

 		}
 
 		// check if we've detected the failure before we started building
 		if !strings.Contains(out, "no permission to read from ") {

 			c.Fatalf("output should've contained the string: no permission to read from but contained: %s", out)

 		}
 
 		if !strings.Contains(out, "Error checking context is accessible") {

 			c.Fatalf("output should've contained the string: Error checking context is accessible")

 		}
 	}
 	{

 		name := "testbuildinaccessibledirectory"
 		ctx, err := fakeContext("FROM scratch\nADD . /foo/", map[string]string{"directoryWeCantStat/bar": "foo"})
 		if err != nil {

 			c.Fatal(err)

 		}
 		defer ctx.Close()

 		// This is used to ensure we detect inaccessible directories early during build in the cli client

 		pathToDirectoryWithoutReadAccess := filepath.Join(ctx.Dir, "directoryWeCantStat")

 		pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")
 

 		if err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {

 			c.Fatalf("failed to chown directory to root: %s", err)

 		}
 		if err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {

 			c.Fatalf("failed to chmod directory to 444: %s", err)

 		}
 		if err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {

 			c.Fatalf("failed to chmod file to 700: %s", err)

 		}

 		buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))
 		buildCmd.Dir = ctx.Dir

 		out, _, err := runCommandWithOutput(buildCmd)
 		if err == nil {

 			c.Fatalf("build should have failed: %s %s", err, out)

 		}
 
 		// check if we've detected the failure before we started building
 		if !strings.Contains(out, "can't stat") {

 			c.Fatalf("output should've contained the string: can't access %s", out)

 		}
 
 		if !strings.Contains(out, "Error checking context is accessible") {

 			c.Fatalf("output should've contained the string: Error checking context is accessible")

 		}
 
 	}
 	{

 		name := "testlinksok"
 		ctx, err := fakeContext("FROM scratch\nADD . /foo/", nil)
 		if err != nil {

 			c.Fatal(err)

 		}
 		defer ctx.Close()

 
 		target := "../../../../../../../../../../../../../../../../../../../azA"
 		if err := os.Symlink(filepath.Join(ctx.Dir, "g"), target); err != nil {

 			c.Fatal(err)

 		}

 		defer os.Remove(target)

 		// This is used to ensure we don't follow links when checking if everything in the context is accessible
 		// This test doesn't require that we run commands as an unprivileged user

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

 			c.Fatal(err)

 		}
 	}

 	{

 		name := "testbuildignoredinaccessible"
 		ctx, err := fakeContext("FROM scratch\nADD . /foo/",
 			map[string]string{
 				"directoryWeCantStat/bar": "foo",
 				".dockerignore":           "directoryWeCantStat",
 			})
 		if err != nil {

 			c.Fatal(err)

 		}
 		defer ctx.Close()

 		// This is used to ensure we don't try to add inaccessible files when they are ignored by a .dockerignore pattern

 		pathToDirectoryWithoutReadAccess := filepath.Join(ctx.Dir, "directoryWeCantStat")

 		pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")

 		if err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {

 			c.Fatalf("failed to chown directory to root: %s", err)

 		}
 		if err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {

 			c.Fatalf("failed to chmod directory to 755: %s", err)

 		}
 		if err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {

 			c.Fatalf("failed to chmod file to 444: %s", err)

 		}

 		buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))
 		buildCmd.Dir = ctx.Dir

 		if out, _, err := runCommandWithOutput(buildCmd); err != nil {

 			c.Fatalf("build should have worked: %s %s", err, out)

 		}
 
 	}

 }
 

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

 	containerCountBefore, err := getContainerCount()
 	if err != nil {

 		c.Fatalf("failed to get the container count: %s", err)

 	}

 	name := "testbuildforcerm"
 	ctx, err := fakeContext("FROM scratch\nRUN true\nRUN thiswillfail", nil)
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()

 	buildCmd := exec.Command(dockerBinary, "build", "-t", name, "--force-rm", ".")
 	buildCmd.Dir = ctx.Dir

 	if out, _, err := runCommandWithOutput(buildCmd); err == nil {

 		c.Fatalf("failed to build the image: %s, %v", out, err)

 	}
 
 	containerCountAfter, err := getContainerCount()
 	if err != nil {

 		c.Fatalf("failed to get the container count: %s", err)

 	}
 
 	if containerCountBefore != containerCountAfter {

 		c.Fatalf("--force-rm shouldn't have left containers behind")

 	}
 
 }
 

 // Test that an infinite sleep during a build is killed if the client disconnects.
 // This test is fairly hairy because there are lots of ways to race.
 // Strategy:
 // * Monitor the output of docker events starting from before
 // * Run a 1-year-long sleep from a docker build.
 // * When docker events sees container start, close the "docker build" command
 // * Wait for docker events to emit a dying event.

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

 	name := "testbuildcancelation"
 
 	// (Note: one year, will never finish)
 	ctx, err := fakeContext("FROM busybox\nRUN sleep 31536000", nil)
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()
 
 	finish := make(chan struct{})
 	defer close(finish)
 
 	eventStart := make(chan struct{})
 	eventDie := make(chan struct{})

 	containerID := make(chan string)

 	startEpoch := daemonTime(c).Unix()

 	// Watch for events since epoch.
 	eventsCmd := exec.Command(
 		dockerBinary, "events",
 		"--since", strconv.FormatInt(startEpoch, 10))
 	stdout, err := eventsCmd.StdoutPipe()
 	if err != nil {
 		c.Fatal(err)
 	}
 	if err := eventsCmd.Start(); err != nil {
 		c.Fatal(err)
 	}
 	defer eventsCmd.Process.Kill()

 	// Goroutine responsible for watching start/die events from `docker events`

 	go func() {

 		cid := <-containerID

 		matchStart := regexp.MustCompile(cid + `(.*) start$`)
 		matchDie := regexp.MustCompile(cid + `(.*) die$`)

 
 		//
 		// Read lines of `docker events` looking for container start and stop.
 		//
 		scanner := bufio.NewScanner(stdout)
 		for scanner.Scan() {

 			switch {
 			case matchStart.MatchString(scanner.Text()):

 				close(eventStart)

 			case matchDie.MatchString(scanner.Text()):

 				close(eventDie)
 			}
 		}
 	}()
 
 	buildCmd := exec.Command(dockerBinary, "build", "-t", name, ".")
 	buildCmd.Dir = ctx.Dir
 

 	stdoutBuild, err := buildCmd.StdoutPipe()

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

 		c.Fatalf("failed to run build: %s", err)

 	}
 

 	matchCID := regexp.MustCompile("Running in ")
 	scanner := bufio.NewScanner(stdoutBuild)
 	for scanner.Scan() {
 		line := scanner.Text()
 		if ok := matchCID.MatchString(line); ok {
 			containerID <- line[len(line)-12:]
 			break
 		}
 	}
 

 	select {

 	case <-time.After(5 * time.Second):

 		c.Fatal("failed to observe build container start in timely fashion")

 	case <-eventStart:
 		// Proceeds from here when we see the container fly past in the
 		// output of "docker events".
 		// Now we know the container is running.
 	}
 
 	// Send a kill to the `docker build` command.
 	// Causes the underlying build to be cancelled due to socket close.

 	if err := buildCmd.Process.Kill(); err != nil {

 		c.Fatalf("error killing build command: %s", err)

 	}
 
 	// Get the exit status of `docker build`, check it exited because killed.

 	if err := buildCmd.Wait(); err != nil && !IsKilled(err) {

 		c.Fatalf("wait failed during build run: %T %s", err, err)

 	}
 
 	select {

 	case <-time.After(5 * time.Second):

 		// If we don't get here in a timely fashion, it wasn't killed.

 		c.Fatal("container cancel did not succeed")

 	case <-eventDie:
 		// We saw the container shut down in the `docker events` stream,
 		// as expected.
 	}
 
 }
 

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

 	name := "testbuildrm"
 	ctx, err := fakeContext("FROM scratch\nADD foo /\nADD foo /", map[string]string{"foo": "bar"})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()

 	{
 		containerCountBefore, err := getContainerCount()
 		if err != nil {

 			c.Fatalf("failed to get the container count: %s", err)

 		}
 

 		out, _, err := dockerCmdInDir(c, ctx.Dir, "build", "--rm", "-t", name, ".")

 		if err != nil {

 			c.Fatal("failed to build the image", out)

 		}
 
 		containerCountAfter, err := getContainerCount()
 		if err != nil {

 			c.Fatalf("failed to get the container count: %s", err)

 		}
 
 		if containerCountBefore != containerCountAfter {

 			c.Fatalf("-rm shouldn't have left containers behind")

 		}

 		deleteImages(name)

 	}
 
 	{
 		containerCountBefore, err := getContainerCount()
 		if err != nil {

 			c.Fatalf("failed to get the container count: %s", err)

 		}
 

 		out, _, err := dockerCmdInDir(c, ctx.Dir, "build", "-t", name, ".")

 		if err != nil {

 			c.Fatal("failed to build the image", out)

 		}
 
 		containerCountAfter, err := getContainerCount()
 		if err != nil {

 			c.Fatalf("failed to get the container count: %s", err)

 		}
 
 		if containerCountBefore != containerCountAfter {

 			c.Fatalf("--rm shouldn't have left containers behind")

 		}

 		deleteImages(name)

 	}
 
 	{
 		containerCountBefore, err := getContainerCount()
 		if err != nil {

 			c.Fatalf("failed to get the container count: %s", err)

 		}
 

 		out, _, err := dockerCmdInDir(c, ctx.Dir, "build", "--rm=false", "-t", name, ".")

 		if err != nil {

 			c.Fatal("failed to build the image", out)

 		}
 
 		containerCountAfter, err := getContainerCount()
 		if err != nil {

 			c.Fatalf("failed to get the container count: %s", err)

 		}
 
 		if containerCountBefore == containerCountAfter {

 			c.Fatalf("--rm=false should have left containers behind")

 		}

 		deleteImages(name)

 
 	}
 
 }

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

 	var (
 		result   map[string]map[string]struct{}
 		name     = "testbuildvolumes"
 		emptyMap = make(map[string]struct{})

 		expected = map[string]map[string]struct{}{
 			"/test1":  emptyMap,
 			"/test2":  emptyMap,
 			"/test3":  emptyMap,
 			"/test4":  emptyMap,
 			"/test5":  emptyMap,
 			"/test6":  emptyMap,
 			"[/test7": emptyMap,
 			"/test8]": emptyMap,
 		}

 	)

 	_, err := buildImage(name,
 		`FROM scratch
 		VOLUME /test1

 		VOLUME /test2
     VOLUME /test3 /test4
     VOLUME ["/test5", "/test6"]
     VOLUME [/test7 /test8]
     `,

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}

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

 	if err != nil {

 		c.Fatal(err)

 	}

 
 	err = unmarshalJSON([]byte(res), &result)
 	if err != nil {

 		c.Fatal(err)

 	}

 	equal := reflect.DeepEqual(&result, &expected)

 
 	if !equal {

 		c.Fatalf("Volumes %s, expected %s", result, expected)

 	}
 

 }
 

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

 	name := "testbuildmaintainer"
 	expected := "dockerio"
 	_, err := buildImage(name,
 		`FROM scratch
         MAINTAINER dockerio`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Author")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Maintainer %s, expected %s", res, expected)

 	}

 }
 

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

 	name := "testbuilduser"
 	expected := "dockerio"
 	_, err := buildImage(name,
 		`FROM busybox

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

 		RUN [ $(whoami) = 'dockerio' ]`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.User")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("User %s, expected %s", res, expected)

 	}

 }
 

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

 	name := "testbuildrelativeworkdir"
 	expected := "/test2/test3"
 	_, err := buildImage(name,
 		`FROM busybox

 		RUN [ "$PWD" = '/' ]
 		WORKDIR test1
 		RUN [ "$PWD" = '/test1' ]
 		WORKDIR /test2
 		RUN [ "$PWD" = '/test2' ]
 		WORKDIR test3

 		RUN [ "$PWD" = '/test2/test3' ]`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.WorkingDir")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Workdir %s, expected %s", res, expected)

 	}

 }
 

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

 	name := "testbuildworkdirwithenvvariables"

 	expected := "/test1/test2"

 	_, err := buildImage(name,
 		`FROM busybox
 		ENV DIRPATH /test1
 		ENV SUBDIRNAME test2
 		WORKDIR $DIRPATH
 		WORKDIR $SUBDIRNAME/$MISSING_VAR`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.WorkingDir")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Workdir %s, expected %s", res, expected)

 	}
 }
 

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

 	name := "testbuildrelativecopy"
 	dockerfile := `
 		FROM busybox
 			WORKDIR /test1
 			WORKDIR test2
 			RUN [ "$PWD" = '/test1/test2' ]
 			COPY foo ./
 			RUN [ "$(cat /test1/test2/foo)" = 'hello' ]
 			ADD foo ./bar/baz
 			RUN [ "$(cat /test1/test2/bar/baz)" = 'hello' ]
 			COPY foo ./bar/baz2
 			RUN [ "$(cat /test1/test2/bar/baz2)" = 'hello' ]
 			WORKDIR ..
 			COPY foo ./
 			RUN [ "$(cat /test1/foo)" = 'hello' ]
 			COPY foo /test3/
 			RUN [ "$(cat /test3/foo)" = 'hello' ]
 			WORKDIR /test4
 			COPY . .
 			RUN [ "$(cat /test4/foo)" = 'hello' ]
 			WORKDIR /test5/test6
 			COPY foo ../
 			RUN [ "$(cat /test5/foo)" = 'hello' ]
 			`
 	ctx, err := fakeContext(dockerfile, map[string]string{
 		"foo": "hello",
 	})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	_, err = buildImageFromContext(name, ctx, false)
 	if err != nil {

 		c.Fatal(err)

 	}
 }
 

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

 	name := "testbuildenv"

 	expected := "[PATH=/test:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin PORT=2375]"

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

 		ENV PATH /test:$PATH

         ENV PORT 2375
 		RUN [ $(env | grep PORT) = 'PORT=2375' ]`,

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.Env")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Env %s, expected %s", res, expected)

 	}

 }
 

 func (s *DockerSuite) TestBuildContextCleanup(c *check.C) {
 	testRequires(c, SameHostDaemon)

 	name := "testbuildcontextcleanup"
 	entries, err := ioutil.ReadDir("/var/lib/docker/tmp")
 	if err != nil {

 		c.Fatalf("failed to list contents of tmp dir: %s", err)

 	}
 	_, err = buildImage(name,
 		`FROM scratch
         ENTRYPOINT ["/bin/echo"]`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	entriesFinal, err := ioutil.ReadDir("/var/lib/docker/tmp")
 	if err != nil {

 		c.Fatalf("failed to list contents of tmp dir: %s", err)

 	}
 	if err = compareDirectoryEntries(entries, entriesFinal); err != nil {

 		c.Fatalf("context should have been deleted, but wasn't")

 	}
 
 }
 

 func (s *DockerSuite) TestBuildContextCleanupFailedBuild(c *check.C) {
 	testRequires(c, SameHostDaemon)

 	name := "testbuildcontextcleanup"
 	entries, err := ioutil.ReadDir("/var/lib/docker/tmp")
 	if err != nil {

 		c.Fatalf("failed to list contents of tmp dir: %s", err)

 	}
 	_, err = buildImage(name,
 		`FROM scratch
 	RUN /non/existing/command`,
 		true)
 	if err == nil {

 		c.Fatalf("expected build to fail, but it didn't")

 	}
 	entriesFinal, err := ioutil.ReadDir("/var/lib/docker/tmp")
 	if err != nil {

 		c.Fatalf("failed to list contents of tmp dir: %s", err)

 	}
 	if err = compareDirectoryEntries(entries, entriesFinal); err != nil {

 		c.Fatalf("context should have been deleted, but wasn't")

 	}
 
 }
 

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

 	name := "testbuildcmd"

 	expected := "{[/bin/echo Hello World]}"

 	_, err := buildImage(name,
 		`FROM scratch
         CMD ["/bin/echo", "Hello World"]`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.Cmd")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Cmd %s, expected %s", res, expected)

 	}

 }
 

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

 	name := "testbuildexpose"

 	expected := "map[2375/tcp:{}]"

 	_, err := buildImage(name,
 		`FROM scratch

         EXPOSE 2375`,

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.ExposedPorts")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Exposed ports %s, expected %s", res, expected)

 	}

 }
 

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

 	// start building docker file with a large number of ports
 	portList := make([]string, 50)
 	line := make([]string, 100)
 	expectedPorts := make([]int, len(portList)*len(line))
 	for i := 0; i < len(portList); i++ {
 		for j := 0; j < len(line); j++ {
 			p := i*len(line) + j + 1
 			line[j] = strconv.Itoa(p)
 			expectedPorts[p-1] = p
 		}
 		if i == len(portList)-1 {
 			portList[i] = strings.Join(line, " ")
 		} else {
 			portList[i] = strings.Join(line, " ") + ` \`
 		}
 	}
 
 	dockerfile := `FROM scratch
 	EXPOSE {{range .}} {{.}}
 	{{end}}`
 	tmpl := template.Must(template.New("dockerfile").Parse(dockerfile))
 	buf := bytes.NewBuffer(nil)
 	tmpl.Execute(buf, portList)
 
 	name := "testbuildexpose"
 	_, err := buildImage(name, buf.String(), true)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	// check if all the ports are saved inside Config.ExposedPorts
 	res, err := inspectFieldJSON(name, "Config.ExposedPorts")
 	if err != nil {

 		c.Fatal(err)

 	}
 	var exposedPorts map[string]interface{}
 	if err := json.Unmarshal([]byte(res), &exposedPorts); err != nil {

 		c.Fatal(err)

 	}
 
 	for _, p := range expectedPorts {
 		ep := fmt.Sprintf("%d/tcp", p)
 		if _, ok := exposedPorts[ep]; !ok {

 			c.Errorf("Port(%s) is not exposed", ep)

 		} else {
 			delete(exposedPorts, ep)
 		}
 	}
 	if len(exposedPorts) != 0 {

 		c.Errorf("Unexpected extra exposed ports %v", exposedPorts)

 	}
 }
 

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

 	buildID := func(name, exposed string) string {
 		_, err := buildImage(name, fmt.Sprintf(`FROM scratch
 		EXPOSE %s`, exposed), true)
 		if err != nil {

 			c.Fatal(err)

 		}
 		id, err := inspectField(name, "Id")
 		if err != nil {

 			c.Fatal(err)

 		}
 		return id
 	}
 
 	id1 := buildID("testbuildexpose1", "80 2375")
 	id2 := buildID("testbuildexpose2", "2375 80")
 	if id1 != id2 {

 		c.Errorf("EXPOSE should invalidate the cache only when ports actually changed")

 	}
 }
 

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

 	name := "testbuildexposeuppercaseproto"

 	expected := "map[5678/udp:{}]"

 	_, err := buildImage(name,
 		`FROM scratch
         EXPOSE 5678/UDP`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.ExposedPorts")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Exposed ports %s, expected %s", res, expected)

 	}
 }
 

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

 	// start building docker file with ip:hostPort:containerPort
 	name := "testbuildexpose"

 	expected := "map[5678/tcp:{}]"

 	_, out, err := buildImageWithOut(name,
 		`FROM scratch
         EXPOSE 192.168.1.2:2375:5678`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	if !strings.Contains(out, "to map host ports to container ports (ip:hostPort:containerPort) is deprecated.") {

 		c.Fatal("Missing warning message")

 	}
 
 	res, err := inspectField(name, "Config.ExposedPorts")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Exposed ports %s, expected %s", res, expected)

 	}
 }
 

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

 	name := "testbuildentrypointinheritance"
 	name2 := "testbuildentrypointinheritance2"
 
 	_, err := buildImage(name,
 		`FROM busybox
         ENTRYPOINT ["/bin/echo"]`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.Entrypoint")
 	if err != nil {

 		c.Fatal(err)

 	}
 

 	expected := "{[/bin/echo]}"

 	if res != expected {

 		c.Fatalf("Entrypoint %s, expected %s", res, expected)

 	}
 
 	_, err = buildImage(name2,
 		fmt.Sprintf(`FROM %s
         ENTRYPOINT []`, name),
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err = inspectField(name2, "Config.Entrypoint")
 	if err != nil {

 		c.Fatal(err)

 	}
 

 	expected = "{[]}"

 
 	if res != expected {

 		c.Fatalf("Entrypoint %s, expected %s", res, expected)

 	}
 
 }
 

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

 	name := "testbuildentrypoint"

 	expected := "{[]}"

 	_, err := buildImage(name,

 		`FROM busybox
         ENTRYPOINT []`,

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.Entrypoint")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Entrypoint %s, expected %s", res, expected)

 	}

 }

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

 	name := "testbuildentrypoint"

 	expected := "{[/bin/echo]}"

 	_, err := buildImage(name,
 		`FROM scratch
         ENTRYPOINT ["/bin/echo"]`,

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}

 	res, err := inspectField(name, "Config.Entrypoint")

 	if err != nil {

 		c.Fatal(err)

 	}
 	if res != expected {

 		c.Fatalf("Entrypoint %s, expected %s", res, expected)

 	}
 

 }
 

 // #6445 ensure ONBUILD triggers aren't committed to grandchildren

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

 	var (
 		out2, out3 string
 	)
 	{
 		name1 := "testonbuildtrigger1"
 		dockerfile1 := `

 		FROM busybox
 		RUN echo "GRANDPARENT"
 		ONBUILD RUN echo "ONBUILD PARENT"

 		`
 		ctx, err := fakeContext(dockerfile1, nil)
 		if err != nil {

 			c.Fatal(err)

 		}

 		defer ctx.Close()

 		out1, _, err := dockerCmdInDir(c, ctx.Dir, "build", "-t", name1, ".")

 		if err != nil {

 			c.Fatalf("build failed to complete: %s, %v", out1, err)

 		}

 	}

 	{
 		name2 := "testonbuildtrigger2"
 		dockerfile2 := `
 		FROM testonbuildtrigger1
 		`
 		ctx, err := fakeContext(dockerfile2, nil)
 		if err != nil {

 			c.Fatal(err)

 		}

 		defer ctx.Close()

 		out2, _, err = dockerCmdInDir(c, ctx.Dir, "build", "-t", name2, ".")

 		if err != nil {

 			c.Fatalf("build failed to complete: %s, %v", out2, err)

 		}

 	}

 	{
 		name3 := "testonbuildtrigger3"
 		dockerfile3 := `
 		FROM testonbuildtrigger2
 		`
 		ctx, err := fakeContext(dockerfile3, nil)
 		if err != nil {

 			c.Fatal(err)

 		}

 		defer ctx.Close()

 		out3, _, err = dockerCmdInDir(c, ctx.Dir, "build", "-t", name3, ".")

 		if err != nil {

 			c.Fatalf("build failed to complete: %s, %v", out3, err)

 		}
 

 	}

 
 	// ONBUILD should be run in second build.
 	if !strings.Contains(out2, "ONBUILD PARENT") {

 		c.Fatalf("ONBUILD instruction did not run in child of ONBUILD parent")

 	}
 
 	// ONBUILD should *not* be run in third build.
 	if strings.Contains(out3, "ONBUILD PARENT") {

 		c.Fatalf("ONBUILD instruction ran in grandchild of ONBUILD parent")

 	}
 
 }
 

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

 	name := "testbuildwithcache"
 	id1, err := buildImage(name,
 		`FROM scratch
 		MAINTAINER dockerio
 		EXPOSE 5432
         ENTRYPOINT ["/bin/echo"]`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	id2, err := buildImage(name,
 		`FROM scratch
 		MAINTAINER dockerio
 		EXPOSE 5432
         ENTRYPOINT ["/bin/echo"]`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 != id2 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}
 }

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

 	name := "testbuildwithoutcache"

 	name2 := "testbuildwithoutcache2"

 	id1, err := buildImage(name,
 		`FROM scratch
 		MAINTAINER dockerio
 		EXPOSE 5432
         ENTRYPOINT ["/bin/echo"]`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}

 
 	id2, err := buildImage(name2,

 		`FROM scratch
 		MAINTAINER dockerio
 		EXPOSE 5432
         ENTRYPOINT ["/bin/echo"]`,
 		false)
 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 == id2 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}
 }
 

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

 	name := "testbuildconditionalcache"
 
 	dockerfile := `
 		FROM busybox
         ADD foo /tmp/`
 	ctx, err := fakeContext(dockerfile, map[string]string{
 		"foo": "hello",
 	})

 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()

 
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatalf("Error building #1: %s", err)

 	}
 
 	if err := ctx.Add("foo", "bye"); err != nil {

 		c.Fatalf("Error modifying foo: %s", err)

 	}
 
 	id2, err := buildImageFromContext(name, ctx, false)
 	if err != nil {

 		c.Fatalf("Error building #2: %s", err)

 	}
 	if id2 == id1 {

 		c.Fatal("Should not have used the cache")

 	}
 
 	id3, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatalf("Error building #3: %s", err)

 	}
 	if id3 != id2 {

 		c.Fatal("Should have used the cache")

 	}
 }
 

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

 	name := "testbuildaddlocalfilewithcache"

 	name2 := "testbuildaddlocalfilewithcache2"

 	dockerfile := `
 		FROM busybox
         MAINTAINER dockerio
         ADD foo /usr/lib/bla/bar
 		RUN [ "$(cat /usr/lib/bla/bar)" = "hello" ]`
 	ctx, err := fakeContext(dockerfile, map[string]string{
 		"foo": "hello",
 	})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}

 	id2, err := buildImageFromContext(name2, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 != id2 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}
 }
 

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

 	name := "testbuildaddmultiplelocalfilewithcache"

 	name2 := "testbuildaddmultiplelocalfilewithcache2"

 	dockerfile := `
 		FROM busybox
         MAINTAINER dockerio
         ADD foo Dockerfile /usr/lib/bla/
 		RUN [ "$(cat /usr/lib/bla/foo)" = "hello" ]`
 	ctx, err := fakeContext(dockerfile, map[string]string{
 		"foo": "hello",
 	})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}

 	id2, err := buildImageFromContext(name2, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 != id2 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}
 }
 

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

 	name := "testbuildaddlocalfilewithoutcache"

 	name2 := "testbuildaddlocalfilewithoutcache2"

 	dockerfile := `
 		FROM busybox
         MAINTAINER dockerio
         ADD foo /usr/lib/bla/bar
 		RUN [ "$(cat /usr/lib/bla/bar)" = "hello" ]`
 	ctx, err := fakeContext(dockerfile, map[string]string{
 		"foo": "hello",
 	})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}

 	id2, err := buildImageFromContext(name2, ctx, false)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 == id2 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}
 }
 

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

 	name := "testbuildcopydirbutnotfile"

 	name2 := "testbuildcopydirbutnotfile2"

 	dockerfile := `
         FROM scratch
         COPY dir /tmp/`
 	ctx, err := fakeContext(dockerfile, map[string]string{
 		"dir/foo": "hello",
 	})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	// Check that adding file with similar name doesn't mess with cache
 	if err := ctx.Add("dir_file", "hello2"); err != nil {

 		c.Fatal(err)

 	}

 	id2, err := buildImageFromContext(name2, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 != id2 {

 		c.Fatal("The cache should have been used but wasn't")

 	}
 }
 

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

 	name := "testbuildaddcurrentdirwithcache"

 	name2 := name + "2"
 	name3 := name + "3"
 	name4 := name + "4"
 	name5 := name + "5"

 	dockerfile := `
         FROM scratch
         MAINTAINER dockerio
         ADD . /usr/lib/bla`
 	ctx, err := fakeContext(dockerfile, map[string]string{
 		"foo": "hello",
 	})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	// Check that adding file invalidate cache of "ADD ."
 	if err := ctx.Add("bar", "hello2"); err != nil {

 		c.Fatal(err)

 	}

 	id2, err := buildImageFromContext(name2, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 == id2 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}
 	// Check that changing file invalidate cache of "ADD ."
 	if err := ctx.Add("foo", "hello1"); err != nil {

 		c.Fatal(err)

 	}

 	id3, err := buildImageFromContext(name3, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id2 == id3 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}
 	// Check that changing file to same content invalidate cache of "ADD ."
 	time.Sleep(1 * time.Second) // wait second because of mtime precision
 	if err := ctx.Add("foo", "hello1"); err != nil {

 		c.Fatal(err)

 	}

 	id4, err := buildImageFromContext(name4, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id3 == id4 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}

 	id5, err := buildImageFromContext(name5, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id4 != id5 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}
 }
 

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

 	name := "testbuildaddcurrentdirwithoutcache"

 	name2 := "testbuildaddcurrentdirwithoutcache2"

 	dockerfile := `
         FROM scratch
         MAINTAINER dockerio
         ADD . /usr/lib/bla`
 	ctx, err := fakeContext(dockerfile, map[string]string{
 		"foo": "hello",
 	})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}

 	id2, err := buildImageFromContext(name2, ctx, false)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 == id2 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}
 }
 

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

 	name := "testbuildaddremotefilewithcache"
 	server, err := fakeStorage(map[string]string{
 		"baz": "hello",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()

 	id1, err := buildImage(name,
 		fmt.Sprintf(`FROM scratch
         MAINTAINER dockerio

         ADD %s/baz /usr/lib/baz/quux`, server.URL()),

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	id2, err := buildImage(name,
 		fmt.Sprintf(`FROM scratch
         MAINTAINER dockerio

         ADD %s/baz /usr/lib/baz/quux`, server.URL()),

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 != id2 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}
 }
 

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

 	name := "testbuildaddremotefilewithoutcache"

 	name2 := "testbuildaddremotefilewithoutcache2"

 	server, err := fakeStorage(map[string]string{
 		"baz": "hello",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()

 	id1, err := buildImage(name,
 		fmt.Sprintf(`FROM scratch
         MAINTAINER dockerio

         ADD %s/baz /usr/lib/baz/quux`, server.URL()),

 		true)
 	if err != nil {

 		c.Fatal(err)

 	}

 	id2, err := buildImage(name2,

 		fmt.Sprintf(`FROM scratch
         MAINTAINER dockerio

         ADD %s/baz /usr/lib/baz/quux`, server.URL()),

 		false)
 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 == id2 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}
 }
 

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

 	name := "testbuildaddremotefilemtime"

 	name2 := name + "2"
 	name3 := name + "3"
 	name4 := name + "4"
 

 	files := map[string]string{"baz": "hello"}
 	server, err := fakeStorage(files)

 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()
 
 	ctx, err := fakeContext(fmt.Sprintf(`FROM scratch
         MAINTAINER dockerio

         ADD %s/baz /usr/lib/baz/quux`, server.URL()), nil)

 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()
 
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 

 	id2, err := buildImageFromContext(name2, ctx, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 != id2 {

 		c.Fatal("The cache should have been used but wasn't - #1")

 	}
 

 	// Now create a different server withsame contents (causes different mtim)

 	// This time the cache should not be used

 
 	// allow some time for clock to pass as mtime precision is only 1s
 	time.Sleep(2 * time.Second)
 
 	server2, err := fakeStorage(files)

 	if err != nil {

 		c.Fatal(err)

 	}

 	defer server2.Close()

 	ctx2, err := fakeContext(fmt.Sprintf(`FROM scratch
         MAINTAINER dockerio
         ADD %s/baz /usr/lib/baz/quux`, server2.URL()), nil)
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx2.Close()
 	id3, err := buildImageFromContext(name3, ctx2, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 == id3 {

 		c.Fatal("The cache should not have been used but was")

 	}
 
 	// And for good measure do it again and make sure cache is used this time

 	id4, err := buildImageFromContext(name4, ctx2, true)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id3 != id4 {

 		c.Fatal("The cache should have been used but wasn't - #2")

 	}
 }
 

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

 	name := "testbuildaddlocalandremotefilewithcache"
 	server, err := fakeStorage(map[string]string{
 		"baz": "hello",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()

 	ctx, err := fakeContext(fmt.Sprintf(`FROM scratch
         MAINTAINER dockerio
         ADD foo /usr/lib/bla/bar

         ADD %s/baz /usr/lib/baz/quux`, server.URL()),

 		map[string]string{
 			"foo": "hello world",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	id2, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 != id2 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}
 }
 

 func testContextTar(c *check.C, compression archive.Compression) {

 	ctx, err := fakeContext(
 		`FROM busybox
 ADD foo /foo
 CMD ["cat", "/foo"]`,
 		map[string]string{
 			"foo": "bar",
 		},
 	)
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	context, err := archive.Tar(ctx.Dir, compression)

 	if err != nil {

 		c.Fatalf("failed to build context tar: %v", err)

 	}

 	name := "contexttar"
 	buildCmd := exec.Command(dockerBinary, "build", "-t", name, "-")

 	buildCmd.Stdin = context
 

 	if out, _, err := runCommandWithOutput(buildCmd); err != nil {

 		c.Fatalf("build failed to complete: %v %v", out, err)

 	}
 }
 

 func (s *DockerSuite) TestBuildContextTarGzip(c *check.C) {
 	testContextTar(c, archive.Gzip)

 }
 

 func (s *DockerSuite) TestBuildContextTarNoCompression(c *check.C) {
 	testContextTar(c, archive.Uncompressed)

 }
 

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

 	buildCmd := exec.Command(dockerBinary, "build", "-t", "nocontext", "-")
 	buildCmd.Stdin = strings.NewReader("FROM busybox\nCMD echo ok\n")
 

 	if out, _, err := runCommandWithOutput(buildCmd); err != nil {

 		c.Fatalf("build failed to complete: %v %v", out, err)

 	}
 

 	if out, _ := dockerCmd(c, "run", "--rm", "nocontext"); out != "ok\n" {
 		c.Fatalf("run produced invalid output: %q, expected %q", out, "ok")

 	}
 }
 

 // TODO: TestCaching

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

 	name := "testbuildaddlocalandremotefilewithoutcache"

 	name2 := "testbuildaddlocalandremotefilewithoutcache2"

 	server, err := fakeStorage(map[string]string{
 		"baz": "hello",
 	})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer server.Close()

 	ctx, err := fakeContext(fmt.Sprintf(`FROM scratch
         MAINTAINER dockerio
         ADD foo /usr/lib/bla/bar

         ADD %s/baz /usr/lib/baz/quux`, server.URL()),

 		map[string]string{
 			"foo": "hello world",
 		})
 	if err != nil {

 		c.Fatal(err)

 	}
 	defer ctx.Close()
 	id1, err := buildImageFromContext(name, ctx, true)
 	if err != nil {

 		c.Fatal(err)

 	}

 	id2, err := buildImageFromContext(name2, ctx, false)

 	if err != nil {

 		c.Fatal(err)

 	}
 	if id1 == id2 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}
 }

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

 	name := "testbuildimg"
 
 	_, err := buildImage(name,
 		`FROM busybox:latest
         RUN mkdir /test && chown daemon:daemon /test && chmod 0600 /test
         VOLUME /test`,
 		true)
 
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	cmd := exec.Command(dockerBinary, "run", "--rm", "testbuildimg", "ls", "-la", "/test")
 	out, _, err := runCommandWithOutput(cmd)
 	if err != nil {

 		c.Fatal(out, err)

 	}
 
 	if expected := "drw-------"; !strings.Contains(out, expected) {

 		c.Fatalf("expected %s received %s", expected, out)

 	}
 
 	if expected := "daemon   daemon"; !strings.Contains(out, expected) {

 		c.Fatalf("expected %s received %s", expected, out)

 	}
 
 }

 
 // testing #1405 - config.Cmd does not get cleaned up if
 // utilizing cache

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

 	name := "testbuildcmdcleanup"
 	if _, err := buildImage(name,
 		`FROM busybox
         RUN echo "hello"`,
 		true); err != nil {

 		c.Fatal(err)

 	}
 
 	ctx, err := fakeContext(`FROM busybox
         RUN echo "hello"
         ADD foo /foo
         ENTRYPOINT ["/bin/echo"]`,
 		map[string]string{
 			"foo": "hello",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

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

 		c.Fatal(err)

 	}
 	res, err := inspectField(name, "Config.Cmd")
 	if err != nil {

 		c.Fatal(err)

 	}

 	// Cmd must be cleaned up

 	if res != "<nil>" {
 		c.Fatalf("Cmd %s, expected nil", res)

 	}
 }

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

 	name := "testbuildforbidpath"
 	ctx, err := fakeContext(`FROM scratch
         ADD ../../ test/
         `,
 		map[string]string{
 			"test.txt":  "test1",
 			"other.txt": "other",
 		})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}

 
 	expected := "Forbidden path outside the build context: ../../ "
 	if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {

 		c.Fatalf("Wrong error: (should contain \"%s\") got:\n%v", expected, err)

 	}

 }

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

 	name := "testbuildaddnotfound"
 	ctx, err := fakeContext(`FROM scratch
         ADD foo /usr/local/bar`,
 		map[string]string{"bar": "hello"})
 	defer ctx.Close()
 	if err != nil {

 		c.Fatal(err)

 	}
 	if _, err := buildImageFromContext(name, ctx, true); err != nil {
 		if !strings.Contains(err.Error(), "foo: no such file or directory") {

 			c.Fatalf("Wrong error %v, must be about missing foo file or directory", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 }

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

 	name := "testbuildinheritance"
 
 	_, err := buildImage(name,
 		`FROM scratch
 		EXPOSE 2375`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	ports1, err := inspectField(name, "Config.ExposedPorts")
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	_, err = buildImage(name,
 		fmt.Sprintf(`FROM %s
 		ENTRYPOINT ["/bin/echo"]`, name),
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 
 	res, err := inspectField(name, "Config.Entrypoint")
 	if err != nil {

 		c.Fatal(err)

 	}

 	if expected := "{[/bin/echo]}"; res != expected {

 		c.Fatalf("Entrypoint %s, expected %s", res, expected)

 	}
 	ports2, err := inspectField(name, "Config.ExposedPorts")
 	if err != nil {

 		c.Fatal(err)

 	}
 	if ports1 != ports2 {

 		c.Fatalf("Ports must be same: %s != %s", ports1, ports2)

 	}
 }

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

 	name := "testbuildfails"
 	_, err := buildImage(name,
 		`FROM busybox
 		RUN sh -c "exit 23"`,
 		true)
 	if err != nil {
 		if !strings.Contains(err.Error(), "returned a non-zero code: 23") {

 			c.Fatalf("Wrong error %v, must be about non-zero code 23", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 }

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

 	name := "testbuildfails"
 	_, err := buildImage(name, ``, true)
 	if err != nil {

 		if !strings.Contains(err.Error(), "The Dockerfile (Dockerfile) cannot be empty") {

 			c.Fatalf("Wrong error %v, must be about empty Dockerfile", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 }

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

 	name := "testbuildonbuild"
 	_, err := buildImage(name,
 		`FROM busybox
 		ONBUILD RUN touch foobar`,
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 	_, err = buildImage(name,
 		fmt.Sprintf(`FROM %s
 		RUN [ -f foobar ]`, name),
 		true)
 	if err != nil {

 		c.Fatal(err)

 	}
 }

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

 	name := "testbuildonbuildforbiddenchained"
 	_, err := buildImage(name,
 		`FROM busybox
 		ONBUILD ONBUILD RUN touch foobar`,
 		true)
 	if err != nil {
 		if !strings.Contains(err.Error(), "Chaining ONBUILD via `ONBUILD ONBUILD` isn't allowed") {

 			c.Fatalf("Wrong error %v, must be about chaining ONBUILD", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 }

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

 	name := "testbuildonbuildforbiddenfrom"
 	_, err := buildImage(name,
 		`FROM busybox
 		ONBUILD FROM scratch`,
 		true)
 	if err != nil {
 		if !strings.Contains(err.Error(), "FROM isn't allowed as an ONBUILD trigger") {

 			c.Fatalf("Wrong error %v, must be about FROM forbidden", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 }

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

 	name := "testbuildonbuildforbiddenmaintainer"
 	_, err := buildImage(name,
 		`FROM busybox
 		ONBUILD MAINTAINER docker.io`,
 		true)
 	if err != nil {
 		if !strings.Contains(err.Error(), "MAINTAINER isn't allowed as an ONBUILD trigger") {

 			c.Fatalf("Wrong error %v, must be about MAINTAINER forbidden", err)

 		}
 	} else {

 		c.Fatal("Error must not be nil")

 	}
 }

 
 // gh #2446