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