src/pkg/os/exec/exec_test.go - go - Git at Google

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Use an external test to avoid os/exec -> net/http -> crypto/x509 -> os/exec
 // circular dependency on non-cgo darwin.

 package exec_test

 import (
 	"bufio"
 	"bytes"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"log"
 	"net"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strconv"
 	"strings"
 	"testing"
 	"time"
 )

 func helperCommand(t *testing.T, s ...string) *exec.Cmd {
 	if runtime.GOOS == "nacl" {
 		t.Skip("skipping on nacl")
 	}
 	cs := []string{"-test.run=TestHelperProcess", "--"}
 	cs = append(cs, s...)
 	cmd := exec.Command(os.Args[0], cs...)
 	cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}
 	return cmd
 }

 func TestEcho(t *testing.T) {
 	bs, err := helperCommand(t, "echo", "foo bar", "baz").Output()
 	if err != nil {
 		t.Errorf("echo: %v", err)
 	}
 	if g, e := string(bs), "foo bar baz\n"; g != e {
 		t.Errorf("echo: want %q, got %q", e, g)
 	}
 }

 func TestCommandRelativeName(t *testing.T) {
 	// Run our own binary as a relative path
 	// (e.g. "_test/exec.test") our parent directory.
 	base := filepath.Base(os.Args[0]) // "exec.test"
 	dir := filepath.Dir(os.Args[0])   // "/tmp/go-buildNNNN/os/exec/_test"
 	if dir == "." {
 		t.Skip("skipping; running test at root somehow")
 	}
 	parentDir := filepath.Dir(dir) // "/tmp/go-buildNNNN/os/exec"
 	dirBase := filepath.Base(dir)  // "_test"
 	if dirBase == "." {
 		t.Skipf("skipping; unexpected shallow dir of %q", dir)
 	}

 	cmd := exec.Command(filepath.Join(dirBase, base), "-test.run=TestHelperProcess", "--", "echo", "foo")
 	cmd.Dir = parentDir
 	cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}

 	out, err := cmd.Output()
 	if err != nil {
 		t.Errorf("echo: %v", err)
 	}
 	if g, e := string(out), "foo\n"; g != e {
 		t.Errorf("echo: want %q, got %q", e, g)
 	}
 }

 func TestCatStdin(t *testing.T) {
 	// Cat, testing stdin and stdout.
 	input := "Input string\nLine 2"
 	p := helperCommand(t, "cat")
 	p.Stdin = strings.NewReader(input)
 	bs, err := p.Output()
 	if err != nil {
 		t.Errorf("cat: %v", err)
 	}
 	s := string(bs)
 	if s != input {
 		t.Errorf("cat: want %q, got %q", input, s)
 	}
 }

 func TestCatGoodAndBadFile(t *testing.T) {
 	// Testing combined output and error values.
 	bs, err := helperCommand(t, "cat", "/bogus/file.foo", "exec_test.go").CombinedOutput()
 	if _, ok := err.(*exec.ExitError); !ok {
 		t.Errorf("expected *exec.ExitError from cat combined; got %T: %v", err, err)
 	}
 	s := string(bs)
 	sp := strings.SplitN(s, "\n", 2)
 	if len(sp) != 2 {
 		t.Fatalf("expected two lines from cat; got %q", s)
 	}
 	errLine, body := sp[0], sp[1]
 	if !strings.HasPrefix(errLine, "Error: open /bogus/file.foo") {
 		t.Errorf("expected stderr to complain about file; got %q", errLine)
 	}
 	if !strings.Contains(body, "func TestHelperProcess(t *testing.T)") {
 		t.Errorf("expected test code; got %q (len %d)", body, len(body))
 	}
 }

 func TestNoExistBinary(t *testing.T) {
 	// Can't run a non-existent binary
 	err := exec.Command("/no-exist-binary").Run()
 	if err == nil {
 		t.Error("expected error from /no-exist-binary")
 	}
 }

 func TestExitStatus(t *testing.T) {
 	// Test that exit values are returned correctly
 	cmd := helperCommand(t, "exit", "42")
 	err := cmd.Run()
 	want := "exit status 42"
 	switch runtime.GOOS {
 	case "plan9":
 		want = fmt.Sprintf("exit status: '%s %d: 42'", filepath.Base(cmd.Path), cmd.ProcessState.Pid())
 	}
 	if werr, ok := err.(*exec.ExitError); ok {
 		if s := werr.Error(); s != want {
 			t.Errorf("from exit 42 got exit %q, want %q", s, want)
 		}
 	} else {
 		t.Fatalf("expected *exec.ExitError from exit 42; got %T: %v", err, err)
 	}
 }

 func TestPipes(t *testing.T) {
 	check := func(what string, err error) {
 		if err != nil {
 			t.Fatalf("%s: %v", what, err)
 		}
 	}
 	// Cat, testing stdin and stdout.
 	c := helperCommand(t, "pipetest")
 	stdin, err := c.StdinPipe()
 	check("StdinPipe", err)
 	stdout, err := c.StdoutPipe()
 	check("StdoutPipe", err)
 	stderr, err := c.StderrPipe()
 	check("StderrPipe", err)

 	outbr := bufio.NewReader(stdout)
 	errbr := bufio.NewReader(stderr)
 	line := func(what string, br *bufio.Reader) string {
 		line, _, err := br.ReadLine()
 		if err != nil {
 			t.Fatalf("%s: %v", what, err)
 		}
 		return string(line)
 	}

 	err = c.Start()
 	check("Start", err)

 	_, err = stdin.Write([]byte("O:I am output\n"))
 	check("first stdin Write", err)
 	if g, e := line("first output line", outbr), "O:I am output"; g != e {
 		t.Errorf("got %q, want %q", g, e)
 	}

 	_, err = stdin.Write([]byte("E:I am error\n"))
 	check("second stdin Write", err)
 	if g, e := line("first error line", errbr), "E:I am error"; g != e {
 		t.Errorf("got %q, want %q", g, e)
 	}

 	_, err = stdin.Write([]byte("O:I am output2\n"))
 	check("third stdin Write 3", err)
 	if g, e := line("second output line", outbr), "O:I am output2"; g != e {
 		t.Errorf("got %q, want %q", g, e)
 	}

 	stdin.Close()
 	err = c.Wait()
 	check("Wait", err)
 }

 const stdinCloseTestString = "Some test string."

 // Issue 6270.
 func TestStdinClose(t *testing.T) {
 	check := func(what string, err error) {
 		if err != nil {
 			t.Fatalf("%s: %v", what, err)
 		}
 	}
 	cmd := helperCommand(t, "stdinClose")
 	stdin, err := cmd.StdinPipe()
 	check("StdinPipe", err)
 	// Check that we can access methods of the underlying os.File.`
 	if _, ok := stdin.(interface {
 		Fd() uintptr
 	}); !ok {
 		t.Error("can't access methods of underlying *os.File")
 	}
 	check("Start", cmd.Start())
 	go func() {
 		_, err := io.Copy(stdin, strings.NewReader(stdinCloseTestString))
 		check("Copy", err)
 		// Before the fix, this next line would race with cmd.Wait.
 		check("Close", stdin.Close())
 	}()
 	check("Wait", cmd.Wait())
 }

 // Issue 5071
 func TestPipeLookPathLeak(t *testing.T) {
 	fd0, lsof0 := numOpenFDS(t)
 	for i := 0; i < 4; i++ {
 		cmd := exec.Command("something-that-does-not-exist-binary")
 		cmd.StdoutPipe()
 		cmd.StderrPipe()
 		cmd.StdinPipe()
 		if err := cmd.Run(); err == nil {
 			t.Fatal("unexpected success")
 		}
 	}
 	for triesLeft := 3; triesLeft >= 0; triesLeft-- {
 		open, lsof := numOpenFDS(t)
 		fdGrowth := open - fd0
 		if fdGrowth > 2 {
 			if triesLeft > 0 {
 				// Work around what appears to be a race with Linux's
 				// proc filesystem (as used by lsof). It seems to only
 				// be eventually consistent. Give it awhile to settle.
 				// See golang.org/issue/7808
 				time.Sleep(100 * time.Millisecond)
 				continue
 			}
 			t.Errorf("leaked %d fds; want ~0; have:\n%s\noriginally:\n%s", fdGrowth, lsof, lsof0)
 		}
 		break
 	}
 }

 func numOpenFDS(t *testing.T) (n int, lsof []byte) {
 	lsof, err := exec.Command("lsof", "-n", "-p", strconv.Itoa(os.Getpid())).Output()
 	if err != nil {
 		t.Skip("skipping test; error finding or running lsof")
 	}
 	return bytes.Count(lsof, []byte("\n")), lsof
 }

 var testedAlreadyLeaked = false

 // basefds returns the number of expected file descriptors
 // to be present in a process at start.
 func basefds() uintptr {
 	n := os.Stderr.Fd() + 1

 	// Go runtime for 32-bit Plan 9 requires that /dev/bintime
 	// be kept open.
 	// See ../../runtime/time_plan9_386.c:/^runtime·nanotime
 	if runtime.GOOS == "plan9" && runtime.GOARCH == "386" {
 		n++
 	}
 	return n
 }

 func closeUnexpectedFds(t *testing.T, m string) {
 	for fd := basefds(); fd <= 101; fd++ {
 		err := os.NewFile(fd, "").Close()
 		if err == nil {
 			t.Logf("%s: Something already leaked - closed fd %d", m, fd)
 		}
 	}
 }

 func TestExtraFilesFDShuffle(t *testing.T) {
 	t.Skip("flaky test; see http://golang.org/issue/5780")
 	switch runtime.GOOS {
 	case "darwin":
 		// TODO(cnicolaou): http://golang.org/issue/2603
 		// leads to leaked file descriptors in this test when it's
 		// run from a builder.
 		closeUnexpectedFds(t, "TestExtraFilesFDShuffle")
 	case "netbsd":
 		// http://golang.org/issue/3955
 		closeUnexpectedFds(t, "TestExtraFilesFDShuffle")
 	case "windows":
 		t.Skip("no operating system support; skipping")
 	}

 	// syscall.StartProcess maps all the FDs passed to it in
 	// ProcAttr.Files (the concatenation of stdin,stdout,stderr and
 	// ExtraFiles) into consecutive FDs in the child, that is:
 	// Files{11, 12, 6, 7, 9, 3} should result in the file
 	// represented by FD 11 in the parent being made available as 0
 	// in the child, 12 as 1, etc.
 	//
 	// We want to test that FDs in the child do not get overwritten
 	// by one another as this shuffle occurs. The original implementation
 	// was buggy in that in some data dependent cases it would ovewrite
 	// stderr in the child with one of the ExtraFile members.
 	// Testing for this case is difficult because it relies on using
 	// the same FD values as that case. In particular, an FD of 3
 	// must be at an index of 4 or higher in ProcAttr.Files and
 	// the FD of the write end of the Stderr pipe (as obtained by
 	// StderrPipe()) must be the same as the size of ProcAttr.Files;
 	// therefore we test that the read end of this pipe (which is what
 	// is returned to the parent by StderrPipe() being one less than
 	// the size of ProcAttr.Files, i.e. 3+len(cmd.ExtraFiles).
 	//
 	// Moving this test case around within the overall tests may
 	// affect the FDs obtained and hence the checks to catch these cases.
 	npipes := 2
 	c := helperCommand(t, "extraFilesAndPipes", strconv.Itoa(npipes+1))
 	rd, wr, _ := os.Pipe()
 	defer rd.Close()
 	if rd.Fd() != 3 {
 		t.Errorf("bad test value for test pipe: fd %d", rd.Fd())
 	}
 	stderr, _ := c.StderrPipe()
 	wr.WriteString("_LAST")
 	wr.Close()

 	pipes := make([]struct {
 		r, w *os.File
 	}, npipes)
 	data := []string{"a", "b"}

 	for i := 0; i < npipes; i++ {
 		r, w, err := os.Pipe()
 		if err != nil {
 			t.Fatalf("unexpected error creating pipe: %s", err)
 		}
 		pipes[i].r = r
 		pipes[i].w = w
 		w.WriteString(data[i])
 		c.ExtraFiles = append(c.ExtraFiles, pipes[i].r)
 		defer func() {
 			r.Close()
 			w.Close()
 		}()
 	}
 	// Put fd 3 at the end.
 	c.ExtraFiles = append(c.ExtraFiles, rd)

 	stderrFd := int(stderr.(*os.File).Fd())
 	if stderrFd != ((len(c.ExtraFiles) + 3) - 1) {
 		t.Errorf("bad test value for stderr pipe")
 	}

 	expected := "child: " + strings.Join(data, "") + "_LAST"

 	err := c.Start()
 	if err != nil {
 		t.Fatalf("Run: %v", err)
 	}
 	ch := make(chan string, 1)
 	go func(ch chan string) {
 		buf := make([]byte, 512)
 		n, err := stderr.Read(buf)
 		if err != nil {
 			t.Fatalf("Read: %s", err)
 			ch <- err.Error()
 		} else {
 			ch <- string(buf[:n])
 		}
 		close(ch)
 	}(ch)
 	select {
 	case m := <-ch:
 		if m != expected {
 			t.Errorf("Read: '%s' not '%s'", m, expected)
 		}
 	case <-time.After(5 * time.Second):
 		t.Errorf("Read timedout")
 	}
 	c.Wait()
 }

 func TestExtraFiles(t *testing.T) {
 	if runtime.GOOS == "windows" {
 		t.Skip("no operating system support; skipping")
 	}

 	// Ensure that file descriptors have not already been leaked into
 	// our environment.
 	if !testedAlreadyLeaked {
 		testedAlreadyLeaked = true
 		closeUnexpectedFds(t, "TestExtraFiles")
 	}

 	// Force network usage, to verify the epoll (or whatever) fd
 	// doesn't leak to the child,
 	ln, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer ln.Close()

 	// Make sure duplicated fds don't leak to the child.
 	f, err := ln.(*net.TCPListener).File()
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer f.Close()
 	ln2, err := net.FileListener(f)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer ln2.Close()

 	// Force TLS root certs to be loaded (which might involve
 	// cgo), to make sure none of that potential C code leaks fds.
 	ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
 	// quiet expected TLS handshake error "remote error: bad certificate"
 	ts.Config.ErrorLog = log.New(ioutil.Discard, "", 0)
 	ts.StartTLS()
 	defer ts.Close()
 	_, err = http.Get(ts.URL)
 	if err == nil {
 		t.Errorf("success trying to fetch %s; want an error", ts.URL)
 	}

 	tf, err := ioutil.TempFile("", "")
 	if err != nil {
 		t.Fatalf("TempFile: %v", err)
 	}
 	defer os.Remove(tf.Name())
 	defer tf.Close()

 	const text = "Hello, fd 3!"
 	_, err = tf.Write([]byte(text))
 	if err != nil {
 		t.Fatalf("Write: %v", err)
 	}
 	_, err = tf.Seek(0, os.SEEK_SET)
 	if err != nil {
 		t.Fatalf("Seek: %v", err)
 	}

 	c := helperCommand(t, "read3")
 	var stdout, stderr bytes.Buffer
 	c.Stdout = &stdout
 	c.Stderr = &stderr
 	c.ExtraFiles = []*os.File{tf}
 	err = c.Run()
 	if err != nil {
 		t.Fatalf("Run: %v; stdout %q, stderr %q", err, stdout.Bytes(), stderr.Bytes())
 	}
 	if stdout.String() != text {
 		t.Errorf("got stdout %q, stderr %q; want %q on stdout", stdout.String(), stderr.String(), text)
 	}
 }

 func TestExtraFilesRace(t *testing.T) {
 	if runtime.GOOS == "windows" {
 		t.Skip("no operating system support; skipping")
 	}
 	listen := func() net.Listener {
 		ln, err := net.Listen("tcp", "127.0.0.1:0")
 		if err != nil {
 			t.Fatal(err)
 		}
 		return ln
 	}
 	listenerFile := func(ln net.Listener) *os.File {
 		f, err := ln.(*net.TCPListener).File()
 		if err != nil {
 			t.Fatal(err)
 		}
 		return f
 	}
 	runCommand := func(c *exec.Cmd, out chan<- string) {
 		bout, err := c.CombinedOutput()
 		if err != nil {
 			out <- "ERROR:" + err.Error()
 		} else {
 			out <- string(bout)
 		}
 	}

 	for i := 0; i < 10; i++ {
 		la := listen()
 		ca := helperCommand(t, "describefiles")
 		ca.ExtraFiles = []*os.File{listenerFile(la)}
 		lb := listen()
 		cb := helperCommand(t, "describefiles")
 		cb.ExtraFiles = []*os.File{listenerFile(lb)}
 		ares := make(chan string)
 		bres := make(chan string)
 		go runCommand(ca, ares)
 		go runCommand(cb, bres)
 		if got, want := <-ares, fmt.Sprintf("fd3: listener %s\n", la.Addr()); got != want {
 			t.Errorf("iteration %d, process A got:\n%s\nwant:\n%s\n", i, got, want)
 		}
 		if got, want := <-bres, fmt.Sprintf("fd3: listener %s\n", lb.Addr()); got != want {
 			t.Errorf("iteration %d, process B got:\n%s\nwant:\n%s\n", i, got, want)
 		}
 		la.Close()
 		lb.Close()
 		for _, f := range ca.ExtraFiles {
 			f.Close()
 		}
 		for _, f := range cb.ExtraFiles {
 			f.Close()
 		}

 	}
 }

 // TestHelperProcess isn't a real test. It's used as a helper process
 // for TestParameterRun.
 func TestHelperProcess(*testing.T) {
 	if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
 		return
 	}
 	defer os.Exit(0)

 	// Determine which command to use to display open files.
 	ofcmd := "lsof"
 	switch runtime.GOOS {
 	case "dragonfly", "freebsd", "netbsd", "openbsd":
 		ofcmd = "fstat"
 	case "plan9":
 		ofcmd = "/bin/cat"
 	}

 	args := os.Args
 	for len(args) > 0 {
 		if args[0] == "--" {
 			args = args[1:]
 			break
 		}
 		args = args[1:]
 	}
 	if len(args) == 0 {
 		fmt.Fprintf(os.Stderr, "No command\n")
 		os.Exit(2)
 	}

 	cmd, args := args[0], args[1:]
 	switch cmd {
 	case "echo":
 		iargs := []interface{}{}
 		for _, s := range args {
 			iargs = append(iargs, s)
 		}
 		fmt.Println(iargs...)
 	case "cat":
 		if len(args) == 0 {
 			io.Copy(os.Stdout, os.Stdin)
 			return
 		}
 		exit := 0
 		for _, fn := range args {
 			f, err := os.Open(fn)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 				exit = 2
 			} else {
 				defer f.Close()
 				io.Copy(os.Stdout, f)
 			}
 		}
 		os.Exit(exit)
 	case "pipetest":
 		bufr := bufio.NewReader(os.Stdin)
 		for {
 			line, _, err := bufr.ReadLine()
 			if err == io.EOF {
 				break
 			} else if err != nil {
 				os.Exit(1)
 			}
 			if bytes.HasPrefix(line, []byte("O:")) {
 				os.Stdout.Write(line)
 				os.Stdout.Write([]byte{'\n'})
 			} else if bytes.HasPrefix(line, []byte("E:")) {
 				os.Stderr.Write(line)
 				os.Stderr.Write([]byte{'\n'})
 			} else {
 				os.Exit(1)
 			}
 		}
 	case "stdinClose":
 		b, err := ioutil.ReadAll(os.Stdin)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 			os.Exit(1)
 		}
 		if s := string(b); s != stdinCloseTestString {
 			fmt.Fprintf(os.Stderr, "Error: Read %q, want %q", s, stdinCloseTestString)
 			os.Exit(1)
 		}
 		os.Exit(0)
 	case "read3": // read fd 3
 		fd3 := os.NewFile(3, "fd3")
 		bs, err := ioutil.ReadAll(fd3)
 		if err != nil {
 			fmt.Printf("ReadAll from fd 3: %v", err)
 			os.Exit(1)
 		}
 		switch runtime.GOOS {
 		case "dragonfly":
 			// TODO(jsing): Determine why DragonFly is leaking
 			// file descriptors...
 		case "darwin":
 			// TODO(bradfitz): broken? Sometimes.
 			// http://golang.org/issue/2603
 			// Skip this additional part of the test for now.
 		case "netbsd":
 			// TODO(jsing): This currently fails on NetBSD due to
 			// the cloned file descriptors that result from opening
 			// /dev/urandom.
 			// http://golang.org/issue/3955
 		case "plan9":
 			// TODO(0intro): Determine why Plan 9 is leaking
 			// file descriptors.
 			// http://golang.org/issue/7118
 		case "solaris":
 			// TODO(aram): This fails on Solaris because libc opens
 			// its own files, as it sees fit. Darwin does the same,
 			// see: http://golang.org/issue/2603
 		default:
 			// Now verify that there are no other open fds.
 			var files []*os.File
 			for wantfd := basefds() + 1; wantfd <= 100; wantfd++ {
 				f, err := os.Open(os.Args[0])
 				if err != nil {
 					fmt.Printf("error opening file with expected fd %d: %v", wantfd, err)
 					os.Exit(1)
 				}
 				if got := f.Fd(); got != wantfd {
 					fmt.Printf("leaked parent file. fd = %d; want %d\n", got, wantfd)
 					var args []string
 					switch runtime.GOOS {
 					case "plan9":
 						args = []string{fmt.Sprintf("/proc/%d/fd", os.Getpid())}
 					default:
 						args = []string{"-p", fmt.Sprint(os.Getpid())}
 					}
 					out, _ := exec.Command(ofcmd, args...).CombinedOutput()
 					fmt.Print(string(out))
 					os.Exit(1)
 				}
 				files = append(files, f)
 			}
 			for _, f := range files {
 				f.Close()
 			}
 		}
 		// Referring to fd3 here ensures that it is not
 		// garbage collected, and therefore closed, while
 		// executing the wantfd loop above.  It doesn't matter
 		// what we do with fd3 as long as we refer to it;
 		// closing it is the easy choice.
 		fd3.Close()
 		os.Stdout.Write(bs)
 	case "exit":
 		n, _ := strconv.Atoi(args[0])
 		os.Exit(n)
 	case "describefiles":
 		f := os.NewFile(3, fmt.Sprintf("fd3"))
 		ln, err := net.FileListener(f)
 		if err == nil {
 			fmt.Printf("fd3: listener %s\n", ln.Addr())
 			ln.Close()
 		}
 		os.Exit(0)
 	case "extraFilesAndPipes":
 		n, _ := strconv.Atoi(args[0])
 		pipes := make([]*os.File, n)
 		for i := 0; i < n; i++ {
 			pipes[i] = os.NewFile(uintptr(3+i), strconv.Itoa(i))
 		}
 		response := ""
 		for i, r := range pipes {
 			ch := make(chan string, 1)
 			go func(c chan string) {
 				buf := make([]byte, 10)
 				n, err := r.Read(buf)
 				if err != nil {
 					fmt.Fprintf(os.Stderr, "Child: read error: %v on pipe %d\n", err, i)
 					os.Exit(1)
 				}
 				c <- string(buf[:n])
 				close(c)
 			}(ch)
 			select {
 			case m := <-ch:
 				response = response + m
 			case <-time.After(5 * time.Second):
 				fmt.Fprintf(os.Stderr, "Child: Timeout reading from pipe: %d\n", i)
 				os.Exit(1)
 			}
 		}
 		fmt.Fprintf(os.Stderr, "child: %s", response)
 		os.Exit(0)
 	case "exec":
 		cmd := exec.Command(args[1])
 		cmd.Dir = args[0]
 		output, err := cmd.CombinedOutput()
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Child: %s %s", err, string(output))
 			os.Exit(1)
 		}
 		fmt.Printf("%s", string(output))
 		os.Exit(0)
 	case "lookpath":
 		p, err := exec.LookPath(args[0])
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "LookPath failed: %v\n", err)
 			os.Exit(1)
 		}
 		fmt.Print(p)
 		os.Exit(0)
 	default:
 		fmt.Fprintf(os.Stderr, "Unknown command %q\n", cmd)
 		os.Exit(2)
 	}
 }
	// Copyright 2009 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Use an external test to avoid os/exec -> net/http -> crypto/x509 -> os/exec
	// circular dependency on non-cgo darwin.

	package exec_test

	import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"testing"
	"time"
	)

	func helperCommand(t testing.T, s ...string) exec.Cmd {
	if runtime.GOOS == "nacl" {
	t.Skip("skipping on nacl")
	}
	cs := []string{"-test.run=TestHelperProcess", "--"}
	cs = append(cs, s...)
	cmd := exec.Command(os.Args[0], cs...)
	cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}
	return cmd
	}

	func TestEcho(t *testing.T) {
	bs, err := helperCommand(t, "echo", "foo bar", "baz").Output()
	if err != nil {
	t.Errorf("echo: %v", err)
	}
	if g, e := string(bs), "foo bar baz\n"; g != e {
	t.Errorf("echo: want %q, got %q", e, g)
	}
	}

	func TestCommandRelativeName(t *testing.T) {
	// Run our own binary as a relative path
	// (e.g. "_test/exec.test") our parent directory.
	base := filepath.Base(os.Args[0]) // "exec.test"
	dir := filepath.Dir(os.Args[0]) // "/tmp/go-buildNNNN/os/exec/_test"
	if dir == "." {
	t.Skip("skipping; running test at root somehow")
	}
	parentDir := filepath.Dir(dir) // "/tmp/go-buildNNNN/os/exec"
	dirBase := filepath.Base(dir) // "_test"
	if dirBase == "." {
	t.Skipf("skipping; unexpected shallow dir of %q", dir)
	}

	cmd := exec.Command(filepath.Join(dirBase, base), "-test.run=TestHelperProcess", "--", "echo", "foo")
	cmd.Dir = parentDir
	cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}

	out, err := cmd.Output()
	if err != nil {
	t.Errorf("echo: %v", err)
	}
	if g, e := string(out), "foo\n"; g != e {
	t.Errorf("echo: want %q, got %q", e, g)
	}
	}

	func TestCatStdin(t *testing.T) {
	// Cat, testing stdin and stdout.
	input := "Input string\nLine 2"
	p := helperCommand(t, "cat")
	p.Stdin = strings.NewReader(input)
	bs, err := p.Output()
	if err != nil {
	t.Errorf("cat: %v", err)
	}
	s := string(bs)
	if s != input {
	t.Errorf("cat: want %q, got %q", input, s)
	}
	}

	func TestCatGoodAndBadFile(t *testing.T) {
	// Testing combined output and error values.
	bs, err := helperCommand(t, "cat", "/bogus/file.foo", "exec_test.go").CombinedOutput()
	if _, ok := err.(*exec.ExitError); !ok {
	t.Errorf("expected *exec.ExitError from cat combined; got %T: %v", err, err)
	}
	s := string(bs)
	sp := strings.SplitN(s, "\n", 2)
	if len(sp) != 2 {
	t.Fatalf("expected two lines from cat; got %q", s)
	}
	errLine, body := sp[0], sp[1]
	if !strings.HasPrefix(errLine, "Error: open /bogus/file.foo") {
	t.Errorf("expected stderr to complain about file; got %q", errLine)
	}
	if !strings.Contains(body, "func TestHelperProcess(t *testing.T)") {
	t.Errorf("expected test code; got %q (len %d)", body, len(body))
	}
	}

	func TestNoExistBinary(t *testing.T) {
	// Can't run a non-existent binary
	err := exec.Command("/no-exist-binary").Run()
	if err == nil {
	t.Error("expected error from /no-exist-binary")
	}
	}

	func TestExitStatus(t *testing.T) {
	// Test that exit values are returned correctly
	cmd := helperCommand(t, "exit", "42")
	err := cmd.Run()
	want := "exit status 42"
	switch runtime.GOOS {
	case "plan9":
	want = fmt.Sprintf("exit status: '%s %d: 42'", filepath.Base(cmd.Path), cmd.ProcessState.Pid())
	}
	if werr, ok := err.(*exec.ExitError); ok {
	if s := werr.Error(); s != want {
	t.Errorf("from exit 42 got exit %q, want %q", s, want)
	}
	} else {
	t.Fatalf("expected *exec.ExitError from exit 42; got %T: %v", err, err)
	}
	}

	func TestPipes(t *testing.T) {
	check := func(what string, err error) {
	if err != nil {
	t.Fatalf("%s: %v", what, err)
	}
	}
	// Cat, testing stdin and stdout.
	c := helperCommand(t, "pipetest")
	stdin, err := c.StdinPipe()
	check("StdinPipe", err)
	stdout, err := c.StdoutPipe()
	check("StdoutPipe", err)
	stderr, err := c.StderrPipe()
	check("StderrPipe", err)

	outbr := bufio.NewReader(stdout)
	errbr := bufio.NewReader(stderr)
	line := func(what string, br *bufio.Reader) string {
	line, _, err := br.ReadLine()
	if err != nil {
	t.Fatalf("%s: %v", what, err)
	}
	return string(line)
	}

	err = c.Start()
	check("Start", err)

	_, err = stdin.Write([]byte("O:I am output\n"))
	check("first stdin Write", err)
	if g, e := line("first output line", outbr), "O:I am output"; g != e {
	t.Errorf("got %q, want %q", g, e)
	}

	_, err = stdin.Write([]byte("E:I am error\n"))
	check("second stdin Write", err)
	if g, e := line("first error line", errbr), "E:I am error"; g != e {
	t.Errorf("got %q, want %q", g, e)
	}

	_, err = stdin.Write([]byte("O:I am output2\n"))
	check("third stdin Write 3", err)
	if g, e := line("second output line", outbr), "O:I am output2"; g != e {
	t.Errorf("got %q, want %q", g, e)
	}

	stdin.Close()
	err = c.Wait()
	check("Wait", err)
	}

	const stdinCloseTestString = "Some test string."

	// Issue 6270.
	func TestStdinClose(t *testing.T) {
	check := func(what string, err error) {
	if err != nil {
	t.Fatalf("%s: %v", what, err)
	}
	}
	cmd := helperCommand(t, "stdinClose")
	stdin, err := cmd.StdinPipe()
	check("StdinPipe", err)
	// Check that we can access methods of the underlying os.File.`
	if _, ok := stdin.(interface {
	Fd() uintptr
	}); !ok {
	t.Error("can't access methods of underlying *os.File")
	}
	check("Start", cmd.Start())
	go func() {
	_, err := io.Copy(stdin, strings.NewReader(stdinCloseTestString))
	check("Copy", err)
	// Before the fix, this next line would race with cmd.Wait.
	check("Close", stdin.Close())
	}()
	check("Wait", cmd.Wait())
	}

	// Issue 5071
	func TestPipeLookPathLeak(t *testing.T) {
	fd0, lsof0 := numOpenFDS(t)
	for i := 0; i < 4; i++ {
	cmd := exec.Command("something-that-does-not-exist-binary")
	cmd.StdoutPipe()
	cmd.StderrPipe()
	cmd.StdinPipe()
	if err := cmd.Run(); err == nil {
	t.Fatal("unexpected success")
	}
	}
	for triesLeft := 3; triesLeft >= 0; triesLeft-- {
	open, lsof := numOpenFDS(t)
	fdGrowth := open - fd0
	if fdGrowth > 2 {
	if triesLeft > 0 {
	// Work around what appears to be a race with Linux's
	// proc filesystem (as used by lsof). It seems to only
	// be eventually consistent. Give it awhile to settle.
	// See golang.org/issue/7808
	time.Sleep(100 * time.Millisecond)
	continue
	}
	t.Errorf("leaked %d fds; want ~0; have:\n%s\noriginally:\n%s", fdGrowth, lsof, lsof0)
	}
	break
	}
	}

	func numOpenFDS(t *testing.T) (n int, lsof []byte) {
	lsof, err := exec.Command("lsof", "-n", "-p", strconv.Itoa(os.Getpid())).Output()
	if err != nil {
	t.Skip("skipping test; error finding or running lsof")
	}
	return bytes.Count(lsof, []byte("\n")), lsof
	}

	var testedAlreadyLeaked = false

	// basefds returns the number of expected file descriptors
	// to be present in a process at start.
	func basefds() uintptr {
	n := os.Stderr.Fd() + 1

	// Go runtime for 32-bit Plan 9 requires that /dev/bintime
	// be kept open.
	// See ../../runtime/time_plan9_386.c:/^runtime·nanotime
	if runtime.GOOS == "plan9" && runtime.GOARCH == "386" {
	n++
	}
	return n
	}

	func closeUnexpectedFds(t *testing.T, m string) {
	for fd := basefds(); fd <= 101; fd++ {
	err := os.NewFile(fd, "").Close()
	if err == nil {
	t.Logf("%s: Something already leaked - closed fd %d", m, fd)
	}
	}
	}

	func TestExtraFilesFDShuffle(t *testing.T) {
	t.Skip("flaky test; see http://golang.org/issue/5780")
	switch runtime.GOOS {
	case "darwin":
	// TODO(cnicolaou): http://golang.org/issue/2603
	// leads to leaked file descriptors in this test when it's
	// run from a builder.
	closeUnexpectedFds(t, "TestExtraFilesFDShuffle")
	case "netbsd":
	// http://golang.org/issue/3955
	closeUnexpectedFds(t, "TestExtraFilesFDShuffle")
	case "windows":
	t.Skip("no operating system support; skipping")
	}

	// syscall.StartProcess maps all the FDs passed to it in
	// ProcAttr.Files (the concatenation of stdin,stdout,stderr and
	// ExtraFiles) into consecutive FDs in the child, that is:
	// Files{11, 12, 6, 7, 9, 3} should result in the file
	// represented by FD 11 in the parent being made available as 0
	// in the child, 12 as 1, etc.
	//
	// We want to test that FDs in the child do not get overwritten
	// by one another as this shuffle occurs. The original implementation
	// was buggy in that in some data dependent cases it would ovewrite
	// stderr in the child with one of the ExtraFile members.
	// Testing for this case is difficult because it relies on using
	// the same FD values as that case. In particular, an FD of 3
	// must be at an index of 4 or higher in ProcAttr.Files and
	// the FD of the write end of the Stderr pipe (as obtained by
	// StderrPipe()) must be the same as the size of ProcAttr.Files;
	// therefore we test that the read end of this pipe (which is what
	// is returned to the parent by StderrPipe() being one less than
	// the size of ProcAttr.Files, i.e. 3+len(cmd.ExtraFiles).
	//
	// Moving this test case around within the overall tests may
	// affect the FDs obtained and hence the checks to catch these cases.
	npipes := 2
	c := helperCommand(t, "extraFilesAndPipes", strconv.Itoa(npipes+1))
	rd, wr, _ := os.Pipe()
	defer rd.Close()
	if rd.Fd() != 3 {
	t.Errorf("bad test value for test pipe: fd %d", rd.Fd())
	}
	stderr, _ := c.StderrPipe()
	wr.WriteString("_LAST")
	wr.Close()

	pipes := make([]struct {
	r, w *os.File
	}, npipes)
	data := []string{"a", "b"}

	for i := 0; i < npipes; i++ {
	r, w, err := os.Pipe()
	if err != nil {
	t.Fatalf("unexpected error creating pipe: %s", err)
	}
	pipes[i].r = r
	pipes[i].w = w
	w.WriteString(data[i])
	c.ExtraFiles = append(c.ExtraFiles, pipes[i].r)
	defer func() {
	r.Close()
	w.Close()
	}()
	}
	// Put fd 3 at the end.
	c.ExtraFiles = append(c.ExtraFiles, rd)

	stderrFd := int(stderr.(*os.File).Fd())
	if stderrFd != ((len(c.ExtraFiles) + 3) - 1) {
	t.Errorf("bad test value for stderr pipe")
	}

	expected := "child: " + strings.Join(data, "") + "_LAST"

	err := c.Start()
	if err != nil {
	t.Fatalf("Run: %v", err)
	}
	ch := make(chan string, 1)
	go func(ch chan string) {
	buf := make([]byte, 512)
	n, err := stderr.Read(buf)
	if err != nil {
	t.Fatalf("Read: %s", err)
	ch <- err.Error()
	} else {
	ch <- string(buf[:n])
	}
	close(ch)
	}(ch)
	select {
	case m := <-ch:
	if m != expected {
	t.Errorf("Read: '%s' not '%s'", m, expected)
	}
	case <-time.After(5 * time.Second):
	t.Errorf("Read timedout")
	}
	c.Wait()
	}

	func TestExtraFiles(t *testing.T) {
	if runtime.GOOS == "windows" {
	t.Skip("no operating system support; skipping")
	}

	// Ensure that file descriptors have not already been leaked into
	// our environment.
	if !testedAlreadyLeaked {
	testedAlreadyLeaked = true
	closeUnexpectedFds(t, "TestExtraFiles")
	}

	// Force network usage, to verify the epoll (or whatever) fd
	// doesn't leak to the child,
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
	t.Fatal(err)
	}
	defer ln.Close()

	// Make sure duplicated fds don't leak to the child.
	f, err := ln.(*net.TCPListener).File()
	if err != nil {
	t.Fatal(err)
	}
	defer f.Close()
	ln2, err := net.FileListener(f)
	if err != nil {
	t.Fatal(err)
	}
	defer ln2.Close()

	// Force TLS root certs to be loaded (which might involve
	// cgo), to make sure none of that potential C code leaks fds.
	ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
	// quiet expected TLS handshake error "remote error: bad certificate"
	ts.Config.ErrorLog = log.New(ioutil.Discard, "", 0)
	ts.StartTLS()
	defer ts.Close()
	_, err = http.Get(ts.URL)
	if err == nil {
	t.Errorf("success trying to fetch %s; want an error", ts.URL)
	}

	tf, err := ioutil.TempFile("", "")
	if err != nil {
	t.Fatalf("TempFile: %v", err)
	}
	defer os.Remove(tf.Name())
	defer tf.Close()

	const text = "Hello, fd 3!"
	_, err = tf.Write([]byte(text))
	if err != nil {
	t.Fatalf("Write: %v", err)
	}
	_, err = tf.Seek(0, os.SEEK_SET)
	if err != nil {
	t.Fatalf("Seek: %v", err)
	}

	c := helperCommand(t, "read3")
	var stdout, stderr bytes.Buffer
	c.Stdout = &stdout
	c.Stderr = &stderr
	c.ExtraFiles = []*os.File{tf}
	err = c.Run()
	if err != nil {
	t.Fatalf("Run: %v; stdout %q, stderr %q", err, stdout.Bytes(), stderr.Bytes())
	}
	if stdout.String() != text {
	t.Errorf("got stdout %q, stderr %q; want %q on stdout", stdout.String(), stderr.String(), text)
	}
	}

	func TestExtraFilesRace(t *testing.T) {
	if runtime.GOOS == "windows" {
	t.Skip("no operating system support; skipping")
	}
	listen := func() net.Listener {
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
	t.Fatal(err)
	}
	return ln
	}
	listenerFile := func(ln net.Listener) *os.File {
	f, err := ln.(*net.TCPListener).File()
	if err != nil {
	t.Fatal(err)
	}
	return f
	}
	runCommand := func(c *exec.Cmd, out chan<- string) {
	bout, err := c.CombinedOutput()
	if err != nil {
	out <- "ERROR:" + err.Error()
	} else {
	out <- string(bout)
	}
	}

	for i := 0; i < 10; i++ {
	la := listen()
	ca := helperCommand(t, "describefiles")
	ca.ExtraFiles = []*os.File{listenerFile(la)}
	lb := listen()
	cb := helperCommand(t, "describefiles")
	cb.ExtraFiles = []*os.File{listenerFile(lb)}
	ares := make(chan string)
	bres := make(chan string)
	go runCommand(ca, ares)
	go runCommand(cb, bres)
	if got, want := <-ares, fmt.Sprintf("fd3: listener %s\n", la.Addr()); got != want {
	t.Errorf("iteration %d, process A got:\n%s\nwant:\n%s\n", i, got, want)
	}
	if got, want := <-bres, fmt.Sprintf("fd3: listener %s\n", lb.Addr()); got != want {
	t.Errorf("iteration %d, process B got:\n%s\nwant:\n%s\n", i, got, want)
	}
	la.Close()
	lb.Close()
	for _, f := range ca.ExtraFiles {
	f.Close()
	}
	for _, f := range cb.ExtraFiles {
	f.Close()
	}

	}
	}

	// TestHelperProcess isn't a real test. It's used as a helper process
	// for TestParameterRun.
	func TestHelperProcess(*testing.T) {
	if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
	return
	}
	defer os.Exit(0)

	// Determine which command to use to display open files.
	ofcmd := "lsof"
	switch runtime.GOOS {
	case "dragonfly", "freebsd", "netbsd", "openbsd":
	ofcmd = "fstat"
	case "plan9":
	ofcmd = "/bin/cat"
	}

	args := os.Args
	for len(args) > 0 {
	if args[0] == "--" {
	args = args[1:]
	break
	}
	args = args[1:]
	}
	if len(args) == 0 {
	fmt.Fprintf(os.Stderr, "No command\n")
	os.Exit(2)
	}

	cmd, args := args[0], args[1:]
	switch cmd {
	case "echo":
	iargs := []interface{}{}
	for _, s := range args {
	iargs = append(iargs, s)
	}
	fmt.Println(iargs...)
	case "cat":
	if len(args) == 0 {
	io.Copy(os.Stdout, os.Stdin)
	return
	}
	exit := 0
	for _, fn := range args {
	f, err := os.Open(fn)
	if err != nil {
	fmt.Fprintf(os.Stderr, "Error: %v\n", err)
	exit = 2
	} else {
	defer f.Close()
	io.Copy(os.Stdout, f)
	}
	}
	os.Exit(exit)
	case "pipetest":
	bufr := bufio.NewReader(os.Stdin)
	for {
	line, _, err := bufr.ReadLine()
	if err == io.EOF {
	break
	} else if err != nil {
	os.Exit(1)
	}
	if bytes.HasPrefix(line, []byte("O:")) {
	os.Stdout.Write(line)
	os.Stdout.Write([]byte{'\n'})
	} else if bytes.HasPrefix(line, []byte("E:")) {
	os.Stderr.Write(line)
	os.Stderr.Write([]byte{'\n'})
	} else {
	os.Exit(1)
	}
	}
	case "stdinClose":
	b, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
	fmt.Fprintf(os.Stderr, "Error: %v\n", err)
	os.Exit(1)
	}
	if s := string(b); s != stdinCloseTestString {
	fmt.Fprintf(os.Stderr, "Error: Read %q, want %q", s, stdinCloseTestString)
	os.Exit(1)
	}
	os.Exit(0)
	case "read3": // read fd 3
	fd3 := os.NewFile(3, "fd3")
	bs, err := ioutil.ReadAll(fd3)
	if err != nil {
	fmt.Printf("ReadAll from fd 3: %v", err)
	os.Exit(1)
	}
	switch runtime.GOOS {
	case "dragonfly":
	// TODO(jsing): Determine why DragonFly is leaking
	// file descriptors...
	case "darwin":
	// TODO(bradfitz): broken? Sometimes.
	// http://golang.org/issue/2603
	// Skip this additional part of the test for now.
	case "netbsd":
	// TODO(jsing): This currently fails on NetBSD due to
	// the cloned file descriptors that result from opening
	// /dev/urandom.
	// http://golang.org/issue/3955
	case "plan9":
	// TODO(0intro): Determine why Plan 9 is leaking
	// file descriptors.
	// http://golang.org/issue/7118
	case "solaris":
	// TODO(aram): This fails on Solaris because libc opens
	// its own files, as it sees fit. Darwin does the same,
	// see: http://golang.org/issue/2603
	default:
	// Now verify that there are no other open fds.
	var files []*os.File
	for wantfd := basefds() + 1; wantfd <= 100; wantfd++ {
	f, err := os.Open(os.Args[0])
	if err != nil {
	fmt.Printf("error opening file with expected fd %d: %v", wantfd, err)
	os.Exit(1)
	}
	if got := f.Fd(); got != wantfd {
	fmt.Printf("leaked parent file. fd = %d; want %d\n", got, wantfd)
	var args []string
	switch runtime.GOOS {
	case "plan9":
	args = []string{fmt.Sprintf("/proc/%d/fd", os.Getpid())}
	default:
	args = []string{"-p", fmt.Sprint(os.Getpid())}
	}
	out, _ := exec.Command(ofcmd, args...).CombinedOutput()
	fmt.Print(string(out))
	os.Exit(1)
	}
	files = append(files, f)
	}
	for _, f := range files {
	f.Close()
	}
	}
	// Referring to fd3 here ensures that it is not
	// garbage collected, and therefore closed, while
	// executing the wantfd loop above. It doesn't matter
	// what we do with fd3 as long as we refer to it;
	// closing it is the easy choice.
	fd3.Close()
	os.Stdout.Write(bs)
	case "exit":
	n, _ := strconv.Atoi(args[0])
	os.Exit(n)
	case "describefiles":
	f := os.NewFile(3, fmt.Sprintf("fd3"))
	ln, err := net.FileListener(f)
	if err == nil {
	fmt.Printf("fd3: listener %s\n", ln.Addr())
	ln.Close()
	}
	os.Exit(0)
	case "extraFilesAndPipes":
	n, _ := strconv.Atoi(args[0])
	pipes := make([]*os.File, n)
	for i := 0; i < n; i++ {
	pipes[i] = os.NewFile(uintptr(3+i), strconv.Itoa(i))
	}
	response := ""
	for i, r := range pipes {
	ch := make(chan string, 1)
	go func(c chan string) {
	buf := make([]byte, 10)
	n, err := r.Read(buf)
	if err != nil {
	fmt.Fprintf(os.Stderr, "Child: read error: %v on pipe %d\n", err, i)
	os.Exit(1)
	}
	c <- string(buf[:n])
	close(c)
	}(ch)
	select {
	case m := <-ch:
	response = response + m
	case <-time.After(5 * time.Second):
	fmt.Fprintf(os.Stderr, "Child: Timeout reading from pipe: %d\n", i)
	os.Exit(1)
	}
	}
	fmt.Fprintf(os.Stderr, "child: %s", response)
	os.Exit(0)
	case "exec":
	cmd := exec.Command(args[1])
	cmd.Dir = args[0]
	output, err := cmd.CombinedOutput()
	if err != nil {
	fmt.Fprintf(os.Stderr, "Child: %s %s", err, string(output))
	os.Exit(1)
	}
	fmt.Printf("%s", string(output))
	os.Exit(0)
	case "lookpath":
	p, err := exec.LookPath(args[0])
	if err != nil {
	fmt.Fprintf(os.Stderr, "LookPath failed: %v\n", err)
	os.Exit(1)
	}
	fmt.Print(p)
	os.Exit(0)
	default:
	fmt.Fprintf(os.Stderr, "Unknown command %q\n", cmd)
	os.Exit(2)
	}
	}