Source file
src/net/file_test.go
1
2
3
4
5
6
7 package net
8
9 import (
10 "os"
11 "reflect"
12 "runtime"
13 "sync"
14 "testing"
15 )
16
17
18
19
20
21
22
23 var fileConnTests = []struct {
24 network string
25 }{
26 {"tcp"},
27 {"udp"},
28 {"unix"},
29 {"unixpacket"},
30 }
31
32 func TestFileConn(t *testing.T) {
33 switch runtime.GOOS {
34 case "plan9", "windows":
35 t.Skipf("not supported on %s", runtime.GOOS)
36 }
37
38 for _, tt := range fileConnTests {
39 if !testableNetwork(tt.network) {
40 t.Logf("skipping %s test", tt.network)
41 continue
42 }
43
44 var network, address string
45 switch tt.network {
46 case "udp":
47 c := newLocalPacketListener(t, tt.network)
48 defer c.Close()
49 network = c.LocalAddr().Network()
50 address = c.LocalAddr().String()
51 default:
52 handler := func(ls *localServer, ln Listener) {
53 c, err := ln.Accept()
54 if err != nil {
55 return
56 }
57 defer c.Close()
58 var b [1]byte
59 c.Read(b[:])
60 }
61 ls := newLocalServer(t, tt.network)
62 defer ls.teardown()
63 if err := ls.buildup(handler); err != nil {
64 t.Fatal(err)
65 }
66 network = ls.Listener.Addr().Network()
67 address = ls.Listener.Addr().String()
68 }
69
70 c1, err := Dial(network, address)
71 if err != nil {
72 if perr := parseDialError(err); perr != nil {
73 t.Error(perr)
74 }
75 t.Fatal(err)
76 }
77 addr := c1.LocalAddr()
78
79 var f *os.File
80 switch c1 := c1.(type) {
81 case *TCPConn:
82 f, err = c1.File()
83 case *UDPConn:
84 f, err = c1.File()
85 case *UnixConn:
86 f, err = c1.File()
87 }
88 if err := c1.Close(); err != nil {
89 if perr := parseCloseError(err, false); perr != nil {
90 t.Error(perr)
91 }
92 t.Error(err)
93 }
94 if err != nil {
95 if perr := parseCommonError(err); perr != nil {
96 t.Error(perr)
97 }
98 t.Fatal(err)
99 }
100
101 c2, err := FileConn(f)
102 if err := f.Close(); err != nil {
103 t.Error(err)
104 }
105 if err != nil {
106 if perr := parseCommonError(err); perr != nil {
107 t.Error(perr)
108 }
109 t.Fatal(err)
110 }
111 defer c2.Close()
112
113 if _, err := c2.Write([]byte("FILECONN TEST")); err != nil {
114 if perr := parseWriteError(err); perr != nil {
115 t.Error(perr)
116 }
117 t.Fatal(err)
118 }
119 if !reflect.DeepEqual(c2.LocalAddr(), addr) {
120 t.Fatalf("got %#v; want %#v", c2.LocalAddr(), addr)
121 }
122 }
123 }
124
125 var fileListenerTests = []struct {
126 network string
127 }{
128 {"tcp"},
129 {"unix"},
130 {"unixpacket"},
131 }
132
133 func TestFileListener(t *testing.T) {
134 switch runtime.GOOS {
135 case "plan9", "windows":
136 t.Skipf("not supported on %s", runtime.GOOS)
137 }
138
139 for _, tt := range fileListenerTests {
140 if !testableNetwork(tt.network) {
141 t.Logf("skipping %s test", tt.network)
142 continue
143 }
144
145 ln1 := newLocalListener(t, tt.network)
146 switch tt.network {
147 case "unix", "unixpacket":
148 defer os.Remove(ln1.Addr().String())
149 }
150 addr := ln1.Addr()
151
152 var (
153 f *os.File
154 err error
155 )
156 switch ln1 := ln1.(type) {
157 case *TCPListener:
158 f, err = ln1.File()
159 case *UnixListener:
160 f, err = ln1.File()
161 }
162 switch tt.network {
163 case "unix", "unixpacket":
164 defer ln1.Close()
165 default:
166 if err := ln1.Close(); err != nil {
167 t.Error(err)
168 }
169 }
170 if err != nil {
171 if perr := parseCommonError(err); perr != nil {
172 t.Error(perr)
173 }
174 t.Fatal(err)
175 }
176
177 ln2, err := FileListener(f)
178 if err := f.Close(); err != nil {
179 t.Error(err)
180 }
181 if err != nil {
182 if perr := parseCommonError(err); perr != nil {
183 t.Error(perr)
184 }
185 t.Fatal(err)
186 }
187 defer ln2.Close()
188
189 var wg sync.WaitGroup
190 wg.Add(1)
191 go func() {
192 defer wg.Done()
193 c, err := Dial(ln2.Addr().Network(), ln2.Addr().String())
194 if err != nil {
195 if perr := parseDialError(err); perr != nil {
196 t.Error(perr)
197 }
198 t.Error(err)
199 return
200 }
201 c.Close()
202 }()
203 c, err := ln2.Accept()
204 if err != nil {
205 if perr := parseAcceptError(err); perr != nil {
206 t.Error(perr)
207 }
208 t.Fatal(err)
209 }
210 c.Close()
211 wg.Wait()
212 if !reflect.DeepEqual(ln2.Addr(), addr) {
213 t.Fatalf("got %#v; want %#v", ln2.Addr(), addr)
214 }
215 }
216 }
217
218 var filePacketConnTests = []struct {
219 network string
220 }{
221 {"udp"},
222 {"unixgram"},
223 }
224
225 func TestFilePacketConn(t *testing.T) {
226 switch runtime.GOOS {
227 case "plan9", "windows":
228 t.Skipf("not supported on %s", runtime.GOOS)
229 }
230
231 for _, tt := range filePacketConnTests {
232 if !testableNetwork(tt.network) {
233 t.Logf("skipping %s test", tt.network)
234 continue
235 }
236
237 c1 := newLocalPacketListener(t, tt.network)
238 switch tt.network {
239 case "unixgram":
240 defer os.Remove(c1.LocalAddr().String())
241 }
242 addr := c1.LocalAddr()
243
244 var (
245 f *os.File
246 err error
247 )
248 switch c1 := c1.(type) {
249 case *UDPConn:
250 f, err = c1.File()
251 case *UnixConn:
252 f, err = c1.File()
253 }
254 if err := c1.Close(); err != nil {
255 if perr := parseCloseError(err, false); perr != nil {
256 t.Error(perr)
257 }
258 t.Error(err)
259 }
260 if err != nil {
261 if perr := parseCommonError(err); perr != nil {
262 t.Error(perr)
263 }
264 t.Fatal(err)
265 }
266
267 c2, err := FilePacketConn(f)
268 if err := f.Close(); err != nil {
269 t.Error(err)
270 }
271 if err != nil {
272 if perr := parseCommonError(err); perr != nil {
273 t.Error(perr)
274 }
275 t.Fatal(err)
276 }
277 defer c2.Close()
278
279 if _, err := c2.WriteTo([]byte("FILEPACKETCONN TEST"), addr); err != nil {
280 if perr := parseWriteError(err); perr != nil {
281 t.Error(perr)
282 }
283 t.Fatal(err)
284 }
285 if !reflect.DeepEqual(c2.LocalAddr(), addr) {
286 t.Fatalf("got %#v; want %#v", c2.LocalAddr(), addr)
287 }
288 }
289 }
290
291
292 func TestFileCloseRace(t *testing.T) {
293 switch runtime.GOOS {
294 case "plan9", "windows":
295 t.Skipf("not supported on %s", runtime.GOOS)
296 }
297 if !testableNetwork("tcp") {
298 t.Skip("tcp not supported")
299 }
300
301 handler := func(ls *localServer, ln Listener) {
302 c, err := ln.Accept()
303 if err != nil {
304 return
305 }
306 defer c.Close()
307 var b [1]byte
308 c.Read(b[:])
309 }
310
311 ls := newLocalServer(t, "tcp")
312 defer ls.teardown()
313 if err := ls.buildup(handler); err != nil {
314 t.Fatal(err)
315 }
316
317 const tries = 100
318 for i := 0; i < tries; i++ {
319 c1, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String())
320 if err != nil {
321 t.Fatal(err)
322 }
323 tc := c1.(*TCPConn)
324
325 var wg sync.WaitGroup
326 wg.Add(2)
327 go func() {
328 defer wg.Done()
329 f, err := tc.File()
330 if err == nil {
331 f.Close()
332 }
333 }()
334 go func() {
335 defer wg.Done()
336 c1.Close()
337 }()
338 wg.Wait()
339 }
340 }
341
View as plain text