1 // Copyright 2009 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.
13 var parseIPTests
= []struct {
17 {"127.0.1.2", IPv4(127, 0, 1, 2)},
18 {"127.0.0.1", IPv4(127, 0, 0, 1)},
22 {"::ffff:127.0.0.1", IPv4(127, 0, 0, 1)},
23 {"2001:4860:0:2001::68", IP
{0x20, 0x01, 0x48, 0x60, 0, 0, 0x20, 0x01, 0, 0, 0, 0, 0, 0, 0x00, 0x68}},
24 {"::ffff:4a7d:1363", IPv4(74, 125, 19, 99)},
30 func TestParseIP(t
*testing
.T
) {
31 for _
, tt
:= range parseIPTests
{
32 if out
:= ParseIP(tt
.in
); !reflect
.DeepEqual(out
, tt
.out
) {
33 t
.Errorf("ParseIP(%q) = %v, want %v", tt
.in
, out
, tt
.out
)
38 var ipStringTests
= []struct {
40 out
string // see RFC 5952
42 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, "2001:db8::123:12:1"},
43 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1}, "2001:db8::1"},
44 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0x1, 0, 0, 0, 0x1, 0, 0, 0, 0x1}, "2001:db8:0:1:0:1:0:1"},
45 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0x1, 0, 0, 0, 0x1, 0, 0, 0, 0x1, 0, 0}, "2001:db8:1:0:1:0:1:0"},
46 {IP
{0x20, 0x1, 0, 0, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1}, "2001::1:0:0:1"},
47 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0}, "2001:db8:0:0:1::"},
48 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1}, "2001:db8::1:0:0:1"},
49 {IP
{0x20, 0x1, 0xD, 0xB8, 0, 0, 0, 0, 0, 0xA, 0, 0xB, 0, 0xC, 0, 0xD}, "2001:db8::a:b:c:d"},
53 func TestIPString(t
*testing
.T
) {
54 for _
, tt
:= range ipStringTests
{
55 if out
:= tt
.in
.String(); out
!= tt
.out
{
56 t
.Errorf("IP.String(%v) = %q, want %q", tt
.in
, out
, tt
.out
)
61 var ipMaskTests
= []struct {
66 {IPv4(192, 168, 1, 127), IPv4Mask(255, 255, 255, 128), IPv4(192, 168, 1, 0)},
67 {IPv4(192, 168, 1, 127), IPMask(ParseIP("255.255.255.192")), IPv4(192, 168, 1, 64)},
68 {IPv4(192, 168, 1, 127), IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffe0")), IPv4(192, 168, 1, 96)},
69 {IPv4(192, 168, 1, 127), IPv4Mask(255, 0, 255, 0), IPv4(192, 0, 1, 0)},
70 {ParseIP("2001:db8::1"), IPMask(ParseIP("ffff:ff80::")), ParseIP("2001:d80::")},
71 {ParseIP("2001:db8::1"), IPMask(ParseIP("f0f0:0f0f::")), ParseIP("2000:d08::")},
74 func TestIPMask(t
*testing
.T
) {
75 for _
, tt
:= range ipMaskTests
{
76 if out
:= tt
.in
.Mask(tt
.mask
); out
== nil ||
!tt
.out
.Equal(out
) {
77 t
.Errorf("IP(%v).Mask(%v) = %v, want %v", tt
.in
, tt
.mask
, out
, tt
.out
)
82 var ipMaskStringTests
= []struct {
86 {IPv4Mask(255, 255, 255, 240), "fffffff0"},
87 {IPv4Mask(255, 0, 128, 0), "ff008000"},
88 {IPMask(ParseIP("ffff:ff80::")), "ffffff80000000000000000000000000"},
89 {IPMask(ParseIP("ef00:ff80::cafe:0")), "ef00ff800000000000000000cafe0000"},
93 func TestIPMaskString(t
*testing
.T
) {
94 for _
, tt
:= range ipMaskStringTests
{
95 if out
:= tt
.in
.String(); out
!= tt
.out
{
96 t
.Errorf("IPMask.String(%v) = %q, want %q", tt
.in
, out
, tt
.out
)
101 var parseCIDRTests
= []struct {
107 {"135.104.0.0/32", IPv4(135, 104, 0, 0), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 255)}, nil},
108 {"0.0.0.0/24", IPv4(0, 0, 0, 0), &IPNet
{IP
: IPv4(0, 0, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
109 {"135.104.0.0/24", IPv4(135, 104, 0, 0), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
110 {"135.104.0.1/32", IPv4(135, 104, 0, 1), &IPNet
{IP
: IPv4(135, 104, 0, 1), Mask
: IPv4Mask(255, 255, 255, 255)}, nil},
111 {"135.104.0.1/24", IPv4(135, 104, 0, 1), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
112 {"::1/128", ParseIP("::1"), &IPNet
{IP
: ParseIP("::1"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))}, nil},
113 {"abcd:2345::/127", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"))}, nil},
114 {"abcd:2345::/65", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:8000::"))}, nil},
115 {"abcd:2345::/64", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff::"))}, nil},
116 {"abcd:2345::/63", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:fffe::"))}, nil},
117 {"abcd:2345::/33", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:8000::"))}, nil},
118 {"abcd:2345::/32", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff::"))}, nil},
119 {"abcd:2344::/31", ParseIP("abcd:2344::"), &IPNet
{IP
: ParseIP("abcd:2344::"), Mask
: IPMask(ParseIP("ffff:fffe::"))}, nil},
120 {"abcd:2300::/24", ParseIP("abcd:2300::"), &IPNet
{IP
: ParseIP("abcd:2300::"), Mask
: IPMask(ParseIP("ffff:ff00::"))}, nil},
121 {"abcd:2345::/24", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2300::"), Mask
: IPMask(ParseIP("ffff:ff00::"))}, nil},
122 {"2001:DB8::/48", ParseIP("2001:DB8::"), &IPNet
{IP
: ParseIP("2001:DB8::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
123 {"2001:DB8::1/48", ParseIP("2001:DB8::1"), &IPNet
{IP
: ParseIP("2001:DB8::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
124 {"192.168.1.1/255.255.255.0", nil, nil, &ParseError
{"CIDR address", "192.168.1.1/255.255.255.0"}},
125 {"192.168.1.1/35", nil, nil, &ParseError
{"CIDR address", "192.168.1.1/35"}},
126 {"2001:db8::1/-1", nil, nil, &ParseError
{"CIDR address", "2001:db8::1/-1"}},
127 {"", nil, nil, &ParseError
{"CIDR address", ""}},
130 func TestParseCIDR(t
*testing
.T
) {
131 for _
, tt
:= range parseCIDRTests
{
132 ip
, net
, err
:= ParseCIDR(tt
.in
)
133 if !reflect
.DeepEqual(err
, tt
.err
) {
134 t
.Errorf("ParseCIDR(%q) = %v, %v; want %v, %v", tt
.in
, ip
, net
, tt
.ip
, tt
.net
)
136 if err
== nil && (!tt
.ip
.Equal(ip
) ||
!tt
.net
.IP
.Equal(net
.IP
) ||
!reflect
.DeepEqual(net
.Mask
, tt
.net
.Mask
)) {
137 t
.Errorf("ParseCIDR(%q) = %v, {%v, %v}; want %v, {%v, %v}", tt
.in
, ip
, net
.IP
, net
.Mask
, tt
.ip
, tt
.net
.IP
, tt
.net
.Mask
)
142 var ipNetContainsTests
= []struct {
147 {IPv4(172, 16, 1, 1), &IPNet
{IP
: IPv4(172, 16, 0, 0), Mask
: CIDRMask(12, 32)}, true},
148 {IPv4(172, 24, 0, 1), &IPNet
{IP
: IPv4(172, 16, 0, 0), Mask
: CIDRMask(13, 32)}, false},
149 {IPv4(192, 168, 0, 3), &IPNet
{IP
: IPv4(192, 168, 0, 0), Mask
: IPv4Mask(0, 0, 255, 252)}, true},
150 {IPv4(192, 168, 0, 4), &IPNet
{IP
: IPv4(192, 168, 0, 0), Mask
: IPv4Mask(0, 255, 0, 252)}, false},
151 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: CIDRMask(47, 128)}, true},
152 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:2::"), Mask
: CIDRMask(47, 128)}, false},
153 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: IPMask(ParseIP("ffff:0:ffff::"))}, true},
154 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: IPMask(ParseIP("0:0:0:ffff::"))}, false},
157 func TestIPNetContains(t
*testing
.T
) {
158 for _
, tt
:= range ipNetContainsTests
{
159 if ok
:= tt
.net
.Contains(tt
.ip
); ok
!= tt
.ok
{
160 t
.Errorf("IPNet(%v).Contains(%v) = %v, want %v", tt
.net
, tt
.ip
, ok
, tt
.ok
)
165 var ipNetStringTests
= []struct {
169 {&IPNet
{IP
: IPv4(192, 168, 1, 0), Mask
: CIDRMask(26, 32)}, "192.168.1.0/26"},
170 {&IPNet
{IP
: IPv4(192, 168, 1, 0), Mask
: IPv4Mask(255, 0, 255, 0)}, "192.168.1.0/ff00ff00"},
171 {&IPNet
{IP
: ParseIP("2001:db8::"), Mask
: CIDRMask(55, 128)}, "2001:db8::/55"},
172 {&IPNet
{IP
: ParseIP("2001:db8::"), Mask
: IPMask(ParseIP("8000:f123:0:cafe::"))}, "2001:db8::/8000f1230000cafe0000000000000000"},
175 func TestIPNetString(t
*testing
.T
) {
176 for _
, tt
:= range ipNetStringTests
{
177 if out
:= tt
.in
.String(); out
!= tt
.out
{
178 t
.Errorf("IPNet.String(%v) = %q, want %q", tt
.in
, out
, tt
.out
)
183 var cidrMaskTests
= []struct {
188 {0, 32, IPv4Mask(0, 0, 0, 0)},
189 {12, 32, IPv4Mask(255, 240, 0, 0)},
190 {24, 32, IPv4Mask(255, 255, 255, 0)},
191 {32, 32, IPv4Mask(255, 255, 255, 255)},
192 {0, 128, IPMask
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
193 {4, 128, IPMask
{0xf0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
194 {48, 128, IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
195 {128, 128, IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
202 func TestCIDRMask(t
*testing
.T
) {
203 for _
, tt
:= range cidrMaskTests
{
204 if out
:= CIDRMask(tt
.ones
, tt
.bits
); !reflect
.DeepEqual(out
, tt
.out
) {
205 t
.Errorf("CIDRMask(%v, %v) = %v, want %v", tt
.ones
, tt
.bits
, out
, tt
.out
)
211 v4addr
= IP
{192, 168, 0, 1}
212 v4mappedv6addr
= IP
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 0, 1}
213 v6addr
= IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}
214 v4mask
= IPMask
{255, 255, 255, 0}
215 v4mappedv6mask
= IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 255, 255, 255, 0}
216 v6mask
= IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0}
217 badaddr
= IP
{192, 168, 0}
218 badmask
= IPMask
{255, 255, 0}
219 v4maskzero
= IPMask
{0, 0, 0, 0}
222 var networkNumberAndMaskTests
= []struct {
226 {IPNet
{IP
: v4addr
, Mask
: v4mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
227 {IPNet
{IP
: v4addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
228 {IPNet
{IP
: v4mappedv6addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
229 {IPNet
{IP
: v4mappedv6addr
, Mask
: v6mask
}, IPNet
{IP
: v4addr
, Mask
: v4maskzero
}},
230 {IPNet
{IP
: v4addr
, Mask
: v6mask
}, IPNet
{IP
: v4addr
, Mask
: v4maskzero
}},
231 {IPNet
{IP
: v6addr
, Mask
: v6mask
}, IPNet
{IP
: v6addr
, Mask
: v6mask
}},
232 {IPNet
{IP
: v6addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v6addr
, Mask
: v4mappedv6mask
}},
233 {in
: IPNet
{IP
: v6addr
, Mask
: v4mask
}},
234 {in
: IPNet
{IP
: v4addr
, Mask
: badmask
}},
235 {in
: IPNet
{IP
: v4mappedv6addr
, Mask
: badmask
}},
236 {in
: IPNet
{IP
: v6addr
, Mask
: badmask
}},
237 {in
: IPNet
{IP
: badaddr
, Mask
: v4mask
}},
238 {in
: IPNet
{IP
: badaddr
, Mask
: v4mappedv6mask
}},
239 {in
: IPNet
{IP
: badaddr
, Mask
: v6mask
}},
240 {in
: IPNet
{IP
: badaddr
, Mask
: badmask
}},
243 func TestNetworkNumberAndMask(t
*testing
.T
) {
244 for _
, tt
:= range networkNumberAndMaskTests
{
245 ip
, m
:= networkNumberAndMask(&tt
.in
)
246 out
:= &IPNet
{IP
: ip
, Mask
: m
}
247 if !reflect
.DeepEqual(&tt
.out
, out
) {
248 t
.Errorf("networkNumberAndMask(%v) = %v, want %v", tt
.in
, out
, &tt
.out
)
253 var splitJoinTests
= []struct {
258 {"www.google.com", "80", "www.google.com:80"},
259 {"127.0.0.1", "1234", "127.0.0.1:1234"},
260 {"::1", "80", "[::1]:80"},
261 {"fe80::1%lo0", "80", "[fe80::1%lo0]:80"},
262 {"localhost%lo0", "80", "[localhost%lo0]:80"},
265 {"google.com", "https%foo", "google.com:https%foo"}, // Go 1.0 behavior
266 {"127.0.0.1", "", "127.0.0.1:"}, // Go 1.0 behaviour
267 {"www.google.com", "", "www.google.com:"}, // Go 1.0 behaviour
270 var splitFailureTests
= []struct {
274 {"www.google.com", "missing port in address"},
275 {"127.0.0.1", "missing port in address"},
276 {"[::1]", "missing port in address"},
277 {"[fe80::1%lo0]", "missing port in address"},
278 {"[localhost%lo0]", "missing port in address"},
279 {"localhost%lo0", "missing port in address"},
281 {"::1", "too many colons in address"},
282 {"fe80::1%lo0", "too many colons in address"},
283 {"fe80::1%lo0:80", "too many colons in address"},
285 {"localhost%lo0:80", "missing brackets in address"},
287 // Test cases that didn't fail in Go 1.0
289 {"[foo:bar]", "missing port in address"},
290 {"[foo:bar]baz", "missing port in address"},
291 {"[foo]bar:baz", "missing port in address"},
293 {"[foo]:[bar]:baz", "too many colons in address"},
295 {"[foo]:[bar]baz", "unexpected '[' in address"},
296 {"foo[bar]:baz", "unexpected '[' in address"},
298 {"foo]bar:baz", "unexpected ']' in address"},
301 func TestSplitHostPort(t
*testing
.T
) {
302 for _
, tt
:= range splitJoinTests
{
303 if host
, port
, err
:= SplitHostPort(tt
.join
); host
!= tt
.host || port
!= tt
.port || err
!= nil {
304 t
.Errorf("SplitHostPort(%q) = %q, %q, %v; want %q, %q, nil", tt
.join
, host
, port
, err
, tt
.host
, tt
.port
)
307 for _
, tt
:= range splitFailureTests
{
308 if _
, _
, err
:= SplitHostPort(tt
.hostPort
); err
== nil {
309 t
.Errorf("SplitHostPort(%q) should have failed", tt
.hostPort
)
311 e
:= err
.(*AddrError
)
313 t
.Errorf("SplitHostPort(%q) = _, _, %q; want %q", tt
.hostPort
, e
.Err
, tt
.err
)
319 func TestJoinHostPort(t
*testing
.T
) {
320 for _
, tt
:= range splitJoinTests
{
321 if join
:= JoinHostPort(tt
.host
, tt
.port
); join
!= tt
.join
{
322 t
.Errorf("JoinHostPort(%q, %q) = %q; want %q", tt
.host
, tt
.port
, join
, tt
.join
)
327 var ipAddrFamilyTests
= []struct {
332 {IPv4bcast
, true, false},
333 {IPv4allsys
, true, false},
334 {IPv4allrouter
, true, false},
335 {IPv4zero
, true, false},
336 {IPv4(224, 0, 0, 1), true, false},
337 {IPv4(127, 0, 0, 1), true, false},
338 {IPv4(240, 0, 0, 1), true, false},
339 {IPv6unspecified
, false, true},
340 {IPv6loopback
, false, true},
341 {IPv6interfacelocalallnodes
, false, true},
342 {IPv6linklocalallnodes
, false, true},
343 {IPv6linklocalallrouters
, false, true},
344 {ParseIP("ff05::a:b:c:d"), false, true},
345 {ParseIP("fe80::1:2:3:4"), false, true},
346 {ParseIP("2001:db8::123:12:1"), false, true},
349 func TestIPAddrFamily(t
*testing
.T
) {
350 for _
, tt
:= range ipAddrFamilyTests
{
351 if af
:= tt
.in
.To4() != nil; af
!= tt
.af4
{
352 t
.Errorf("verifying IPv4 address family for %q = %v, want %v", tt
.in
, af
, tt
.af4
)
354 if af
:= len(tt
.in
) == IPv6len
&& tt
.in
.To4() == nil; af
!= tt
.af6
{
355 t
.Errorf("verifying IPv6 address family for %q = %v, want %v", tt
.in
, af
, tt
.af6
)
360 var ipAddrScopeTests
= []struct {
365 {IP
.IsUnspecified
, IPv4zero
, true},
366 {IP
.IsUnspecified
, IPv4(127, 0, 0, 1), false},
367 {IP
.IsUnspecified
, IPv6unspecified
, true},
368 {IP
.IsUnspecified
, IPv6interfacelocalallnodes
, false},
369 {IP
.IsLoopback
, IPv4(127, 0, 0, 1), true},
370 {IP
.IsLoopback
, IPv4(127, 255, 255, 254), true},
371 {IP
.IsLoopback
, IPv4(128, 1, 2, 3), false},
372 {IP
.IsLoopback
, IPv6loopback
, true},
373 {IP
.IsLoopback
, IPv6linklocalallrouters
, false},
374 {IP
.IsMulticast
, IPv4(224, 0, 0, 0), true},
375 {IP
.IsMulticast
, IPv4(239, 0, 0, 0), true},
376 {IP
.IsMulticast
, IPv4(240, 0, 0, 0), false},
377 {IP
.IsMulticast
, IPv6linklocalallnodes
, true},
378 {IP
.IsMulticast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
379 {IP
.IsMulticast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
380 {IP
.IsLinkLocalMulticast
, IPv4(224, 0, 0, 0), true},
381 {IP
.IsLinkLocalMulticast
, IPv4(239, 0, 0, 0), false},
382 {IP
.IsLinkLocalMulticast
, IPv6linklocalallrouters
, true},
383 {IP
.IsLinkLocalMulticast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
384 {IP
.IsLinkLocalUnicast
, IPv4(169, 254, 0, 0), true},
385 {IP
.IsLinkLocalUnicast
, IPv4(169, 255, 0, 0), false},
386 {IP
.IsLinkLocalUnicast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
387 {IP
.IsLinkLocalUnicast
, IP
{0xfe, 0xc0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
388 {IP
.IsGlobalUnicast
, IPv4(240, 0, 0, 0), true},
389 {IP
.IsGlobalUnicast
, IPv4(232, 0, 0, 0), false},
390 {IP
.IsGlobalUnicast
, IPv4(169, 254, 0, 0), false},
391 {IP
.IsGlobalUnicast
, IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, true},
392 {IP
.IsGlobalUnicast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
393 {IP
.IsGlobalUnicast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
396 func name(f
interface{}) string {
397 return runtime
.FuncForPC(reflect
.ValueOf(f
).Pointer()).Name()
400 func TestIPAddrScope(t
*testing
.T
) {
401 for _
, tt
:= range ipAddrScopeTests
{
402 if ok
:= tt
.scope(tt
.in
); ok
!= tt
.ok
{
403 t
.Errorf("%s(%q) = %v, want %v", name(tt
.scope
), tt
.in
, ok
, tt
.ok
)