libgo/go/net/tcp_test.go

   1 // Copyright 2012 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         "reflect"
   9         "runtime"
  10         "testing"
  11         "time"
  12 )
  13
  14 func BenchmarkTCPOneShot(b *testing.B) {
  15         benchmarkTCP(b, false, false)
  16 }
  17
  18 func BenchmarkTCPOneShotTimeout(b *testing.B) {
  19         benchmarkTCP(b, false, true)
  20 }
  21
  22 func BenchmarkTCPPersistent(b *testing.B) {
  23         benchmarkTCP(b, true, false)
  24 }
  25
  26 func BenchmarkTCPPersistentTimeout(b *testing.B) {
  27         benchmarkTCP(b, true, true)
  28 }
  29
  30 func benchmarkTCP(b *testing.B, persistent, timeout bool) {
  31         const msgLen = 512
  32         conns := b.N
  33         numConcurrent := runtime.GOMAXPROCS(-1) * 16
  34         msgs := 1
  35         if persistent {
  36                 conns = numConcurrent
  37                 msgs = b.N / conns
  38                 if msgs == 0 {
  39                         msgs = 1
  40                 }
  41                 if conns > b.N {
  42                         conns = b.N
  43                 }
  44         }
  45         sendMsg := func(c Conn, buf []byte) bool {
  46                 n, err := c.Write(buf)
  47                 if n != len(buf) || err != nil {
  48                         b.Logf("Write failed: %v", err)
  49                         return false
  50                 }
  51                 return true
  52         }
  53         recvMsg := func(c Conn, buf []byte) bool {
  54                 for read := 0; read != len(buf); {
  55                         n, err := c.Read(buf)
  56                         read += n
  57                         if err != nil {
  58                                 b.Logf("Read failed: %v", err)
  59                                 return false
  60                         }
  61                 }
  62                 return true
  63         }
  64         ln, err := Listen("tcp", "127.0.0.1:0")
  65         if err != nil {
  66                 b.Fatalf("Listen failed: %v", err)
  67         }
  68         defer ln.Close()
  69         // Acceptor.
  70         go func() {
  71                 for {
  72                         c, err := ln.Accept()
  73                         if err != nil {
  74                                 break
  75                         }
  76                         // Server connection.
  77                         go func(c Conn) {
  78                                 defer c.Close()
  79                                 if timeout {
  80                                         c.SetDeadline(time.Now().Add(time.Hour)) // Not intended to fire.
  81                                 }
  82                                 var buf [msgLen]byte
  83                                 for m := 0; m < msgs; m++ {
  84                                         if !recvMsg(c, buf[:]) || !sendMsg(c, buf[:]) {
  85                                                 break
  86                                         }
  87                                 }
  88                         }(c)
  89                 }
  90         }()
  91         sem := make(chan bool, numConcurrent)
  92         for i := 0; i < conns; i++ {
  93                 sem <- true
  94                 // Client connection.
  95                 go func() {
  96                         defer func() {
  97                                 <-sem
  98                         }()
  99                         c, err := Dial("tcp", ln.Addr().String())
 100                         if err != nil {
 101                                 b.Logf("Dial failed: %v", err)
 102                                 return
 103                         }
 104                         defer c.Close()
 105                         if timeout {
 106                                 c.SetDeadline(time.Now().Add(time.Hour)) // Not intended to fire.
 107                         }
 108                         var buf [msgLen]byte
 109                         for m := 0; m < msgs; m++ {
 110                                 if !sendMsg(c, buf[:]) || !recvMsg(c, buf[:]) {
 111                                         break
 112                                 }
 113                         }
 114                 }()
 115         }
 116         for i := 0; i < cap(sem); i++ {
 117                 sem <- true
 118         }
 119 }
 120
 121 var resolveTCPAddrTests = []struct {
 122         net     string
 123         litAddr string
 124         addr    *TCPAddr
 125         err     error
 126 }{
 127         {"tcp", "127.0.0.1:0", &TCPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil},
 128         {"tcp4", "127.0.0.1:65535", &TCPAddr{IP: IPv4(127, 0, 0, 1), Port: 65535}, nil},
 129
 130         {"tcp", "[::1]:1", &TCPAddr{IP: ParseIP("::1"), Port: 1}, nil},
 131         {"tcp6", "[::1]:65534", &TCPAddr{IP: ParseIP("::1"), Port: 65534}, nil},
 132
 133         {"", "127.0.0.1:0", &TCPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil}, // Go 1.0 behavior
 134         {"", "[::1]:0", &TCPAddr{IP: ParseIP("::1"), Port: 0}, nil},         // Go 1.0 behavior
 135
 136         {"http", "127.0.0.1:0", nil, UnknownNetworkError("http")},
 137 }
 138
 139 func TestResolveTCPAddr(t *testing.T) {
 140         for _, tt := range resolveTCPAddrTests {
 141                 addr, err := ResolveTCPAddr(tt.net, tt.litAddr)
 142                 if err != tt.err {
 143                         t.Fatalf("ResolveTCPAddr(%v, %v) failed: %v", tt.net, tt.litAddr, err)
 144                 }
 145                 if !reflect.DeepEqual(addr, tt.addr) {
 146                         t.Fatalf("got %#v; expected %#v", addr, tt.addr)
 147                 }
 148         }
 149 }
 150
 151 var tcpListenerNameTests = []struct {
 152         net   string
 153         laddr *TCPAddr
 154 }{
 155         {"tcp4", &TCPAddr{IP: IPv4(127, 0, 0, 1)}},
 156         {"tcp4", &TCPAddr{}},
 157         {"tcp4", nil},
 158 }
 159
 160 func TestTCPListenerName(t *testing.T) {
 161         if testing.Short() || !*testExternal {
 162                 t.Skip("skipping test to avoid external network")
 163         }
 164
 165         for _, tt := range tcpListenerNameTests {
 166                 ln, err := ListenTCP(tt.net, tt.laddr)
 167                 if err != nil {
 168                         t.Errorf("ListenTCP failed: %v", err)
 169                         return
 170                 }
 171                 defer ln.Close()
 172                 la := ln.Addr()
 173                 if a, ok := la.(*TCPAddr); !ok || a.Port == 0 {
 174                         t.Errorf("got %v; expected a proper address with non-zero port number", la)
 175                         return
 176                 }
 177         }
 178 }