ENOTSOCK        Errno = 57
	ENOTSUP         Errno = 58
	ENOTTY          Errno = 59
	ENXIO           Errno = 60
	EOVERFLOW       Errno = 61
	EOWNERDEAD      Errno = 62
	EPERM           Errno = 63
	EPIPE           Errno = 64
	EPROTO          Errno = 65
	EPROTONOSUPPORT Errno = 66
	EPROTOTYPE      Errno = 67
	ERANGE          Errno = 68
	EROFS           Errno = 69
	ESPIPE          Errno = 70
	ESRCH           Errno = 71

	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 {

			}

			int fd[2];
			if (pipe(fd) != 0) {
				printf("pipe(2) failed\n");
				return 0;
			}
			// Close the reading end.
			close(fd[0]);
			// Expect that write(2) fails (EPIPE)
			if (write(fd[1], "some data", 9) != -1) {
				printf("write(2) unexpectedly succeeded\n");
				return 0;
			}
			printf("did not receive SIGPIPE\n");
			return 0;
		}
		case 4: {
			fprintf(stderr, "OK\n");

			// will wake up a goroutine waiting to write;
			// that goroutine will try the write again,
			// and the appropriate thing will happen based
			// on what that write returns (success, EPIPE, EAGAIN).
			if ev.flags&_EV_EOF != 0 {
				mode += 'w'
			}
		case _EVFILT_WRITE:
			mode += 'w'
		}
		if mode != 0 {
			var pd *pollDesc
			var tag uintptr
			if goarch.PtrSize == 4 {

to a broken pipe on some other file descriptor will take no action on
the SIGPIPE signal, and the write will fail with an EPIPE error.

If the program has called Notify to receive SIGPIPE signals, the file
descriptor number does not matter. The SIGPIPE signal will be
delivered to the Notify channel, and the write will fail with an EPIPE
error.

This means that, by default, command line programs will behave like

	return f
}

func sigpipe() // implemented in package runtime

// epipecheck raises SIGPIPE if we get an EPIPE error on standard
// output or standard error. See the SIGPIPE docs in os/signal, and
// issue 11845.
func epipecheck(file *File, e error) {
	if e == syscall.EPIPE && file.stdoutOrErr {
		sigpipe()
	}
}

// DevNull is the name of the operating system's “null device.”

		if err != EINTR {
			break
		}
	}
	Close(p[0])
	if err != nil || n != 0 {
		if n == int(unsafe.Sizeof(err1)) {
			err = Errno(err1)
		}
		if err == nil {
			err = EPIPE
		}

		// Child failed; wait for it to exit, to make sure
		// the zombies don't accumulate.
		_, err1 := Wait4(pid, &wstatus, 0, nil)
		for err1 == EINTR {
			_, err1 = Wait4(pid, &wstatus, 0, nil)
		}

	EOPNOTSUPP      = syscall.Errno(0x40)
	EOVERFLOW       = syscall.Errno(0x7f)
	EOWNERDEAD      = syscall.Errno(0x5f)
	EPERM           = syscall.Errno(0x1)
	EPFNOSUPPORT    = syscall.Errno(0x41)
	EPIPE           = syscall.Errno(0x20)
	EPROCLIM        = syscall.Errno(0x53)
	EPROTO          = syscall.Errno(0x79)
	EPROTONOSUPPORT = syscall.Errno(0x3e)
	EPROTOTYPE      = syscall.Errno(0x3c)

	EOPNOTSUPP      = syscall.Errno(0x7a)
	EOVERFLOW       = syscall.Errno(0x4f)
	EOWNERDEAD      = syscall.Errno(0x3a)
	EPERM           = syscall.Errno(0x1)
	EPFNOSUPPORT    = syscall.Errno(0x7b)
	EPIPE           = syscall.Errno(0x20)
	EPROTO          = syscall.Errno(0x47)
	EPROTONOSUPPORT = syscall.Errno(0x78)
	EPROTOTYPE      = syscall.Errno(0x62)
	ERANGE          = syscall.Errno(0x22)

	EOPNOTSUPP      = syscall.Errno(0x40)
	EOVERFLOW       = syscall.Errno(0x7f)
	EOWNERDEAD      = syscall.Errno(0x5f)
	EPERM           = syscall.Errno(0x1)
	EPFNOSUPPORT    = syscall.Errno(0x41)
	EPIPE           = syscall.Errno(0x20)
	EPROCLIM        = syscall.Errno(0x53)
	EPROTO          = syscall.Errno(0x79)
	EPROTONOSUPPORT = syscall.Errno(0x3e)
	EPROTOTYPE      = syscall.Errno(0x3c)