// build go dll
	cmd := testenv.Command(t, testenv.GoToolPath(t), "build", "-o", dllfile, "-buildmode", "c-shared", "testdata/testwintls/main.go")
	out, err := testenv.CleanCmdEnv(cmd).CombinedOutput()
	if err != nil {
		t.Fatalf("failed to build go library: %s\n%s", err, out)
	}

	// build c program
	cmd = testenv.Command(t, cc, "-o", exefile, "testdata/testwintls/main.c")
	testenv.CleanCmdEnv(cmd)

}

func main() {
	gopath := changeVolume(os.Args[1], strings.ToLower)
	dir := changeVolume(os.Args[2], strings.ToUpper)
	cmd := exec.Command("go", "run", "hello.go")
	cmd.Dir = dir
	cmd.Env = append(os.Environ(), "GOPATH="+gopath)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

-- vend/hello/hello.go --
package main

}

func ExampleCommand() {
	cmd := exec.Command("tr", "a-z", "A-Z")
	cmd.Stdin = strings.NewReader("some input")
	var out strings.Builder
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("in all caps: %q\n", out.String())
}

func ExampleCommand_environment() {
	cmd := exec.Command("prog")
	cmd.Env = append(os.Environ(),
		"FOO=duplicate_value", // ignored

tests of cmd/go and its subpackages.

They are written in a dialect of the same script language as in
cmd/go/testdata/script, and the outputs are hosted by the server in
cmd/go/internal/vcweb.

To see the conditions and commands available for these scripts, run:

	go test cmd/go/internal/vcweb -v --run=TestHelp

To host these scripts in a standalone server, run:

import (
	"os/exec"
	"strings"
)

// setDir sets cmd.Dir to dir, and also adds PWD=dir to cmd's environment.
func setDir(cmd *exec.Cmd, dir string) {
	cmd.Dir = dir
	if cmd.Env != nil {
		// os/exec won't set PWD automatically.
		setEnv(cmd, "PWD", dir)
	}
}

// setEnv sets cmd.Env so that key = value.
func setEnv(cmd *exec.Cmd, key, value string) {
	cmd.Env = append(cmd.Environ(), key+"="+value)
}

	x := filepath.Join(root, "syscall.test")
	cmd := exec.Command(testenv.GoToolPath(t), "test", "-c", "-o", x, "syscall")
	cmd.Env = append(os.Environ(), "CGO_ENABLED=0")
	if o, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("Build of syscall in jail root failed, output %v, err %v", o, err)
	}

	cmd = exec.Command("/syscall.test", "-test.run=TestJailAttach", "/")
	cmd.Env = append(os.Environ(), "GO_WANT_HELPER_PROCESS=1")

// at http://daviddeley.com/autohotkey/parameters/parameters.htm#WINARGV
func commandLineToArgv(cmd string) []string {
	var args []string
	for len(cmd) > 0 {
		if cmd[0] == ' ' || cmd[0] == '\t' {
			cmd = cmd[1:]
			continue
		}
		var arg []byte
		arg, cmd = readNextArg(cmd)
		args = append(args, string(arg))
	}
	return args
}

			t.Errorf("stderr is not a terminal")
		}
	})
}

func runTerminalPassthrough(t *testing.T, r, w *os.File) (stdout, stderr bool) {
	cmd := testenv.Command(t, testGo, "test", "-run=^$")
	cmd.Env = append(cmd.Environ(), "GO_TEST_TERMINAL_PASSTHROUGH=1")
	cmd.Stdout = w
	cmd.Stderr = w

	// The behavior of reading from a PTY after the child closes it is very
	// strange: on Linux, Read returns EIO, and on at least some versions of

	}

	executable, err := os.Executable()
	if err != nil {
		executable = os.Args[0]
	}

	cmd := testenv.Command(t, executable, "-test.run=^TestRlimitRestored$")
	cmd = testenv.CleanCmdEnv(cmd)
	cmd.Env = append(cmd.Env, "GO_WANT_HELPER_PROCESS=1")

	out, err := cmd.CombinedOutput()
	if len(out) > 0 {
		t.Logf("%s", out)
	}
	if err != nil {
		t.Fatalf("subprocess failed: %v", err)
	}

	var cancel func(cmd *exec.Cmd) error
	if interrupt != nil {
		cancel = func(cmd *exec.Cmd) error {
			return cmd.Process.Signal(interrupt)
		}
	}

	cmdExec := script.Exec(cancel, waitDelay)
	cmds["exec"] = cmdExec

	add := func(name string, cmd script.Cmd) {
		if _, ok := cmds[name]; ok {
			panic(fmt.Sprintf("command %q is already registered", name))
		}
		cmds[name] = cmd
	}

	add("cc", scriptCC(cmdExec))