OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	02/02/2024 06:09:55 PM	rwxr-xr-x
📄 dir.go	4.4 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dir_darwin.go	3.34 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dir_plan9.go	2.1 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dir_unix.go	5.24 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dir_windows.go	7.17 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_aix.go	759 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_dragonfly.go	1.28 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_freebsd.go	1.16 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_js.go	678 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_linux.go	1.18 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_netbsd.go	1.16 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_openbsd.go	1.16 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_solaris.go	759 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 dirent_wasip1.go	1.36 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 endian_big.go	244 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 endian_little.go	304 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 env.go	3.85 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 env_test.go	5.04 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 env_unix_test.go	1.22 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 error.go	4.76 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 error_errno.go	247 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 error_plan9.go	234 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 error_posix.go	538 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 error_test.go	4.92 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 error_unix_test.go	1.49 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 error_windows_test.go	1.72 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 example_test.go	8.39 KB	02/02/2024 06:09:55 PM	rw-r--r--
📁 exec	-	02/02/2024 06:09:55 PM	rwxr-xr-x
📄 exec.go	6.01 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 exec_plan9.go	3.27 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 exec_posix.go	3.44 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 exec_unix.go	2.09 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 exec_unix_test.go	999 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 exec_windows.go	4.57 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 exec_windows_test.go	1.78 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable.go	774 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_darwin.go	613 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_dragonfly.go	293 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_freebsd.go	292 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_path.go	2.31 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_plan9.go	427 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_procfs.go	904 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_solaris.go	695 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_sysctl.go	891 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_test.go	3.4 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_wasm.go	333 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 executable_windows.go	641 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 export_linux_test.go	337 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 export_test.go	433 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 export_unix_test.go	241 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 export_windows_test.go	395 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 fifo_test.go	4.62 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 file.go	24.91 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 file_mutex_plan9.go	1.81 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 file_open_unix.go	397 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 file_open_wasip1.go	818 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 file_plan9.go	15.99 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 file_posix.go	7.1 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 file_unix.go	14.05 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 file_wasip1.go	633 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 file_windows.go	12.65 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 getwd.go	2.52 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 os_test.go	77.07 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 os_unix_test.go	11.47 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 os_windows_test.go	41.83 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 path.go	2.27 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 path_plan9.go	492 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 path_test.go	2.96 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 path_unix.go	1.56 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 path_windows.go	5.66 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 path_windows_test.go	4.03 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 pipe2_unix.go	640 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 pipe_test.go	12.41 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 pipe_unix.go	760 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 pipe_wasm.go	488 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 proc.go	2.27 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 rawconn.go	993 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 rawconn_test.go	1.15 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 read_test.go	3.2 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 readfrom_linux_test.go	20.3 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 removeall_at.go	4.91 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 removeall_noat.go	3.13 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 removeall_test.go	11.96 KB	02/02/2024 06:09:55 PM	rw-r--r--
📁 signal	-	02/02/2024 06:09:55 PM	rwxr-xr-x
📄 stat.go	965 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_aix.go	1.18 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_darwin.go	1.09 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_dragonfly.go	1.06 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_freebsd.go	1.07 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_js.go	1.11 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_linux.go	1.06 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_netbsd.go	1.07 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_openbsd.go	1.06 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_plan9.go	2.37 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_solaris.go	1.3 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_test.go	6.46 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_unix.go	1.23 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_wasip1.go	956 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 stat_windows.go	4.93 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 sticky_bsd.go	425 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sticky_notbsd.go	320 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys.go	294 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_aix.go	682 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_bsd.go	466 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_js.go	313 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_linux.go	1.04 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_plan9.go	453 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_solaris.go	265 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_unix.go	493 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_wasip1.go	309 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 sys_windows.go	874 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 tempfile.go	3.8 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 tempfile_test.go	5.49 KB	02/02/2024 06:09:55 PM	rw-r--r--
📁 testdata	-	02/02/2024 06:09:55 PM	rwxr-xr-x
📄 timeout_test.go	17.09 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 types.go	2.79 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 types_plan9.go	797 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 types_unix.go	776 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 types_windows.go	10.01 KB	02/02/2024 06:09:55 PM	rw-r--r--
📁 user	-	02/02/2024 06:09:55 PM	rwxr-xr-x
📄 wait6_dragonfly.go	496 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 wait6_freebsd64.go	547 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 wait6_freebsd_386.go	544 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 wait6_freebsd_arm.go	549 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 wait6_netbsd.go	534 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 wait_unimp.go	831 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 wait_wait6.go	781 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 wait_waitid.go	1.32 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 writeto_linux_test.go	4.21 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 zero_copy_linux.go	4.38 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 zero_copy_stub.go	406 bytes	02/02/2024 06:09:55 PM	rw-r--r--

