URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [net/] [unicast_test.go] - Blame information for rev 747

Details | Compare with Previous | View Log


// Copyright 2011 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
package net
 
import (
        "io"
        "runtime"
        "testing"
)
 
var unicastTests = []struct {
        net    string
        laddr  string
        ipv6   bool
        packet bool
}{
        {net: "tcp4", laddr: "127.0.0.1:0"},
        {net: "tcp4", laddr: "previous"},
        {net: "tcp6", laddr: "[::1]:0", ipv6: true},
        {net: "tcp6", laddr: "previous", ipv6: true},
        {net: "udp4", laddr: "127.0.0.1:0", packet: true},
        {net: "udp6", laddr: "[::1]:0", ipv6: true, packet: true},
}
 
func TestUnicastTCPAndUDP(t *testing.T) {
        if runtime.GOOS == "plan9" || runtime.GOOS == "windows" {
                return
        }
 
        prevladdr := ""
        for _, tt := range unicastTests {
                if tt.ipv6 && !supportsIPv6 {
                        continue
                }
                var (
                        fd     *netFD
                        closer io.Closer
                )
                if !tt.packet {
                        if tt.laddr == "previous" {
                                tt.laddr = prevladdr
                        }
                        l, err := Listen(tt.net, tt.laddr)
                        if err != nil {
                                t.Fatalf("Listen failed: %v", err)
                        }
                        prevladdr = l.Addr().String()
                        closer = l
                        fd = l.(*TCPListener).fd
                } else {
                        c, err := ListenPacket(tt.net, tt.laddr)
                        if err != nil {
                                t.Fatalf("ListenPacket failed: %v", err)
                        }
                        closer = c
                        fd = c.(*UDPConn).fd
                }
                if !tt.ipv6 {
                        testIPv4UnicastSocketOptions(t, fd)
                } else {
                        testIPv6UnicastSocketOptions(t, fd)
                }
                closer.Close()
        }
}
 
func testIPv4UnicastSocketOptions(t *testing.T, fd *netFD) {
        tos, err := ipv4TOS(fd)
        if err != nil {
                t.Fatalf("ipv4TOS failed: %v", err)
        }
        t.Logf("IPv4 TOS: %v", tos)
        err = setIPv4TOS(fd, 1)
        if err != nil {
                t.Fatalf("setIPv4TOS failed: %v", err)
        }
 
        ttl, err := ipv4TTL(fd)
        if err != nil {
                t.Fatalf("ipv4TTL failed: %v", err)
        }
        t.Logf("IPv4 TTL: %v", ttl)
        err = setIPv4TTL(fd, 1)
        if err != nil {
                t.Fatalf("setIPv4TTL failed: %v", err)
        }
}
 
func testIPv6UnicastSocketOptions(t *testing.T, fd *netFD) {
        tos, err := ipv6TrafficClass(fd)
        if err != nil {
                t.Fatalf("ipv6TrafficClass failed: %v", err)
        }
        t.Logf("IPv6 TrafficClass: %v", tos)
        err = setIPv6TrafficClass(fd, 1)
        if err != nil {
                t.Fatalf("setIPv6TrafficClass failed: %v", err)
        }
 
        hoplim, err := ipv6HopLimit(fd)
        if err != nil {
                t.Fatalf("ipv6HopLimit failed: %v", err)
        }
        t.Logf("IPv6 HopLimit: %v", hoplim)
        err = setIPv6HopLimit(fd, 1)
        if err != nil {
                t.Fatalf("setIPv6HopLimit failed: %v", err)
        }
}

