blob: f90066cea3122bab263eb983ade8b03d5cb254cc [file] [log] [blame]
// 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"
"context"
"fmt"
"internal/poll"
"internal/testenv"
"io"
"log"
"net"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"os/exec/internal/fdtest"
"path/filepath"
"reflect"
"runtime"
"strconv"
"strings"
"testing"
"time"
)
// haveUnexpectedFDs is set at init time to report whether any file descriptors
// were open at program start.
var haveUnexpectedFDs bool
func init() {
if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" {
return
}
if runtime.GOOS == "windows" {
return
}
for fd := uintptr(3); fd <= 100; fd++ {
if poll.IsPollDescriptor(fd) {
continue
}
if fdtest.Exists(fd) {
haveUnexpectedFDs = true
return
}
}
}
func helperCommandContext(t *testing.T, ctx context.Context, s ...string) (cmd *exec.Cmd) {
testenv.MustHaveExec(t)
// Use os.Executable instead of os.Args[0] in case the caller modifies
// cmd.Dir: if the test binary is invoked like "./exec.test", it should
// not fail spuriously.
exe, err := os.Executable()
if err != nil {
t.Fatal(err)
}
cs := []string{"-test.run=TestHelperProcess", "--"}
cs = append(cs, s...)
if ctx != nil {
cmd = exec.CommandContext(ctx, exe, cs...)
} else {
cmd = exec.Command(exe, cs...)
}
cmd.Env = append(os.Environ(), "GO_WANT_HELPER_PROCESS=1")
return cmd
}
func helperCommand(t *testing.T, s ...string) *exec.Cmd {
return helperCommandContext(t, nil, s...)
}
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) {
testenv.MustHaveExec(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 TestEchoFileRace(t *testing.T) {
cmd := helperCommand(t, "echo")
stdin, err := cmd.StdinPipe()
if err != nil {
t.Fatalf("StdinPipe: %v", err)
}
if err := cmd.Start(); err != nil {
t.Fatalf("Start: %v", err)
}
wrote := make(chan bool)
go func() {
defer close(wrote)
fmt.Fprint(stdin, "echo\n")
}()
if err := cmd.Wait(); err != nil {
t.Fatalf("Wait: %v", err)
}
<-wrote
}
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)
}
errLine, body, ok := strings.Cut(string(bs), "\n")
if !ok {
t.Fatalf("expected two lines from cat; got %q", bs)
}
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 TestNoExistExecutable(t *testing.T) {
// Can't run a non-existent executable
err := exec.Command("/no-exist-executable").Run()
if err == nil {
t.Error("expected error from /no-exist-executable")
}
}
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 TestExitCode(t *testing.T) {
// Test that exit code are returned correctly
cmd := helperCommand(t, "exit", "42")
cmd.Run()
want := 42
if runtime.GOOS == "plan9" {
want = 1
}
got := cmd.ProcessState.ExitCode()
if want != got {
t.Errorf("ExitCode got %d, want %d", got, want)
}
cmd = helperCommand(t, "/no-exist-executable")
cmd.Run()
want = 2
if runtime.GOOS == "plan9" {
want = 1
}
got = cmd.ProcessState.ExitCode()
if want != got {
t.Errorf("ExitCode got %d, want %d", got, want)
}
cmd = helperCommand(t, "exit", "255")
cmd.Run()
want = 255
if runtime.GOOS == "plan9" {
want = 1
}
got = cmd.ProcessState.ExitCode()
if want != got {
t.Errorf("ExitCode got %d, want %d", got, want)
}
cmd = helperCommand(t, "cat")
cmd.Run()
want = 0
got = cmd.ProcessState.ExitCode()
if want != got {
t.Errorf("ExitCode got %d, want %d", got, want)
}
// Test when command does not call Run().
cmd = helperCommand(t, "cat")
want = -1
got = cmd.ProcessState.ExitCode()
if want != got {
t.Errorf("ExitCode got %d, want %d", got, want)
}
}
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 17647.
// It used to be the case that TestStdinClose, above, would fail when
// run under the race detector. This test is a variant of TestStdinClose
// that also used to fail when run under the race detector.
// This test is run by cmd/dist under the race detector to verify that
// the race detector no longer reports any problems.
func TestStdinCloseRace(t *testing.T) {
cmd := helperCommand(t, "stdinClose")
stdin, err := cmd.StdinPipe()
if err != nil {
t.Fatalf("StdinPipe: %v", err)
}
if err := cmd.Start(); err != nil {
t.Fatalf("Start: %v", err)
}
go func() {
// We don't check the error return of Kill. It is
// possible that the process has already exited, in
// which case Kill will return an error "process
// already finished". The purpose of this test is to
// see whether the race detector reports an error; it
// doesn't matter whether this Kill succeeds or not.
cmd.Process.Kill()
}()
go func() {
// Send the wrong string, so that the child fails even
// if the other goroutine doesn't manage to kill it first.
// This test is to check that the race detector does not
// falsely report an error, so it doesn't matter how the
// child process fails.
io.Copy(stdin, strings.NewReader("unexpected string"))
if err := stdin.Close(); err != nil {
t.Errorf("stdin.Close: %v", err)
}
}()
if err := cmd.Wait(); err == nil {
t.Fatalf("Wait: succeeded unexpectedly")
}
}
// Issue 5071
func TestPipeLookPathLeak(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("we don't currently suppore counting open handles on windows")
}
openFDs := func() []uintptr {
var fds []uintptr
for i := uintptr(0); i < 100; i++ {
if fdtest.Exists(i) {
fds = append(fds, i)
}
}
return fds
}
want := openFDs()
for i := 0; i < 6; i++ {
cmd := exec.Command("something-that-does-not-exist-executable")
cmd.StdoutPipe()
cmd.StderrPipe()
cmd.StdinPipe()
if err := cmd.Run(); err == nil {
t.Fatal("unexpected success")
}
}
got := openFDs()
if !reflect.DeepEqual(got, want) {
t.Errorf("set of open file descriptors changed: got %v, want %v", got, want)
}
}
func TestExtraFilesFDShuffle(t *testing.T) {
testenv.SkipFlaky(t, 5780)
switch runtime.GOOS {
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 overwrite
// 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.Errorf("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 haveUnexpectedFDs {
// The point of this test is to make sure that any
// descriptors we open are marked close-on-exec.
// If haveUnexpectedFDs is true then there were other
// descriptors open when we started the test,
// so those descriptors are clearly not close-on-exec,
// and they will confuse the test. We could modify
// the test to expect those descriptors to remain open,
// but since we don't know where they came from or what
// they are doing, that seems fragile. For example,
// perhaps they are from the startup code on this
// system for some reason. Also, this test is not
// system-specific; as long as most systems do not skip
// the test, we will still be testing what we care about.
t.Skip("skipping test because test was run with FDs open")
}
testenv.MustHaveExec(t)
testenv.MustHaveGoBuild(t)
// This test runs with cgo disabled. External linking needs cgo, so
// it doesn't work if external linking is required.
testenv.MustInternalLink(t)
if runtime.GOOS == "windows" {
t.Skipf("skipping test on %q", runtime.GOOS)
}
// 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(io.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 := os.CreateTemp("", "")
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, io.SeekStart)
if err != nil {
t.Fatalf("Seek: %v", err)
}
tempdir := t.TempDir()
exe := filepath.Join(tempdir, "read3.exe")
c := exec.Command(testenv.GoToolPath(t), "build", "-o", exe, "read3.go")
// Build the test without cgo, so that C library functions don't
// open descriptors unexpectedly. See issue 25628.
c.Env = append(os.Environ(), "CGO_ENABLED=0")
if output, err := c.CombinedOutput(); err != nil {
t.Logf("go build -o %s read3.go\n%s", exe, output)
t.Fatalf("go build failed: %v", err)
}
// Use a deadline to try to get some output even if the program hangs.
ctx := context.Background()
if deadline, ok := t.Deadline(); ok {
// Leave a 20% grace period to flush output, which may be large on the
// linux/386 builders because we're running the subprocess under strace.
deadline = deadline.Add(-time.Until(deadline) / 5)
var cancel context.CancelFunc
ctx, cancel = context.WithDeadline(ctx, deadline)
defer cancel()
}
c = exec.CommandContext(ctx, exe)
var stdout, stderr bytes.Buffer
c.Stdout = &stdout
c.Stderr = &stderr
c.ExtraFiles = []*os.File{tf}
if runtime.GOOS == "illumos" {
// Some facilities in illumos are implemented via access
// to /proc by libc; such accesses can briefly occupy a
// low-numbered fd. If this occurs concurrently with the
// test that checks for leaked descriptors, the check can
// become confused and report a spurious leaked descriptor.
// (See issue #42431 for more detailed analysis.)
//
// Attempt to constrain the use of additional threads in the
// child process to make this test less flaky:
c.Env = append(os.Environ(), "GOMAXPROCS=1")
}
err = c.Run()
if err != nil {
t.Fatalf("Run: %v\n--- stdout:\n%s--- stderr:\n%s", 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++ {
if testing.Short() && i >= 3 {
break
}
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)
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 := []any{}
for _, s := range args {
iargs = append(iargs, s)
}
fmt.Println(iargs...)
case "echoenv":
for _, s := range args {
fmt.Println(os.Getenv(s))
}
os.Exit(0)
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 := io.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 "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)
case "stderrfail":
fmt.Fprintf(os.Stderr, "some stderr text\n")
os.Exit(1)
case "sleep":
time.Sleep(3 * time.Second)
os.Exit(0)
case "pipehandle":
handle, _ := strconv.ParseUint(args[0], 16, 64)
pipe := os.NewFile(uintptr(handle), "")
_, err := fmt.Fprint(pipe, args[1])
if err != nil {
fmt.Fprintf(os.Stderr, "writing to pipe failed: %v\n", err)
os.Exit(1)
}
pipe.Close()
os.Exit(0)
case "pwd":
pwd, err := os.Getwd()
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
fmt.Println(pwd)
os.Exit(0)
default:
fmt.Fprintf(os.Stderr, "Unknown command %q\n", cmd)
os.Exit(2)
}
}
type delayedInfiniteReader struct{}
func (delayedInfiniteReader) Read(b []byte) (int, error) {
time.Sleep(100 * time.Millisecond)
for i := range b {
b[i] = 'x'
}
return len(b), nil
}
// Issue 9173: ignore stdin pipe writes if the program completes successfully.
func TestIgnorePipeErrorOnSuccess(t *testing.T) {
testenv.MustHaveExec(t)
testWith := func(r io.Reader) func(*testing.T) {
return func(t *testing.T) {
cmd := helperCommand(t, "echo", "foo")
var out bytes.Buffer
cmd.Stdin = r
cmd.Stdout = &out
if err := cmd.Run(); err != nil {
t.Fatal(err)
}
if got, want := out.String(), "foo\n"; got != want {
t.Errorf("output = %q; want %q", got, want)
}
}
}
t.Run("10MB", testWith(strings.NewReader(strings.Repeat("x", 10<<20))))
t.Run("Infinite", testWith(delayedInfiniteReader{}))
}
type badWriter struct{}
func (w *badWriter) Write(data []byte) (int, error) {
return 0, io.ErrUnexpectedEOF
}
func TestClosePipeOnCopyError(t *testing.T) {
testenv.MustHaveExec(t)
if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
t.Skipf("skipping test on %s - no yes command", runtime.GOOS)
}
cmd := exec.Command("yes")
cmd.Stdout = new(badWriter)
c := make(chan int, 1)
go func() {
err := cmd.Run()
if err == nil {
t.Errorf("yes completed successfully")
}
c <- 1
}()
select {
case <-c:
// ok
case <-time.After(5 * time.Second):
t.Fatalf("yes got stuck writing to bad writer")
}
}
func TestOutputStderrCapture(t *testing.T) {
testenv.MustHaveExec(t)
cmd := helperCommand(t, "stderrfail")
_, err := cmd.Output()
ee, ok := err.(*exec.ExitError)
if !ok {
t.Fatalf("Output error type = %T; want ExitError", err)
}
got := string(ee.Stderr)
want := "some stderr text\n"
if got != want {
t.Errorf("ExitError.Stderr = %q; want %q", got, want)
}
}
func TestContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
c := helperCommandContext(t, ctx, "pipetest")
stdin, err := c.StdinPipe()
if err != nil {
t.Fatal(err)
}
stdout, err := c.StdoutPipe()
if err != nil {
t.Fatal(err)
}
if err := c.Start(); err != nil {
t.Fatal(err)
}
if _, err := stdin.Write([]byte("O:hi\n")); err != nil {
t.Fatal(err)
}
buf := make([]byte, 5)
n, err := io.ReadFull(stdout, buf)
if n != len(buf) || err != nil || string(buf) != "O:hi\n" {
t.Fatalf("ReadFull = %d, %v, %q", n, err, buf[:n])
}
waitErr := make(chan error, 1)
go func() {
waitErr <- c.Wait()
}()
cancel()
select {
case err := <-waitErr:
if err == nil {
t.Fatal("expected Wait failure")
}
case <-time.After(3 * time.Second):
t.Fatal("timeout waiting for child process death")
}
}
func TestContextCancel(t *testing.T) {
if runtime.GOOS == "netbsd" && runtime.GOARCH == "arm64" {
testenv.SkipFlaky(t, 42061)
}
// To reduce noise in the final goroutine dump,
// let other parallel tests complete if possible.
t.Parallel()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
c := helperCommandContext(t, ctx, "cat")
stdin, err := c.StdinPipe()
if err != nil {
t.Fatal(err)
}
defer stdin.Close()
if err := c.Start(); err != nil {
t.Fatal(err)
}
// At this point the process is alive. Ensure it by sending data to stdin.
if _, err := io.WriteString(stdin, "echo"); err != nil {
t.Fatal(err)
}
cancel()
// Calling cancel should have killed the process, so writes
// should now fail. Give the process a little while to die.
start := time.Now()
delay := 1 * time.Millisecond
for {
if _, err := io.WriteString(stdin, "echo"); err != nil {
break
}
if time.Since(start) > time.Minute {
// Panic instead of calling t.Fatal so that we get a goroutine dump.
// We want to know exactly what the os/exec goroutines got stuck on.
panic("canceling context did not stop program")
}
// Back off exponentially (up to 1-second sleeps) to give the OS time to
// terminate the process.
delay *= 2
if delay > 1*time.Second {
delay = 1 * time.Second
}
time.Sleep(delay)
}
if err := c.Wait(); err == nil {
t.Error("program unexpectedly exited successfully")
} else {
t.Logf("exit status: %v", err)
}
}
// test that environment variables are de-duped.
func TestDedupEnvEcho(t *testing.T) {
testenv.MustHaveExec(t)
cmd := helperCommand(t, "echoenv", "FOO")
cmd.Env = append(cmd.Env, "FOO=bad", "FOO=good")
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatal(err)
}
if got, want := strings.TrimSpace(string(out)), "good"; got != want {
t.Errorf("output = %q; want %q", got, want)
}
}
func TestString(t *testing.T) {
echoPath, err := exec.LookPath("echo")
if err != nil {
t.Skip(err)
}
tests := [...]struct {
path string
args []string
want string
}{
{"echo", nil, echoPath},
{"echo", []string{"a"}, echoPath + " a"},
{"echo", []string{"a", "b"}, echoPath + " a b"},
}
for _, test := range tests {
cmd := exec.Command(test.path, test.args...)
if got := cmd.String(); got != test.want {
t.Errorf("String(%q, %q) = %q, want %q", test.path, test.args, got, test.want)
}
}
}
func TestStringPathNotResolved(t *testing.T) {
_, err := exec.LookPath("makemeasandwich")
if err == nil {
t.Skip("wow, thanks")
}
cmd := exec.Command("makemeasandwich", "-lettuce")
want := "makemeasandwich -lettuce"
if got := cmd.String(); got != want {
t.Errorf("String(%q, %q) = %q, want %q", "makemeasandwich", "-lettuce", got, want)
}
}
// start a child process without the user code explicitly starting
// with a copy of the parent's. (The Windows SYSTEMROOT issue: Issue
// 25210)
func TestChildCriticalEnv(t *testing.T) {
testenv.MustHaveExec(t)
if runtime.GOOS != "windows" {
t.Skip("only testing on Windows")
}
cmd := helperCommand(t, "echoenv", "SYSTEMROOT")
cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatal(err)
}
if strings.TrimSpace(string(out)) == "" {
t.Error("no SYSTEMROOT found")
}
}