Editing: pipe_test.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.
//
//go:build !plan9 && !js && !wasip1

package os_test

import (
	"bufio"
	"bytes"
	"fmt"
	"internal/testenv"
	"io"
	"io/fs"
	"os"
	"os/exec"
	"os/signal"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"syscall"
	"testing"
	"time"
)

func TestEPIPE(t *testing.T) {
	// This test cannot be run in parallel because of a race similar
	// to the one reported in https://go.dev/issue/22315.
	//
	// Even though the pipe is opened with O_CLOEXEC, if another test forks in
	// between the call to os.Pipe and the call to r.Close, that child process can
	// retain an open copy of r's file descriptor until it execs. If one of our
	// Write calls occurs during that interval it can spuriously succeed,
	// buffering the write to the child's copy of the pipe (even though the child
	// will not actually read the buffered bytes).

r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	if err := r.Close(); err != nil {
		t.Fatal(err)
	}

expect := syscall.EPIPE
	if runtime.GOOS == "windows" {
		// 232 is Windows error code ERROR_NO_DATA, "The pipe is being closed".
		expect = syscall.Errno(232)
	}
	// 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.(*fs.PathError); ok {
			err = pe.Err
		}
		if se, ok := err.(*os.SyscallError); ok {
			err = se.Err
		}
		if err != expect {
			t.Errorf("iteration %d: got %v, expected %v", i, err, expect)
		}
	}
}

func TestStdPipe(t *testing.T) {
	switch runtime.GOOS {
	case "windows":
		t.Skip("Windows doesn't support SIGPIPE")
	}

if os.Getenv("GO_TEST_STD_PIPE_HELPER") != "" {
		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:
			panic("unrecognized value for GO_TEST_STD_PIPE_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)
	}

testenv.MustHaveExec(t)
	// This test cannot be run in parallel due to the same race as for TestEPIPE.
	// (We expect a write to a closed pipe can fail, but a concurrent fork of a
	// child process can cause the pipe to unexpectedly remain open.)

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 := testenv.Command(t, os.Args[0], "-test.run", "TestStdPipe")
			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.(*exec.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 %d sig %t", err, dest, sig)
			}
		}
	}

// Test redirecting stdout but not stderr.  Issue 40076.
	cmd := testenv.Command(t, os.Args[0], "-test.run", "TestStdPipe")
	cmd.Stdout = w
	var stderr bytes.Buffer
	cmd.Stderr = &stderr
	cmd.Env = append(cmd.Environ(), "GO_TEST_STD_PIPE_HELPER=1")
	if err := cmd.Run(); err == nil {
		t.Errorf("unexpected success of write to closed stdout")
	} else if ee, ok := err.(*exec.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 {
		t.Errorf("unexpected exit status %v for write to closed stdout", err)
	}
	if output := stderr.Bytes(); len(output) > 0 {
		t.Errorf("unexpected output on stderr: %s", output)
	}
}

