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.
17 var parseIPTests
= []struct {
21 {"127.0.1.2", IPv4(127, 0, 1, 2)},
22 {"127.0.0.1", IPv4(127, 0, 0, 1)},
23 {"127.001.002.003", IPv4(127, 1, 2, 3)},
24 {"::ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
25 {"::ffff:127.001.002.003", IPv4(127, 1, 2, 3)},
26 {"::ffff:7f01:0203", IPv4(127, 1, 2, 3)},
27 {"0:0:0:0:0000:ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
28 {"0:0:0:0:000000:ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
29 {"0:0:0:0::ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
31 {"2001:4860:0:2001::68", IP
{0x20, 0x01, 0x48, 0x60, 0, 0, 0x20, 0x01, 0, 0, 0, 0, 0, 0, 0x00, 0x68}},
32 {"2001:4860:0000:2001:0000:0000:0000:0068", IP
{0x20, 0x01, 0x48, 0x60, 0, 0, 0x20, 0x01, 0, 0, 0, 0, 0, 0, 0x00, 0x68}},
44 {"a1:a2:a3:a4::b1:b2:b3:b4", nil}, // Issue 6628
47 func TestParseIP(t
*testing
.T
) {
48 for _
, tt
:= range parseIPTests
{
49 if out
:= ParseIP(tt
.in
); !reflect
.DeepEqual(out
, tt
.out
) {
50 t
.Errorf("ParseIP(%q) = %v, want %v", tt
.in
, out
, tt
.out
)
53 // Tested in TestMarshalEmptyIP below.
57 if err
:= out
.UnmarshalText([]byte(tt
.in
)); !reflect
.DeepEqual(out
, tt
.out
) ||
(tt
.out
== nil) != (err
!= nil) {
58 t
.Errorf("IP.UnmarshalText(%q) = %v, %v, want %v", tt
.in
, out
, err
, tt
.out
)
63 func TestLookupWithIP(t
*testing
.T
) {
64 _
, err
:= LookupIP("")
66 t
.Errorf(`LookupIP("") succeeded, should fail`)
68 _
, err
= LookupHost("")
70 t
.Errorf(`LookupIP("") succeeded, should fail`)
73 // Test that LookupHost and LookupIP, which normally
74 // expect host names, work with IP addresses.
75 for _
, tt
:= range parseIPTests
{
77 addrs
, err
:= LookupHost(tt
.in
)
78 if len(addrs
) != 1 || addrs
[0] != tt
.in || err
!= nil {
79 t
.Errorf("LookupHost(%q) = %v, %v, want %v, nil", tt
.in
, addrs
, err
, []string{tt
.in
})
81 } else if !testing
.Short() {
82 // We can't control what the host resolver does; if it can resolve, say,
83 // 127.0.0.256 or fe80::1%911 or a host named 'abc', who are we to judge?
84 // Warn about these discrepancies but don't fail the test.
85 addrs
, err
:= LookupHost(tt
.in
)
87 t
.Logf("warning: LookupHost(%q) = %v, want error", tt
.in
, addrs
)
92 ips
, err
:= LookupIP(tt
.in
)
93 if len(ips
) != 1 ||
!reflect
.DeepEqual(ips
[0], tt
.out
) || err
!= nil {
94 t
.Errorf("LookupIP(%q) = %v, %v, want %v, nil", tt
.in
, ips
, err
, []IP
{tt
.out
})
96 } else if !testing
.Short() {
97 ips
, err
:= LookupIP(tt
.in
)
98 // We can't control what the host resolver does. See above.
100 t
.Logf("warning: LookupIP(%q) = %v, want error", tt
.in
, ips
)
106 func BenchmarkParseIP(b
*testing
.B
) {
107 testHookUninstaller
.Do(uninstallTestHooks
)
109 for i
:= 0; i
< b
.N
; i
++ {
110 for _
, tt
:= range parseIPTests
{
117 func TestMarshalEmptyIP(t
*testing
.T
) {
118 for _
, in
:= range [][]byte{nil, []byte("")} {
119 var out
= IP
{1, 2, 3, 4}
120 if err
:= out
.UnmarshalText(in
); err
!= nil || out
!= nil {
121 t
.Errorf("UnmarshalText(%v) = %v, %v; want nil, nil", in
, out
, err
)
125 got
, err
:= ip
.MarshalText()
129 if !reflect
.DeepEqual(got
, []byte("")) {
130 t
.Errorf(`got %#v, want []byte("")`, got
)
134 var ipStringTests
= []*struct {
135 in IP
// see RFC 791 and RFC 4291
136 str
string // see RFC 791, RFC 4291 and RFC 5952
154 // IPv4-mapped IPv6 address
156 IP
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 0, 2, 1},
162 IP
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 0, 0, 0},
170 IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1},
171 "2001:db8::123:12:1",
172 []byte("2001:db8::123:12:1"),
176 IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1},
178 []byte("2001:db8::1"),
182 IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0x1, 0, 0, 0, 0x1, 0, 0, 0, 0x1},
183 "2001:db8:0:1:0:1:0:1",
184 []byte("2001:db8:0:1:0:1:0:1"),
188 IP
{0x20, 0x1, 0xd, 0xb8, 0, 0x1, 0, 0, 0, 0x1, 0, 0, 0, 0x1, 0, 0},
189 "2001:db8:1:0:1:0:1:0",
190 []byte("2001:db8:1:0:1:0:1:0"),
194 IP
{0x20, 0x1, 0, 0, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1},
196 []byte("2001::1:0:0:1"),
200 IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0},
202 []byte("2001:db8:0:0:1::"),
206 IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1},
208 []byte("2001:db8::1:0:0:1"),
212 IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0xa, 0, 0xb, 0, 0xc, 0, 0xd},
214 []byte("2001:db8::a:b:c:d"),
224 // IP wildcard equivalent address in Dial/Listen API
232 // Opaque byte sequence
234 IP
{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
237 &AddrError
{Err
: "invalid IP address", Addr
: "0123456789abcdef"},
241 func TestIPString(t
*testing
.T
) {
242 for _
, tt
:= range ipStringTests
{
243 if out
:= tt
.in
.String(); out
!= tt
.str
{
244 t
.Errorf("IP.String(%v) = %q, want %q", tt
.in
, out
, tt
.str
)
246 if out
, err
:= tt
.in
.MarshalText(); !bytes
.Equal(out
, tt
.byt
) ||
!reflect
.DeepEqual(err
, tt
.error
) {
247 t
.Errorf("IP.MarshalText(%v) = %v, %v, want %v, %v", tt
.in
, out
, err
, tt
.byt
, tt
.error
)
254 func BenchmarkIPString(b
*testing
.B
) {
255 testHookUninstaller
.Do(uninstallTestHooks
)
257 b
.Run("IPv4", func(b
*testing
.B
) {
258 benchmarkIPString(b
, IPv4len
)
261 b
.Run("IPv6", func(b
*testing
.B
) {
262 benchmarkIPString(b
, IPv6len
)
266 func benchmarkIPString(b
*testing
.B
, size
int) {
269 for i
:= 0; i
< b
.N
; i
++ {
270 for _
, tt
:= range ipStringTests
{
271 if tt
.in
!= nil && len(tt
.in
) == size
{
272 sink
= tt
.in
.String()
278 var ipMaskTests
= []struct {
283 {IPv4(192, 168, 1, 127), IPv4Mask(255, 255, 255, 128), IPv4(192, 168, 1, 0)},
284 {IPv4(192, 168, 1, 127), IPMask(ParseIP("255.255.255.192")), IPv4(192, 168, 1, 64)},
285 {IPv4(192, 168, 1, 127), IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffe0")), IPv4(192, 168, 1, 96)},
286 {IPv4(192, 168, 1, 127), IPv4Mask(255, 0, 255, 0), IPv4(192, 0, 1, 0)},
287 {ParseIP("2001:db8::1"), IPMask(ParseIP("ffff:ff80::")), ParseIP("2001:d80::")},
288 {ParseIP("2001:db8::1"), IPMask(ParseIP("f0f0:0f0f::")), ParseIP("2000:d08::")},
291 func TestIPMask(t
*testing
.T
) {
292 for _
, tt
:= range ipMaskTests
{
293 if out
:= tt
.in
.Mask(tt
.mask
); out
== nil ||
!tt
.out
.Equal(out
) {
294 t
.Errorf("IP(%v).Mask(%v) = %v, want %v", tt
.in
, tt
.mask
, out
, tt
.out
)
299 var ipMaskStringTests
= []struct {
303 {IPv4Mask(255, 255, 255, 240), "fffffff0"},
304 {IPv4Mask(255, 0, 128, 0), "ff008000"},
305 {IPMask(ParseIP("ffff:ff80::")), "ffffff80000000000000000000000000"},
306 {IPMask(ParseIP("ef00:ff80::cafe:0")), "ef00ff800000000000000000cafe0000"},
310 func TestIPMaskString(t
*testing
.T
) {
311 for _
, tt
:= range ipMaskStringTests
{
312 if out
:= tt
.in
.String(); out
!= tt
.out
{
313 t
.Errorf("IPMask.String(%v) = %q, want %q", tt
.in
, out
, tt
.out
)
318 func BenchmarkIPMaskString(b
*testing
.B
) {
319 testHookUninstaller
.Do(uninstallTestHooks
)
321 for i
:= 0; i
< b
.N
; i
++ {
322 for _
, tt
:= range ipMaskStringTests
{
323 sink
= tt
.in
.String()
328 var parseCIDRTests
= []struct {
334 {"135.104.0.0/32", IPv4(135, 104, 0, 0), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 255)}, nil},
335 {"0.0.0.0/24", IPv4(0, 0, 0, 0), &IPNet
{IP
: IPv4(0, 0, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
336 {"135.104.0.0/24", IPv4(135, 104, 0, 0), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
337 {"135.104.0.1/32", IPv4(135, 104, 0, 1), &IPNet
{IP
: IPv4(135, 104, 0, 1), Mask
: IPv4Mask(255, 255, 255, 255)}, nil},
338 {"135.104.0.1/24", IPv4(135, 104, 0, 1), &IPNet
{IP
: IPv4(135, 104, 0, 0), Mask
: IPv4Mask(255, 255, 255, 0)}, nil},
339 {"::1/128", ParseIP("::1"), &IPNet
{IP
: ParseIP("::1"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))}, nil},
340 {"abcd:2345::/127", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"))}, nil},
341 {"abcd:2345::/65", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff:8000::"))}, nil},
342 {"abcd:2345::/64", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:ffff::"))}, nil},
343 {"abcd:2345::/63", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff:fffe::"))}, nil},
344 {"abcd:2345::/33", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff:8000::"))}, nil},
345 {"abcd:2345::/32", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2345::"), Mask
: IPMask(ParseIP("ffff:ffff::"))}, nil},
346 {"abcd:2344::/31", ParseIP("abcd:2344::"), &IPNet
{IP
: ParseIP("abcd:2344::"), Mask
: IPMask(ParseIP("ffff:fffe::"))}, nil},
347 {"abcd:2300::/24", ParseIP("abcd:2300::"), &IPNet
{IP
: ParseIP("abcd:2300::"), Mask
: IPMask(ParseIP("ffff:ff00::"))}, nil},
348 {"abcd:2345::/24", ParseIP("abcd:2345::"), &IPNet
{IP
: ParseIP("abcd:2300::"), Mask
: IPMask(ParseIP("ffff:ff00::"))}, nil},
349 {"2001:DB8::/48", ParseIP("2001:DB8::"), &IPNet
{IP
: ParseIP("2001:DB8::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
350 {"2001:DB8::1/48", ParseIP("2001:DB8::1"), &IPNet
{IP
: ParseIP("2001:DB8::"), Mask
: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
351 {"192.168.1.1/255.255.255.0", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "192.168.1.1/255.255.255.0"}},
352 {"192.168.1.1/35", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "192.168.1.1/35"}},
353 {"2001:db8::1/-1", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "2001:db8::1/-1"}},
354 {"2001:db8::1/-0", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "2001:db8::1/-0"}},
355 {"-0.0.0.0/32", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "-0.0.0.0/32"}},
356 {"0.-1.0.0/32", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "0.-1.0.0/32"}},
357 {"0.0.-2.0/32", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "0.0.-2.0/32"}},
358 {"0.0.0.-3/32", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "0.0.0.-3/32"}},
359 {"0.0.0.0/-0", nil, nil, &ParseError
{Type
: "CIDR address", Text
: "0.0.0.0/-0"}},
360 {"", nil, nil, &ParseError
{Type
: "CIDR address", Text
: ""}},
363 func TestParseCIDR(t
*testing
.T
) {
364 for _
, tt
:= range parseCIDRTests
{
365 ip
, net
, err
:= ParseCIDR(tt
.in
)
366 if !reflect
.DeepEqual(err
, tt
.err
) {
367 t
.Errorf("ParseCIDR(%q) = %v, %v; want %v, %v", tt
.in
, ip
, net
, tt
.ip
, tt
.net
)
369 if err
== nil && (!tt
.ip
.Equal(ip
) ||
!tt
.net
.IP
.Equal(net
.IP
) ||
!reflect
.DeepEqual(net
.Mask
, tt
.net
.Mask
)) {
370 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
)
375 var ipNetContainsTests
= []struct {
380 {IPv4(172, 16, 1, 1), &IPNet
{IP
: IPv4(172, 16, 0, 0), Mask
: CIDRMask(12, 32)}, true},
381 {IPv4(172, 24, 0, 1), &IPNet
{IP
: IPv4(172, 16, 0, 0), Mask
: CIDRMask(13, 32)}, false},
382 {IPv4(192, 168, 0, 3), &IPNet
{IP
: IPv4(192, 168, 0, 0), Mask
: IPv4Mask(0, 0, 255, 252)}, true},
383 {IPv4(192, 168, 0, 4), &IPNet
{IP
: IPv4(192, 168, 0, 0), Mask
: IPv4Mask(0, 255, 0, 252)}, false},
384 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: CIDRMask(47, 128)}, true},
385 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:2::"), Mask
: CIDRMask(47, 128)}, false},
386 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: IPMask(ParseIP("ffff:0:ffff::"))}, true},
387 {ParseIP("2001:db8:1:2::1"), &IPNet
{IP
: ParseIP("2001:db8:1::"), Mask
: IPMask(ParseIP("0:0:0:ffff::"))}, false},
390 func TestIPNetContains(t
*testing
.T
) {
391 for _
, tt
:= range ipNetContainsTests
{
392 if ok
:= tt
.net
.Contains(tt
.ip
); ok
!= tt
.ok
{
393 t
.Errorf("IPNet(%v).Contains(%v) = %v, want %v", tt
.net
, tt
.ip
, ok
, tt
.ok
)
398 var ipNetStringTests
= []struct {
402 {&IPNet
{IP
: IPv4(192, 168, 1, 0), Mask
: CIDRMask(26, 32)}, "192.168.1.0/26"},
403 {&IPNet
{IP
: IPv4(192, 168, 1, 0), Mask
: IPv4Mask(255, 0, 255, 0)}, "192.168.1.0/ff00ff00"},
404 {&IPNet
{IP
: ParseIP("2001:db8::"), Mask
: CIDRMask(55, 128)}, "2001:db8::/55"},
405 {&IPNet
{IP
: ParseIP("2001:db8::"), Mask
: IPMask(ParseIP("8000:f123:0:cafe::"))}, "2001:db8::/8000f1230000cafe0000000000000000"},
408 func TestIPNetString(t
*testing
.T
) {
409 for _
, tt
:= range ipNetStringTests
{
410 if out
:= tt
.in
.String(); out
!= tt
.out
{
411 t
.Errorf("IPNet.String(%v) = %q, want %q", tt
.in
, out
, tt
.out
)
416 var cidrMaskTests
= []struct {
421 {0, 32, IPv4Mask(0, 0, 0, 0)},
422 {12, 32, IPv4Mask(255, 240, 0, 0)},
423 {24, 32, IPv4Mask(255, 255, 255, 0)},
424 {32, 32, IPv4Mask(255, 255, 255, 255)},
425 {0, 128, IPMask
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
426 {4, 128, IPMask
{0xf0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
427 {48, 128, IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
428 {128, 128, IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
435 func TestCIDRMask(t
*testing
.T
) {
436 for _
, tt
:= range cidrMaskTests
{
437 if out
:= CIDRMask(tt
.ones
, tt
.bits
); !reflect
.DeepEqual(out
, tt
.out
) {
438 t
.Errorf("CIDRMask(%v, %v) = %v, want %v", tt
.ones
, tt
.bits
, out
, tt
.out
)
444 v4addr
= IP
{192, 168, 0, 1}
445 v4mappedv6addr
= IP
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 0, 1}
446 v6addr
= IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}
447 v4mask
= IPMask
{255, 255, 255, 0}
448 v4mappedv6mask
= IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 255, 255, 255, 0}
449 v6mask
= IPMask
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0}
450 badaddr
= IP
{192, 168, 0}
451 badmask
= IPMask
{255, 255, 0}
452 v4maskzero
= IPMask
{0, 0, 0, 0}
455 var networkNumberAndMaskTests
= []struct {
459 {IPNet
{IP
: v4addr
, Mask
: v4mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
460 {IPNet
{IP
: v4addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
461 {IPNet
{IP
: v4mappedv6addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v4addr
, Mask
: v4mask
}},
462 {IPNet
{IP
: v4mappedv6addr
, Mask
: v6mask
}, IPNet
{IP
: v4addr
, Mask
: v4maskzero
}},
463 {IPNet
{IP
: v4addr
, Mask
: v6mask
}, IPNet
{IP
: v4addr
, Mask
: v4maskzero
}},
464 {IPNet
{IP
: v6addr
, Mask
: v6mask
}, IPNet
{IP
: v6addr
, Mask
: v6mask
}},
465 {IPNet
{IP
: v6addr
, Mask
: v4mappedv6mask
}, IPNet
{IP
: v6addr
, Mask
: v4mappedv6mask
}},
466 {in
: IPNet
{IP
: v6addr
, Mask
: v4mask
}},
467 {in
: IPNet
{IP
: v4addr
, Mask
: badmask
}},
468 {in
: IPNet
{IP
: v4mappedv6addr
, Mask
: badmask
}},
469 {in
: IPNet
{IP
: v6addr
, Mask
: badmask
}},
470 {in
: IPNet
{IP
: badaddr
, Mask
: v4mask
}},
471 {in
: IPNet
{IP
: badaddr
, Mask
: v4mappedv6mask
}},
472 {in
: IPNet
{IP
: badaddr
, Mask
: v6mask
}},
473 {in
: IPNet
{IP
: badaddr
, Mask
: badmask
}},
476 func TestNetworkNumberAndMask(t
*testing
.T
) {
477 for _
, tt
:= range networkNumberAndMaskTests
{
478 ip
, m
:= networkNumberAndMask(&tt
.in
)
479 out
:= &IPNet
{IP
: ip
, Mask
: m
}
480 if !reflect
.DeepEqual(&tt
.out
, out
) {
481 t
.Errorf("networkNumberAndMask(%v) = %v, want %v", tt
.in
, out
, &tt
.out
)
486 func TestSplitHostPort(t
*testing
.T
) {
487 for _
, tt
:= range []struct {
493 {"localhost:http", "localhost", "http"},
494 {"localhost:80", "localhost", "80"},
496 // Go-specific host name with zone identifier
497 {"localhost%lo0:http", "localhost%lo0", "http"},
498 {"localhost%lo0:80", "localhost%lo0", "80"},
499 {"[localhost%lo0]:http", "localhost%lo0", "http"}, // Go 1 behavior
500 {"[localhost%lo0]:80", "localhost%lo0", "80"}, // Go 1 behavior
503 {"127.0.0.1:http", "127.0.0.1", "http"},
504 {"127.0.0.1:80", "127.0.0.1", "80"},
505 {"[::1]:http", "::1", "http"},
506 {"[::1]:80", "::1", "80"},
508 // IP literal with zone identifier
509 {"[::1%lo0]:http", "::1%lo0", "http"},
510 {"[::1%lo0]:80", "::1%lo0", "80"},
512 // Go-specific wildcard for host name
513 {":http", "", "http"}, // Go 1 behavior
514 {":80", "", "80"}, // Go 1 behavior
516 // Go-specific wildcard for service name or transport port number
517 {"golang.org:", "golang.org", ""}, // Go 1 behavior
518 {"127.0.0.1:", "127.0.0.1", ""}, // Go 1 behavior
519 {"[::1]:", "::1", ""}, // Go 1 behavior
521 // Opaque service name
522 {"golang.org:https%foo", "golang.org", "https%foo"}, // Go 1 behavior
524 if host
, port
, err
:= SplitHostPort(tt
.hostPort
); host
!= tt
.host || port
!= tt
.port || err
!= nil {
525 t
.Errorf("SplitHostPort(%q) = %q, %q, %v; want %q, %q, nil", tt
.hostPort
, host
, port
, err
, tt
.host
, tt
.port
)
529 for _
, tt
:= range []struct {
533 {"golang.org", "missing port in address"},
534 {"127.0.0.1", "missing port in address"},
535 {"[::1]", "missing port in address"},
536 {"[fe80::1%lo0]", "missing port in address"},
537 {"[localhost%lo0]", "missing port in address"},
538 {"localhost%lo0", "missing port in address"},
540 {"::1", "too many colons in address"},
541 {"fe80::1%lo0", "too many colons in address"},
542 {"fe80::1%lo0:80", "too many colons in address"},
544 // Test cases that didn't fail in Go 1
546 {"[foo:bar]", "missing port in address"},
547 {"[foo:bar]baz", "missing port in address"},
548 {"[foo]bar:baz", "missing port in address"},
550 {"[foo]:[bar]:baz", "too many colons in address"},
552 {"[foo]:[bar]baz", "unexpected '[' in address"},
553 {"foo[bar]:baz", "unexpected '[' in address"},
555 {"foo]bar:baz", "unexpected ']' in address"},
557 if host
, port
, err
:= SplitHostPort(tt
.hostPort
); err
== nil {
558 t
.Errorf("SplitHostPort(%q) should have failed", tt
.hostPort
)
560 e
:= err
.(*AddrError
)
562 t
.Errorf("SplitHostPort(%q) = _, _, %q; want %q", tt
.hostPort
, e
.Err
, tt
.err
)
564 if host
!= "" || port
!= "" {
565 t
.Errorf("SplitHostPort(%q) = %q, %q, err; want %q, %q, err on failure", tt
.hostPort
, host
, port
, "", "")
571 func TestJoinHostPort(t
*testing
.T
) {
572 for _
, tt
:= range []struct {
578 {"localhost", "http", "localhost:http"},
579 {"localhost", "80", "localhost:80"},
581 // Go-specific host name with zone identifier
582 {"localhost%lo0", "http", "localhost%lo0:http"},
583 {"localhost%lo0", "80", "localhost%lo0:80"},
586 {"127.0.0.1", "http", "127.0.0.1:http"},
587 {"127.0.0.1", "80", "127.0.0.1:80"},
588 {"::1", "http", "[::1]:http"},
589 {"::1", "80", "[::1]:80"},
591 // IP literal with zone identifier
592 {"::1%lo0", "http", "[::1%lo0]:http"},
593 {"::1%lo0", "80", "[::1%lo0]:80"},
595 // Go-specific wildcard for host name
596 {"", "http", ":http"}, // Go 1 behavior
597 {"", "80", ":80"}, // Go 1 behavior
599 // Go-specific wildcard for service name or transport port number
600 {"golang.org", "", "golang.org:"}, // Go 1 behavior
601 {"127.0.0.1", "", "127.0.0.1:"}, // Go 1 behavior
602 {"::1", "", "[::1]:"}, // Go 1 behavior
604 // Opaque service name
605 {"golang.org", "https%foo", "golang.org:https%foo"}, // Go 1 behavior
607 if hostPort
:= JoinHostPort(tt
.host
, tt
.port
); hostPort
!= tt
.hostPort
{
608 t
.Errorf("JoinHostPort(%q, %q) = %q; want %q", tt
.host
, tt
.port
, hostPort
, tt
.hostPort
)
613 var ipAddrFamilyTests
= []struct {
618 {IPv4bcast
, true, false},
619 {IPv4allsys
, true, false},
620 {IPv4allrouter
, true, false},
621 {IPv4zero
, true, false},
622 {IPv4(224, 0, 0, 1), true, false},
623 {IPv4(127, 0, 0, 1), true, false},
624 {IPv4(240, 0, 0, 1), true, false},
625 {IPv6unspecified
, false, true},
626 {IPv6loopback
, false, true},
627 {IPv6interfacelocalallnodes
, false, true},
628 {IPv6linklocalallnodes
, false, true},
629 {IPv6linklocalallrouters
, false, true},
630 {ParseIP("ff05::a:b:c:d"), false, true},
631 {ParseIP("fe80::1:2:3:4"), false, true},
632 {ParseIP("2001:db8::123:12:1"), false, true},
635 func TestIPAddrFamily(t
*testing
.T
) {
636 for _
, tt
:= range ipAddrFamilyTests
{
637 if af
:= tt
.in
.To4() != nil; af
!= tt
.af4
{
638 t
.Errorf("verifying IPv4 address family for %q = %v, want %v", tt
.in
, af
, tt
.af4
)
640 if af
:= len(tt
.in
) == IPv6len
&& tt
.in
.To4() == nil; af
!= tt
.af6
{
641 t
.Errorf("verifying IPv6 address family for %q = %v, want %v", tt
.in
, af
, tt
.af6
)
646 var ipAddrScopeTests
= []struct {
651 {IP
.IsUnspecified
, IPv4zero
, true},
652 {IP
.IsUnspecified
, IPv4(127, 0, 0, 1), false},
653 {IP
.IsUnspecified
, IPv6unspecified
, true},
654 {IP
.IsUnspecified
, IPv6interfacelocalallnodes
, false},
655 {IP
.IsUnspecified
, nil, false},
656 {IP
.IsLoopback
, IPv4(127, 0, 0, 1), true},
657 {IP
.IsLoopback
, IPv4(127, 255, 255, 254), true},
658 {IP
.IsLoopback
, IPv4(128, 1, 2, 3), false},
659 {IP
.IsLoopback
, IPv6loopback
, true},
660 {IP
.IsLoopback
, IPv6linklocalallrouters
, false},
661 {IP
.IsLoopback
, nil, false},
662 {IP
.IsMulticast
, IPv4(224, 0, 0, 0), true},
663 {IP
.IsMulticast
, IPv4(239, 0, 0, 0), true},
664 {IP
.IsMulticast
, IPv4(240, 0, 0, 0), false},
665 {IP
.IsMulticast
, IPv6linklocalallnodes
, true},
666 {IP
.IsMulticast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
667 {IP
.IsMulticast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
668 {IP
.IsMulticast
, nil, false},
669 {IP
.IsInterfaceLocalMulticast
, IPv4(224, 0, 0, 0), false},
670 {IP
.IsInterfaceLocalMulticast
, IPv4(0xff, 0x01, 0, 0), false},
671 {IP
.IsInterfaceLocalMulticast
, IPv6interfacelocalallnodes
, true},
672 {IP
.IsInterfaceLocalMulticast
, nil, false},
673 {IP
.IsLinkLocalMulticast
, IPv4(224, 0, 0, 0), true},
674 {IP
.IsLinkLocalMulticast
, IPv4(239, 0, 0, 0), false},
675 {IP
.IsLinkLocalMulticast
, IPv4(0xff, 0x02, 0, 0), false},
676 {IP
.IsLinkLocalMulticast
, IPv6linklocalallrouters
, true},
677 {IP
.IsLinkLocalMulticast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
678 {IP
.IsLinkLocalMulticast
, nil, false},
679 {IP
.IsLinkLocalUnicast
, IPv4(169, 254, 0, 0), true},
680 {IP
.IsLinkLocalUnicast
, IPv4(169, 255, 0, 0), false},
681 {IP
.IsLinkLocalUnicast
, IPv4(0xfe, 0x80, 0, 0), false},
682 {IP
.IsLinkLocalUnicast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
683 {IP
.IsLinkLocalUnicast
, IP
{0xfe, 0xc0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
684 {IP
.IsLinkLocalUnicast
, nil, false},
685 {IP
.IsGlobalUnicast
, IPv4(240, 0, 0, 0), true},
686 {IP
.IsGlobalUnicast
, IPv4(232, 0, 0, 0), false},
687 {IP
.IsGlobalUnicast
, IPv4(169, 254, 0, 0), false},
688 {IP
.IsGlobalUnicast
, IPv4bcast
, false},
689 {IP
.IsGlobalUnicast
, IP
{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, true},
690 {IP
.IsGlobalUnicast
, IP
{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
691 {IP
.IsGlobalUnicast
, IP
{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
692 {IP
.IsGlobalUnicast
, nil, false},
695 func name(f
interface{}) string {
696 return runtime
.FuncForPC(reflect
.ValueOf(f
).Pointer()).Name()
699 func TestIPAddrScope(t
*testing
.T
) {
700 for _
, tt
:= range ipAddrScopeTests
{
701 if ok
:= tt
.scope(tt
.in
); ok
!= tt
.ok
{
702 t
.Errorf("%s(%q) = %v, want %v", name(tt
.scope
), tt
.in
, ok
, tt
.ok
)
708 if ok
:= tt
.scope(ip
); ok
!= tt
.ok
{
709 t
.Errorf("%s(%q) = %v, want %v", name(tt
.scope
), ip
, ok
, tt
.ok
)
714 func BenchmarkIPEqual(b
*testing
.B
) {
715 b
.Run("IPv4", func(b
*testing
.B
) {
716 benchmarkIPEqual(b
, IPv4len
)
718 b
.Run("IPv6", func(b
*testing
.B
) {
719 benchmarkIPEqual(b
, IPv6len
)
723 func benchmarkIPEqual(b
*testing
.B
, size
int) {
724 ips
:= make([]IP
, 1000)
726 ips
[i
] = make(IP
, size
)
729 // Half of the N are equal.
730 for i
:= 0; i
< b
.N
/2; i
++ {
735 // The other half are not equal.
736 for i
:= 0; i
< b
.N
/2; i
++ {
738 y
:= ips
[(i
+1)%len
(ips
)]