github.com/mdempsky/go@v0.0.0-20151201204031-5dd372bd1e70/src/net/net_test.go (about) 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 "os" 10 "runtime" 11 "testing" 12 ) 13 14 func TestCloseRead(t *testing.T) { 15 switch runtime.GOOS { 16 case "nacl", "plan9": 17 t.Skipf("not supported on %s", runtime.GOOS) 18 } 19 20 for _, network := range []string{"tcp", "unix", "unixpacket"} { 21 if !testableNetwork(network) { 22 t.Logf("skipping %s test", network) 23 continue 24 } 25 26 ln, err := newLocalListener(network) 27 if err != nil { 28 t.Fatal(err) 29 } 30 switch network { 31 case "unix", "unixpacket": 32 defer os.Remove(ln.Addr().String()) 33 } 34 defer ln.Close() 35 36 c, err := Dial(ln.Addr().Network(), ln.Addr().String()) 37 if err != nil { 38 t.Fatal(err) 39 } 40 switch network { 41 case "unix", "unixpacket": 42 defer os.Remove(c.LocalAddr().String()) 43 } 44 defer c.Close() 45 46 switch c := c.(type) { 47 case *TCPConn: 48 err = c.CloseRead() 49 case *UnixConn: 50 err = c.CloseRead() 51 } 52 if err != nil { 53 if perr := parseCloseError(err); perr != nil { 54 t.Error(perr) 55 } 56 t.Fatal(err) 57 } 58 var b [1]byte 59 n, err := c.Read(b[:]) 60 if n != 0 || err == nil { 61 t.Fatalf("got (%d, %v); want (0, error)", n, err) 62 } 63 } 64 } 65 66 func TestCloseWrite(t *testing.T) { 67 switch runtime.GOOS { 68 case "nacl", "plan9": 69 t.Skipf("not supported on %s", runtime.GOOS) 70 } 71 72 handler := func(ls *localServer, ln Listener) { 73 c, err := ln.Accept() 74 if err != nil { 75 t.Error(err) 76 return 77 } 78 defer c.Close() 79 80 var b [1]byte 81 n, err := c.Read(b[:]) 82 if n != 0 || err != io.EOF { 83 t.Errorf("got (%d, %v); want (0, io.EOF)", n, err) 84 return 85 } 86 switch c := c.(type) { 87 case *TCPConn: 88 err = c.CloseWrite() 89 case *UnixConn: 90 err = c.CloseWrite() 91 } 92 if err != nil { 93 if perr := parseCloseError(err); perr != nil { 94 t.Error(perr) 95 } 96 t.Error(err) 97 return 98 } 99 n, err = c.Write(b[:]) 100 if err == nil { 101 t.Errorf("got (%d, %v); want (any, error)", n, err) 102 return 103 } 104 } 105 106 for _, network := range []string{"tcp", "unix", "unixpacket"} { 107 if !testableNetwork(network) { 108 t.Logf("skipping %s test", network) 109 continue 110 } 111 112 ls, err := newLocalServer(network) 113 if err != nil { 114 t.Fatal(err) 115 } 116 defer ls.teardown() 117 if err := ls.buildup(handler); err != nil { 118 t.Fatal(err) 119 } 120 121 c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String()) 122 if err != nil { 123 t.Fatal(err) 124 } 125 switch network { 126 case "unix", "unixpacket": 127 defer os.Remove(c.LocalAddr().String()) 128 } 129 defer c.Close() 130 131 switch c := c.(type) { 132 case *TCPConn: 133 err = c.CloseWrite() 134 case *UnixConn: 135 err = c.CloseWrite() 136 } 137 if err != nil { 138 if perr := parseCloseError(err); perr != nil { 139 t.Error(perr) 140 } 141 t.Fatal(err) 142 } 143 var b [1]byte 144 n, err := c.Read(b[:]) 145 if n != 0 || err != io.EOF { 146 t.Fatalf("got (%d, %v); want (0, io.EOF)", n, err) 147 } 148 n, err = c.Write(b[:]) 149 if err == nil { 150 t.Fatalf("got (%d, %v); want (any, error)", n, err) 151 } 152 } 153 } 154 155 func TestConnClose(t *testing.T) { 156 for _, network := range []string{"tcp", "unix", "unixpacket"} { 157 if !testableNetwork(network) { 158 t.Logf("skipping %s test", network) 159 continue 160 } 161 162 ln, err := newLocalListener(network) 163 if err != nil { 164 t.Fatal(err) 165 } 166 switch network { 167 case "unix", "unixpacket": 168 defer os.Remove(ln.Addr().String()) 169 } 170 defer ln.Close() 171 172 c, err := Dial(ln.Addr().Network(), ln.Addr().String()) 173 if err != nil { 174 t.Fatal(err) 175 } 176 switch network { 177 case "unix", "unixpacket": 178 defer os.Remove(c.LocalAddr().String()) 179 } 180 defer c.Close() 181 182 if err := c.Close(); err != nil { 183 if perr := parseCloseError(err); perr != nil { 184 t.Error(perr) 185 } 186 t.Fatal(err) 187 } 188 var b [1]byte 189 n, err := c.Read(b[:]) 190 if n != 0 || err == nil { 191 t.Fatalf("got (%d, %v); want (0, error)", n, err) 192 } 193 } 194 } 195 196 func TestListenerClose(t *testing.T) { 197 for _, network := range []string{"tcp", "unix", "unixpacket"} { 198 if !testableNetwork(network) { 199 t.Logf("skipping %s test", network) 200 continue 201 } 202 203 ln, err := newLocalListener(network) 204 if err != nil { 205 t.Fatal(err) 206 } 207 switch network { 208 case "unix", "unixpacket": 209 defer os.Remove(ln.Addr().String()) 210 } 211 212 if err := ln.Close(); err != nil { 213 if perr := parseCloseError(err); perr != nil { 214 t.Error(perr) 215 } 216 t.Fatal(err) 217 } 218 c, err := ln.Accept() 219 if err == nil { 220 c.Close() 221 t.Fatal("should fail") 222 } 223 224 if network == "tcp" { 225 cc, err := Dial("tcp", ln.Addr().String()) 226 if err == nil { 227 t.Error("Dial to closed TCP listener succeeeded.") 228 cc.Close() 229 } 230 } 231 } 232 } 233 234 func TestPacketConnClose(t *testing.T) { 235 for _, network := range []string{"udp", "unixgram"} { 236 if !testableNetwork(network) { 237 t.Logf("skipping %s test", network) 238 continue 239 } 240 241 c, err := newLocalPacketListener(network) 242 if err != nil { 243 t.Fatal(err) 244 } 245 switch network { 246 case "unixgram": 247 defer os.Remove(c.LocalAddr().String()) 248 } 249 defer c.Close() 250 251 if err := c.Close(); err != nil { 252 if perr := parseCloseError(err); perr != nil { 253 t.Error(perr) 254 } 255 t.Fatal(err) 256 } 257 var b [1]byte 258 n, _, err := c.ReadFrom(b[:]) 259 if n != 0 || err == nil { 260 t.Fatalf("got (%d, %v); want (0, error)", n, err) 261 } 262 } 263 } 264 265 // nacl was previous failing to reuse an address. 266 func TestListenCloseListen(t *testing.T) { 267 const maxTries = 10 268 for tries := 0; tries < maxTries; tries++ { 269 ln, err := newLocalListener("tcp") 270 if err != nil { 271 t.Fatal(err) 272 } 273 addr := ln.Addr().String() 274 if err := ln.Close(); err != nil { 275 t.Fatal(err) 276 } 277 ln, err = Listen("tcp", addr) 278 if err == nil { 279 // Success. nacl couldn't do this before. 280 ln.Close() 281 return 282 } 283 t.Errorf("failed on try %d/%d: %v", tries+1, maxTries, err) 284 } 285 t.Fatalf("failed to listen/close/listen on same address after %d tries", maxTries) 286 }