func testClosedPipeRace(t *testing.T, read bool) {
	// This test cannot be run in parallel due to the same race as for TestEPIPE.
	// (We expect a write to a closed pipe can fail, but a concurrent fork of a
	// child process can cause the pipe to unexpectedly remain open.)

limit := 1
	if !read {
		// Get the amount we have to write to overload a pipe
		// with no reader.
		limit = 131073
		if b, err := os.ReadFile("/proc/sys/fs/pipe-max-size"); err == nil {
			if i, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil {
				limit = i + 1
			}
		}
		t.Logf("using pipe write limit of %d", limit)
	}

r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	defer r.Close()
	defer w.Close()

// Close the read end of the pipe in a goroutine while we are
	// writing to the write end, or vice-versa.
	go func() {
		// Give the main goroutine a chance to enter the Read or
		// Write call. This is sloppy but the test will pass even
		// if we close before the read/write.
		time.Sleep(20 * time.Millisecond)

var err error
		if read {
			err = r.Close()
		} else {
			err = w.Close()
		}
		if err != nil {
			t.Error(err)
		}
	}()

b := make([]byte, limit)
	if read {
		_, err = r.Read(b[:])
	} else {
		_, err = w.Write(b[:])
	}
	if err == nil {
		t.Error("I/O on closed pipe unexpectedly succeeded")
	} else if pe, ok := err.(*fs.PathError); !ok {
		t.Errorf("I/O on closed pipe returned unexpected error type %T; expected fs.PathError", pe)
	} else if pe.Err != fs.ErrClosed {
		t.Errorf("got error %q but expected %q", pe.Err, fs.ErrClosed)
	} else {
		t.Logf("I/O returned expected error %q", err)
	}
}

func TestClosedPipeRaceRead(t *testing.T) {
	testClosedPipeRace(t, true)
}

func TestClosedPipeRaceWrite(t *testing.T) {
	testClosedPipeRace(t, false)
}

// Issue 20915: Reading on nonblocking fd should not return "waiting
// for unsupported file type." Currently it returns EAGAIN; it is
// possible that in the future it will simply wait for data.
func TestReadNonblockingFd(t *testing.T) {
	switch runtime.GOOS {
	case "windows":
		t.Skip("Windows doesn't support SetNonblock")
	}
	if os.Getenv("GO_WANT_READ_NONBLOCKING_FD") == "1" {
		fd := syscallDescriptor(os.Stdin.Fd())
		syscall.SetNonblock(fd, true)
		defer syscall.SetNonblock(fd, false)
		_, err := os.Stdin.Read(make([]byte, 1))
		if err != nil {
			if perr, ok := err.(*fs.PathError); !ok || perr.Err != syscall.EAGAIN {
				t.Fatalf("read on nonblocking stdin got %q, should have gotten EAGAIN", err)
			}
		}
		os.Exit(0)
	}

testenv.MustHaveExec(t)
	t.Parallel()

r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	defer r.Close()
	defer w.Close()
	cmd := testenv.Command(t, os.Args[0], "-test.run=^"+t.Name()+"$")
	cmd.Env = append(cmd.Environ(), "GO_WANT_READ_NONBLOCKING_FD=1")
	cmd.Stdin = r
	output, err := cmd.CombinedOutput()
	t.Logf("%s", output)
	if err != nil {
		t.Errorf("child process failed: %v", err)
	}
}

func TestCloseWithBlockingReadByNewFile(t *testing.T) {
	t.Parallel()

var p [2]syscallDescriptor
	err := syscall.Pipe(p[:])
	if err != nil {
		t.Fatal(err)
	}
	// os.NewFile returns a blocking mode file.
	testCloseWithBlockingRead(t, os.NewFile(uintptr(p[0]), "reader"), os.NewFile(uintptr(p[1]), "writer"))
}

func TestCloseWithBlockingReadByFd(t *testing.T) {
	t.Parallel()

r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	// Calling Fd will put the file into blocking mode.
	_ = r.Fd()
	testCloseWithBlockingRead(t, r, w)
}

