libgo/go/net/net_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         "io"
   9         "io/ioutil"
  10         "os"
  11         "runtime"
  12         "testing"
  13         "time"
  14 )
  15
  16 func TestShutdown(t *testing.T) {
  17         if runtime.GOOS == "plan9" {
  18                 t.Skipf("skipping test on %q", runtime.GOOS)
  19         }
  20         ln, err := Listen("tcp", "127.0.0.1:0")
  21         if err != nil {
  22                 if ln, err = Listen("tcp6", "[::1]:0"); err != nil {
  23                         t.Fatalf("ListenTCP on :0: %v", err)
  24                 }
  25         }
  26
  27         go func() {
  28                 c, err := ln.Accept()
  29                 if err != nil {
  30                         t.Fatalf("Accept: %v", err)
  31                 }
  32                 var buf [10]byte
  33                 n, err := c.Read(buf[:])
  34                 if n != 0 || err != io.EOF {
  35                         t.Fatalf("server Read = %d, %v; want 0, io.EOF", n, err)
  36                 }
  37                 c.Write([]byte("response"))
  38                 c.Close()
  39         }()
  40
  41         c, err := Dial("tcp", ln.Addr().String())
  42         if err != nil {
  43                 t.Fatalf("Dial: %v", err)
  44         }
  45         defer c.Close()
  46
  47         err = c.(*TCPConn).CloseWrite()
  48         if err != nil {
  49                 t.Fatalf("CloseWrite: %v", err)
  50         }
  51         var buf [10]byte
  52         n, err := c.Read(buf[:])
  53         if err != nil {
  54                 t.Fatalf("client Read: %d, %v", n, err)
  55         }
  56         got := string(buf[:n])
  57         if got != "response" {
  58                 t.Errorf("read = %q, want \"response\"", got)
  59         }
  60 }
  61
  62 func TestShutdownUnix(t *testing.T) {
  63         switch runtime.GOOS {
  64         case "windows", "plan9":
  65                 t.Skipf("skipping test on %q", runtime.GOOS)
  66         }
  67         f, err := ioutil.TempFile("", "go_net_unixtest")
  68         if err != nil {
  69                 t.Fatalf("TempFile: %s", err)
  70         }
  71         f.Close()
  72         tmpname := f.Name()
  73         os.Remove(tmpname)
  74         ln, err := Listen("unix", tmpname)
  75         if err != nil {
  76                 t.Fatalf("ListenUnix on %s: %s", tmpname, err)
  77         }
  78         defer os.Remove(tmpname)
  79
  80         go func() {
  81                 c, err := ln.Accept()
  82                 if err != nil {
  83                         t.Fatalf("Accept: %v", err)
  84                 }
  85                 var buf [10]byte
  86                 n, err := c.Read(buf[:])
  87                 if n != 0 || err != io.EOF {
  88                         t.Fatalf("server Read = %d, %v; want 0, io.EOF", n, err)
  89                 }
  90                 c.Write([]byte("response"))
  91                 c.Close()
  92         }()
  93
  94         c, err := Dial("unix", tmpname)
  95         if err != nil {
  96                 t.Fatalf("Dial: %v", err)
  97         }
  98         defer c.Close()
  99
 100         err = c.(*UnixConn).CloseWrite()
 101         if err != nil {
 102                 t.Fatalf("CloseWrite: %v", err)
 103         }
 104         var buf [10]byte
 105         n, err := c.Read(buf[:])
 106         if err != nil {
 107                 t.Fatalf("client Read: %d, %v", n, err)
 108         }
 109         got := string(buf[:n])
 110         if got != "response" {
 111                 t.Errorf("read = %q, want \"response\"", got)
 112         }
 113 }
 114
 115 func TestTCPListenClose(t *testing.T) {
 116         ln, err := Listen("tcp", "127.0.0.1:0")
 117         if err != nil {
 118                 t.Fatalf("Listen failed: %v", err)
 119         }
 120
 121         done := make(chan bool, 1)
 122         go func() {
 123                 time.Sleep(100 * time.Millisecond)
 124                 ln.Close()
 125         }()
 126         go func() {
 127                 c, err := ln.Accept()
 128                 if err == nil {
 129                         c.Close()
 130                         t.Error("Accept succeeded")
 131                 } else {
 132                         t.Logf("Accept timeout error: %s (any error is fine)", err)
 133                 }
 134                 done <- true
 135         }()
 136         select {
 137         case <-done:
 138         case <-time.After(2 * time.Second):
 139                 t.Fatal("timeout waiting for TCP close")
 140         }
 141 }
 142
 143 func TestUDPListenClose(t *testing.T) {
 144         switch runtime.GOOS {
 145         case "plan9":
 146                 t.Skipf("skipping test on %q", runtime.GOOS)
 147         }
 148         ln, err := ListenPacket("udp", "127.0.0.1:0")
 149         if err != nil {
 150                 t.Fatalf("Listen failed: %v", err)
 151         }
 152
 153         buf := make([]byte, 1000)
 154         done := make(chan bool, 1)
 155         go func() {
 156                 time.Sleep(100 * time.Millisecond)
 157                 ln.Close()
 158         }()
 159         go func() {
 160                 _, _, err = ln.ReadFrom(buf)
 161                 if err == nil {
 162                         t.Error("ReadFrom succeeded")
 163                 } else {
 164                         t.Logf("ReadFrom timeout error: %s (any error is fine)", err)
 165                 }
 166                 done <- true
 167         }()
 168         select {
 169         case <-done:
 170         case <-time.After(2 * time.Second):
 171                 t.Fatal("timeout waiting for UDP close")
 172         }
 173 }
 174
 175 func TestTCPClose(t *testing.T) {
 176         switch runtime.GOOS {
 177         case "plan9":
 178                 t.Skipf("skipping test on %q", runtime.GOOS)
 179         }
 180         l, err := Listen("tcp", "127.0.0.1:0")
 181         if err != nil {
 182                 t.Fatal(err)
 183         }
 184         defer l.Close()
 185
 186         read := func(r io.Reader) error {
 187                 var m [1]byte
 188                 _, err := r.Read(m[:])
 189                 return err
 190         }
 191
 192         go func() {
 193                 c, err := Dial("tcp", l.Addr().String())
 194                 if err != nil {
 195                         t.Fatal(err)
 196                 }
 197
 198                 go read(c)
 199
 200                 time.Sleep(10 * time.Millisecond)
 201                 c.Close()
 202         }()
 203
 204         c, err := l.Accept()
 205         if err != nil {
 206                 t.Fatal(err)
 207         }
 208         defer c.Close()
 209
 210         for err == nil {
 211                 err = read(c)
 212         }
 213         if err != nil && err != io.EOF {
 214                 t.Fatal(err)
 215         }
 216 }