← Back to branch summary

~james-page/ubuntu/wily/juju-core/mir-fixes

« back to all changes in this revision

Viewing changes to src/golang.org/x/net/ipv6/readwrite_test.go

  • Committer: Package Import Robot
  • Author(s): Curtis C. Hovey
  • Date: 2015-06-05 17:40:37 UTC
  • mfrom: (1.1.34)
  • Revision ID: package-import@ubuntu.com-20150605174037-lcv12myq9gu4194e
Tags: 1.22.5-0ubuntu1
https://launchpad.net/bugs/1462001
* New upstream bugfix release (Lp: #1462001).
* d/copyright: Updated to reflect changes in the codebase.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/golang.org/x/net/ipv6/readwrite_test.go
 
1
// Copyright 2013 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
package ipv6_test
 
6
 
 
7
import (
 
8
        "bytes"
 
9
        "net"
 
10
        "runtime"
 
11
        "sync"
 
12
        "testing"
 
13
 
 
14
        "golang.org/x/net/internal/iana"
 
15
        "golang.org/x/net/internal/nettest"
 
16
        "golang.org/x/net/ipv6"
 
17
)
 
18
 
 
19
func benchmarkUDPListener() (net.PacketConn, net.Addr, error) {
 
20
        c, err := net.ListenPacket("udp6", "[::1]:0")
 
21
        if err != nil {
 
22
                return nil, nil, err
 
23
        }
 
24
        dst, err := net.ResolveUDPAddr("udp6", c.LocalAddr().String())
 
25
        if err != nil {
 
26
                c.Close()
 
27
                return nil, nil, err
 
28
        }
 
29
        return c, dst, nil
 
30
}
 
31
 
 
32
func BenchmarkReadWriteNetUDP(b *testing.B) {
 
33
        if !supportsIPv6 {
 
34
                b.Skip("ipv6 is not supported")
 
35
        }
 
36
 
 
37
        c, dst, err := benchmarkUDPListener()
 
38
        if err != nil {
 
39
                b.Fatal(err)
 
40
        }
 
41
        defer c.Close()
 
42
 
 
43
        wb, rb := []byte("HELLO-R-U-THERE"), make([]byte, 128)
 
44
        b.ResetTimer()
 
45
        for i := 0; i < b.N; i++ {
 
46
                benchmarkReadWriteNetUDP(b, c, wb, rb, dst)
 
47
        }
 
48
}
 
49
 
 
50
func benchmarkReadWriteNetUDP(b *testing.B, c net.PacketConn, wb, rb []byte, dst net.Addr) {
 
51
        if _, err := c.WriteTo(wb, dst); err != nil {
 
52
                b.Fatal(err)
 
53
        }
 
54
        if _, _, err := c.ReadFrom(rb); err != nil {
 
55
                b.Fatal(err)
 
56
        }
 
57
}
 
58
 
 
59
func BenchmarkReadWriteIPv6UDP(b *testing.B) {
 
60
        if !supportsIPv6 {
 
61
                b.Skip("ipv6 is not supported")
 
62
        }
 
63
 
 
64
        c, dst, err := benchmarkUDPListener()
 
65
        if err != nil {
 
66
                b.Fatal(err)
 
67
        }
 
68
        defer c.Close()
 
69
 
 
70
        p := ipv6.NewPacketConn(c)
 
71
        cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
 
72
        if err := p.SetControlMessage(cf, true); err != nil {
 
73
                b.Fatal(err)
 
74
        }
 
75
        ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
 
76
 
 
77
        wb, rb := []byte("HELLO-R-U-THERE"), make([]byte, 128)
 
78
        b.ResetTimer()
 
79
        for i := 0; i < b.N; i++ {
 
80
                benchmarkReadWriteIPv6UDP(b, p, wb, rb, dst, ifi)
 
81
        }
 
82
}
 
83
 
 
84
func benchmarkReadWriteIPv6UDP(b *testing.B, p *ipv6.PacketConn, wb, rb []byte, dst net.Addr, ifi *net.Interface) {
 
85
        cm := ipv6.ControlMessage{
 
86
                TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
 
87
                HopLimit:     1,
 
88
        }
 
89
        if ifi != nil {
 
90
                cm.IfIndex = ifi.Index
 
91
        }
 
92
        if n, err := p.WriteTo(wb, &cm, dst); err != nil {
 
93
                b.Fatal(err)
 
94
        } else if n != len(wb) {
 
95
                b.Fatalf("got %v; want %v", n, len(wb))
 
96
        }
 
97
        if _, _, _, err := p.ReadFrom(rb); err != nil {
 
98
                b.Fatal(err)
 
99
        }
 
100
}
 
101
 
 
102
func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
 
103
        switch runtime.GOOS {
 
104
        case "nacl", "plan9", "solaris", "windows":
 
105
                t.Skipf("not supported on %s", runtime.GOOS)
 
106
        }
 
107
        if !supportsIPv6 {
 
108
                t.Skip("ipv6 is not supported")
 
109
        }
 
110
 
 
111
        c, err := net.ListenPacket("udp6", "[::1]:0")
 
112
        if err != nil {
 
113
                t.Fatal(err)
 
114
        }
 
115
        defer c.Close()
 
116
        p := ipv6.NewPacketConn(c)
 
117
        defer p.Close()
 
118
 
 
119
        dst, err := net.ResolveUDPAddr("udp6", c.LocalAddr().String())
 
120
        if err != nil {
 
121
                t.Fatal(err)
 
122
        }
 
123
 
 
124
        ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
 
125
        cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
 
126
        wb := []byte("HELLO-R-U-THERE")
 
127
 
 
128
        if err := p.SetControlMessage(cf, true); err != nil { // probe before test
 
129
                if nettest.ProtocolNotSupported(err) {
 
130
                        t.Skipf("not supported on %s", runtime.GOOS)
 
131
                }
 
132
                t.Fatal(err)
 
133
        }
 
134
 
 
135
        var wg sync.WaitGroup
 
136
        reader := func() {
 
137
                defer wg.Done()
 
138
                rb := make([]byte, 128)
 
139
                if n, cm, _, err := p.ReadFrom(rb); err != nil {
 
140
                        t.Error(err)
 
141
                        return
 
142
                } else if !bytes.Equal(rb[:n], wb) {
 
143
                        t.Errorf("got %v; want %v", rb[:n], wb)
 
144
                        return
 
145
                } else {
 
146
                        t.Logf("rcvd cmsg: %v", cm)
 
147
                }
 
148
        }
 
149
        writer := func(toggle bool) {
 
150
                defer wg.Done()
 
151
                cm := ipv6.ControlMessage{
 
152
                        TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
 
153
                        Src:          net.IPv6loopback,
 
154
                }
 
155
                if ifi != nil {
 
156
                        cm.IfIndex = ifi.Index
 
157
                }
 
158
                if err := p.SetControlMessage(cf, toggle); err != nil {
 
159
                        t.Error(err)
 
160
                        return
 
161
                }
 
162
                if n, err := p.WriteTo(wb, &cm, dst); err != nil {
 
163
                        t.Error(err)
 
164
                        return
 
165
                } else if n != len(wb) {
 
166
                        t.Errorf("got %v; want %v", n, len(wb))
 
167
                        return
 
168
                }
 
169
        }
 
170
 
 
171
        const N = 10
 
172
        wg.Add(N)
 
173
        for i := 0; i < N; i++ {
 
174
                go reader()
 
175
        }
 
176
        wg.Add(2 * N)
 
177
        for i := 0; i < 2*N; i++ {
 
178
                go writer(i%2 != 0)
 
179
        }
 
180
        wg.Add(N)
 
181
        for i := 0; i < N; i++ {
 
182
                go reader()
 
183
        }
 
184
        wg.Wait()
 
185
}