Source file src/net/timeout_test.go

Documentation: net

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  //go:build !js
     6  // +build !js
     7  
     8  package net
     9  
    10  import (
    11  	"errors"
    12  	"fmt"
    13  	"internal/testenv"
    14  	"io"
    15  	"net/internal/socktest"
    16  	"os"
    17  	"runtime"
    18  	"sync"
    19  	"testing"
    20  	"time"
    21  )
    22  
    23  var dialTimeoutTests = []struct {
    24  	timeout time.Duration
    25  	delta   time.Duration // for deadline
    26  
    27  	guard time.Duration
    28  	max   time.Duration
    29  }{
    30  	// Tests that dial timeouts, deadlines in the past work.
    31  	{-5 * time.Second, 0, -5 * time.Second, 100 * time.Millisecond},
    32  	{0, -5 * time.Second, -5 * time.Second, 100 * time.Millisecond},
    33  	{-5 * time.Second, 5 * time.Second, -5 * time.Second, 100 * time.Millisecond}, // timeout over deadline
    34  	{-1 << 63, 0, time.Second, 100 * time.Millisecond},
    35  	{0, -1 << 63, time.Second, 100 * time.Millisecond},
    36  
    37  	{50 * time.Millisecond, 0, 100 * time.Millisecond, time.Second},
    38  	{0, 50 * time.Millisecond, 100 * time.Millisecond, time.Second},
    39  	{50 * time.Millisecond, 5 * time.Second, 100 * time.Millisecond, time.Second}, // timeout over deadline
    40  }
    41  
    42  func TestDialTimeout(t *testing.T) {
    43  	// Cannot use t.Parallel - modifies global hooks.
    44  	origTestHookDialChannel := testHookDialChannel
    45  	defer func() { testHookDialChannel = origTestHookDialChannel }()
    46  	defer sw.Set(socktest.FilterConnect, nil)
    47  
    48  	for i, tt := range dialTimeoutTests {
    49  		switch runtime.GOOS {
    50  		case "plan9", "windows":
    51  			testHookDialChannel = func() { time.Sleep(tt.guard) }
    52  			if runtime.GOOS == "plan9" {
    53  				break
    54  			}
    55  			fallthrough
    56  		default:
    57  			sw.Set(socktest.FilterConnect, func(so *socktest.Status) (socktest.AfterFilter, error) {
    58  				time.Sleep(tt.guard)
    59  				return nil, errTimedout
    60  			})
    61  		}
    62  
    63  		ch := make(chan error)
    64  		d := Dialer{Timeout: tt.timeout}
    65  		if tt.delta != 0 {
    66  			d.Deadline = time.Now().Add(tt.delta)
    67  		}
    68  		max := time.NewTimer(tt.max)
    69  		defer max.Stop()
    70  		go func() {
    71  			// This dial never starts to send any TCP SYN
    72  			// segment because of above socket filter and
    73  			// test hook.
    74  			c, err := d.Dial("tcp", "127.0.0.1:0")
    75  			if err == nil {
    76  				err = fmt.Errorf("unexpectedly established: tcp:%s->%s", c.LocalAddr(), c.RemoteAddr())
    77  				c.Close()
    78  			}
    79  			ch <- err
    80  		}()
    81  
    82  		select {
    83  		case <-max.C:
    84  			t.Fatalf("#%d: Dial didn't return in an expected time", i)
    85  		case err := <-ch:
    86  			if perr := parseDialError(err); perr != nil {
    87  				t.Errorf("#%d: %v", i, perr)
    88  			}
    89  			if nerr, ok := err.(Error); !ok || !nerr.Timeout() {
    90  				t.Fatalf("#%d: %v", i, err)
    91  			}
    92  		}
    93  	}
    94  }
    95  
    96  var dialTimeoutMaxDurationTests = []struct {
    97  	timeout time.Duration
    98  	delta   time.Duration // for deadline
    99  }{
   100  	// Large timeouts that will overflow an int64 unix nanos.
   101  	{1<<63 - 1, 0},
   102  	{0, 1<<63 - 1},
   103  }
   104  
   105  func TestDialTimeoutMaxDuration(t *testing.T) {
   106  	if runtime.GOOS == "openbsd" {
   107  		testenv.SkipFlaky(t, 15157)
   108  	}
   109  
   110  	ln, err := newLocalListener("tcp")
   111  	if err != nil {
   112  		t.Fatal(err)
   113  	}
   114  	defer ln.Close()
   115  
   116  	for i, tt := range dialTimeoutMaxDurationTests {
   117  		ch := make(chan error)
   118  		max := time.NewTimer(250 * time.Millisecond)
   119  		defer max.Stop()
   120  		go func() {
   121  			d := Dialer{Timeout: tt.timeout}
   122  			if tt.delta != 0 {
   123  				d.Deadline = time.Now().Add(tt.delta)
   124  			}
   125  			c, err := d.Dial(ln.Addr().Network(), ln.Addr().String())
   126  			if err == nil {
   127  				c.Close()
   128  			}
   129  			ch <- err
   130  		}()
   131  
   132  		select {
   133  		case <-max.C:
   134  			t.Fatalf("#%d: Dial didn't return in an expected time", i)
   135  		case err := <-ch:
   136  			if perr := parseDialError(err); perr != nil {
   137  				t.Error(perr)
   138  			}
   139  			if err != nil {
   140  				t.Errorf("#%d: %v", i, err)
   141  			}
   142  		}
   143  	}
   144  }
   145  
   146  var acceptTimeoutTests = []struct {
   147  	timeout time.Duration
   148  	xerrs   [2]error // expected errors in transition
   149  }{
   150  	// Tests that accept deadlines in the past work, even if
   151  	// there's incoming connections available.
   152  	{-5 * time.Second, [2]error{os.ErrDeadlineExceeded, os.ErrDeadlineExceeded}},
   153  
   154  	{50 * time.Millisecond, [2]error{nil, os.ErrDeadlineExceeded}},
   155  }
   156  
   157  func TestAcceptTimeout(t *testing.T) {
   158  	testenv.SkipFlaky(t, 17948)
   159  	t.Parallel()
   160  
   161  	switch runtime.GOOS {
   162  	case "plan9":
   163  		t.Skipf("not supported on %s", runtime.GOOS)
   164  	}
   165  
   166  	ln, err := newLocalListener("tcp")
   167  	if err != nil {
   168  		t.Fatal(err)
   169  	}
   170  	defer ln.Close()
   171  
   172  	var wg sync.WaitGroup
   173  	for i, tt := range acceptTimeoutTests {
   174  		if tt.timeout < 0 {
   175  			wg.Add(1)
   176  			go func() {
   177  				defer wg.Done()
   178  				d := Dialer{Timeout: 100 * time.Millisecond}
   179  				c, err := d.Dial(ln.Addr().Network(), ln.Addr().String())
   180  				if err != nil {
   181  					t.Error(err)
   182  					return
   183  				}
   184  				c.Close()
   185  			}()
   186  		}
   187  
   188  		if err := ln.(*TCPListener).SetDeadline(time.Now().Add(tt.timeout)); err != nil {
   189  			t.Fatalf("$%d: %v", i, err)
   190  		}
   191  		for j, xerr := range tt.xerrs {
   192  			for {
   193  				c, err := ln.Accept()
   194  				if xerr != nil {
   195  					if perr := parseAcceptError(err); perr != nil {
   196  						t.Errorf("#%d/%d: %v", i, j, perr)
   197  					}
   198  					if !isDeadlineExceeded(err) {
   199  						t.Fatalf("#%d/%d: %v", i, j, err)
   200  					}
   201  				}
   202  				if err == nil {
   203  					c.Close()
   204  					time.Sleep(10 * time.Millisecond)
   205  					continue
   206  				}
   207  				break
   208  			}
   209  		}
   210  	}
   211  	wg.Wait()
   212  }
   213  
   214  func TestAcceptTimeoutMustReturn(t *testing.T) {
   215  	t.Parallel()
   216  
   217  	switch runtime.GOOS {
   218  	case "plan9":
   219  		t.Skipf("not supported on %s", runtime.GOOS)
   220  	}
   221  
   222  	ln, err := newLocalListener("tcp")
   223  	if err != nil {
   224  		t.Fatal(err)
   225  	}
   226  	defer ln.Close()
   227  
   228  	max := time.NewTimer(time.Second)
   229  	defer max.Stop()
   230  	ch := make(chan error)
   231  	go func() {
   232  		if err := ln.(*TCPListener).SetDeadline(noDeadline); err != nil {
   233  			t.Error(err)
   234  		}
   235  		if err := ln.(*TCPListener).SetDeadline(time.Now().Add(10 * time.Millisecond)); err != nil {
   236  			t.Error(err)
   237  		}
   238  		c, err := ln.Accept()
   239  		if err == nil {
   240  			c.Close()
   241  		}
   242  		ch <- err
   243  	}()
   244  
   245  	select {
   246  	case <-max.C:
   247  		ln.Close()
   248  		<-ch // wait for tester goroutine to stop
   249  		t.Fatal("Accept didn't return in an expected time")
   250  	case err := <-ch:
   251  		if perr := parseAcceptError(err); perr != nil {
   252  			t.Error(perr)
   253  		}
   254  		if !isDeadlineExceeded(err) {
   255  			t.Fatal(err)
   256  		}
   257  	}
   258  }
   259  
   260  func TestAcceptTimeoutMustNotReturn(t *testing.T) {
   261  	t.Parallel()
   262  
   263  	switch runtime.GOOS {
   264  	case "plan9":
   265  		t.Skipf("not supported on %s", runtime.GOOS)
   266  	}
   267  
   268  	ln, err := newLocalListener("tcp")
   269  	if err != nil {
   270  		t.Fatal(err)
   271  	}
   272  	defer ln.Close()
   273  
   274  	max := time.NewTimer(100 * time.Millisecond)
   275  	defer max.Stop()
   276  	ch := make(chan error)
   277  	go func() {
   278  		if err := ln.(*TCPListener).SetDeadline(time.Now().Add(-5 * time.Second)); err != nil {
   279  			t.Error(err)
   280  		}
   281  		if err := ln.(*TCPListener).SetDeadline(noDeadline); err != nil {
   282  			t.Error(err)
   283  		}
   284  		_, err := ln.Accept()
   285  		ch <- err
   286  	}()
   287  
   288  	select {
   289  	case err := <-ch:
   290  		if perr := parseAcceptError(err); perr != nil {
   291  			t.Error(perr)
   292  		}
   293  		t.Fatalf("expected Accept to not return, but it returned with %v", err)
   294  	case <-max.C:
   295  		ln.Close()
   296  		<-ch // wait for tester goroutine to stop
   297  	}
   298  }
   299  
   300  var readTimeoutTests = []struct {
   301  	timeout time.Duration
   302  	xerrs   [2]error // expected errors in transition
   303  }{
   304  	// Tests that read deadlines work, even if there's data ready
   305  	// to be read.
   306  	{-5 * time.Second, [2]error{os.ErrDeadlineExceeded, os.ErrDeadlineExceeded}},
   307  
   308  	{50 * time.Millisecond, [2]error{nil, os.ErrDeadlineExceeded}},
   309  }
   310  
   311  func TestReadTimeout(t *testing.T) {
   312  	handler := func(ls *localServer, ln Listener) {
   313  		c, err := ln.Accept()
   314  		if err != nil {
   315  			t.Error(err)
   316  			return
   317  		}
   318  		c.Write([]byte("READ TIMEOUT TEST"))
   319  		defer c.Close()
   320  	}
   321  	ls, err := newLocalServer("tcp")
   322  	if err != nil {
   323  		t.Fatal(err)
   324  	}
   325  	defer ls.teardown()
   326  	if err := ls.buildup(handler); err != nil {
   327  		t.Fatal(err)
   328  	}
   329  
   330  	c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String())
   331  	if err != nil {
   332  		t.Fatal(err)
   333  	}
   334  	defer c.Close()
   335  
   336  	for i, tt := range readTimeoutTests {
   337  		if err := c.SetReadDeadline(time.Now().Add(tt.timeout)); err != nil {
   338  			t.Fatalf("#%d: %v", i, err)
   339  		}
   340  		var b [1]byte
   341  		for j, xerr := range tt.xerrs {
   342  			for {
   343  				n, err := c.Read(b[:])
   344  				if xerr != nil {
   345  					if perr := parseReadError(err); perr != nil {
   346  						t.Errorf("#%d/%d: %v", i, j, perr)
   347  					}
   348  					if !isDeadlineExceeded(err) {
   349  						t.Fatalf("#%d/%d: %v", i, j, err)
   350  					}
   351  				}
   352  				if err == nil {
   353  					time.Sleep(tt.timeout / 3)
   354  					continue
   355  				}
   356  				if n != 0 {
   357  					t.Fatalf("#%d/%d: read %d; want 0", i, j, n)
   358  				}
   359  				break
   360  			}
   361  		}
   362  	}
   363  }
   364  
   365  func TestReadTimeoutMustNotReturn(t *testing.T) {
   366  	t.Parallel()
   367  
   368  	switch runtime.GOOS {
   369  	case "plan9":
   370  		t.Skipf("not supported on %s", runtime.GOOS)
   371  	}
   372  
   373  	ln, err := newLocalListener("tcp")
   374  	if err != nil {
   375  		t.Fatal(err)
   376  	}
   377  	defer ln.Close()
   378  
   379  	c, err := Dial(ln.Addr().Network(), ln.Addr().String())
   380  	if err != nil {
   381  		t.Fatal(err)
   382  	}
   383  	defer c.Close()
   384  
   385  	max := time.NewTimer(100 * time.Millisecond)
   386  	defer max.Stop()
   387  	ch := make(chan error)
   388  	go func() {
   389  		if err := c.SetDeadline(time.Now().Add(-5 * time.Second)); err != nil {
   390  			t.Error(err)
   391  		}
   392  		if err := c.SetWriteDeadline(time.Now().Add(-5 * time.Second)); err != nil {
   393  			t.Error(err)
   394  		}
   395  		if err := c.SetReadDeadline(noDeadline); err != nil {
   396  			t.Error(err)
   397  		}
   398  		var b [1]byte
   399  		_, err := c.Read(b[:])
   400  		ch <- err
   401  	}()
   402  
   403  	select {
   404  	case err := <-ch:
   405  		if perr := parseReadError(err); perr != nil {
   406  			t.Error(perr)
   407  		}
   408  		t.Fatalf("expected Read to not return, but it returned with %v", err)
   409  	case <-max.C:
   410  		c.Close()
   411  		err := <-ch // wait for tester goroutine to stop
   412  		if perr := parseReadError(err); perr != nil {
   413  			t.Error(perr)
   414  		}
   415  		if nerr, ok := err.(Error); !ok || nerr.Timeout() || nerr.Temporary() {
   416  			t.Fatal(err)
   417  		}
   418  	}
   419  }
   420  
   421  var readFromTimeoutTests = []struct {
   422  	timeout time.Duration
   423  	xerrs   [2]error // expected errors in transition
   424  }{
   425  	// Tests that read deadlines work, even if there's data ready
   426  	// to be read.
   427  	{-5 * time.Second, [2]error{os.ErrDeadlineExceeded, os.ErrDeadlineExceeded}},
   428  
   429  	{50 * time.Millisecond, [2]error{nil, os.ErrDeadlineExceeded}},
   430  }
   431  
   432  func TestReadFromTimeout(t *testing.T) {
   433  	ch := make(chan Addr)
   434  	defer close(ch)
   435  	handler := func(ls *localPacketServer, c PacketConn) {
   436  		if dst, ok := <-ch; ok {
   437  			c.WriteTo([]byte("READFROM TIMEOUT TEST"), dst)
   438  		}
   439  	}
   440  	ls, err := newLocalPacketServer("udp")
   441  	if err != nil {
   442  		t.Fatal(err)
   443  	}
   444  	defer ls.teardown()
   445  	if err := ls.buildup(handler); err != nil {
   446  		t.Fatal(err)
   447  	}
   448  
   449  	host, _, err := SplitHostPort(ls.PacketConn.LocalAddr().String())
   450  	if err != nil {
   451  		t.Fatal(err)
   452  	}
   453  	c, err := ListenPacket(ls.PacketConn.LocalAddr().Network(), JoinHostPort(host, "0"))
   454  	if err != nil {
   455  		t.Fatal(err)
   456  	}
   457  	defer c.Close()
   458  	ch <- c.LocalAddr()
   459  
   460  	for i, tt := range readFromTimeoutTests {
   461  		if err := c.SetReadDeadline(time.Now().Add(tt.timeout)); err != nil {
   462  			t.Fatalf("#%d: %v", i, err)
   463  		}
   464  		var b [1]byte
   465  		for j, xerr := range tt.xerrs {
   466  			for {
   467  				n, _, err := c.ReadFrom(b[:])
   468  				if xerr != nil {
   469  					if perr := parseReadError(err); perr != nil {
   470  						t.Errorf("#%d/%d: %v", i, j, perr)
   471  					}
   472  					if !isDeadlineExceeded(err) {
   473  						t.Fatalf("#%d/%d: %v", i, j, err)
   474  					}
   475  				}
   476  				if err == nil {
   477  					time.Sleep(tt.timeout / 3)
   478  					continue
   479  				}
   480  				if nerr, ok := err.(Error); ok && nerr.Timeout() && n != 0 {
   481  					t.Fatalf("#%d/%d: read %d; want 0", i, j, n)
   482  				}
   483  				break
   484  			}
   485  		}
   486  	}
   487  }
   488  
   489  var writeTimeoutTests = []struct {
   490  	timeout time.Duration
   491  	xerrs   [2]error // expected errors in transition
   492  }{
   493  	// Tests that write deadlines work, even if there's buffer
   494  	// space available to write.
   495  	{-5 * time.Second, [2]error{os.ErrDeadlineExceeded, os.ErrDeadlineExceeded}},
   496  
   497  	{10 * time.Millisecond, [2]error{nil, os.ErrDeadlineExceeded}},
   498  }
   499  
   500  func TestWriteTimeout(t *testing.T) {
   501  	t.Parallel()
   502  
   503  	ln, err := newLocalListener("tcp")
   504  	if err != nil {
   505  		t.Fatal(err)
   506  	}
   507  	defer ln.Close()
   508  
   509  	for i, tt := range writeTimeoutTests {
   510  		c, err := Dial(ln.Addr().Network(), ln.Addr().String())
   511  		if err != nil {
   512  			t.Fatal(err)
   513  		}
   514  		defer c.Close()
   515  
   516  		if err := c.SetWriteDeadline(time.Now().Add(tt.timeout)); err != nil {
   517  			t.Fatalf("#%d: %v", i, err)
   518  		}
   519  		for j, xerr := range tt.xerrs {
   520  			for {
   521  				n, err := c.Write([]byte("WRITE TIMEOUT TEST"))
   522  				if xerr != nil {
   523  					if perr := parseWriteError(err); perr != nil {
   524  						t.Errorf("#%d/%d: %v", i, j, perr)
   525  					}
   526  					if !isDeadlineExceeded(err) {
   527  						t.Fatalf("#%d/%d: %v", i, j, err)
   528  					}
   529  				}
   530  				if err == nil {
   531  					time.Sleep(tt.timeout / 3)
   532  					continue
   533  				}
   534  				if n != 0 {
   535  					t.Fatalf("#%d/%d: wrote %d; want 0", i, j, n)
   536  				}
   537  				break
   538  			}
   539  		}
   540  	}
   541  }
   542  
   543  func TestWriteTimeoutMustNotReturn(t *testing.T) {
   544  	t.Parallel()
   545  
   546  	switch runtime.GOOS {
   547  	case "plan9":
   548  		t.Skipf("not supported on %s", runtime.GOOS)
   549  	}
   550  
   551  	ln, err := newLocalListener("tcp")
   552  	if err != nil {
   553  		t.Fatal(err)
   554  	}
   555  	defer ln.Close()
   556  
   557  	c, err := Dial(ln.Addr().Network(), ln.Addr().String())
   558  	if err != nil {
   559  		t.Fatal(err)
   560  	}
   561  	defer c.Close()
   562  
   563  	max := time.NewTimer(100 * time.Millisecond)
   564  	defer max.Stop()
   565  	ch := make(chan error)
   566  	go func() {
   567  		if err := c.SetDeadline(time.Now().Add(-5 * time.Second)); err != nil {
   568  			t.Error(err)
   569  		}
   570  		if err := c.SetReadDeadline(time.Now().Add(-5 * time.Second)); err != nil {
   571  			t.Error(err)
   572  		}
   573  		if err := c.SetWriteDeadline(noDeadline); err != nil {
   574  			t.Error(err)
   575  		}
   576  		var b [1]byte
   577  		for {
   578  			if _, err := c.Write(b[:]); err != nil {
   579  				ch <- err
   580  				break
   581  			}
   582  		}
   583  	}()
   584  
   585  	select {
   586  	case err := <-ch:
   587  		if perr := parseWriteError(err); perr != nil {
   588  			t.Error(perr)
   589  		}
   590  		t.Fatalf("expected Write to not return, but it returned with %v", err)
   591  	case <-max.C:
   592  		c.Close()
   593  		err := <-ch // wait for tester goroutine to stop
   594  		if perr := parseWriteError(err); perr != nil {
   595  			t.Error(perr)
   596  		}
   597  		if nerr, ok := err.(Error); !ok || nerr.Timeout() || nerr.Temporary() {
   598  			t.Fatal(err)
   599  		}
   600  	}
   601  }
   602  
   603  var writeToTimeoutTests = []struct {
   604  	timeout time.Duration
   605  	xerrs   [2]error // expected errors in transition
   606  }{
   607  	// Tests that write deadlines work, even if there's buffer
   608  	// space available to write.
   609  	{-5 * time.Second, [2]error{os.ErrDeadlineExceeded, os.ErrDeadlineExceeded}},
   610  
   611  	{10 * time.Millisecond, [2]error{nil, os.ErrDeadlineExceeded}},
   612  }
   613  
   614  func TestWriteToTimeout(t *testing.T) {
   615  	t.Parallel()
   616  
   617  	c1, err := newLocalPacketListener("udp")
   618  	if err != nil {
   619  		t.Fatal(err)
   620  	}
   621  	defer c1.Close()
   622  
   623  	host, _, err := SplitHostPort(c1.LocalAddr().String())
   624  	if err != nil {
   625  		t.Fatal(err)
   626  	}
   627  
   628  	for i, tt := range writeToTimeoutTests {
   629  		c2, err := ListenPacket(c1.LocalAddr().Network(), JoinHostPort(host, "0"))
   630  		if err != nil {
   631  			t.Fatal(err)
   632  		}
   633  		defer c2.Close()
   634  
   635  		if err := c2.SetWriteDeadline(time.Now().Add(tt.timeout)); err != nil {
   636  			t.Fatalf("#%d: %v", i, err)
   637  		}
   638  		for j, xerr := range tt.xerrs {
   639  			for {
   640  				n, err := c2.WriteTo([]byte("WRITETO TIMEOUT TEST"), c1.LocalAddr())
   641  				if xerr != nil {
   642  					if perr := parseWriteError(err); perr != nil {
   643  						t.Errorf("#%d/%d: %v", i, j, perr)
   644  					}
   645  					if !isDeadlineExceeded(err) {
   646  						t.Fatalf("#%d/%d: %v", i, j, err)
   647  					}
   648  				}
   649  				if err == nil {
   650  					time.Sleep(tt.timeout / 3)
   651  					continue
   652  				}
   653  				if n != 0 {
   654  					t.Fatalf("#%d/%d: wrote %d; want 0", i, j, n)
   655  				}
   656  				break
   657  			}
   658  		}
   659  	}
   660  }
   661  
   662  func TestReadTimeoutFluctuation(t *testing.T) {
   663  	t.Parallel()
   664  
   665  	ln, err := newLocalListener("tcp")
   666  	if err != nil {
   667  		t.Fatal(err)
   668  	}
   669  	defer ln.Close()
   670  
   671  	c, err := Dial(ln.Addr().Network(), ln.Addr().String())
   672  	if err != nil {
   673  		t.Fatal(err)
   674  	}
   675  	defer c.Close()
   676  
   677  	max := time.NewTimer(time.Second)
   678  	defer max.Stop()
   679  	ch := make(chan error)
   680  	go timeoutReceiver(c, 100*time.Millisecond, 50*time.Millisecond, 250*time.Millisecond, ch)
   681  
   682  	select {
   683  	case <-max.C:
   684  		t.Fatal("Read took over 1s; expected 0.1s")
   685  	case err := <-ch:
   686  		if perr := parseReadError(err); perr != nil {
   687  			t.Error(perr)
   688  		}
   689  		if !isDeadlineExceeded(err) {
   690  			t.Fatal(err)
   691  		}
   692  	}
   693  }
   694  
   695  func TestReadFromTimeoutFluctuation(t *testing.T) {
   696  	t.Parallel()
   697  
   698  	c1, err := newLocalPacketListener("udp")
   699  	if err != nil {
   700  		t.Fatal(err)
   701  	}
   702  	defer c1.Close()
   703  
   704  	c2, err := Dial(c1.LocalAddr().Network(), c1.LocalAddr().String())
   705  	if err != nil {
   706  		t.Fatal(err)
   707  	}
   708  	defer c2.Close()
   709  
   710  	max := time.NewTimer(time.Second)
   711  	defer max.Stop()
   712  	ch := make(chan error)
   713  	go timeoutPacketReceiver(c2.(PacketConn), 100*time.Millisecond, 50*time.Millisecond, 250*time.Millisecond, ch)
   714  
   715  	select {
   716  	case <-max.C:
   717  		t.Fatal("ReadFrom took over 1s; expected 0.1s")
   718  	case err := <-ch:
   719  		if perr := parseReadError(err); perr != nil {
   720  			t.Error(perr)
   721  		}
   722  		if !isDeadlineExceeded(err) {
   723  			t.Fatal(err)
   724  		}
   725  	}
   726  }
   727  
   728  func TestWriteTimeoutFluctuation(t *testing.T) {
   729  	t.Parallel()
   730  
   731  	switch runtime.GOOS {
   732  	case "plan9":
   733  		t.Skipf("not supported on %s", runtime.GOOS)
   734  	}
   735  
   736  	ln, err := newLocalListener("tcp")
   737  	if err != nil {
   738  		t.Fatal(err)
   739  	}
   740  	defer ln.Close()
   741  
   742  	c, err := Dial(ln.Addr().Network(), ln.Addr().String())
   743  	if err != nil {
   744  		t.Fatal(err)
   745  	}
   746  	defer c.Close()
   747  
   748  	d := time.Second
   749  	if iOS() {
   750  		d = 3 * time.Second // see golang.org/issue/10775
   751  	}
   752  	max := time.NewTimer(d)
   753  	defer max.Stop()
   754  	ch := make(chan error)
   755  	go timeoutTransmitter(c, 100*time.Millisecond, 50*time.Millisecond, 250*time.Millisecond, ch)
   756  
   757  	select {
   758  	case <-max.C:
   759  		t.Fatalf("Write took over %v; expected 0.1s", d)
   760  	case err := <-ch:
   761  		if perr := parseWriteError(err); perr != nil {
   762  			t.Error(perr)
   763  		}
   764  		if !isDeadlineExceeded(err) {
   765  			t.Fatal(err)
   766  		}
   767  	}
   768  }
   769  
   770  func TestVariousDeadlines(t *testing.T) {
   771  	t.Parallel()
   772  	testVariousDeadlines(t)
   773  }
   774  
   775  func TestVariousDeadlines1Proc(t *testing.T) {
   776  	// Cannot use t.Parallel - modifies global GOMAXPROCS.
   777  	if testing.Short() {
   778  		t.Skip("skipping in short mode")
   779  	}
   780  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
   781  	testVariousDeadlines(t)
   782  }
   783  
   784  func TestVariousDeadlines4Proc(t *testing.T) {
   785  	// Cannot use t.Parallel - modifies global GOMAXPROCS.
   786  	if testing.Short() {
   787  		t.Skip("skipping in short mode")
   788  	}
   789  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
   790  	testVariousDeadlines(t)
   791  }
   792  
   793  type neverEnding byte
   794  
   795  func (b neverEnding) Read(p []byte) (int, error) {
   796  	for i := range p {
   797  		p[i] = byte(b)
   798  	}
   799  	return len(p), nil
   800  }
   801  
   802  func testVariousDeadlines(t *testing.T) {
   803  	if runtime.GOOS == "plan9" {
   804  		t.Skip("skipping test on plan9; see golang.org/issue/26945")
   805  	}
   806  	type result struct {
   807  		n   int64
   808  		err error
   809  		d   time.Duration
   810  	}
   811  
   812  	handler := func(ls *localServer, ln Listener) {
   813  		for {
   814  			c, err := ln.Accept()
   815  			if err != nil {
   816  				break
   817  			}
   818  			c.Read(make([]byte, 1)) // wait for client to close connection
   819  			c.Close()
   820  		}
   821  	}
   822  	ls, err := newLocalServer("tcp")
   823  	if err != nil {
   824  		t.Fatal(err)
   825  	}
   826  	defer ls.teardown()
   827  	if err := ls.buildup(handler); err != nil {
   828  		t.Fatal(err)
   829  	}
   830  
   831  	for _, timeout := range []time.Duration{
   832  		1 * time.Nanosecond,
   833  		2 * time.Nanosecond,
   834  		5 * time.Nanosecond,
   835  		50 * time.Nanosecond,
   836  		100 * time.Nanosecond,
   837  		200 * time.Nanosecond,
   838  		500 * time.Nanosecond,
   839  		750 * time.Nanosecond,
   840  		1 * time.Microsecond,
   841  		5 * time.Microsecond,
   842  		25 * time.Microsecond,
   843  		250 * time.Microsecond,
   844  		500 * time.Microsecond,
   845  		1 * time.Millisecond,
   846  		5 * time.Millisecond,
   847  		100 * time.Millisecond,
   848  		250 * time.Millisecond,
   849  		500 * time.Millisecond,
   850  		1 * time.Second,
   851  	} {
   852  		numRuns := 3
   853  		if testing.Short() {
   854  			numRuns = 1
   855  			if timeout > 500*time.Microsecond {
   856  				continue
   857  			}
   858  		}
   859  		for run := 0; run < numRuns; run++ {
   860  			name := fmt.Sprintf("%v %d/%d", timeout, run, numRuns)
   861  			t.Log(name)
   862  
   863  			tooSlow := time.NewTimer(5 * time.Second)
   864  			defer tooSlow.Stop()
   865  
   866  			c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String())
   867  			if err != nil {
   868  				t.Fatal(err)
   869  			}
   870  
   871  			ch := make(chan result, 1)
   872  			go func() {
   873  				t0 := time.Now()
   874  				if err := c.SetDeadline(t0.Add(timeout)); err != nil {
   875  					t.Error(err)
   876  				}
   877  				n, err := io.Copy(io.Discard, c)
   878  				dt := time.Since(t0)
   879  				c.Close()
   880  				ch <- result{n, err, dt}
   881  			}()
   882  
   883  			select {
   884  			case res := <-ch:
   885  				if nerr, ok := res.err.(Error); ok && nerr.Timeout() {
   886  					t.Logf("%v: good timeout after %v; %d bytes", name, res.d, res.n)
   887  				} else {
   888  					t.Fatalf("%v: Copy = %d, %v; want timeout", name, res.n, res.err)
   889  				}
   890  			case <-tooSlow.C:
   891  				t.Fatalf("%v: client stuck in Dial+Copy", name)
   892  			}
   893  		}
   894  	}
   895  }
   896  
   897  // TestReadWriteProlongedTimeout tests concurrent deadline
   898  // modification. Known to cause data races in the past.
   899  func TestReadWriteProlongedTimeout(t *testing.T) {
   900  	t.Parallel()
   901  
   902  	switch runtime.GOOS {
   903  	case "plan9":
   904  		t.Skipf("not supported on %s", runtime.GOOS)
   905  	}
   906  
   907  	handler := func(ls *localServer, ln Listener) {
   908  		c, err := ln.Accept()
   909  		if err != nil {
   910  			t.Error(err)
   911  			return
   912  		}
   913  		defer c.Close()
   914  
   915  		var wg sync.WaitGroup
   916  		wg.Add(2)
   917  		go func() {
   918  			defer wg.Done()
   919  			var b [1]byte
   920  			for {
   921  				if err := c.SetReadDeadline(time.Now().Add(time.Hour)); err != nil {
   922  					if perr := parseCommonError(err); perr != nil {
   923  						t.Error(perr)
   924  					}
   925  					t.Error(err)
   926  					return
   927  				}
   928  				if _, err := c.Read(b[:]); err != nil {
   929  					if perr := parseReadError(err); perr != nil {
   930  						t.Error(perr)
   931  					}
   932  					return
   933  				}
   934  			}
   935  		}()
   936  		go func() {
   937  			defer wg.Done()
   938  			var b [1]byte
   939  			for {
   940  				if err := c.SetWriteDeadline(time.Now().Add(time.Hour)); err != nil {
   941  					if perr := parseCommonError(err); perr != nil {
   942  						t.Error(perr)
   943  					}
   944  					t.Error(err)
   945  					return
   946  				}
   947  				if _, err := c.Write(b[:]); err != nil {
   948  					if perr := parseWriteError(err); perr != nil {
   949  						t.Error(perr)
   950  					}
   951  					return
   952  				}
   953  			}
   954  		}()
   955  		wg.Wait()
   956  	}
   957  	ls, err := newLocalServer("tcp")
   958  	if err != nil {
   959  		t.Fatal(err)
   960  	}
   961  	defer ls.teardown()
   962  	if err := ls.buildup(handler); err != nil {
   963  		t.Fatal(err)
   964  	}
   965  
   966  	c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String())
   967  	if err != nil {
   968  		t.Fatal(err)
   969  	}
   970  	defer c.Close()
   971  
   972  	var b [1]byte
   973  	for i := 0; i < 1000; i++ {
   974  		c.Write(b[:])
   975  		c.Read(b[:])
   976  	}
   977  }
   978  
   979  func TestReadWriteDeadlineRace(t *testing.T) {
   980  	t.Parallel()
   981  
   982  	N := 1000
   983  	if testing.Short() {
   984  		N = 50
   985  	}
   986  
   987  	ln, err := newLocalListener("tcp")
   988  	if err != nil {
   989  		t.Fatal(err)
   990  	}
   991  	defer ln.Close()
   992  
   993  	c, err := Dial(ln.Addr().Network(), ln.Addr().String())
   994  	if err != nil {
   995  		t.Fatal(err)
   996  	}
   997  	defer c.Close()
   998  
   999  	var wg sync.WaitGroup
  1000  	wg.Add(3)
  1001  	go func() {
  1002  		defer wg.Done()
  1003  		tic := time.NewTicker(2 * time.Microsecond)
  1004  		defer tic.Stop()
  1005  		for i := 0; i < N; i++ {
  1006  			if err := c.SetReadDeadline(time.Now().Add(2 * time.Microsecond)); err != nil {
  1007  				if perr := parseCommonError(err); perr != nil {
  1008  					t.Error(perr)
  1009  				}
  1010  				break
  1011  			}
  1012  			if err := c.SetWriteDeadline(time.Now().Add(2 * time.Microsecond)); err != nil {
  1013  				if perr := parseCommonError(err); perr != nil {
  1014  					t.Error(perr)
  1015  				}
  1016  				break
  1017  			}
  1018  			<-tic.C
  1019  		}
  1020  	}()
  1021  	go func() {
  1022  		defer wg.Done()
  1023  		var b [1]byte
  1024  		for i := 0; i < N; i++ {
  1025  			c.Read(b[:]) // ignore possible timeout errors
  1026  		}
  1027  	}()
  1028  	go func() {
  1029  		defer wg.Done()
  1030  		var b [1]byte
  1031  		for i := 0; i < N; i++ {
  1032  			c.Write(b[:]) // ignore possible timeout errors
  1033  		}
  1034  	}()
  1035  	wg.Wait() // wait for tester goroutine to stop
  1036  }
  1037  
  1038  // Issue 35367.
  1039  func TestConcurrentSetDeadline(t *testing.T) {
  1040  	ln, err := newLocalListener("tcp")
  1041  	if err != nil {
  1042  		t.Fatal(err)
  1043  	}
  1044  	defer ln.Close()
  1045  
  1046  	const goroutines = 8
  1047  	const conns = 10
  1048  	const tries = 100
  1049  
  1050  	var c [conns]Conn
  1051  	for i := 0; i < conns; i++ {
  1052  		c[i], err = Dial(ln.Addr().Network(), ln.Addr().String())
  1053  		if err != nil {
  1054  			t.Fatal(err)
  1055  		}
  1056  		defer c[i].Close()
  1057  	}
  1058  
  1059  	var wg sync.WaitGroup
  1060  	wg.Add(goroutines)
  1061  	now := time.Now()
  1062  	for i := 0; i < goroutines; i++ {
  1063  		go func(i int) {
  1064  			defer wg.Done()
  1065  			// Make the deadlines steadily earlier,
  1066  			// to trigger runtime adjusttimers calls.
  1067  			for j := tries; j > 0; j-- {
  1068  				for k := 0; k < conns; k++ {
  1069  					c[k].SetReadDeadline(now.Add(2*time.Hour + time.Duration(i*j*k)*time.Second))
  1070  					c[k].SetWriteDeadline(now.Add(1*time.Hour + time.Duration(i*j*k)*time.Second))
  1071  				}
  1072  			}
  1073  		}(i)
  1074  	}
  1075  	wg.Wait()
  1076  }
  1077  
  1078  // isDeadlineExceeded reports whether err is or wraps os.ErrDeadlineExceeded.
  1079  // We also check that the error implements net.Error, and that the
  1080  // Timeout method returns true.
  1081  func isDeadlineExceeded(err error) bool {
  1082  	nerr, ok := err.(Error)
  1083  	if !ok {
  1084  		return false
  1085  	}
  1086  	if !nerr.Timeout() {
  1087  		return false
  1088  	}
  1089  	if !errors.Is(err, os.ErrDeadlineExceeded) {
  1090  		return false
  1091  	}
  1092  	return true
  1093  }
  1094  

View as plain text