114 lines
3.1 KiB
Go
114 lines
3.1 KiB
Go
// Copyright 2015 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.
|
|
|
|
// Test broken pipes on Unix systems.
|
|
// +build !windows,!plan9,!nacl
|
|
|
|
package os_test
|
|
|
|
import (
|
|
"fmt"
|
|
"internal/testenv"
|
|
"os"
|
|
osexec "os/exec"
|
|
"os/signal"
|
|
"syscall"
|
|
"testing"
|
|
)
|
|
|
|
func TestEPIPE(t *testing.T) {
|
|
r, w, err := os.Pipe()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := r.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Every time we write to the pipe we should get an EPIPE.
|
|
for i := 0; i < 20; i++ {
|
|
_, err = w.Write([]byte("hi"))
|
|
if err == nil {
|
|
t.Fatal("unexpected success of Write to broken pipe")
|
|
}
|
|
if pe, ok := err.(*os.PathError); ok {
|
|
err = pe.Err
|
|
}
|
|
if se, ok := err.(*os.SyscallError); ok {
|
|
err = se.Err
|
|
}
|
|
if err != syscall.EPIPE {
|
|
t.Errorf("iteration %d: got %v, expected EPIPE", i, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStdPipe(t *testing.T) {
|
|
testenv.MustHaveExec(t)
|
|
r, w, err := os.Pipe()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := r.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Invoke the test program to run the test and write to a closed pipe.
|
|
// If sig is false:
|
|
// writing to stdout or stderr should cause an immediate SIGPIPE;
|
|
// writing to descriptor 3 should fail with EPIPE and then exit 0.
|
|
// If sig is true:
|
|
// all writes should fail with EPIPE and then exit 0.
|
|
for _, sig := range []bool{false, true} {
|
|
for dest := 1; dest < 4; dest++ {
|
|
cmd := osexec.Command(os.Args[0], "-test.run", "TestStdPipeHelper")
|
|
cmd.Stdout = w
|
|
cmd.Stderr = w
|
|
cmd.ExtraFiles = []*os.File{w}
|
|
cmd.Env = append(os.Environ(), fmt.Sprintf("GO_TEST_STD_PIPE_HELPER=%d", dest))
|
|
if sig {
|
|
cmd.Env = append(cmd.Env, "GO_TEST_STD_PIPE_HELPER_SIGNAL=1")
|
|
}
|
|
if err := cmd.Run(); err == nil {
|
|
if !sig && dest < 3 {
|
|
t.Errorf("unexpected success of write to closed pipe %d sig %t in child", dest, sig)
|
|
}
|
|
} else if ee, ok := err.(*osexec.ExitError); !ok {
|
|
t.Errorf("unexpected exec error type %T: %v", err, err)
|
|
} else if ws, ok := ee.Sys().(syscall.WaitStatus); !ok {
|
|
t.Errorf("unexpected wait status type %T: %v", ee.Sys(), ee.Sys())
|
|
} else if ws.Signaled() && ws.Signal() == syscall.SIGPIPE {
|
|
if sig || dest > 2 {
|
|
t.Errorf("unexpected SIGPIPE signal for descriptor %d sig %t", dest, sig)
|
|
}
|
|
} else {
|
|
t.Errorf("unexpected exit status %v for descriptor %ds sig %t", err, dest, sig)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// This is a helper for TestStdPipe. It's not a test in itself.
|
|
func TestStdPipeHelper(t *testing.T) {
|
|
if os.Getenv("GO_TEST_STD_PIPE_HELPER_SIGNAL") != "" {
|
|
signal.Notify(make(chan os.Signal, 1), syscall.SIGPIPE)
|
|
}
|
|
switch os.Getenv("GO_TEST_STD_PIPE_HELPER") {
|
|
case "1":
|
|
os.Stdout.Write([]byte("stdout"))
|
|
case "2":
|
|
os.Stderr.Write([]byte("stderr"))
|
|
case "3":
|
|
if _, err := os.NewFile(3, "3").Write([]byte("3")); err == nil {
|
|
os.Exit(3)
|
|
}
|
|
default:
|
|
t.Skip("skipping test helper")
|
|
}
|
|
// For stdout/stderr, we should have crashed with a broken pipe error.
|
|
// The caller will be looking for that exit status,
|
|
// so just exit normally here to cause a failure in the caller.
|
|
// For descriptor 3, a normal exit is expected.
|
|
os.Exit(0)
|
|
}
|