← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/net/net_test.go
6
6
 
7
7
import (
8
8
        "io"
 
9
        "io/ioutil"
 
10
        "os"
9
11
        "runtime"
10
12
        "testing"
11
13
        "time"
13
15
 
14
16
func TestShutdown(t *testing.T) {
15
17
        if runtime.GOOS == "plan9" {
16
 
                t.Logf("skipping test on %q", runtime.GOOS)
17
 
                return
 
18
                t.Skipf("skipping test on %q", runtime.GOOS)
18
19
        }
19
 
        l, err := Listen("tcp", "127.0.0.1:0")
 
20
        ln, err := Listen("tcp", "127.0.0.1:0")
20
21
        if err != nil {
21
 
                if l, err = Listen("tcp6", "[::1]:0"); err != nil {
 
22
                if ln, err = Listen("tcp6", "[::1]:0"); err != nil {
22
23
                        t.Fatalf("ListenTCP on :0: %v", err)
23
24
                }
24
25
        }
25
26
 
26
27
        go func() {
27
 
                c, err := l.Accept()
 
28
                c, err := ln.Accept()
28
29
                if err != nil {
29
30
                        t.Fatalf("Accept: %v", err)
30
31
                }
37
38
                c.Close()
38
39
        }()
39
40
 
40
 
        c, err := Dial("tcp", l.Addr().String())
 
41
        c, err := Dial("tcp", ln.Addr().String())
41
42
        if err != nil {
42
43
                t.Fatalf("Dial: %v", err)
43
44
        }
58
59
        }
59
60
}
60
61
 
 
62
func TestShutdownUnix(t *testing.T) {
 
63
        switch runtime.GOOS {
 
64
        case "windows", "plan9":
 
65
                t.Skipf("skipping test on %q", runtime.GOOS)
 
66
        }
 
67
        f, err := ioutil.TempFile("", "go_net_unixtest")
 
68
        if err != nil {
 
69
                t.Fatalf("TempFile: %s", err)
 
70
        }
 
71
        f.Close()
 
72
        tmpname := f.Name()
 
73
        os.Remove(tmpname)
 
74
        ln, err := Listen("unix", tmpname)
 
75
        if err != nil {
 
76
                t.Fatalf("ListenUnix on %s: %s", tmpname, err)
 
77
        }
 
78
        defer os.Remove(tmpname)
 
79
 
 
80
        go func() {
 
81
                c, err := ln.Accept()
 
82
                if err != nil {
 
83
                        t.Fatalf("Accept: %v", err)
 
84
                }
 
85
                var buf [10]byte
 
86
                n, err := c.Read(buf[:])
 
87
                if n != 0 || err != io.EOF {
 
88
                        t.Fatalf("server Read = %d, %v; want 0, io.EOF", n, err)
 
89
                }
 
90
                c.Write([]byte("response"))
 
91
                c.Close()
 
92
        }()
 
93
 
 
94
        c, err := Dial("unix", tmpname)
 
95
        if err != nil {
 
96
                t.Fatalf("Dial: %v", err)
 
97
        }
 
98
        defer c.Close()
 
99
 
 
100
        err = c.(*UnixConn).CloseWrite()
 
101
        if err != nil {
 
102
                t.Fatalf("CloseWrite: %v", err)
 
103
        }
 
104
        var buf [10]byte
 
105
        n, err := c.Read(buf[:])
 
106
        if err != nil {
 
107
                t.Fatalf("client Read: %d, %v", n, err)
 
108
        }
 
109
        got := string(buf[:n])
 
110
        if got != "response" {
 
111
                t.Errorf("read = %q, want \"response\"", got)
 
112
        }
 
113
}
 
114
 
61
115
func TestTCPListenClose(t *testing.T) {
62
 
        l, err := Listen("tcp", "127.0.0.1:0")
 
116
        ln, err := Listen("tcp", "127.0.0.1:0")
63
117
        if err != nil {
64
118
                t.Fatalf("Listen failed: %v", err)
65
119
        }
67
121
        done := make(chan bool, 1)
68
122
        go func() {
69
123
                time.Sleep(100 * time.Millisecond)
70
 
                l.Close()
 
124
                ln.Close()
71
125
        }()
72
126
        go func() {
73
 
                _, err = l.Accept()
 
127
                c, err := ln.Accept()
74
128
                if err == nil {
 
129
                        c.Close()
75
130
                        t.Error("Accept succeeded")
76
131
                } else {
77
132
                        t.Logf("Accept timeout error: %s (any error is fine)", err)
86
141
}
87
142
 
88
143
func TestUDPListenClose(t *testing.T) {
89
 
        l, err := ListenPacket("udp", "127.0.0.1:0")
 
144
        switch runtime.GOOS {
 
145
        case "plan9":
 
146
                t.Skipf("skipping test on %q", runtime.GOOS)
 
147
        }
 
148
        ln, err := ListenPacket("udp", "127.0.0.1:0")
90
149
        if err != nil {
91
150
                t.Fatalf("Listen failed: %v", err)
92
151
        }
95
154
        done := make(chan bool, 1)
96
155
        go func() {
97
156
                time.Sleep(100 * time.Millisecond)
98
 
                l.Close()
 
157
                ln.Close()
99
158
        }()
100
159
        go func() {
101
 
                _, _, err = l.ReadFrom(buf)
 
160
                _, _, err = ln.ReadFrom(buf)
102
161
                if err == nil {
103
162
                        t.Error("ReadFrom succeeded")
104
163
                } else {
112
171
                t.Fatal("timeout waiting for UDP close")
113
172
        }
114
173
}
 
174
 
 
175
func TestTCPClose(t *testing.T) {
 
176
        switch runtime.GOOS {
 
177
        case "plan9":
 
178
                t.Skipf("skipping test on %q", runtime.GOOS)
 
179
        }
 
180
        l, err := Listen("tcp", "127.0.0.1:0")
 
181
        if err != nil {
 
182
                t.Fatal(err)
 
183
        }
 
184
        defer l.Close()
 
185
 
 
186
        read := func(r io.Reader) error {
 
187
                var m [1]byte
 
188
                _, err := r.Read(m[:])
 
189
                return err
 
190
        }
 
191
 
 
192
        go func() {
 
193
                c, err := Dial("tcp", l.Addr().String())
 
194
                if err != nil {
 
195
                        t.Fatal(err)
 
196
                }
 
197
 
 
198
                go read(c)
 
199
 
 
200
                time.Sleep(10 * time.Millisecond)
 
201
                c.Close()
 
202
        }()
 
203
 
 
204
        c, err := l.Accept()
 
205
        if err != nil {
 
206
                t.Fatal(err)
 
207
        }
 
208
        defer c.Close()
 
209
 
 
210
        for err == nil {
 
211
                err = read(c)
 
212
        }
 
213
        if err != nil && err != io.EOF {
 
214
                t.Fatal(err)
 
215
        }
 
216
}