libgo/go/net/timeout_test.go

   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 package net
   6
   7 import (
   8         "fmt"
   9         "runtime"
  10         "testing"
  11         "time"
  12 )
  13
  14 func testTimeout(t *testing.T, net, addr string, readFrom bool) {
  15         c, err := Dial(net, addr)
  16         if err != nil {
  17                 t.Errorf("Dial(%q, %q) failed: %v", net, addr, err)
  18                 return
  19         }
  20         defer c.Close()
  21         what := "Read"
  22         if readFrom {
  23                 what = "ReadFrom"
  24         }
  25
  26         errc := make(chan error, 1)
  27         go func() {
  28                 t0 := time.Now()
  29                 c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
  30                 var b [100]byte
  31                 var n int
  32                 var err error
  33                 if readFrom {
  34                         n, _, err = c.(PacketConn).ReadFrom(b[0:])
  35                 } else {
  36                         n, err = c.Read(b[0:])
  37                 }
  38                 t1 := time.Now()
  39                 if n != 0 || err == nil || !err.(Error).Timeout() {
  40                         errc <- fmt.Errorf("%s(%q, %q) did not return 0, timeout: %v, %v", what, net, addr, n, err)
  41                         return
  42                 }
  43                 if dt := t1.Sub(t0); dt < 50*time.Millisecond || !testing.Short() && dt > 250*time.Millisecond {
  44                         errc <- fmt.Errorf("%s(%q, %q) took %s, expected 0.1s", what, net, addr, dt)
  45                         return
  46                 }
  47                 errc <- nil
  48         }()
  49         select {
  50         case err := <-errc:
  51                 if err != nil {
  52                         t.Error(err)
  53                 }
  54         case <-time.After(1 * time.Second):
  55                 t.Errorf("%s(%q, %q) took over 1 second, expected 0.1s", what, net, addr)
  56         }
  57 }
  58
  59 func TestTimeoutUDP(t *testing.T) {
  60         switch runtime.GOOS {
  61         case "plan9":
  62                 t.Logf("skipping test on %q", runtime.GOOS)
  63                 return
  64         }
  65
  66         // set up a listener that won't talk back
  67         listening := make(chan string)
  68         done := make(chan int)
  69         go runDatagramPacketConnServer(t, "udp", "127.0.0.1:0", listening, done)
  70         addr := <-listening
  71
  72         testTimeout(t, "udp", addr, false)
  73         testTimeout(t, "udp", addr, true)
  74         <-done
  75 }
  76
  77 func TestTimeoutTCP(t *testing.T) {
  78         switch runtime.GOOS {
  79         case "plan9":
  80                 t.Logf("skipping test on %q", runtime.GOOS)
  81                 return
  82         }
  83
  84         // set up a listener that won't talk back
  85         listening := make(chan string)
  86         done := make(chan int)
  87         go runStreamConnServer(t, "tcp", "127.0.0.1:0", listening, done)
  88         addr := <-listening
  89
  90         testTimeout(t, "tcp", addr, false)
  91         <-done
  92 }
  93
  94 func TestDeadlineReset(t *testing.T) {
  95         switch runtime.GOOS {
  96         case "plan9":
  97                 t.Logf("skipping test on %q", runtime.GOOS)
  98                 return
  99         }
 100         ln, err := Listen("tcp", "127.0.0.1:0")
 101         if err != nil {
 102                 t.Fatal(err)
 103         }
 104         defer ln.Close()
 105         tl := ln.(*TCPListener)
 106         tl.SetDeadline(time.Now().Add(1 * time.Minute))
 107         tl.SetDeadline(time.Time{}) // reset it
 108         errc := make(chan error, 1)
 109         go func() {
 110                 _, err := ln.Accept()
 111                 errc <- err
 112         }()
 113         select {
 114         case <-time.After(50 * time.Millisecond):
 115                 // Pass.
 116         case err := <-errc:
 117                 // Accept should never return; we never
 118                 // connected to it.
 119                 t.Errorf("unexpected return from Accept; err=%v", err)
 120         }
 121 }