Line No.	Rev	Author	Line
1	747	jeremybenn	`// Copyright 2011 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 net`
6
7			`import (`
8			`"io"`
9			`"runtime"`
10			`"testing"`
11			`)`
12
13			`var unicastTests = []struct {`
14			`net string`
15			`laddr string`
16			`ipv6 bool`
17			`packet bool`
18			`}{`
19			`{net: "tcp4", laddr: "127.0.0.1:0"},`
20			`{net: "tcp4", laddr: "previous"},`
21			`{net: "tcp6", laddr: "[::1]:0", ipv6: true},`
22			`{net: "tcp6", laddr: "previous", ipv6: true},`
23			`{net: "udp4", laddr: "127.0.0.1:0", packet: true},`
24			`{net: "udp6", laddr: "[::1]:0", ipv6: true, packet: true},`
25			`}`
26
27			`func TestUnicastTCPAndUDP(t *testing.T) {`
28			`if runtime.GOOS == "plan9" \|\| runtime.GOOS == "windows" {`
29			`return`
30			`}`
31
32			`prevladdr := ""`
33			`for _, tt := range unicastTests {`
34			`if tt.ipv6 && !supportsIPv6 {`
35			`continue`
36			`}`
37			`var (`
38			`fd *netFD`
39			`closer io.Closer`
40			`)`
41			`if !tt.packet {`
42			`if tt.laddr == "previous" {`
43			`tt.laddr = prevladdr`
44			`}`
45			`l, err := Listen(tt.net, tt.laddr)`
46			`if err != nil {`
47			`t.Fatalf("Listen failed: %v", err)`
48			`}`
49			`prevladdr = l.Addr().String()`
50			`closer = l`
51			`fd = l.(*TCPListener).fd`
52			`} else {`
53			`c, err := ListenPacket(tt.net, tt.laddr)`
54			`if err != nil {`
55			`t.Fatalf("ListenPacket failed: %v", err)`
56			`}`
57			`closer = c`
58			`fd = c.(*UDPConn).fd`
59			`}`
60			`if !tt.ipv6 {`
61			`testIPv4UnicastSocketOptions(t, fd)`
62			`} else {`
63			`testIPv6UnicastSocketOptions(t, fd)`
64			`}`
65			`closer.Close()`
66			`}`
67			`}`
68
69			`func testIPv4UnicastSocketOptions(t testing.T, fd netFD) {`
70			`tos, err := ipv4TOS(fd)`
71			`if err != nil {`
72			`t.Fatalf("ipv4TOS failed: %v", err)`
73			`}`
74			`t.Logf("IPv4 TOS: %v", tos)`
75			`err = setIPv4TOS(fd, 1)`
76			`if err != nil {`
77			`t.Fatalf("setIPv4TOS failed: %v", err)`
78			`}`
79
80			`ttl, err := ipv4TTL(fd)`
81			`if err != nil {`
82			`t.Fatalf("ipv4TTL failed: %v", err)`
83			`}`
84			`t.Logf("IPv4 TTL: %v", ttl)`
85			`err = setIPv4TTL(fd, 1)`
86			`if err != nil {`
87			`t.Fatalf("setIPv4TTL failed: %v", err)`
88			`}`
89			`}`
90
91			`func testIPv6UnicastSocketOptions(t testing.T, fd netFD) {`
92			`tos, err := ipv6TrafficClass(fd)`
93			`if err != nil {`
94			`t.Fatalf("ipv6TrafficClass failed: %v", err)`
95			`}`
96			`t.Logf("IPv6 TrafficClass: %v", tos)`
97			`err = setIPv6TrafficClass(fd, 1)`
98			`if err != nil {`
99			`t.Fatalf("setIPv6TrafficClass failed: %v", err)`
100			`}`
101
102			`hoplim, err := ipv6HopLimit(fd)`
103			`if err != nil {`
104			`t.Fatalf("ipv6HopLimit failed: %v", err)`
105			`}`
106			`t.Logf("IPv6 HopLimit: %v", hoplim)`
107			`err = setIPv6HopLimit(fd, 1)`
108			`if err != nil {`
109			`t.Fatalf("setIPv6HopLimit failed: %v", err)`
110			`}`
111			`}`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [net/] [unicast_test.go] - Blame information for rev 747