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         "runtime"
  10         "testing"
  11         "time"
  12 )
  13
  14 func TestShutdown(t *testing.T) {
  15         if runtime.GOOS == "plan9" {
  16                 t.Logf("skipping test on %q", runtime.GOOS)
  17                 return
  18         }
  19         l, err := Listen("tcp", "127.0.0.1:0")
  20         if err != nil {
  21                 if l, err = Listen("tcp6", "[::1]:0"); err != nil {
  22                         t.Fatalf("ListenTCP on :0: %v", err)
  23                 }
  24         }
  25
  26         go func() {
  27                 c, err := l.Accept()
  28                 if err != nil {
  29                         t.Fatalf("Accept: %v", err)
  30                 }
  31                 var buf [10]byte
  32                 n, err := c.Read(buf[:])
  33                 if n != 0 || err != io.EOF {
  34                         t.Fatalf("server Read = %d, %v; want 0, io.EOF", n, err)
  35                 }
  36                 c.Write([]byte("response"))
  37                 c.Close()
  38         }()
  39
  40         c, err := Dial("tcp", l.Addr().String())
  41         if err != nil {
  42                 t.Fatalf("Dial: %v", err)
  43         }
  44         defer c.Close()
  45
  46         err = c.(*TCPConn).CloseWrite()
  47         if err != nil {
  48                 t.Fatalf("CloseWrite: %v", err)
  49         }
  50         var buf [10]byte
  51         n, err := c.Read(buf[:])
  52         if err != nil {
  53                 t.Fatalf("client Read: %d, %v", n, err)
  54         }
  55         got := string(buf[:n])
  56         if got != "response" {
  57                 t.Errorf("read = %q, want \"response\"", got)
  58         }
  59 }
  60
  61 func TestTCPListenClose(t *testing.T) {
  62         l, err := Listen("tcp", "127.0.0.1:0")
  63         if err != nil {
  64                 t.Fatalf("Listen failed: %v", err)
  65         }
  66
  67         done := make(chan bool, 1)
  68         go func() {
  69                 time.Sleep(100 * time.Millisecond)
  70                 l.Close()
  71         }()
  72         go func() {
  73                 _, err = l.Accept()
  74                 if err == nil {
  75                         t.Error("Accept succeeded")
  76                 } else {
  77                         t.Logf("Accept timeout error: %s (any error is fine)", err)
  78                 }
  79                 done <- true
  80         }()
  81         select {
  82         case <-done:
  83         case <-time.After(2 * time.Second):
  84                 t.Fatal("timeout waiting for TCP close")
  85         }
  86 }
  87
  88 func TestUDPListenClose(t *testing.T) {
  89         l, err := ListenPacket("udp", "127.0.0.1:0")
  90         if err != nil {
  91                 t.Fatalf("Listen failed: %v", err)
  92         }
  93
  94         buf := make([]byte, 1000)
  95         done := make(chan bool, 1)
  96         go func() {
  97                 time.Sleep(100 * time.Millisecond)
  98                 l.Close()
  99         }()
 100         go func() {
 101                 _, _, err = l.ReadFrom(buf)
 102                 if err == nil {
 103                         t.Error("ReadFrom succeeded")
 104                 } else {
 105                         t.Logf("ReadFrom timeout error: %s (any error is fine)", err)
 106                 }
 107                 done <- true
 108         }()
 109         select {
 110         case <-done:
 111         case <-time.After(2 * time.Second):
 112                 t.Fatal("timeout waiting for UDP close")
 113         }
 114 }