// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:build !js && !plan9 && !wasip1 && !windows
+//go:build !js && !plan9 && !wasip1
package os_test
"io"
"math/rand"
"os"
- "os/signal"
"runtime"
"sync"
- "syscall"
"testing"
"time"
)
func TestNonpollableDeadline(t *testing.T) {
// On BSD systems regular files seem to be pollable,
- // so just run this test on Linux.
- if runtime.GOOS != "linux" {
+ // so just run this test on Linux and Windows.
+ if runtime.GOOS != "linux" && runtime.GOOS != "windows" {
t.Skipf("skipping on %s", runtime.GOOS)
}
t.Parallel()
}
}
+type pipeDeadlineTest struct {
+ name string
+ create func(t *testing.T) (r, w *os.File)
+}
+
+var pipeDeadlinesTestCases []pipeDeadlineTest
+
// noDeadline is a zero time.Time value, which cancels a deadline.
var noDeadline time.Time
func TestReadTimeout(t *testing.T) {
t.Parallel()
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
- defer w.Close()
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
- if _, err := w.Write([]byte("READ TIMEOUT TEST")); err != nil {
- t.Fatal(err)
- }
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
- for i, tt := range readTimeoutTests {
- if err := r.SetReadDeadline(time.Now().Add(tt.timeout)); err != nil {
- t.Fatalf("#%d: %v", i, err)
- }
- var b [1]byte
- for j, xerr := range tt.xerrs {
- for {
- n, err := r.Read(b[:])
- if xerr != nil {
- if !isDeadlineExceeded(err) {
- t.Fatalf("#%d/%d: %v", i, j, err)
- }
- }
- if err == nil {
- time.Sleep(tt.timeout / 3)
- continue
+ if _, err := w.Write([]byte("READ TIMEOUT TEST")); err != nil {
+ t.Fatal(err)
+ }
+
+ for i, tt := range readTimeoutTests {
+ if err := r.SetReadDeadline(time.Now().Add(tt.timeout)); err != nil {
+ t.Fatalf("#%d: %v", i, err)
}
- if n != 0 {
- t.Fatalf("#%d/%d: read %d; want 0", i, j, n)
+ var b [1]byte
+ for j, xerr := range tt.xerrs {
+ for {
+ n, err := r.Read(b[:])
+ if xerr != nil {
+ if !isDeadlineExceeded(err) {
+ t.Fatalf("#%d/%d: %v", i, j, err)
+ }
+ }
+ if err == nil {
+ time.Sleep(tt.timeout / 3)
+ continue
+ }
+ if n != 0 {
+ t.Fatalf("#%d/%d: read %d; want 0", i, j, n)
+ }
+ break
+ }
}
- break
}
- }
+ })
}
}
func TestReadTimeoutMustNotReturn(t *testing.T) {
t.Parallel()
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
- defer w.Close()
-
- max := time.NewTimer(100 * time.Millisecond)
- defer max.Stop()
- ch := make(chan error)
- go func() {
- if err := r.SetDeadline(time.Now().Add(-5 * time.Second)); err != nil {
- t.Error(err)
- }
- if err := r.SetWriteDeadline(time.Now().Add(-5 * time.Second)); err != nil {
- t.Error(err)
- }
- if err := r.SetReadDeadline(noDeadline); err != nil {
- t.Error(err)
- }
- var b [1]byte
- _, err := r.Read(b[:])
- ch <- err
- }()
-
- select {
- case err := <-ch:
- t.Fatalf("expected Read to not return, but it returned with %v", err)
- case <-max.C:
- w.Close()
- err := <-ch // wait for tester goroutine to stop
- if os.IsTimeout(err) {
- t.Fatal(err)
- }
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
+
+ max := time.NewTimer(100 * time.Millisecond)
+ defer max.Stop()
+ ch := make(chan error)
+ go func() {
+ if err := r.SetDeadline(time.Now().Add(-5 * time.Second)); err != nil {
+ t.Error(err)
+ }
+ if err := r.SetWriteDeadline(time.Now().Add(-5 * time.Second)); err != nil {
+ t.Error(err)
+ }
+ if err := r.SetReadDeadline(noDeadline); err != nil {
+ t.Error(err)
+ }
+ var b [1]byte
+ _, err := r.Read(b[:])
+ ch <- err
+ }()
+
+ select {
+ case err := <-ch:
+ t.Fatalf("expected Read to not return, but it returned with %v", err)
+ case <-max.C:
+ w.Close()
+ err := <-ch // wait for tester goroutine to stop
+ if os.IsTimeout(err) {
+ t.Fatal(err)
+ }
+ }
+ })
}
}
func TestWriteTimeout(t *testing.T) {
t.Parallel()
- for i, tt := range writeTimeoutTests {
- t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) {
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
- defer w.Close()
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
- if err := w.SetWriteDeadline(time.Now().Add(tt.timeout)); err != nil {
- t.Fatalf("%v", err)
- }
- for j, xerr := range tt.xerrs {
- for {
- n, err := w.Write([]byte("WRITE TIMEOUT TEST"))
- if xerr != nil {
- if !isDeadlineExceeded(err) {
- t.Fatalf("%d: %v", j, err)
- }
- }
- if err == nil {
- time.Sleep(tt.timeout / 3)
- continue
+ for i, tt := range writeTimeoutTests {
+ t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) {
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
+
+ if err := w.SetWriteDeadline(time.Now().Add(tt.timeout)); err != nil {
+ t.Fatalf("%v", err)
}
- if n != 0 {
- t.Fatalf("%d: wrote %d; want 0", j, n)
+ for j, xerr := range tt.xerrs {
+ for {
+ n, err := w.Write([]byte("WRITE TIMEOUT TEST"))
+ if xerr != nil {
+ if !isDeadlineExceeded(err) {
+ t.Fatalf("%d: %v", j, err)
+ }
+ }
+ if err == nil {
+ time.Sleep(tt.timeout / 3)
+ continue
+ }
+ if n != 0 {
+ t.Fatalf("%d: wrote %d; want 0", j, n)
+ }
+ break
+ }
}
- break
- }
+ })
}
})
}
func TestWriteTimeoutMustNotReturn(t *testing.T) {
t.Parallel()
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
- defer w.Close()
-
- max := time.NewTimer(100 * time.Millisecond)
- defer max.Stop()
- ch := make(chan error)
- go func() {
- if err := w.SetDeadline(time.Now().Add(-5 * time.Second)); err != nil {
- t.Error(err)
- }
- if err := w.SetReadDeadline(time.Now().Add(-5 * time.Second)); err != nil {
- t.Error(err)
- }
- if err := w.SetWriteDeadline(noDeadline); err != nil {
- t.Error(err)
- }
- var b [1]byte
- for {
- if _, err := w.Write(b[:]); err != nil {
- ch <- err
- break
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
+
+ max := time.NewTimer(100 * time.Millisecond)
+ defer max.Stop()
+ ch := make(chan error)
+ go func() {
+ if err := w.SetDeadline(time.Now().Add(-5 * time.Second)); err != nil {
+ t.Error(err)
+ }
+ if err := w.SetReadDeadline(time.Now().Add(-5 * time.Second)); err != nil {
+ t.Error(err)
+ }
+ if err := w.SetWriteDeadline(noDeadline); err != nil {
+ t.Error(err)
+ }
+ var b [1]byte
+ for {
+ if _, err := w.Write(b[:]); err != nil {
+ ch <- err
+ break
+ }
+ }
+ }()
+
+ select {
+ case err := <-ch:
+ t.Fatalf("expected Write to not return, but it returned with %v", err)
+ case <-max.C:
+ r.Close()
+ err := <-ch // wait for tester goroutine to stop
+ if os.IsTimeout(err) {
+ t.Fatal(err)
+ }
}
- }
- }()
-
- select {
- case err := <-ch:
- t.Fatalf("expected Write to not return, but it returned with %v", err)
- case <-max.C:
- r.Close()
- err := <-ch // wait for tester goroutine to stop
- if os.IsTimeout(err) {
- t.Fatal(err)
- }
+ })
}
}
func TestReadTimeoutFluctuation(t *testing.T) {
t.Parallel()
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
- defer w.Close()
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
- d := minDynamicTimeout
- b := make([]byte, 256)
- for {
- t.Logf("SetReadDeadline(+%v)", d)
- t0 := time.Now()
- deadline := t0.Add(d)
- if err = r.SetReadDeadline(deadline); err != nil {
- t.Fatalf("SetReadDeadline(%v): %v", deadline, err)
- }
- var n int
- n, err = r.Read(b)
- t1 := time.Now()
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
- if n != 0 || err == nil || !isDeadlineExceeded(err) {
- t.Errorf("Read did not return (0, timeout): (%d, %v)", n, err)
- }
+ d := minDynamicTimeout
+ b := make([]byte, 256)
+ for {
+ t.Logf("SetReadDeadline(+%v)", d)
+ t0 := time.Now()
+ deadline := t0.Add(d)
+ if err := r.SetReadDeadline(deadline); err != nil {
+ t.Fatalf("SetReadDeadline(%v): %v", deadline, err)
+ }
+ var n int
+ n, err := r.Read(b)
+ t1 := time.Now()
- actual := t1.Sub(t0)
- if t1.Before(deadline) {
- t.Errorf("Read took %s; expected at least %s", actual, d)
- }
- if t.Failed() {
- return
- }
- if want := timeoutUpperBound(d); actual > want {
- next, ok := nextTimeout(actual)
- if !ok {
- t.Fatalf("Read took %s; expected at most %v", actual, want)
- }
- // Maybe this machine is too slow to reliably schedule goroutines within
- // the requested duration. Increase the timeout and try again.
- t.Logf("Read took %s (expected %s); trying with longer timeout", actual, d)
- d = next
- continue
- }
+ if n != 0 || err == nil || !isDeadlineExceeded(err) {
+ t.Errorf("Read did not return (0, timeout): (%d, %v)", n, err)
+ }
+
+ actual := t1.Sub(t0)
+ if t1.Before(deadline) {
+ t.Errorf("Read took %s; expected at least %s", actual, d)
+ }
+ if t.Failed() {
+ return
+ }
+ if want := timeoutUpperBound(d); actual > want {
+ next, ok := nextTimeout(actual)
+ if !ok {
+ t.Fatalf("Read took %s; expected at most %v", actual, want)
+ }
+ // Maybe this machine is too slow to reliably schedule goroutines within
+ // the requested duration. Increase the timeout and try again.
+ t.Logf("Read took %s (expected %s); trying with longer timeout", actual, d)
+ d = next
+ continue
+ }
- break
+ break
+ }
+ })
}
}
func TestWriteTimeoutFluctuation(t *testing.T) {
t.Parallel()
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
- defer w.Close()
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
- d := minDynamicTimeout
- for {
- t.Logf("SetWriteDeadline(+%v)", d)
- t0 := time.Now()
- deadline := t0.Add(d)
- if err := w.SetWriteDeadline(deadline); err != nil {
- t.Fatalf("SetWriteDeadline(%v): %v", deadline, err)
- }
- var n int64
- var err error
- for {
- var dn int
- dn, err = w.Write([]byte("TIMEOUT TRANSMITTER"))
- n += int64(dn)
- if err != nil {
- break
- }
- }
- t1 := time.Now()
- // Inv: err != nil
- if !isDeadlineExceeded(err) {
- t.Fatalf("Write did not return (any, timeout): (%d, %v)", n, err)
- }
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
- actual := t1.Sub(t0)
- if t1.Before(deadline) {
- t.Errorf("Write took %s; expected at least %s", actual, d)
- }
- if t.Failed() {
- return
- }
- if want := timeoutUpperBound(d); actual > want {
- if n > 0 {
- // SetWriteDeadline specifies a time “after which I/O operations fail
- // instead of blocking”. However, the kernel's send buffer is not yet
- // full, we may be able to write some arbitrary (but finite) number of
- // bytes to it without blocking.
- t.Logf("Wrote %d bytes into send buffer; retrying until buffer is full", n)
- if d <= maxDynamicTimeout/2 {
- // We don't know how long the actual write loop would have taken if
- // the buffer were full, so just guess and double the duration so that
- // the next attempt can make twice as much progress toward filling it.
- d *= 2
+ d := minDynamicTimeout
+ for {
+ t.Logf("SetWriteDeadline(+%v)", d)
+ t0 := time.Now()
+ deadline := t0.Add(d)
+ if err := w.SetWriteDeadline(deadline); err != nil {
+ t.Fatalf("SetWriteDeadline(%v): %v", deadline, err)
+ }
+ var n int64
+ var err error
+ for {
+ var dn int
+ dn, err = w.Write([]byte("TIMEOUT TRANSMITTER"))
+ n += int64(dn)
+ if err != nil {
+ break
+ }
+ }
+ t1 := time.Now()
+ // Inv: err != nil
+ if !isDeadlineExceeded(err) {
+ t.Fatalf("Write did not return (any, timeout): (%d, %v)", n, err)
+ }
+
+ actual := t1.Sub(t0)
+ if t1.Before(deadline) {
+ t.Errorf("Write took %s; expected at least %s", actual, d)
+ }
+ if t.Failed() {
+ return
+ }
+ if want := timeoutUpperBound(d); actual > want {
+ if n > 0 {
+ // SetWriteDeadline specifies a time “after which I/O operations fail
+ // instead of blocking”. However, the kernel's send buffer is not yet
+ // full, we may be able to write some arbitrary (but finite) number of
+ // bytes to it without blocking.
+ t.Logf("Wrote %d bytes into send buffer; retrying until buffer is full", n)
+ if d <= maxDynamicTimeout/2 {
+ // We don't know how long the actual write loop would have taken if
+ // the buffer were full, so just guess and double the duration so that
+ // the next attempt can make twice as much progress toward filling it.
+ d *= 2
+ }
+ } else if next, ok := nextTimeout(actual); !ok {
+ t.Fatalf("Write took %s; expected at most %s", actual, want)
+ } else {
+ // Maybe this machine is too slow to reliably schedule goroutines within
+ // the requested duration. Increase the timeout and try again.
+ t.Logf("Write took %s (expected %s); trying with longer timeout", actual, d)
+ d = next
+ }
+ continue
}
- } else if next, ok := nextTimeout(actual); !ok {
- t.Fatalf("Write took %s; expected at most %s", actual, want)
- } else {
- // Maybe this machine is too slow to reliably schedule goroutines within
- // the requested duration. Increase the timeout and try again.
- t.Logf("Write took %s (expected %s); trying with longer timeout", actual, d)
- d = next
- }
- continue
- }
- break
+ break
+ }
+ })
}
}
// There is a very similar copy of this in net/timeout_test.go.
func TestVariousDeadlines(t *testing.T) {
t.Parallel()
- testVariousDeadlines(t)
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+ testVariousDeadlines(t, tc.create)
+ })
+ }
}
// There is a very similar copy of this in net/timeout_test.go.
t.Skip("skipping in short mode")
}
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
- testVariousDeadlines(t)
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+ testVariousDeadlines(t, tc.create)
+ })
+ }
}
// There is a very similar copy of this in net/timeout_test.go.
t.Skip("skipping in short mode")
}
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
- testVariousDeadlines(t)
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+ testVariousDeadlines(t, tc.create)
+ })
+ }
}
type neverEnding byte
return len(p), nil
}
-func testVariousDeadlines(t *testing.T) {
+func testVariousDeadlines(t *testing.T, create func(t *testing.T) (r, w *os.File)) {
type result struct {
n int64
err error
}
for run := 0; run < numRuns; run++ {
t.Run(fmt.Sprintf("%v-%d", timeout, run+1), func(t *testing.T) {
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
+ r, w := create(t)
defer r.Close()
defer w.Close()
select {
case res := <-actvch:
- if !isDeadlineExceeded(err) {
+ if isDeadlineExceeded(res.err) {
t.Logf("good client timeout after %v, reading %d bytes", res.d, res.n)
} else {
t.Fatalf("client Copy = %d, %v; want timeout", res.n, res.err)
N = 50
}
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
+
+ var wg sync.WaitGroup
+ wg.Add(3)
+ go func() {
+ defer wg.Done()
+ tic := time.NewTicker(2 * time.Microsecond)
+ defer tic.Stop()
+ for i := 0; i < N; i++ {
+ if err := r.SetReadDeadline(time.Now().Add(2 * time.Microsecond)); err != nil {
+ break
+ }
+ if err := w.SetWriteDeadline(time.Now().Add(2 * time.Microsecond)); err != nil {
+ break
+ }
+ <-tic.C
+ }
+ }()
+ go func() {
+ defer wg.Done()
+ var b [1]byte
+ for i := 0; i < N; i++ {
+ _, err := r.Read(b[:])
+ if err != nil && !isDeadlineExceeded(err) {
+ t.Error("Read returned non-timeout error", err)
+ }
+ }
+ }()
+ go func() {
+ defer wg.Done()
+ var b [1]byte
+ for i := 0; i < N; i++ {
+ _, err := w.Write(b[:])
+ if err != nil && !isDeadlineExceeded(err) {
+ t.Error("Write returned non-timeout error", err)
+ }
+ }
+ }()
+ wg.Wait() // wait for tester goroutine to stop
+ })
}
- defer r.Close()
- defer w.Close()
-
- var wg sync.WaitGroup
- wg.Add(3)
- go func() {
- defer wg.Done()
- tic := time.NewTicker(2 * time.Microsecond)
- defer tic.Stop()
- for i := 0; i < N; i++ {
- if err := r.SetReadDeadline(time.Now().Add(2 * time.Microsecond)); err != nil {
- break
- }
- if err := w.SetWriteDeadline(time.Now().Add(2 * time.Microsecond)); err != nil {
- break
- }
- <-tic.C
- }
- }()
- go func() {
- defer wg.Done()
- var b [1]byte
- for i := 0; i < N; i++ {
- _, err := r.Read(b[:])
- if err != nil && !isDeadlineExceeded(err) {
- t.Error("Read returned non-timeout error", err)
- }
- }
- }()
- go func() {
- defer wg.Done()
- var b [1]byte
- for i := 0; i < N; i++ {
- _, err := w.Write(b[:])
- if err != nil && !isDeadlineExceeded(err) {
- t.Error("Write returned non-timeout error", err)
- }
- }
- }()
- wg.Wait() // wait for tester goroutine to stop
}
// TestRacyRead tests that it is safe to mutate the input Read buffer
func TestRacyRead(t *testing.T) {
t.Parallel()
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
- defer w.Close()
-
- var wg sync.WaitGroup
- defer wg.Wait()
-
- go io.Copy(w, rand.New(rand.NewSource(0)))
-
- r.SetReadDeadline(time.Now().Add(time.Millisecond))
- for i := 0; i < 10; i++ {
- wg.Add(1)
- go func() {
- defer wg.Done()
-
- b1 := make([]byte, 1024)
- b2 := make([]byte, 1024)
- for j := 0; j < 100; j++ {
- _, err := r.Read(b1)
- copy(b1, b2) // Mutate b1 to trigger potential race
- if err != nil {
- if !isDeadlineExceeded(err) {
- t.Error(err)
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
+
+ var wg sync.WaitGroup
+ defer wg.Wait()
+
+ go io.Copy(w, rand.New(rand.NewSource(0)))
+
+ r.SetReadDeadline(time.Now().Add(time.Millisecond))
+ for i := 0; i < 10; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+
+ b1 := make([]byte, 1024)
+ b2 := make([]byte, 1024)
+ for j := 0; j < 100; j++ {
+ _, err := r.Read(b1)
+ copy(b1, b2) // Mutate b1 to trigger potential race
+ if err != nil {
+ if !isDeadlineExceeded(err) {
+ t.Error(err)
+ }
+ r.SetReadDeadline(time.Now().Add(time.Millisecond))
+ }
}
- r.SetReadDeadline(time.Now().Add(time.Millisecond))
- }
+ }()
}
- }()
+ })
}
}
func TestRacyWrite(t *testing.T) {
t.Parallel()
- r, w, err := os.Pipe()
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
- defer w.Close()
-
- var wg sync.WaitGroup
- defer wg.Wait()
-
- go io.Copy(io.Discard, r)
-
- w.SetWriteDeadline(time.Now().Add(time.Millisecond))
- for i := 0; i < 10; i++ {
- wg.Add(1)
- go func() {
- defer wg.Done()
-
- b1 := make([]byte, 1024)
- b2 := make([]byte, 1024)
- for j := 0; j < 100; j++ {
- _, err := w.Write(b1)
- copy(b1, b2) // Mutate b1 to trigger potential race
- if err != nil {
- if !isDeadlineExceeded(err) {
- t.Error(err)
- }
- w.SetWriteDeadline(time.Now().Add(time.Millisecond))
- }
- }
- }()
- }
-}
+ for _, tc := range pipeDeadlinesTestCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
-// Closing a TTY while reading from it should not hang. Issue 23943.
-func TestTTYClose(t *testing.T) {
- // Ignore SIGTTIN in case we are running in the background.
- signal.Ignore(syscall.SIGTTIN)
- defer signal.Reset(syscall.SIGTTIN)
+ r, w := tc.create(t)
+ defer r.Close()
+ defer w.Close()
- f, err := os.Open("/dev/tty")
- if err != nil {
- t.Skipf("skipping because opening /dev/tty failed: %v", err)
- }
+ var wg sync.WaitGroup
+ defer wg.Wait()
- go func() {
- var buf [1]byte
- f.Read(buf[:])
- }()
-
- // Give the goroutine a chance to enter the read.
- // It doesn't matter much if it occasionally fails to do so,
- // we won't be testing what we want to test but the test will pass.
- time.Sleep(time.Millisecond)
-
- c := make(chan bool)
- go func() {
- defer close(c)
- f.Close()
- }()
-
- select {
- case <-c:
- case <-time.After(time.Second):
- t.Error("timed out waiting for close")
- }
+ go io.Copy(io.Discard, r)
- // On some systems the goroutines may now be hanging.
- // There's not much we can do about that.
+ w.SetWriteDeadline(time.Now().Add(time.Millisecond))
+ for i := 0; i < 10; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+
+ b1 := make([]byte, 1024)
+ b2 := make([]byte, 1024)
+ for j := 0; j < 100; j++ {
+ _, err := w.Write(b1)
+ copy(b1, b2) // Mutate b1 to trigger potential race
+ if err != nil {
+ if !isDeadlineExceeded(err) {
+ t.Error(err)
+ }
+ w.SetWriteDeadline(time.Now().Add(time.Millisecond))
+ }
+ }
+ }()
+ }
+ })
+ }
}