← Back to branch summary

~ubuntu-branches/ubuntu/saucy/golang/saucy

« back to all changes in this revision

Viewing changes to src/pkg/net/protoconn_test.go

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-07-08 05:52:37 UTC
  • mfrom: (29.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130708055237-at01839e0hp8z3ni
Tags: 2:1.1-1ubuntu1
016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/net/protoconn_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
// This file implements API tests across platforms and will never have a build
 
6
// tag.
 
7
 
 
8
package net
 
9
 
 
10
import (
 
11
        "io/ioutil"
 
12
        "os"
 
13
        "runtime"
 
14
        "testing"
 
15
        "time"
 
16
)
 
17
 
 
18
// testUnixAddr uses ioutil.TempFile to get a name that is unique. It
 
19
// also uses /tmp directory in case it is prohibited to create UNIX
 
20
// sockets in TMPDIR.
 
21
func testUnixAddr() string {
 
22
        f, err := ioutil.TempFile("/tmp", "nettest")
 
23
        if err != nil {
 
24
                panic(err)
 
25
        }
 
26
        addr := f.Name()
 
27
        f.Close()
 
28
        os.Remove(addr)
 
29
        return addr
 
30
}
 
31
 
 
32
var condFatalf = func() func(*testing.T, string, ...interface{}) {
 
33
        // A few APIs are not implemented yet on both Plan 9 and Windows.
 
34
        switch runtime.GOOS {
 
35
        case "plan9", "windows":
 
36
                return (*testing.T).Logf
 
37
        }
 
38
        return (*testing.T).Fatalf
 
39
}()
 
40
 
 
41
func TestTCPListenerSpecificMethods(t *testing.T) {
 
42
        switch runtime.GOOS {
 
43
        case "plan9":
 
44
                t.Skipf("skipping test on %q", runtime.GOOS)
 
45
        }
 
46
 
 
47
        la, err := ResolveTCPAddr("tcp4", "127.0.0.1:0")
 
48
        if err != nil {
 
49
                t.Fatalf("ResolveTCPAddr failed: %v", err)
 
50
        }
 
51
        ln, err := ListenTCP("tcp4", la)
 
52
        if err != nil {
 
53
                t.Fatalf("ListenTCP failed: %v", err)
 
54
        }
 
55
        defer ln.Close()
 
56
        ln.Addr()
 
57
        ln.SetDeadline(time.Now().Add(30 * time.Nanosecond))
 
58
 
 
59
        if c, err := ln.Accept(); err != nil {
 
60
                if !err.(Error).Timeout() {
 
61
                        t.Fatalf("TCPListener.Accept failed: %v", err)
 
62
                }
 
63
        } else {
 
64
                c.Close()
 
65
        }
 
66
        if c, err := ln.AcceptTCP(); err != nil {
 
67
                if !err.(Error).Timeout() {
 
68
                        t.Fatalf("TCPListener.AcceptTCP failed: %v", err)
 
69
                }
 
70
        } else {
 
71
                c.Close()
 
72
        }
 
73
 
 
74
        if f, err := ln.File(); err != nil {
 
75
                condFatalf(t, "TCPListener.File failed: %v", err)
 
76
        } else {
 
77
                f.Close()
 
78
        }
 
79
}
 
80
 
 
81
func TestTCPConnSpecificMethods(t *testing.T) {
 
82
        la, err := ResolveTCPAddr("tcp4", "127.0.0.1:0")
 
83
        if err != nil {
 
84
                t.Fatalf("ResolveTCPAddr failed: %v", err)
 
85
        }
 
86
        ln, err := ListenTCP("tcp4", la)
 
87
        if err != nil {
 
88
                t.Fatalf("ListenTCP failed: %v", err)
 
89
        }
 
90
        defer ln.Close()
 
91
        ln.Addr()
 
92
 
 
93
        done := make(chan int)
 
94
        go transponder(t, ln, done)
 
95
 
 
96
        ra, err := ResolveTCPAddr("tcp4", ln.Addr().String())
 
97
        if err != nil {
 
98
                t.Fatalf("ResolveTCPAddr failed: %v", err)
 
99
        }
 
100
        c, err := DialTCP("tcp4", nil, ra)
 
101
        if err != nil {
 
102
                t.Fatalf("DialTCP failed: %v", err)
 
103
        }
 
104
        defer c.Close()
 
105
        c.SetKeepAlive(false)
 
106
        c.SetLinger(0)
 
107
        c.SetNoDelay(false)
 
108
        c.LocalAddr()
 
109
        c.RemoteAddr()
 
110
        c.SetDeadline(time.Now().Add(someTimeout))
 
111
        c.SetReadDeadline(time.Now().Add(someTimeout))
 
112
        c.SetWriteDeadline(time.Now().Add(someTimeout))
 
113
 
 
114
        if _, err := c.Write([]byte("TCPCONN TEST")); err != nil {
 
115
                t.Fatalf("TCPConn.Write failed: %v", err)
 
116
        }
 
117
        rb := make([]byte, 128)
 
118
        if _, err := c.Read(rb); err != nil {
 
119
                t.Fatalf("TCPConn.Read failed: %v", err)
 
120
        }
 
121
 
 
122
        <-done
 
123
}
 
124
 
 
125
func TestUDPConnSpecificMethods(t *testing.T) {
 
126
        la, err := ResolveUDPAddr("udp4", "127.0.0.1:0")
 
127
        if err != nil {
 
128
                t.Fatalf("ResolveUDPAddr failed: %v", err)
 
129
        }
 
130
        c, err := ListenUDP("udp4", la)
 
131
        if err != nil {
 
132
                t.Fatalf("ListenUDP failed: %v", err)
 
133
        }
 
134
        defer c.Close()
 
135
        c.LocalAddr()
 
136
        c.RemoteAddr()
 
137
        c.SetDeadline(time.Now().Add(someTimeout))
 
138
        c.SetReadDeadline(time.Now().Add(someTimeout))
 
139
        c.SetWriteDeadline(time.Now().Add(someTimeout))
 
140
        c.SetReadBuffer(2048)
 
141
        c.SetWriteBuffer(2048)
 
142
 
 
143
        wb := []byte("UDPCONN TEST")
 
144
        rb := make([]byte, 128)
 
145
        if _, err := c.WriteToUDP(wb, c.LocalAddr().(*UDPAddr)); err != nil {
 
146
                t.Fatalf("UDPConn.WriteToUDP failed: %v", err)
 
147
        }
 
148
        if _, _, err := c.ReadFromUDP(rb); err != nil {
 
149
                t.Fatalf("UDPConn.ReadFromUDP failed: %v", err)
 
150
        }
 
151
        if _, _, err := c.WriteMsgUDP(wb, nil, c.LocalAddr().(*UDPAddr)); err != nil {
 
152
                condFatalf(t, "UDPConn.WriteMsgUDP failed: %v", err)
 
153
        }
 
154
        if _, _, _, _, err := c.ReadMsgUDP(rb, nil); err != nil {
 
155
                condFatalf(t, "UDPConn.ReadMsgUDP failed: %v", err)
 
156
        }
 
157
 
 
158
        if f, err := c.File(); err != nil {
 
159
                condFatalf(t, "UDPConn.File failed: %v", err)
 
160
        } else {
 
161
                f.Close()
 
162
        }
 
163
}
 
164
 
 
165
func TestIPConnSpecificMethods(t *testing.T) {
 
166
        switch runtime.GOOS {
 
167
        case "plan9":
 
168
                t.Skipf("skipping test on %q", runtime.GOOS)
 
169
        }
 
170
        if os.Getuid() != 0 {
 
171
                t.Skipf("skipping test; must be root")
 
172
        }
 
173
 
 
174
        la, err := ResolveIPAddr("ip4", "127.0.0.1")
 
175
        if err != nil {
 
176
                t.Fatalf("ResolveIPAddr failed: %v", err)
 
177
        }
 
178
        c, err := ListenIP("ip4:icmp", la)
 
179
        if err != nil {
 
180
                t.Fatalf("ListenIP failed: %v", err)
 
181
        }
 
182
        defer c.Close()
 
183
        c.LocalAddr()
 
184
        c.RemoteAddr()
 
185
        c.SetDeadline(time.Now().Add(someTimeout))
 
186
        c.SetReadDeadline(time.Now().Add(someTimeout))
 
187
        c.SetWriteDeadline(time.Now().Add(someTimeout))
 
188
        c.SetReadBuffer(2048)
 
189
        c.SetWriteBuffer(2048)
 
190
 
 
191
        wb, err := (&icmpMessage{
 
192
                Type: icmpv4EchoRequest, Code: 0,
 
193
                Body: &icmpEcho{
 
194
                        ID: os.Getpid() & 0xffff, Seq: 1,
 
195
                        Data: []byte("IPCONN TEST "),
 
196
                },
 
197
        }).Marshal()
 
198
        if err != nil {
 
199
                t.Fatalf("icmpMessage.Marshal failed: %v", err)
 
200
        }
 
201
        rb := make([]byte, 20+128)
 
202
        if _, err := c.WriteToIP(wb, c.LocalAddr().(*IPAddr)); err != nil {
 
203
                t.Fatalf("IPConn.WriteToIP failed: %v", err)
 
204
        }
 
205
        if _, _, err := c.ReadFromIP(rb); err != nil {
 
206
                t.Fatalf("IPConn.ReadFromIP failed: %v", err)
 
207
        }
 
208
        if _, _, err := c.WriteMsgIP(wb, nil, c.LocalAddr().(*IPAddr)); err != nil {
 
209
                condFatalf(t, "IPConn.WriteMsgIP failed: %v", err)
 
210
        }
 
211
        if _, _, _, _, err := c.ReadMsgIP(rb, nil); err != nil {
 
212
                condFatalf(t, "IPConn.ReadMsgIP failed: %v", err)
 
213
        }
 
214
 
 
215
        if f, err := c.File(); err != nil {
 
216
                condFatalf(t, "IPConn.File failed: %v", err)
 
217
        } else {
 
218
                f.Close()
 
219
        }
 
220
}
 
221
 
 
222
func TestUnixListenerSpecificMethods(t *testing.T) {
 
223
        switch runtime.GOOS {
 
224
        case "plan9", "windows":
 
225
                t.Skipf("skipping test on %q", runtime.GOOS)
 
226
        }
 
227
 
 
228
        addr := testUnixAddr()
 
229
        la, err := ResolveUnixAddr("unix", addr)
 
230
        if err != nil {
 
231
                t.Fatalf("ResolveUnixAddr failed: %v", err)
 
232
        }
 
233
        ln, err := ListenUnix("unix", la)
 
234
        if err != nil {
 
235
                t.Fatalf("ListenUnix failed: %v", err)
 
236
        }
 
237
        defer ln.Close()
 
238
        defer os.Remove(addr)
 
239
        ln.Addr()
 
240
        ln.SetDeadline(time.Now().Add(30 * time.Nanosecond))
 
241
 
 
242
        if c, err := ln.Accept(); err != nil {
 
243
                if !err.(Error).Timeout() {
 
244
                        t.Fatalf("UnixListener.Accept failed: %v", err)
 
245
                }
 
246
        } else {
 
247
                c.Close()
 
248
        }
 
249
        if c, err := ln.AcceptUnix(); err != nil {
 
250
                if !err.(Error).Timeout() {
 
251
                        t.Fatalf("UnixListener.AcceptUnix failed: %v", err)
 
252
                }
 
253
        } else {
 
254
                c.Close()
 
255
        }
 
256
 
 
257
        if f, err := ln.File(); err != nil {
 
258
                t.Fatalf("UnixListener.File failed: %v", err)
 
259
        } else {
 
260
                f.Close()
 
261
        }
 
262
}
 
263
 
 
264
func TestUnixConnSpecificMethods(t *testing.T) {
 
265
        switch runtime.GOOS {
 
266
        case "plan9", "windows":
 
267
                t.Skipf("skipping test on %q", runtime.GOOS)
 
268
        }
 
269
 
 
270
        addr1, addr2, addr3 := testUnixAddr(), testUnixAddr(), testUnixAddr()
 
271
 
 
272
        a1, err := ResolveUnixAddr("unixgram", addr1)
 
273
        if err != nil {
 
274
                t.Fatalf("ResolveUnixAddr failed: %v", err)
 
275
        }
 
276
        c1, err := DialUnix("unixgram", a1, nil)
 
277
        if err != nil {
 
278
                t.Fatalf("DialUnix failed: %v", err)
 
279
        }
 
280
        defer c1.Close()
 
281
        defer os.Remove(addr1)
 
282
        c1.LocalAddr()
 
283
        c1.RemoteAddr()
 
284
        c1.SetDeadline(time.Now().Add(someTimeout))
 
285
        c1.SetReadDeadline(time.Now().Add(someTimeout))
 
286
        c1.SetWriteDeadline(time.Now().Add(someTimeout))
 
287
        c1.SetReadBuffer(2048)
 
288
        c1.SetWriteBuffer(2048)
 
289
 
 
290
        a2, err := ResolveUnixAddr("unixgram", addr2)
 
291
        if err != nil {
 
292
                t.Fatalf("ResolveUnixAddr failed: %v", err)
 
293
        }
 
294
        c2, err := DialUnix("unixgram", a2, nil)
 
295
        if err != nil {
 
296
                t.Fatalf("DialUnix failed: %v", err)
 
297
        }
 
298
        defer c2.Close()
 
299
        defer os.Remove(addr2)
 
300
        c2.LocalAddr()
 
301
        c2.RemoteAddr()
 
302
        c2.SetDeadline(time.Now().Add(someTimeout))
 
303
        c2.SetReadDeadline(time.Now().Add(someTimeout))
 
304
        c2.SetWriteDeadline(time.Now().Add(someTimeout))
 
305
        c2.SetReadBuffer(2048)
 
306
        c2.SetWriteBuffer(2048)
 
307
 
 
308
        a3, err := ResolveUnixAddr("unixgram", addr3)
 
309
        if err != nil {
 
310
                t.Fatalf("ResolveUnixAddr failed: %v", err)
 
311
        }
 
312
        c3, err := ListenUnixgram("unixgram", a3)
 
313
        if err != nil {
 
314
                t.Fatalf("ListenUnixgram failed: %v", err)
 
315
        }
 
316
        defer c3.Close()
 
317
        defer os.Remove(addr3)
 
318
        c3.LocalAddr()
 
319
        c3.RemoteAddr()
 
320
        c3.SetDeadline(time.Now().Add(someTimeout))
 
321
        c3.SetReadDeadline(time.Now().Add(someTimeout))
 
322
        c3.SetWriteDeadline(time.Now().Add(someTimeout))
 
323
        c3.SetReadBuffer(2048)
 
324
        c3.SetWriteBuffer(2048)
 
325
 
 
326
        wb := []byte("UNIXCONN TEST")
 
327
        rb1 := make([]byte, 128)
 
328
        rb2 := make([]byte, 128)
 
329
        rb3 := make([]byte, 128)
 
330
        if _, _, err := c1.WriteMsgUnix(wb, nil, a2); err != nil {
 
331
                t.Fatalf("UnixConn.WriteMsgUnix failed: %v", err)
 
332
        }
 
333
        if _, _, _, _, err := c2.ReadMsgUnix(rb2, nil); err != nil {
 
334
                t.Fatalf("UnixConn.ReadMsgUnix failed: %v", err)
 
335
        }
 
336
        if _, err := c2.WriteToUnix(wb, a1); err != nil {
 
337
                t.Fatalf("UnixConn.WriteToUnix failed: %v", err)
 
338
        }
 
339
        if _, _, err := c1.ReadFromUnix(rb1); err != nil {
 
340
                t.Fatalf("UnixConn.ReadFromUnix failed: %v", err)
 
341
        }
 
342
        if _, err := c3.WriteToUnix(wb, a1); err != nil {
 
343
                t.Fatalf("UnixConn.WriteToUnix failed: %v", err)
 
344
        }
 
345
        if _, _, err := c1.ReadFromUnix(rb1); err != nil {
 
346
                t.Fatalf("UnixConn.ReadFromUnix failed: %v", err)
 
347
        }
 
348
        if _, err := c2.WriteToUnix(wb, a3); err != nil {
 
349
                t.Fatalf("UnixConn.WriteToUnix failed: %v", err)
 
350
        }
 
351
        if _, _, err := c3.ReadFromUnix(rb3); err != nil {
 
352
                t.Fatalf("UnixConn.ReadFromUnix failed: %v", err)
 
353
        }
 
354
 
 
355
        if f, err := c1.File(); err != nil {
 
356
                t.Fatalf("UnixConn.File failed: %v", err)
 
357
        } else {
 
358
                f.Close()
 
359
        }
 
360
}