Source file
src/net/iprawsock_test.go
1
2
3
4
5
6
7 package net
8
9 import (
10 "internal/testenv"
11 "reflect"
12 "testing"
13 )
14
15
16
17
18
19
20
21 type resolveIPAddrTest struct {
22 network string
23 litAddrOrName string
24 addr *IPAddr
25 err error
26 }
27
28 var resolveIPAddrTests = []resolveIPAddrTest{
29 {"ip", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
30 {"ip4", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
31 {"ip4:icmp", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
32
33 {"ip", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
34 {"ip6", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
35 {"ip6:ipv6-icmp", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
36 {"ip6:IPv6-ICMP", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
37
38 {"ip", "::1%en0", &IPAddr{IP: ParseIP("::1"), Zone: "en0"}, nil},
39 {"ip6", "::1%911", &IPAddr{IP: ParseIP("::1"), Zone: "911"}, nil},
40
41 {"", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
42 {"", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
43
44 {"ip4:icmp", "", &IPAddr{}, nil},
45
46 {"l2tp", "127.0.0.1", nil, UnknownNetworkError("l2tp")},
47 {"l2tp:gre", "127.0.0.1", nil, UnknownNetworkError("l2tp:gre")},
48 {"tcp", "1.2.3.4:123", nil, UnknownNetworkError("tcp")},
49
50 {"ip4", "2001:db8::1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
51 {"ip4:icmp", "2001:db8::1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
52 {"ip6", "127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
53 {"ip6", "::ffff:127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
54 {"ip6:ipv6-icmp", "127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
55 {"ip6:ipv6-icmp", "::ffff:127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
56 }
57
58 func TestResolveIPAddr(t *testing.T) {
59 if !testableNetwork("ip+nopriv") {
60 t.Skip("ip+nopriv test")
61 }
62
63 origTestHookLookupIP := testHookLookupIP
64 defer func() { testHookLookupIP = origTestHookLookupIP }()
65 testHookLookupIP = lookupLocalhost
66
67 for _, tt := range resolveIPAddrTests {
68 addr, err := ResolveIPAddr(tt.network, tt.litAddrOrName)
69 if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
70 t.Errorf("ResolveIPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
71 continue
72 }
73 if err == nil {
74 addr2, err := ResolveIPAddr(addr.Network(), addr.String())
75 if !reflect.DeepEqual(addr2, tt.addr) || err != tt.err {
76 t.Errorf("(%q, %q): ResolveIPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
77 }
78 }
79 }
80 }
81
82 var ipConnLocalNameTests = []struct {
83 net string
84 laddr *IPAddr
85 }{
86 {"ip4:icmp", &IPAddr{IP: IPv4(127, 0, 0, 1)}},
87 {"ip4:icmp", &IPAddr{}},
88 {"ip4:icmp", nil},
89 }
90
91 func TestIPConnLocalName(t *testing.T) {
92 for _, tt := range ipConnLocalNameTests {
93 if !testableNetwork(tt.net) {
94 t.Logf("skipping %s test", tt.net)
95 continue
96 }
97 c, err := ListenIP(tt.net, tt.laddr)
98 if testenv.SyscallIsNotSupported(err) {
99
100 t.Logf("skipping %s test: %v", tt.net, err)
101 continue
102 } else if err != nil {
103 t.Fatal(err)
104 }
105 defer c.Close()
106 if la := c.LocalAddr(); la == nil {
107 t.Fatal("should not fail")
108 }
109 }
110 }
111
112 func TestIPConnRemoteName(t *testing.T) {
113 network := "ip:tcp"
114 if !testableNetwork(network) {
115 t.Skipf("skipping %s test", network)
116 }
117
118 raddr := &IPAddr{IP: IPv4(127, 0, 0, 1).To4()}
119 c, err := DialIP(network, &IPAddr{IP: IPv4(127, 0, 0, 1)}, raddr)
120 if testenv.SyscallIsNotSupported(err) {
121
122 t.Skipf("skipping %s test: %v", network, err)
123 } else if err != nil {
124 t.Fatal(err)
125 }
126 defer c.Close()
127 if !reflect.DeepEqual(raddr, c.RemoteAddr()) {
128 t.Fatalf("got %#v; want %#v", c.RemoteAddr(), raddr)
129 }
130 }
131
132 func TestDialListenIPArgs(t *testing.T) {
133 type test struct {
134 argLists [][2]string
135 shouldFail bool
136 }
137 tests := []test{
138 {
139 argLists: [][2]string{
140 {"ip", "127.0.0.1"},
141 {"ip:", "127.0.0.1"},
142 {"ip::", "127.0.0.1"},
143 {"ip", "::1"},
144 {"ip:", "::1"},
145 {"ip::", "::1"},
146 {"ip4", "127.0.0.1"},
147 {"ip4:", "127.0.0.1"},
148 {"ip4::", "127.0.0.1"},
149 {"ip6", "::1"},
150 {"ip6:", "::1"},
151 {"ip6::", "::1"},
152 },
153 shouldFail: true,
154 },
155 }
156 if testableNetwork("ip") {
157 priv := test{shouldFail: false}
158 for _, tt := range []struct {
159 network, address string
160 args [2]string
161 }{
162 {"ip4:47", "127.0.0.1", [2]string{"ip4:47", "127.0.0.1"}},
163 {"ip6:47", "::1", [2]string{"ip6:47", "::1"}},
164 } {
165 c, err := ListenPacket(tt.network, tt.address)
166 if err != nil {
167 continue
168 }
169 c.Close()
170 priv.argLists = append(priv.argLists, tt.args)
171 }
172 if len(priv.argLists) > 0 {
173 tests = append(tests, priv)
174 }
175 }
176
177 for _, tt := range tests {
178 for _, args := range tt.argLists {
179 _, err := Dial(args[0], args[1])
180 if tt.shouldFail != (err != nil) {
181 t.Errorf("Dial(%q, %q) = %v; want (err != nil) is %t", args[0], args[1], err, tt.shouldFail)
182 }
183 _, err = ListenPacket(args[0], args[1])
184 if tt.shouldFail != (err != nil) {
185 t.Errorf("ListenPacket(%q, %q) = %v; want (err != nil) is %t", args[0], args[1], err, tt.shouldFail)
186 }
187 a, err := ResolveIPAddr("ip", args[1])
188 if err != nil {
189 t.Errorf("ResolveIPAddr(\"ip\", %q) = %v", args[1], err)
190 continue
191 }
192 _, err = DialIP(args[0], nil, a)
193 if tt.shouldFail != (err != nil) {
194 t.Errorf("DialIP(%q, %v) = %v; want (err != nil) is %t", args[0], a, err, tt.shouldFail)
195 }
196 _, err = ListenIP(args[0], a)
197 if tt.shouldFail != (err != nil) {
198 t.Errorf("ListenIP(%q, %v) = %v; want (err != nil) is %t", args[0], a, err, tt.shouldFail)
199 }
200 }
201 }
202 }
203
View as plain text