Source file
src/net/protoconn_test.go
Documentation: net
1
2
3
4
5
6
7
8
9
10
11 package net
12
13 import (
14 "os"
15 "runtime"
16 "testing"
17 "time"
18 )
19
20
21
22
23
24
25
26 func TestTCPListenerSpecificMethods(t *testing.T) {
27 switch runtime.GOOS {
28 case "plan9":
29 t.Skipf("not supported on %s", runtime.GOOS)
30 }
31
32 la, err := ResolveTCPAddr("tcp4", "127.0.0.1:0")
33 if err != nil {
34 t.Fatal(err)
35 }
36 ln, err := ListenTCP("tcp4", la)
37 if err != nil {
38 t.Fatal(err)
39 }
40 defer ln.Close()
41 ln.Addr()
42 ln.SetDeadline(time.Now().Add(30 * time.Nanosecond))
43
44 if c, err := ln.Accept(); err != nil {
45 if !err.(Error).Timeout() {
46 t.Fatal(err)
47 }
48 } else {
49 c.Close()
50 }
51 if c, err := ln.AcceptTCP(); err != nil {
52 if !err.(Error).Timeout() {
53 t.Fatal(err)
54 }
55 } else {
56 c.Close()
57 }
58
59 if f, err := ln.File(); err != nil {
60 condFatalf(t, "file+net", "%v", err)
61 } else {
62 f.Close()
63 }
64 }
65
66 func TestTCPConnSpecificMethods(t *testing.T) {
67 la, err := ResolveTCPAddr("tcp4", "127.0.0.1:0")
68 if err != nil {
69 t.Fatal(err)
70 }
71 ln, err := ListenTCP("tcp4", la)
72 if err != nil {
73 t.Fatal(err)
74 }
75 ch := make(chan error, 1)
76 handler := func(ls *localServer, ln Listener) { ls.transponder(ls.Listener, ch) }
77 ls, err := (&streamListener{Listener: ln}).newLocalServer()
78 if err != nil {
79 t.Fatal(err)
80 }
81 defer ls.teardown()
82 if err := ls.buildup(handler); err != nil {
83 t.Fatal(err)
84 }
85
86 ra, err := ResolveTCPAddr("tcp4", ls.Listener.Addr().String())
87 if err != nil {
88 t.Fatal(err)
89 }
90 c, err := DialTCP("tcp4", nil, ra)
91 if err != nil {
92 t.Fatal(err)
93 }
94 defer c.Close()
95 c.SetKeepAlive(false)
96 c.SetKeepAlivePeriod(3 * time.Second)
97 c.SetLinger(0)
98 c.SetNoDelay(false)
99 c.LocalAddr()
100 c.RemoteAddr()
101 c.SetDeadline(time.Now().Add(someTimeout))
102 c.SetReadDeadline(time.Now().Add(someTimeout))
103 c.SetWriteDeadline(time.Now().Add(someTimeout))
104
105 if _, err := c.Write([]byte("TCPCONN TEST")); err != nil {
106 t.Fatal(err)
107 }
108 rb := make([]byte, 128)
109 if _, err := c.Read(rb); err != nil {
110 t.Fatal(err)
111 }
112
113 for err := range ch {
114 t.Error(err)
115 }
116 }
117
118 func TestUDPConnSpecificMethods(t *testing.T) {
119 la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
120 if err != nil {
121 t.Fatal(err)
122 }
123 c, err := ListenUDP("udp4", la)
124 if err != nil {
125 t.Fatal(err)
126 }
127 defer c.Close()
128 c.LocalAddr()
129 c.RemoteAddr()
130 c.SetDeadline(time.Now().Add(someTimeout))
131 c.SetReadDeadline(time.Now().Add(someTimeout))
132 c.SetWriteDeadline(time.Now().Add(someTimeout))
133 c.SetReadBuffer(2048)
134 c.SetWriteBuffer(2048)
135
136 wb := []byte("UDPCONN TEST")
137 rb := make([]byte, 128)
138 if _, err := c.WriteToUDP(wb, c.LocalAddr().(*UDPAddr)); err != nil {
139 t.Fatal(err)
140 }
141 if _, _, err := c.ReadFromUDP(rb); err != nil {
142 t.Fatal(err)
143 }
144 if _, _, err := c.WriteMsgUDP(wb, nil, c.LocalAddr().(*UDPAddr)); err != nil {
145 condFatalf(t, c.LocalAddr().Network(), "%v", err)
146 }
147 if _, _, _, _, err := c.ReadMsgUDP(rb, nil); err != nil {
148 condFatalf(t, c.LocalAddr().Network(), "%v", err)
149 }
150
151 if f, err := c.File(); err != nil {
152 condFatalf(t, "file+net", "%v", err)
153 } else {
154 f.Close()
155 }
156
157 defer func() {
158 if p := recover(); p != nil {
159 t.Fatalf("panicked: %v", p)
160 }
161 }()
162
163 c.WriteToUDP(wb, nil)
164 c.WriteMsgUDP(wb, nil, nil)
165 }
166
167 func TestIPConnSpecificMethods(t *testing.T) {
168 if os.Getuid() != 0 {
169 t.Skip("must be root")
170 }
171
172 la, err := ResolveIPAddr("ip4", "127.0.0.1")
173 if err != nil {
174 t.Fatal(err)
175 }
176 c, err := ListenIP("ip4:icmp", la)
177 if err != nil {
178 t.Fatal(err)
179 }
180 defer c.Close()
181 c.LocalAddr()
182 c.RemoteAddr()
183 c.SetDeadline(time.Now().Add(someTimeout))
184 c.SetReadDeadline(time.Now().Add(someTimeout))
185 c.SetWriteDeadline(time.Now().Add(someTimeout))
186 c.SetReadBuffer(2048)
187 c.SetWriteBuffer(2048)
188
189 if f, err := c.File(); err != nil {
190 condFatalf(t, "file+net", "%v", err)
191 } else {
192 f.Close()
193 }
194
195 defer func() {
196 if p := recover(); p != nil {
197 t.Fatalf("panicked: %v", p)
198 }
199 }()
200
201 wb := []byte("IPCONN TEST")
202 c.WriteToIP(wb, nil)
203 c.WriteMsgIP(wb, nil, nil)
204 }
205
206 func TestUnixListenerSpecificMethods(t *testing.T) {
207 if !testableNetwork("unix") {
208 t.Skip("unix test")
209 }
210
211 addr := testUnixAddr()
212 la, err := ResolveUnixAddr("unix", addr)
213 if err != nil {
214 t.Fatal(err)
215 }
216 ln, err := ListenUnix("unix", la)
217 if err != nil {
218 t.Fatal(err)
219 }
220 defer ln.Close()
221 defer os.Remove(addr)
222 ln.Addr()
223 ln.SetDeadline(time.Now().Add(30 * time.Nanosecond))
224
225 if c, err := ln.Accept(); err != nil {
226 if !err.(Error).Timeout() {
227 t.Fatal(err)
228 }
229 } else {
230 c.Close()
231 }
232 if c, err := ln.AcceptUnix(); err != nil {
233 if !err.(Error).Timeout() {
234 t.Fatal(err)
235 }
236 } else {
237 c.Close()
238 }
239
240 if f, err := ln.File(); err != nil {
241 t.Fatal(err)
242 } else {
243 f.Close()
244 }
245 }
246
247 func TestUnixConnSpecificMethods(t *testing.T) {
248 if !testableNetwork("unixgram") {
249 t.Skip("unixgram test")
250 }
251
252 addr1, addr2, addr3 := testUnixAddr(), testUnixAddr(), testUnixAddr()
253
254 a1, err := ResolveUnixAddr("unixgram", addr1)
255 if err != nil {
256 t.Fatal(err)
257 }
258 c1, err := DialUnix("unixgram", a1, nil)
259 if err != nil {
260 t.Fatal(err)
261 }
262 defer c1.Close()
263 defer os.Remove(addr1)
264 c1.LocalAddr()
265 c1.RemoteAddr()
266 c1.SetDeadline(time.Now().Add(someTimeout))
267 c1.SetReadDeadline(time.Now().Add(someTimeout))
268 c1.SetWriteDeadline(time.Now().Add(someTimeout))
269 c1.SetReadBuffer(2048)
270 c1.SetWriteBuffer(2048)
271
272 a2, err := ResolveUnixAddr("unixgram", addr2)
273 if err != nil {
274 t.Fatal(err)
275 }
276 c2, err := DialUnix("unixgram", a2, nil)
277 if err != nil {
278 t.Fatal(err)
279 }
280 defer c2.Close()
281 defer os.Remove(addr2)
282 c2.LocalAddr()
283 c2.RemoteAddr()
284 c2.SetDeadline(time.Now().Add(someTimeout))
285 c2.SetReadDeadline(time.Now().Add(someTimeout))
286 c2.SetWriteDeadline(time.Now().Add(someTimeout))
287 c2.SetReadBuffer(2048)
288 c2.SetWriteBuffer(2048)
289
290 a3, err := ResolveUnixAddr("unixgram", addr3)
291 if err != nil {
292 t.Fatal(err)
293 }
294 c3, err := ListenUnixgram("unixgram", a3)
295 if err != nil {
296 t.Fatal(err)
297 }
298 defer c3.Close()
299 defer os.Remove(addr3)
300 c3.LocalAddr()
301 c3.RemoteAddr()
302 c3.SetDeadline(time.Now().Add(someTimeout))
303 c3.SetReadDeadline(time.Now().Add(someTimeout))
304 c3.SetWriteDeadline(time.Now().Add(someTimeout))
305 c3.SetReadBuffer(2048)
306 c3.SetWriteBuffer(2048)
307
308 wb := []byte("UNIXCONN TEST")
309 rb1 := make([]byte, 128)
310 rb2 := make([]byte, 128)
311 rb3 := make([]byte, 128)
312 if _, _, err := c1.WriteMsgUnix(wb, nil, a2); err != nil {
313 t.Fatal(err)
314 }
315 if _, _, _, _, err := c2.ReadMsgUnix(rb2, nil); err != nil {
316 t.Fatal(err)
317 }
318 if _, err := c2.WriteToUnix(wb, a1); err != nil {
319 t.Fatal(err)
320 }
321 if _, _, err := c1.ReadFromUnix(rb1); err != nil {
322 t.Fatal(err)
323 }
324 if _, err := c3.WriteToUnix(wb, a1); err != nil {
325 t.Fatal(err)
326 }
327 if _, _, err := c1.ReadFromUnix(rb1); err != nil {
328 t.Fatal(err)
329 }
330 if _, err := c2.WriteToUnix(wb, a3); err != nil {
331 t.Fatal(err)
332 }
333 if _, _, err := c3.ReadFromUnix(rb3); err != nil {
334 t.Fatal(err)
335 }
336
337 if f, err := c1.File(); err != nil {
338 t.Fatal(err)
339 } else {
340 f.Close()
341 }
342
343 defer func() {
344 if p := recover(); p != nil {
345 t.Fatalf("panicked: %v", p)
346 }
347 }()
348
349 c1.WriteToUnix(wb, nil)
350 c1.WriteMsgUnix(wb, nil, nil)
351 c3.WriteToUnix(wb, nil)
352 c3.WriteMsgUnix(wb, nil, nil)
353 }
354
View as plain text