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)},
28 {"a1:a2:a3:a4::b1:b2:b3:b4", nil}, // Issue 6628
31 func TestParseIP(t
*testing
.T
) {
32 for _
, tt
:= range parseIPTests
{
33 if out
:= ParseIP(tt
.in
); !reflect
.DeepEqual(out
, tt
.out
) {
34 t
.Errorf("ParseIP(%q) = %v, want %v", tt
.in
, out
, tt
.out
)
37 // Tested in TestMarshalEmptyIP below.
41 if err
:= out
.UnmarshalText([]byte(tt
.in
)); !reflect
.DeepEqual(out
, tt
.out
) ||
(tt
.out
== nil) != (err
!= nil) {
42 t
.Errorf("IP.UnmarshalText(%q) = %v, %v, want %v", tt
.in
, out
, err
, tt
.out
)
47 func BenchmarkParseIP(b
*testing
.B
) {
48 for i
:= 0; i
< b
.N
; i
++ {
49 for _
, tt
:= range parseIPTests
{
56 func TestMarshalEmptyIP(t
*testing
.T
) {
57 for _
, in
:= range [][]byte{nil, []byte("")} {
58 var out
= IP
{1, 2, 3, 4}
59 if err
:= out
.UnmarshalText(in
); err
!= nil || out
!= nil {
60 t
.Errorf("UnmarshalText(%v) = %v, %v; want nil, nil", in
, out
, err
)
64 got
, err
:= ip
.MarshalText()
68 if !reflect
.DeepEqual(got
, []byte("")) {
69 t
.Errorf(`got %#v, want []byte("")`, got
)
73 var ipStringTests
= []struct {
75 out
string // see RFC 5952
77 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, "2001:db8::123:12:1"},
78 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1}, "2001:db8::1"},
79 {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"},
80 {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"},
81 {IP
{0x20, 0x1, 0, 0, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1}, "2001::1:0:0:1"},
82 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0}, "2001:db8:0:0:1::"},
83 {IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1}, "2001:db8::1:0:0:1"},
84 {IP
{0x20, 0x1, 0xD, 0xB8, 0, 0, 0, 0, 0, 0xA, 0, 0xB, 0, 0xC, 0, 0xD}, "2001:db8::a:b:c:d"},
85 {IPv4(192, 168, 0, 1), "192.168.0.1"},
89 func TestIPString(t
*testing
.T
) {
90 for _
, tt
:= range ipStringTests
{
92 if out
:= tt
.in
.String(); out
!= tt
.out
{
93 t
.Errorf("IP.String(%v) = %q, want %q", tt
.in
, out
, tt
.out
)
96 if out
, err
:= tt
.in
.MarshalText(); string(out
) != tt
.out || err
!= nil {
97 t
.Errorf("IP.MarshalText(%v) = %q, %v, want %q, nil", tt
.in
, out
, err
, tt
.out
)
102 func BenchmarkIPString(b
*testing
.B
) {
103 for i
:= 0; i
< b
.N
; i
++ {
104 for _
, tt
:= range ipStringTests
{
112 var ipMaskTests
= []struct {
117 {IPv4(192, 168, 1, 127), IPv4Mask(255, 255, 255, 128), IPv4(192, 168, 1, 0)},
118 {IPv4(192, 168, 1, 127), IPMask(ParseIP("255.255.255.192")), IPv4(192, 168, 1, 64)},
119 {IPv4(192, 168, 1, 127), IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffe0")), IPv4(192, 168, 1, 96)},
120 {IPv4(192, 168, 1, 127), IPv4Mask(255, 0, 255, 0), IPv4(192, 0, 1, 0)},
121 {ParseIP("2001:db8::1"), IPMask(ParseIP("ffff:ff80::")), ParseIP("2001:d80::")},
122 {ParseIP("2001:db8::1"), IPMask(ParseIP("f0f0:0f0f::")), ParseIP("2000:d08::")},
125 func TestIPMask(t
*testing
.T
) {
126 for _
, tt
:= range ipMaskTests
{
127 if out
:= tt
.in
.Mask(tt
.mask
); out
== nil ||
!tt
.out
.Equal(out
) {
128 t
.Errorf("IP(%v).Mask(%v) = %v, want %v", tt
.in
, tt
.mask
, out
, tt
.out
)
133 var ipMaskStringTests
= []struct {
137 {IPv4Mask(255, 255, 255, 240), "fffffff0"},
138 {IPv4Mask(255, 0, 128, 0), "ff008000"},
139 {IPMask(ParseIP("ffff:ff80::")), "ffffff80000000000000000000000000"},
140 {IPMask(ParseIP("ef00:ff80::cafe:0")), "ef00ff800000000000000000cafe0000"},
144 func TestIPMaskString(t
*testing
.T
) {
145 for _
, tt
:= range ipMaskStringTests
{
146 if out
:= tt
.in
.String(); out
!= tt
.out
{
147 t
.Errorf("IPMask.String(%v) = %q, want %q", tt
.in
, out
, tt
.out
)
152 func BenchmarkIPMaskString(b
*testing
.B
) {
153 for i
:= 0; i
< b
.N
; i
++ {
154 for _
, tt
:= range ipMaskStringTests
{
160 var parseCIDRTests
= []struct {
166 {"135.104.0.0/32", IPv4(135, 104, 0, 0), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 255)}, nil},
167 {"0.0.0.0/24", IPv4(0, 0, 0, 0), &IPNet
{IP
: IPv4(0, 0, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
168 {"135.104.0.0/24", IPv4(135, 104, 0, 0), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
169 {"135.104.0.1/32", IPv4(135, 104, 0, 1), &IPNet
{IP
: IPv4(135, 104, 0, 1), Mask
: IPv4Mask(255, 255, 255, 255)}, nil},
170 {"135.104.0.1/24", IPv4(135, 104, 0, 1), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
171 {"::1/128", ParseIP("::1"), &IPNet
{IP
: ParseIP("::1"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))}, nil},
172 {"abcd:2345::/127", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"))}, nil},
173 {"abcd:2345::/65", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:8000::"))}, nil},
174 {"abcd:2345::/64", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff::"))}, nil},
175 {"abcd:2345::/63", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:fffe::"))}, nil},
176 {"abcd:2345::/33", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:8000::"))}, nil},
177 {"abcd:2345::/32", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff::"))}, nil},
178 {"abcd:2344::/31", ParseIP("abcd:2344::"), &IPNet
{IP
: ParseIP("abcd:2344::"), Mask
: IPMask(ParseIP("ffff:fffe::"))}, nil},
179 {"abcd:2300::/24", ParseIP("abcd:2300::"), &IPNet
{IP
: ParseIP("abcd:2300::"), Mask
: IPMask(ParseIP("ffff:ff00::"))}, nil},
180 {"abcd:2345::/24", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2300::"), Mask
: IPMask(ParseIP("ffff:ff00::"))}, nil},
181 {"2001:DB8::/48", ParseIP("2001:DB8::"), &IPNet
{IP
: ParseIP("2001:DB8::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
182 {"2001:DB8::1/48", ParseIP("2001:DB8::1"), &IPNet
{IP
: ParseIP("2001:DB8::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
183 {"192.168.1.1/255.255.255.0", nil, nil, &ParseError
{"CIDR address", "192.168.1.1/255.255.255.0"}},
184 {"192.168.1.1/35", nil, nil, &ParseError
{"CIDR address", "192.168.1.1/35"}},
185 {"2001:db8::1/-1", nil, nil, &ParseError
{"CIDR address", "2001:db8::1/-1"}},
186 {"", nil, nil, &ParseError
{"CIDR address", ""}},
189 func TestParseCIDR(t
*testing
.T
) {
190 for _
, tt
:= range parseCIDRTests
{
191 ip
, net
, err
:= ParseCIDR(tt
.in
)
192 if !reflect
.DeepEqual(err
, tt
.err
) {
193 t
.Errorf("ParseCIDR(%q) = %v, %v; want %v, %v", tt
.in
, ip
, net
, tt
.ip
, tt
.net
)
195 if err
== nil && (!tt
.ip
.Equal(ip
) ||
!tt
.net
.IP
.Equal(net
.IP
) ||
!reflect
.DeepEqual(net
.Mask
, tt
.net
.Mask
)) {
196 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
)
201 var ipNetContainsTests
= []struct {
206 {IPv4(172, 16, 1, 1), &IPNet
{IP
: IPv4(172, 16, 0, 0), Mask
: CIDRMask(12, 32)}, true},
207 {IPv4(172, 24, 0, 1), &IPNet
{IP
: IPv4(172, 16, 0, 0), Mask
: CIDRMask(13, 32)}, false},
208 {IPv4(192, 168, 0, 3), &IPNet
{IP
: IPv4(192, 168, 0, 0), Mask
: IPv4Mask(0, 0, 255, 252)}, true},
209 {IPv4(192, 168, 0, 4), &IPNet
{IP
: IPv4(192, 168, 0, 0), Mask
: IPv4Mask(0, 255, 0, 252)}, false},
210 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: CIDRMask(47, 128)}, true},
211 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:2::"), Mask
: CIDRMask(47, 128)}, false},
212 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: IPMask(ParseIP("ffff:0:ffff::"))}, true},
213 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: IPMask(ParseIP("0:0:0:ffff::"))}, false},
216 func TestIPNetContains(t
*testing
.T
) {
217 for _
, tt
:= range ipNetContainsTests
{
218 if ok
:= tt
.net
.Contains(tt
.ip
); ok
!= tt
.ok
{
219 t
.Errorf("IPNet(%v).Contains(%v) = %v, want %v", tt
.net
, tt
.ip
, ok
, tt
.ok
)
224 var ipNetStringTests
= []struct {
228 {&IPNet
{IP
: IPv4(192, 168, 1, 0), Mask
: CIDRMask(26, 32)}, "192.168.1.0/26"},
229 {&IPNet
{IP
: IPv4(192, 168, 1, 0), Mask
: IPv4Mask(255, 0, 255, 0)}, "192.168.1.0/ff00ff00"},
230 {&IPNet
{IP
: ParseIP("2001:db8::"), Mask
: CIDRMask(55, 128)}, "2001:db8::/55"},
231 {&IPNet
{IP
: ParseIP("2001:db8::"), Mask
: IPMask(ParseIP("8000:f123:0:cafe::"))}, "2001:db8::/8000f1230000cafe0000000000000000"},
234 func TestIPNetString(t
*testing
.T
) {
235 for _
, tt
:= range ipNetStringTests
{
236 if out
:= tt
.in
.String(); out
!= tt
.out
{
237 t
.Errorf("IPNet.String(%v) = %q, want %q", tt
.in
, out
, tt
.out
)
242 var cidrMaskTests
= []struct {
247 {0, 32, IPv4Mask(0, 0, 0, 0)},
248 {12, 32, IPv4Mask(255, 240, 0, 0)},
249 {24, 32, IPv4Mask(255, 255, 255, 0)},
250 {32, 32, IPv4Mask(255, 255, 255, 255)},
251 {0, 128, IPMask
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
252 {4, 128, IPMask
{0xf0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
253 {48, 128, IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
254 {128, 128, IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
261 func TestCIDRMask(t
*testing
.T
) {
262 for _
, tt
:= range cidrMaskTests
{
263 if out
:= CIDRMask(tt
.ones
, tt
.bits
); !reflect
.DeepEqual(out
, tt
.out
) {
264 t
.Errorf("CIDRMask(%v, %v) = %v, want %v", tt
.ones
, tt
.bits
, out
, tt
.out
)
270 v4addr
= IP
{192, 168, 0, 1}
271 v4mappedv6addr
= IP
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 0, 1}
272 v6addr
= IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}
273 v4mask
= IPMask
{255, 255, 255, 0}
274 v4mappedv6mask
= IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 255, 255, 255, 0}
275 v6mask
= IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0}
276 badaddr
= IP
{192, 168, 0}
277 badmask
= IPMask
{255, 255, 0}
278 v4maskzero
= IPMask
{0, 0, 0, 0}
281 var networkNumberAndMaskTests
= []struct {
285 {IPNet
{IP
: v4addr
, Mask
: v4mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
286 {IPNet
{IP
: v4addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
287 {IPNet
{IP
: v4mappedv6addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
288 {IPNet
{IP
: v4mappedv6addr
, Mask
: v6mask
}, IPNet
{IP
: v4addr
, Mask
: v4maskzero
}},
289 {IPNet
{IP
: v4addr
, Mask
: v6mask
}, IPNet
{IP
: v4addr
, Mask
: v4maskzero
}},
290 {IPNet
{IP
: v6addr
, Mask
: v6mask
}, IPNet
{IP
: v6addr
, Mask
: v6mask
}},
291 {IPNet
{IP
: v6addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v6addr
, Mask
: v4mappedv6mask
}},
292 {in
: IPNet
{IP
: v6addr
, Mask
: v4mask
}},
293 {in
: IPNet
{IP
: v4addr
, Mask
: badmask
}},
294 {in
: IPNet
{IP
: v4mappedv6addr
, Mask
: badmask
}},
295 {in
: IPNet
{IP
: v6addr
, Mask
: badmask
}},
296 {in
: IPNet
{IP
: badaddr
, Mask
: v4mask
}},
297 {in
: IPNet
{IP
: badaddr
, Mask
: v4mappedv6mask
}},
298 {in
: IPNet
{IP
: badaddr
, Mask
: v6mask
}},
299 {in
: IPNet
{IP
: badaddr
, Mask
: badmask
}},
302 func TestNetworkNumberAndMask(t
*testing
.T
) {
303 for _
, tt
:= range networkNumberAndMaskTests
{
304 ip
, m
:= networkNumberAndMask(&tt
.in
)
305 out
:= &IPNet
{IP
: ip
, Mask
: m
}
306 if !reflect
.DeepEqual(&tt
.out
, out
) {
307 t
.Errorf("networkNumberAndMask(%v) = %v, want %v", tt
.in
, out
, &tt
.out
)
312 var splitJoinTests
= []struct {
317 {"www.google.com", "80", "www.google.com:80"},
318 {"127.0.0.1", "1234", "127.0.0.1:1234"},
319 {"::1", "80", "[::1]:80"},
320 {"fe80::1%lo0", "80", "[fe80::1%lo0]:80"},
321 {"localhost%lo0", "80", "[localhost%lo0]:80"},
324 {"google.com", "https%foo", "google.com:https%foo"}, // Go 1.0 behavior
325 {"127.0.0.1", "", "127.0.0.1:"}, // Go 1.0 behaviour
326 {"www.google.com", "", "www.google.com:"}, // Go 1.0 behaviour
329 var splitFailureTests
= []struct {
333 {"www.google.com", "missing port in address"},
334 {"127.0.0.1", "missing port in address"},
335 {"[::1]", "missing port in address"},
336 {"[fe80::1%lo0]", "missing port in address"},
337 {"[localhost%lo0]", "missing port in address"},
338 {"localhost%lo0", "missing port in address"},
340 {"::1", "too many colons in address"},
341 {"fe80::1%lo0", "too many colons in address"},
342 {"fe80::1%lo0:80", "too many colons in address"},
344 {"localhost%lo0:80", "missing brackets in address"},
346 // Test cases that didn't fail in Go 1.0
348 {"[foo:bar]", "missing port in address"},
349 {"[foo:bar]baz", "missing port in address"},
350 {"[foo]bar:baz", "missing port in address"},
352 {"[foo]:[bar]:baz", "too many colons in address"},
354 {"[foo]:[bar]baz", "unexpected '[' in address"},
355 {"foo[bar]:baz", "unexpected '[' in address"},
357 {"foo]bar:baz", "unexpected ']' in address"},
360 func TestSplitHostPort(t
*testing
.T
) {
361 for _
, tt
:= range splitJoinTests
{
362 if host
, port
, err
:= SplitHostPort(tt
.join
); host
!= tt
.host || port
!= tt
.port || err
!= nil {
363 t
.Errorf("SplitHostPort(%q) = %q, %q, %v; want %q, %q, nil", tt
.join
, host
, port
, err
, tt
.host
, tt
.port
)
366 for _
, tt
:= range splitFailureTests
{
367 if _
, _
, err
:= SplitHostPort(tt
.hostPort
); err
== nil {
368 t
.Errorf("SplitHostPort(%q) should have failed", tt
.hostPort
)
370 e
:= err
.(*AddrError
)
372 t
.Errorf("SplitHostPort(%q) = _, _, %q; want %q", tt
.hostPort
, e
.Err
, tt
.err
)
378 func TestJoinHostPort(t
*testing
.T
) {
379 for _
, tt
:= range splitJoinTests
{
380 if join
:= JoinHostPort(tt
.host
, tt
.port
); join
!= tt
.join
{
381 t
.Errorf("JoinHostPort(%q, %q) = %q; want %q", tt
.host
, tt
.port
, join
, tt
.join
)
386 var ipAddrFamilyTests
= []struct {
391 {IPv4bcast
, true, false},
392 {IPv4allsys
, true, false},
393 {IPv4allrouter
, true, false},
394 {IPv4zero
, true, false},
395 {IPv4(224, 0, 0, 1), true, false},
396 {IPv4(127, 0, 0, 1), true, false},
397 {IPv4(240, 0, 0, 1), true, false},
398 {IPv6unspecified
, false, true},
399 {IPv6loopback
, false, true},
400 {IPv6interfacelocalallnodes
, false, true},
401 {IPv6linklocalallnodes
, false, true},
402 {IPv6linklocalallrouters
, false, true},
403 {ParseIP("ff05::a:b:c:d"), false, true},
404 {ParseIP("fe80::1:2:3:4"), false, true},
405 {ParseIP("2001:db8::123:12:1"), false, true},
408 func TestIPAddrFamily(t
*testing
.T
) {
409 for _
, tt
:= range ipAddrFamilyTests
{
410 if af
:= tt
.in
.To4() != nil; af
!= tt
.af4
{
411 t
.Errorf("verifying IPv4 address family for %q = %v, want %v", tt
.in
, af
, tt
.af4
)
413 if af
:= len(tt
.in
) == IPv6len
&& tt
.in
.To4() == nil; af
!= tt
.af6
{
414 t
.Errorf("verifying IPv6 address family for %q = %v, want %v", tt
.in
, af
, tt
.af6
)
419 var ipAddrScopeTests
= []struct {
424 {IP
.IsUnspecified
, IPv4zero
, true},
425 {IP
.IsUnspecified
, IPv4(127, 0, 0, 1), false},
426 {IP
.IsUnspecified
, IPv6unspecified
, true},
427 {IP
.IsUnspecified
, IPv6interfacelocalallnodes
, false},
428 {IP
.IsLoopback
, IPv4(127, 0, 0, 1), true},
429 {IP
.IsLoopback
, IPv4(127, 255, 255, 254), true},
430 {IP
.IsLoopback
, IPv4(128, 1, 2, 3), false},
431 {IP
.IsLoopback
, IPv6loopback
, true},
432 {IP
.IsLoopback
, IPv6linklocalallrouters
, false},
433 {IP
.IsMulticast
, IPv4(224, 0, 0, 0), true},
434 {IP
.IsMulticast
, IPv4(239, 0, 0, 0), true},
435 {IP
.IsMulticast
, IPv4(240, 0, 0, 0), false},
436 {IP
.IsMulticast
, IPv6linklocalallnodes
, true},
437 {IP
.IsMulticast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
438 {IP
.IsMulticast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
439 {IP
.IsLinkLocalMulticast
, IPv4(224, 0, 0, 0), true},
440 {IP
.IsLinkLocalMulticast
, IPv4(239, 0, 0, 0), false},
441 {IP
.IsLinkLocalMulticast
, IPv6linklocalallrouters
, true},
442 {IP
.IsLinkLocalMulticast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
443 {IP
.IsLinkLocalUnicast
, IPv4(169, 254, 0, 0), true},
444 {IP
.IsLinkLocalUnicast
, IPv4(169, 255, 0, 0), false},
445 {IP
.IsLinkLocalUnicast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
446 {IP
.IsLinkLocalUnicast
, IP
{0xfe, 0xc0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
447 {IP
.IsGlobalUnicast
, IPv4(240, 0, 0, 0), true},
448 {IP
.IsGlobalUnicast
, IPv4(232, 0, 0, 0), false},
449 {IP
.IsGlobalUnicast
, IPv4(169, 254, 0, 0), false},
450 {IP
.IsGlobalUnicast
, IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, true},
451 {IP
.IsGlobalUnicast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
452 {IP
.IsGlobalUnicast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
455 func name(f
interface{}) string {
456 return runtime
.FuncForPC(reflect
.ValueOf(f
).Pointer()).Name()
459 func TestIPAddrScope(t
*testing
.T
) {
460 for _
, tt
:= range ipAddrScopeTests
{
461 if ok
:= tt
.scope(tt
.in
); ok
!= tt
.ok
{
462 t
.Errorf("%s(%q) = %v, want %v", name(tt
.scope
), tt
.in
, ok
, tt
.ok
)