// Test that we don't let a blocking read prevent a close.
func testCloseWithBlockingRead(t *testing.T, r, w *os.File) {
	var (
		enteringRead = make(chan struct{})
		done         = make(chan struct{})
	)
	go func() {
		var b [1]byte
		close(enteringRead)
		_, err := r.Read(b[:])
		if err == nil {
			t.Error("I/O on closed pipe unexpectedly succeeded")
		}

if pe, ok := err.(*fs.PathError); ok {
			err = pe.Err
		}
		if err != io.EOF && err != fs.ErrClosed {
			t.Errorf("got %v, expected EOF or closed", err)
		}
		close(done)
	}()

// Give the goroutine a chance to enter the Read
	// or Write call. This is sloppy but the test will
	// pass even if we close before the read/write.
	<-enteringRead
	time.Sleep(20 * time.Millisecond)

if err := r.Close(); err != nil {
		t.Error(err)
	}
	// r.Close has completed, but since we assume r is in blocking mode that
	// probably didn't unblock the call to r.Read. Close w to unblock it.
	w.Close()
	<-done
}

func TestPipeEOF(t *testing.T) {
	t.Parallel()

r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}

testPipeEOF(t, r, w)
}

// testPipeEOF tests that when the write side of a pipe or FIFO is closed,
// a blocked Read call on the reader side returns io.EOF.
//
// This scenario previously failed to unblock the Read call on darwin.
// (See https://go.dev/issue/24164.)
func testPipeEOF(t *testing.T, r io.ReadCloser, w io.WriteCloser) {
	// parkDelay is an arbitrary delay we wait for a pipe-reader goroutine to park
	// before issuing the corresponding write. The test should pass no matter what
	// delay we use, but with a longer delay is has a higher chance of detecting
	// poller bugs.
	parkDelay := 10 * time.Millisecond
	if testing.Short() {
		parkDelay = 100 * time.Microsecond
	}
	writerDone := make(chan struct{})
	defer func() {
		if err := r.Close(); err != nil {
			t.Errorf("error closing reader: %v", err)
		}
		<-writerDone
	}()

write := make(chan int, 1)
	go func() {
		defer close(writerDone)

for i := range write {
			time.Sleep(parkDelay)
			_, err := fmt.Fprintf(w, "line %d\n", i)
			if err != nil {
				t.Errorf("error writing to fifo: %v", err)
				return
			}
		}

time.Sleep(parkDelay)
		if err := w.Close(); err != nil {
			t.Errorf("error closing writer: %v", err)
		}
	}()

rbuf := bufio.NewReader(r)
	for i := 0; i < 3; i++ {
		write <- i
		b, err := rbuf.ReadBytes('\n')
		if err != nil {
			t.Fatal(err)
		}
		t.Logf("%s\n", bytes.TrimSpace(b))
	}

close(write)
	b, err := rbuf.ReadBytes('\n')
	if err != io.EOF || len(b) != 0 {
		t.Errorf(`ReadBytes: %q, %v; want "", io.EOF`, b, err)
	}
}

// Issue 24481.
func TestFdRace(t *testing.T) {
	// This test starts 100 simultaneous goroutines, which could bury a more
	// interesting stack if this or some other test happens to panic. It is also
	// nearly instantaneous, so any latency benefit from running it in parallel
	// would be minimal.

r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	defer r.Close()
	defer w.Close()

var wg sync.WaitGroup
	call := func() {
		defer wg.Done()
		w.Fd()
	}

const tries = 100
	for i := 0; i < tries; i++ {
		wg.Add(1)
		go call()
	}
	wg.Wait()
}

func TestFdReadRace(t *testing.T) {
	t.Parallel()

r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	defer r.Close()
	defer w.Close()

const count = 10

c := make(chan bool, 1)
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		var buf [count]byte
		r.SetReadDeadline(time.Now().Add(time.Minute))
		c <- true
		if _, err := r.Read(buf[:]); os.IsTimeout(err) {
			t.Error("read timed out")
		}
	}()

wg.Add(1)
	go func() {
		defer wg.Done()
		<-c
		// Give the other goroutine a chance to enter the Read.
		// It doesn't matter if this occasionally fails, the test
		// will still pass, it just won't test anything.
		time.Sleep(10 * time.Millisecond)
		r.Fd()

// The bug was that Fd would hang until Read timed out.
		// If the bug is fixed, then writing to w and closing r here
		// will cause the Read to exit before the timeout expires.
		w.Write(make([]byte, count))
		r.Close()
	}()

wg.Wait()
}