← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

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

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/golang.org/x/net/ipv6/sockopt_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
        "fmt"
 
9
        "net"
 
10
        "runtime"
 
11
        "testing"
 
12
 
 
13
        "golang.org/x/net/internal/iana"
 
14
        "golang.org/x/net/internal/nettest"
 
15
        "golang.org/x/net/ipv6"
 
16
)
 
17
 
 
18
var supportsIPv6 bool = nettest.SupportsIPv6()
 
19
 
 
20
func TestConnInitiatorPathMTU(t *testing.T) {
 
21
        switch runtime.GOOS {
 
22
        case "nacl", "plan9", "solaris", "windows":
 
23
                t.Skipf("not supported on %s", runtime.GOOS)
 
24
        }
 
25
        if !supportsIPv6 {
 
26
                t.Skip("ipv6 is not supported")
 
27
        }
 
28
 
 
29
        ln, err := net.Listen("tcp6", "[::1]:0")
 
30
        if err != nil {
 
31
                t.Fatal(err)
 
32
        }
 
33
        defer ln.Close()
 
34
 
 
35
        done := make(chan bool)
 
36
        go acceptor(t, ln, done)
 
37
 
 
38
        c, err := net.Dial("tcp6", ln.Addr().String())
 
39
        if err != nil {
 
40
                t.Fatal(err)
 
41
        }
 
42
        defer c.Close()
 
43
 
 
44
        if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
 
45
                switch runtime.GOOS {
 
46
                case "darwin": // older darwin kernels don't support IPV6_PATHMTU option
 
47
                        t.Logf("not supported on %s", runtime.GOOS)
 
48
                default:
 
49
                        t.Fatal(err)
 
50
                }
 
51
        } else {
 
52
                t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
 
53
        }
 
54
 
 
55
        <-done
 
56
}
 
57
 
 
58
func TestConnResponderPathMTU(t *testing.T) {
 
59
        switch runtime.GOOS {
 
60
        case "nacl", "plan9", "solaris", "windows":
 
61
                t.Skipf("not supported on %s", runtime.GOOS)
 
62
        }
 
63
        if !supportsIPv6 {
 
64
                t.Skip("ipv6 is not supported")
 
65
        }
 
66
 
 
67
        ln, err := net.Listen("tcp6", "[::1]:0")
 
68
        if err != nil {
 
69
                t.Fatal(err)
 
70
        }
 
71
        defer ln.Close()
 
72
 
 
73
        done := make(chan bool)
 
74
        go connector(t, "tcp6", ln.Addr().String(), done)
 
75
 
 
76
        c, err := ln.Accept()
 
77
        if err != nil {
 
78
                t.Fatal(err)
 
79
        }
 
80
        defer c.Close()
 
81
 
 
82
        if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
 
83
                switch runtime.GOOS {
 
84
                case "darwin": // older darwin kernels don't support IPV6_PATHMTU option
 
85
                        t.Logf("not supported on %s", runtime.GOOS)
 
86
                default:
 
87
                        t.Fatal(err)
 
88
                }
 
89
        } else {
 
90
                t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
 
91
        }
 
92
 
 
93
        <-done
 
94
}
 
95
 
 
96
func TestPacketConnChecksum(t *testing.T) {
 
97
        switch runtime.GOOS {
 
98
        case "nacl", "plan9", "solaris", "windows":
 
99
                t.Skipf("not supported on %s", runtime.GOOS)
 
100
        }
 
101
        if !supportsIPv6 {
 
102
                t.Skip("ipv6 is not supported")
 
103
        }
 
104
        if m, ok := nettest.SupportsRawIPSocket(); !ok {
 
105
                t.Skip(m)
 
106
        }
 
107
 
 
108
        c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolOSPFIGP), "::") // OSPF for IPv6
 
109
        if err != nil {
 
110
                t.Fatal(err)
 
111
        }
 
112
        defer c.Close()
 
113
 
 
114
        p := ipv6.NewPacketConn(c)
 
115
        offset := 12 // see RFC 5340
 
116
 
 
117
        for _, toggle := range []bool{false, true} {
 
118
                if err := p.SetChecksum(toggle, offset); err != nil {
 
119
                        if toggle {
 
120
                                t.Fatalf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err)
 
121
                        } else {
 
122
                                // Some platforms never allow to disable the kernel
 
123
                                // checksum processing.
 
124
                                t.Logf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err)
 
125
                        }
 
126
                }
 
127
                if on, offset, err := p.Checksum(); err != nil {
 
128
                        t.Fatal(err)
 
129
                } else {
 
130
                        t.Logf("kernel checksum processing enabled=%v, offset=%v", on, offset)
 
131
                }
 
132
        }
 
133
}