@@ -9,6 +9,13 @@ import (

 	"github.com/go-check/check"

 )

+// We use the elongated quote mechanism for quoting error returns as

+// the use of strconv.Quote or %q in fmt.Errorf will escape characters. This

+// has a big downside on Windows where the args include paths, so instead

+// of something like c:\directory\file.txt, the output would be

+// c:\\directory\\file.txt. This is highly misleading.

+const quote = `"`

+

 var execCommand = exec.Command

 // DockerCmdWithError executes a docker command that is supposed to fail and returns

@@ -23,7 +30,7 @@ func DockerCmdWithError(dockerBinary string, args ...string) (string, int, error

 func DockerCmdWithStdoutStderr(dockerBinary string, c *check.C, args ...string) (string, string, int) {

 	stdout, stderr, status, err := RunCommandWithStdoutStderr(execCommand(dockerBinary, args...))

 	if c != nil {

-		c.Assert(err, check.IsNil, check.Commentf("%q failed with errors: %s, %v", strings.Join(args, " "), stderr, err))

+		c.Assert(err, check.IsNil, check.Commentf(quote+"%v"+quote+" failed with errors: %s, %v", strings.Join(args, " "), stderr, err))

 	}

 	return stdout, stderr, status

 }

@@ -32,7 +39,7 @@ func DockerCmdWithStdoutStderr(dockerBinary string, c *check.C, args ...string)

 // command returns an error, it will fail and stop the tests.

 func DockerCmd(dockerBinary string, c *check.C, args ...string) (string, int) {

 	out, status, err := RunCommandWithOutput(execCommand(dockerBinary, args...))

-	c.Assert(err, check.IsNil, check.Commentf("%q failed with errors: %s, %v", strings.Join(args, " "), out, err))

+	c.Assert(err, check.IsNil, check.Commentf(quote+"%v"+quote+" failed with errors: %s, %v", strings.Join(args, " "), out, err))

 	return out, status

 }

@@ -41,7 +48,7 @@ func DockerCmd(dockerBinary string, c *check.C, args ...string) (string, int) {

 func DockerCmdWithTimeout(dockerBinary string, timeout time.Duration, args ...string) (string, int, error) {

 	out, status, err := RunCommandWithOutputAndTimeout(execCommand(dockerBinary, args...), timeout)

 	if err != nil {

-		return out, status, fmt.Errorf("%q failed with errors: %v : %q", strings.Join(args, " "), err, out)

+		return out, status, fmt.Errorf(quote+"%v"+quote+" failed with errors: %v : %q", strings.Join(args, " "), err, out)

 	}

 	return out, status, err

 }

@@ -53,7 +60,7 @@ func DockerCmdInDir(dockerBinary string, path string, args ...string) (string, i

 	dockerCommand.Dir = path

 	out, status, err := RunCommandWithOutput(dockerCommand)

 	if err != nil {

-		return out, status, fmt.Errorf("%q failed with errors: %v : %q", strings.Join(args, " "), err, out)

+		return out, status, fmt.Errorf(quote+"%v"+quote+" failed with errors: %v : %q", strings.Join(args, " "), err, out)

 	}

 	return out, status, err

 }

@@ -65,7 +72,7 @@ func DockerCmdInDirWithTimeout(dockerBinary string, timeout time.Duration, path

 	dockerCommand.Dir = path

 	out, status, err := RunCommandWithOutputAndTimeout(dockerCommand, timeout)

 	if err != nil {

-		return out, status, fmt.Errorf("%q failed with errors: %v : %q", strings.Join(args, " "), err, out)

+		return out, status, fmt.Errorf(quote+"%v"+quote+" failed with errors: %v : %q", strings.Join(args, " "), err, out)

 	}

 	return out, status, err

 }

@@ -5,8 +5,9 @@ import (

 	"io/ioutil"

 	"os"

 	"os/exec"

-	"path"

+	"path/filepath"

 	"runtime"

+	"strconv"

 	"strings"

 	"testing"

 	"time"

@@ -23,6 +24,12 @@ func TestIsKilledFalseWithNonKilledProcess(t *testing.T) {

 }

 func TestIsKilledTrueWithKilledProcess(t *testing.T) {

+	// TODO Windows: Using golang 1.5.3, this seems to hit

+	// a bug in go where Process.Kill() causes a panic.

+	// Needs further investigation @jhowardmsft

+	if runtime.GOOS == "windows" {

+		t.SkipNow()

+	}

 	longCmd := exec.Command("top")

 	// Start a command

 	longCmd.Start()

@@ -41,30 +48,56 @@ func TestIsKilledTrueWithKilledProcess(t *testing.T) {

 }

 func TestRunCommandWithOutput(t *testing.T) {

-	echoHelloWorldCmd := exec.Command("echo", "hello", "world")

+	var (

+		echoHelloWorldCmd *exec.Cmd

+		expected          string

+	)

+	if runtime.GOOS != "windows" {

+		echoHelloWorldCmd = exec.Command("echo", "hello", "world")

+		expected = "hello world\n"

+	} else {

+		echoHelloWorldCmd = exec.Command("cmd", "/s", "/c", "echo", "hello", "world")

+		expected = "hello world\r\n"

+	}

+

 	out, exitCode, err := RunCommandWithOutput(echoHelloWorldCmd)

-	expected := "hello world\n"

 	if out != expected || exitCode != 0 || err != nil {

 		t.Fatalf("Expected command to output %s, got %s, %v with exitCode %v", expected, out, err, exitCode)

 	}

 }

 func TestRunCommandWithOutputError(t *testing.T) {

+	var (

+		p                string

+		wrongCmd         *exec.Cmd

+		expected         string

+		expectedExitCode int

+	)

+

+	if runtime.GOOS != "windows" {

+		p = "$PATH"

+		wrongCmd = exec.Command("ls", "-z")

+		expected = `ls: invalid option -- 'z'

+Try 'ls --help' for more information.

+`

+		expectedExitCode = 2

+	} else {

+		p = "%PATH%"

+		wrongCmd = exec.Command("cmd", "/s", "/c", "dir", "/Z")

+		expected = "Invalid switch - " + strconv.Quote("Z") + ".\r\n"

+		expectedExitCode = 1

+	}

 	cmd := exec.Command("doesnotexists")

 	out, exitCode, err := RunCommandWithOutput(cmd)

-	expectedError := `exec: "doesnotexists": executable file not found in $PATH`

+	expectedError := `exec: "doesnotexists": executable file not found in ` + p

 	if out != "" || exitCode != 127 || err == nil || err.Error() != expectedError {

 		t.Fatalf("Expected command to output %s, got %s, %v with exitCode %v", expectedError, out, err, exitCode)

 	}

-	wrongLsCmd := exec.Command("ls", "-z")

-	expected := `ls: invalid option -- 'z'

-Try 'ls --help' for more information.

-`

-	out, exitCode, err = RunCommandWithOutput(wrongLsCmd)

+	out, exitCode, err = RunCommandWithOutput(wrongCmd)

-	if out != expected || exitCode != 2 || err == nil || err.Error() != "exit status 2" {

-		t.Fatalf("Expected command to output %s, got out:%s, err:%v with exitCode %v", expected, out, err, exitCode)

+	if out != expected || exitCode != expectedExitCode || err == nil || !strings.Contains(err.Error(), "exit status "+strconv.Itoa(expectedExitCode)) {

+		t.Fatalf("Expected command to output %s, got out:xxx%sxxx, err:%v with exitCode %v", expected, out, err, exitCode)

 	}

 }

@@ -78,9 +111,13 @@ func TestRunCommandWithStdoutStderr(t *testing.T) {

 }

 func TestRunCommandWithStdoutStderrError(t *testing.T) {

+	p := "$PATH"

+	if runtime.GOOS == "windows" {

+		p = "%PATH%"

+	}

 	cmd := exec.Command("doesnotexists")

 	stdout, stderr, exitCode, err := RunCommandWithStdoutStderr(cmd)

-	expectedError := `exec: "doesnotexists": executable file not found in $PATH`

+	expectedError := `exec: "doesnotexists": executable file not found in ` + p

 	if stdout != "" || stderr != "" || exitCode != 127 || err == nil || err.Error() != expectedError {

 		t.Fatalf("Expected command to output out:%s, stderr:%s, got stdout:%s, stderr:%s, err:%v with exitCode %v", "", "", stdout, stderr, err, exitCode)

 	}

@@ -157,6 +194,10 @@ func TestRunCommandWithOutputAndTimeoutErrors(t *testing.T) {

 }

 func TestRunCommand(t *testing.T) {

+	p := "$PATH"

+	if runtime.GOOS == "windows" {

+		p = "%PATH%"

+	}

 	lsCmd := exec.Command("ls")

 	exitCode, err := RunCommand(lsCmd)

 	if exitCode != 0 || err != nil {

@@ -166,7 +207,7 @@ func TestRunCommand(t *testing.T) {

 	var expectedError string

 	exitCode, err = RunCommand(exec.Command("doesnotexists"))

-	expectedError = `exec: "doesnotexists": executable file not found in $PATH`

+	expectedError = `exec: "doesnotexists": executable file not found in ` + p

 	if exitCode != 127 || err == nil || err.Error() != expectedError {

 		t.Fatalf("Expected runCommand to run the command successfully, got: exitCode:%d, err:%v", exitCode, err)

 	}

@@ -188,6 +229,10 @@ func TestRunCommandPipelineWithOutputWithNotEnoughCmds(t *testing.T) {

 }

 func TestRunCommandPipelineWithOutputErrors(t *testing.T) {

+	p := "$PATH"

+	if runtime.GOOS == "windows" {

+		p = "%PATH%"

+	}

 	cmd1 := exec.Command("ls")

 	cmd1.Stdout = os.Stdout

 	cmd2 := exec.Command("anything really")

@@ -199,7 +244,7 @@ func TestRunCommandPipelineWithOutputErrors(t *testing.T) {

 	cmdWithError := exec.Command("doesnotexists")

 	cmdCat := exec.Command("cat")

 	_, _, err = RunCommandPipelineWithOutput(cmdWithError, cmdCat)

-	if err == nil || err.Error() != `starting doesnotexists failed with error: exec: "doesnotexists": executable file not found in $PATH` {

+	if err == nil || err.Error() != `starting doesnotexists failed with error: exec: "doesnotexists": executable file not found in `+p {

 		t.Fatalf("Expected an error, got %v", err)

 	}

 }

@@ -250,8 +295,8 @@ func TestCompareDirectoryEntries(t *testing.T) {

 	}

 	defer os.RemoveAll(tmpFolder)

-	file1 := path.Join(tmpFolder, "file1")

-	file2 := path.Join(tmpFolder, "file2")

+	file1 := filepath.Join(tmpFolder, "file1")

+	file2 := filepath.Join(tmpFolder, "file2")

 	os.Create(file1)

 	os.Create(file2)

@@ -311,6 +356,10 @@ func TestCompareDirectoryEntries(t *testing.T) {

 // FIXME make an "unhappy path" test for ListTar without "panicking" :-)

 func TestListTar(t *testing.T) {

+	// TODO Windows: Figure out why this fails. Should be portable.

+	if runtime.GOOS == "windows" {

+		t.Skip("Failing on Windows - needs further investigation")

+	}

 	tmpFolder, err := ioutil.TempDir("", "integration-cli-utils-list-tar")

 	if err != nil {

 		t.Fatal(err)

@@ -318,10 +367,10 @@ func TestListTar(t *testing.T) {

 	defer os.RemoveAll(tmpFolder)

 	// Let's create a Tar file

-	srcFile := path.Join(tmpFolder, "src")

-	tarFile := path.Join(tmpFolder, "src.tar")

+	srcFile := filepath.Join(tmpFolder, "src")

+	tarFile := filepath.Join(tmpFolder, "src.tar")

 	os.Create(srcFile)

-	cmd := exec.Command("/bin/sh", "-c", "tar cf "+tarFile+" "+srcFile)

+	cmd := exec.Command("sh", "-c", "tar cf "+tarFile+" "+srcFile)

 	_, err = cmd.CombinedOutput()

 	if err != nil {

 		t.Fatal(err)