github.com/euank/go@v0.0.0-20160829210321-495514729181/src/net/ip_test.go (about) 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. 4 5 package net 6 7 import ( 8 "bytes" 9 "reflect" 10 "runtime" 11 "testing" 12 ) 13 14 var parseIPTests = []struct { 15 in string 16 out IP 17 }{ 18 {"127.0.1.2", IPv4(127, 0, 1, 2)}, 19 {"127.0.0.1", IPv4(127, 0, 0, 1)}, 20 {"127.001.002.003", IPv4(127, 1, 2, 3)}, 21 {"::ffff:127.1.2.3", IPv4(127, 1, 2, 3)}, 22 {"::ffff:127.001.002.003", IPv4(127, 1, 2, 3)}, 23 {"::ffff:7f01:0203", IPv4(127, 1, 2, 3)}, 24 {"0:0:0:0:0000:ffff:127.1.2.3", IPv4(127, 1, 2, 3)}, 25 {"0:0:0:0:000000:ffff:127.1.2.3", IPv4(127, 1, 2, 3)}, 26 {"0:0:0:0::ffff:127.1.2.3", IPv4(127, 1, 2, 3)}, 27 28 {"2001:4860:0:2001::68", IP{0x20, 0x01, 0x48, 0x60, 0, 0, 0x20, 0x01, 0, 0, 0, 0, 0, 0, 0x00, 0x68}}, 29 {"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}}, 30 31 {"127.0.0.256", nil}, 32 {"abc", nil}, 33 {"123:", nil}, 34 {"fe80::1%lo0", nil}, 35 {"fe80::1%911", nil}, 36 {"", nil}, 37 {"a1:a2:a3:a4::b1:b2:b3:b4", nil}, // Issue 6628 38 } 39 40 func TestParseIP(t *testing.T) { 41 for _, tt := range parseIPTests { 42 if out := ParseIP(tt.in); !reflect.DeepEqual(out, tt.out) { 43 t.Errorf("ParseIP(%q) = %v, want %v", tt.in, out, tt.out) 44 } 45 if tt.in == "" { 46 // Tested in TestMarshalEmptyIP below. 47 continue 48 } 49 var out IP 50 if err := out.UnmarshalText([]byte(tt.in)); !reflect.DeepEqual(out, tt.out) || (tt.out == nil) != (err != nil) { 51 t.Errorf("IP.UnmarshalText(%q) = %v, %v, want %v", tt.in, out, err, tt.out) 52 } 53 } 54 } 55 56 func TestLookupWithIP(t *testing.T) { 57 _, err := LookupIP("") 58 if err == nil { 59 t.Errorf(`LookupIP("") succeeded, should fail`) 60 } 61 _, err = LookupHost("") 62 if err == nil { 63 t.Errorf(`LookupIP("") succeeded, should fail`) 64 } 65 66 // Test that LookupHost and LookupIP, which normally 67 // expect host names, work with IP addresses. 68 for _, tt := range parseIPTests { 69 if tt.out != nil { 70 addrs, err := LookupHost(tt.in) 71 if len(addrs) != 1 || addrs[0] != tt.in || err != nil { 72 t.Errorf("LookupHost(%q) = %v, %v, want %v, nil", tt.in, addrs, err, []string{tt.in}) 73 } 74 } else if !testing.Short() { 75 // We can't control what the host resolver does; if it can resolve, say, 76 // 127.0.0.256 or fe80::1%911 or a host named 'abc', who are we to judge? 77 // Warn about these discrepancies but don't fail the test. 78 addrs, err := LookupHost(tt.in) 79 if err == nil { 80 t.Logf("warning: LookupHost(%q) = %v, want error", tt.in, addrs) 81 } 82 } 83 84 if tt.out != nil { 85 ips, err := LookupIP(tt.in) 86 if len(ips) != 1 || !reflect.DeepEqual(ips[0], tt.out) || err != nil { 87 t.Errorf("LookupIP(%q) = %v, %v, want %v, nil", tt.in, ips, err, []IP{tt.out}) 88 } 89 } else if !testing.Short() { 90 ips, err := LookupIP(tt.in) 91 // We can't control what the host resolver does. See above. 92 if err == nil { 93 t.Logf("warning: LookupIP(%q) = %v, want error", tt.in, ips) 94 } 95 } 96 } 97 } 98 99 func BenchmarkParseIP(b *testing.B) { 100 testHookUninstaller.Do(uninstallTestHooks) 101 102 for i := 0; i < b.N; i++ { 103 for _, tt := range parseIPTests { 104 ParseIP(tt.in) 105 } 106 } 107 } 108 109 // Issue 6339 110 func TestMarshalEmptyIP(t *testing.T) { 111 for _, in := range [][]byte{nil, []byte("")} { 112 var out = IP{1, 2, 3, 4} 113 if err := out.UnmarshalText(in); err != nil || out != nil { 114 t.Errorf("UnmarshalText(%v) = %v, %v; want nil, nil", in, out, err) 115 } 116 } 117 var ip IP 118 got, err := ip.MarshalText() 119 if err != nil { 120 t.Fatal(err) 121 } 122 if !reflect.DeepEqual(got, []byte("")) { 123 t.Errorf(`got %#v, want []byte("")`, got) 124 } 125 } 126 127 var ipStringTests = []struct { 128 in IP // see RFC 791 and RFC 4291 129 str string // see RFC 791, RFC 4291 and RFC 5952 130 byt []byte 131 error 132 }{ 133 // IPv4 address 134 { 135 IP{192, 0, 2, 1}, 136 "192.0.2.1", 137 []byte("192.0.2.1"), 138 nil, 139 }, 140 { 141 IP{0, 0, 0, 0}, 142 "0.0.0.0", 143 []byte("0.0.0.0"), 144 nil, 145 }, 146 147 // IPv4-mapped IPv6 address 148 { 149 IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 0, 2, 1}, 150 "192.0.2.1", 151 []byte("192.0.2.1"), 152 nil, 153 }, 154 { 155 IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 0, 0, 0}, 156 "0.0.0.0", 157 []byte("0.0.0.0"), 158 nil, 159 }, 160 161 // IPv6 address 162 { 163 IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, 164 "2001:db8::123:12:1", 165 []byte("2001:db8::123:12:1"), 166 nil, 167 }, 168 { 169 IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1}, 170 "2001:db8::1", 171 []byte("2001:db8::1"), 172 nil, 173 }, 174 { 175 IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0x1, 0, 0, 0, 0x1, 0, 0, 0, 0x1}, 176 "2001:db8:0:1:0:1:0:1", 177 []byte("2001:db8:0:1:0:1:0:1"), 178 nil, 179 }, 180 { 181 IP{0x20, 0x1, 0xd, 0xb8, 0, 0x1, 0, 0, 0, 0x1, 0, 0, 0, 0x1, 0, 0}, 182 "2001:db8:1:0:1:0:1:0", 183 []byte("2001:db8:1:0:1:0:1:0"), 184 nil, 185 }, 186 { 187 IP{0x20, 0x1, 0, 0, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1}, 188 "2001::1:0:0:1", 189 []byte("2001::1:0:0:1"), 190 nil, 191 }, 192 { 193 IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0}, 194 "2001:db8:0:0:1::", 195 []byte("2001:db8:0:0:1::"), 196 nil, 197 }, 198 { 199 IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1}, 200 "2001:db8::1:0:0:1", 201 []byte("2001:db8::1:0:0:1"), 202 nil, 203 }, 204 { 205 IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0xa, 0, 0xb, 0, 0xc, 0, 0xd}, 206 "2001:db8::a:b:c:d", 207 []byte("2001:db8::a:b:c:d"), 208 nil, 209 }, 210 { 211 IPv6unspecified, 212 "::", 213 []byte("::"), 214 nil, 215 }, 216 217 // IP wildcard equivalent address in Dial/Listen API 218 { 219 nil, 220 "<nil>", 221 nil, 222 nil, 223 }, 224 225 // Opaque byte sequence 226 { 227 IP{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, 228 "?0123456789abcdef", 229 nil, 230 &AddrError{Err: "invalid IP address", Addr: "0123456789abcdef"}, 231 }, 232 } 233 234 func TestIPString(t *testing.T) { 235 for _, tt := range ipStringTests { 236 if out := tt.in.String(); out != tt.str { 237 t.Errorf("IP.String(%v) = %q, want %q", tt.in, out, tt.str) 238 } 239 if out, err := tt.in.MarshalText(); !bytes.Equal(out, tt.byt) || !reflect.DeepEqual(err, tt.error) { 240 t.Errorf("IP.MarshalText(%v) = %v, %v, want %v, %v", tt.in, out, err, tt.byt, tt.error) 241 } 242 } 243 } 244 245 var sink string 246 247 func BenchmarkIPString(b *testing.B) { 248 testHookUninstaller.Do(uninstallTestHooks) 249 250 for i := 0; i < b.N; i++ { 251 for _, tt := range ipStringTests { 252 if tt.in != nil { 253 sink = tt.in.String() 254 } 255 } 256 } 257 } 258 259 var ipMaskTests = []struct { 260 in IP 261 mask IPMask 262 out IP 263 }{ 264 {IPv4(192, 168, 1, 127), IPv4Mask(255, 255, 255, 128), IPv4(192, 168, 1, 0)}, 265 {IPv4(192, 168, 1, 127), IPMask(ParseIP("255.255.255.192")), IPv4(192, 168, 1, 64)}, 266 {IPv4(192, 168, 1, 127), IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffe0")), IPv4(192, 168, 1, 96)}, 267 {IPv4(192, 168, 1, 127), IPv4Mask(255, 0, 255, 0), IPv4(192, 0, 1, 0)}, 268 {ParseIP("2001:db8::1"), IPMask(ParseIP("ffff:ff80::")), ParseIP("2001:d80::")}, 269 {ParseIP("2001:db8::1"), IPMask(ParseIP("f0f0:0f0f::")), ParseIP("2000:d08::")}, 270 } 271 272 func TestIPMask(t *testing.T) { 273 for _, tt := range ipMaskTests { 274 if out := tt.in.Mask(tt.mask); out == nil || !tt.out.Equal(out) { 275 t.Errorf("IP(%v).Mask(%v) = %v, want %v", tt.in, tt.mask, out, tt.out) 276 } 277 } 278 } 279 280 var ipMaskStringTests = []struct { 281 in IPMask 282 out string 283 }{ 284 {IPv4Mask(255, 255, 255, 240), "fffffff0"}, 285 {IPv4Mask(255, 0, 128, 0), "ff008000"}, 286 {IPMask(ParseIP("ffff:ff80::")), "ffffff80000000000000000000000000"}, 287 {IPMask(ParseIP("ef00:ff80::cafe:0")), "ef00ff800000000000000000cafe0000"}, 288 {nil, "<nil>"}, 289 } 290 291 func TestIPMaskString(t *testing.T) { 292 for _, tt := range ipMaskStringTests { 293 if out := tt.in.String(); out != tt.out { 294 t.Errorf("IPMask.String(%v) = %q, want %q", tt.in, out, tt.out) 295 } 296 } 297 } 298 299 func BenchmarkIPMaskString(b *testing.B) { 300 testHookUninstaller.Do(uninstallTestHooks) 301 302 for i := 0; i < b.N; i++ { 303 for _, tt := range ipMaskStringTests { 304 sink = tt.in.String() 305 } 306 } 307 } 308 309 var parseCIDRTests = []struct { 310 in string 311 ip IP 312 net *IPNet 313 err error 314 }{ 315 {"135.104.0.0/32", IPv4(135, 104, 0, 0), &IPNet{IP: IPv4(135, 104, 0, 0), Mask: IPv4Mask(255, 255, 255, 255)}, nil}, 316 {"0.0.0.0/24", IPv4(0, 0, 0, 0), &IPNet{IP: IPv4(0, 0, 0, 0), Mask: IPv4Mask(255, 255, 255, 0)}, nil}, 317 {"135.104.0.0/24", IPv4(135, 104, 0, 0), &IPNet{IP: IPv4(135, 104, 0, 0), Mask: IPv4Mask(255, 255, 255, 0)}, nil}, 318 {"135.104.0.1/32", IPv4(135, 104, 0, 1), &IPNet{IP: IPv4(135, 104, 0, 1), Mask: IPv4Mask(255, 255, 255, 255)}, nil}, 319 {"135.104.0.1/24", IPv4(135, 104, 0, 1), &IPNet{IP: IPv4(135, 104, 0, 0), Mask: IPv4Mask(255, 255, 255, 0)}, nil}, 320 {"::1/128", ParseIP("::1"), &IPNet{IP: ParseIP("::1"), Mask: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))}, nil}, 321 {"abcd:2345::/127", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"))}, nil}, 322 {"abcd:2345::/65", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:ffff:ffff:8000::"))}, nil}, 323 {"abcd:2345::/64", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:ffff:ffff::"))}, nil}, 324 {"abcd:2345::/63", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:ffff:fffe::"))}, nil}, 325 {"abcd:2345::/33", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:8000::"))}, nil}, 326 {"abcd:2345::/32", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff::"))}, nil}, 327 {"abcd:2344::/31", ParseIP("abcd:2344::"), &IPNet{IP: ParseIP("abcd:2344::"), Mask: IPMask(ParseIP("ffff:fffe::"))}, nil}, 328 {"abcd:2300::/24", ParseIP("abcd:2300::"), &IPNet{IP: ParseIP("abcd:2300::"), Mask: IPMask(ParseIP("ffff:ff00::"))}, nil}, 329 {"abcd:2345::/24", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2300::"), Mask: IPMask(ParseIP("ffff:ff00::"))}, nil}, 330 {"2001:DB8::/48", ParseIP("2001:DB8::"), &IPNet{IP: ParseIP("2001:DB8::"), Mask: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil}, 331 {"2001:DB8::1/48", ParseIP("2001:DB8::1"), &IPNet{IP: ParseIP("2001:DB8::"), Mask: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil}, 332 {"192.168.1.1/255.255.255.0", nil, nil, &ParseError{Type: "CIDR address", Text: "192.168.1.1/255.255.255.0"}}, 333 {"192.168.1.1/35", nil, nil, &ParseError{Type: "CIDR address", Text: "192.168.1.1/35"}}, 334 {"2001:db8::1/-1", nil, nil, &ParseError{Type: "CIDR address", Text: "2001:db8::1/-1"}}, 335 {"", nil, nil, &ParseError{Type: "CIDR address", Text: ""}}, 336 } 337 338 func TestParseCIDR(t *testing.T) { 339 for _, tt := range parseCIDRTests { 340 ip, net, err := ParseCIDR(tt.in) 341 if !reflect.DeepEqual(err, tt.err) { 342 t.Errorf("ParseCIDR(%q) = %v, %v; want %v, %v", tt.in, ip, net, tt.ip, tt.net) 343 } 344 if err == nil && (!tt.ip.Equal(ip) || !tt.net.IP.Equal(net.IP) || !reflect.DeepEqual(net.Mask, tt.net.Mask)) { 345 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) 346 } 347 } 348 } 349 350 var ipNetContainsTests = []struct { 351 ip IP 352 net *IPNet 353 ok bool 354 }{ 355 {IPv4(172, 16, 1, 1), &IPNet{IP: IPv4(172, 16, 0, 0), Mask: CIDRMask(12, 32)}, true}, 356 {IPv4(172, 24, 0, 1), &IPNet{IP: IPv4(172, 16, 0, 0), Mask: CIDRMask(13, 32)}, false}, 357 {IPv4(192, 168, 0, 3), &IPNet{IP: IPv4(192, 168, 0, 0), Mask: IPv4Mask(0, 0, 255, 252)}, true}, 358 {IPv4(192, 168, 0, 4), &IPNet{IP: IPv4(192, 168, 0, 0), Mask: IPv4Mask(0, 255, 0, 252)}, false}, 359 {ParseIP("2001:db8:1:2::1"), &IPNet{IP: ParseIP("2001:db8:1::"), Mask: CIDRMask(47, 128)}, true}, 360 {ParseIP("2001:db8:1:2::1"), &IPNet{IP: ParseIP("2001:db8:2::"), Mask: CIDRMask(47, 128)}, false}, 361 {ParseIP("2001:db8:1:2::1"), &IPNet{IP: ParseIP("2001:db8:1::"), Mask: IPMask(ParseIP("ffff:0:ffff::"))}, true}, 362 {ParseIP("2001:db8:1:2::1"), &IPNet{IP: ParseIP("2001:db8:1::"), Mask: IPMask(ParseIP("0:0:0:ffff::"))}, false}, 363 } 364 365 func TestIPNetContains(t *testing.T) { 366 for _, tt := range ipNetContainsTests { 367 if ok := tt.net.Contains(tt.ip); ok != tt.ok { 368 t.Errorf("IPNet(%v).Contains(%v) = %v, want %v", tt.net, tt.ip, ok, tt.ok) 369 } 370 } 371 } 372 373 var ipNetStringTests = []struct { 374 in *IPNet 375 out string 376 }{ 377 {&IPNet{IP: IPv4(192, 168, 1, 0), Mask: CIDRMask(26, 32)}, "192.168.1.0/26"}, 378 {&IPNet{IP: IPv4(192, 168, 1, 0), Mask: IPv4Mask(255, 0, 255, 0)}, "192.168.1.0/ff00ff00"}, 379 {&IPNet{IP: ParseIP("2001:db8::"), Mask: CIDRMask(55, 128)}, "2001:db8::/55"}, 380 {&IPNet{IP: ParseIP("2001:db8::"), Mask: IPMask(ParseIP("8000:f123:0:cafe::"))}, "2001:db8::/8000f1230000cafe0000000000000000"}, 381 } 382 383 func TestIPNetString(t *testing.T) { 384 for _, tt := range ipNetStringTests { 385 if out := tt.in.String(); out != tt.out { 386 t.Errorf("IPNet.String(%v) = %q, want %q", tt.in, out, tt.out) 387 } 388 } 389 } 390 391 var cidrMaskTests = []struct { 392 ones int 393 bits int 394 out IPMask 395 }{ 396 {0, 32, IPv4Mask(0, 0, 0, 0)}, 397 {12, 32, IPv4Mask(255, 240, 0, 0)}, 398 {24, 32, IPv4Mask(255, 255, 255, 0)}, 399 {32, 32, IPv4Mask(255, 255, 255, 255)}, 400 {0, 128, IPMask{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 401 {4, 128, IPMask{0xf0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 402 {48, 128, IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 403 {128, 128, IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}, 404 {33, 32, nil}, 405 {32, 33, nil}, 406 {-1, 128, nil}, 407 {128, -1, nil}, 408 } 409 410 func TestCIDRMask(t *testing.T) { 411 for _, tt := range cidrMaskTests { 412 if out := CIDRMask(tt.ones, tt.bits); !reflect.DeepEqual(out, tt.out) { 413 t.Errorf("CIDRMask(%v, %v) = %v, want %v", tt.ones, tt.bits, out, tt.out) 414 } 415 } 416 } 417 418 var ( 419 v4addr = IP{192, 168, 0, 1} 420 v4mappedv6addr = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 0, 1} 421 v6addr = IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1} 422 v4mask = IPMask{255, 255, 255, 0} 423 v4mappedv6mask = IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 255, 255, 255, 0} 424 v6mask = IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0} 425 badaddr = IP{192, 168, 0} 426 badmask = IPMask{255, 255, 0} 427 v4maskzero = IPMask{0, 0, 0, 0} 428 ) 429 430 var networkNumberAndMaskTests = []struct { 431 in IPNet 432 out IPNet 433 }{ 434 {IPNet{IP: v4addr, Mask: v4mask}, IPNet{IP: v4addr, Mask: v4mask}}, 435 {IPNet{IP: v4addr, Mask: v4mappedv6mask}, IPNet{IP: v4addr, Mask: v4mask}}, 436 {IPNet{IP: v4mappedv6addr, Mask: v4mappedv6mask}, IPNet{IP: v4addr, Mask: v4mask}}, 437 {IPNet{IP: v4mappedv6addr, Mask: v6mask}, IPNet{IP: v4addr, Mask: v4maskzero}}, 438 {IPNet{IP: v4addr, Mask: v6mask}, IPNet{IP: v4addr, Mask: v4maskzero}}, 439 {IPNet{IP: v6addr, Mask: v6mask}, IPNet{IP: v6addr, Mask: v6mask}}, 440 {IPNet{IP: v6addr, Mask: v4mappedv6mask}, IPNet{IP: v6addr, Mask: v4mappedv6mask}}, 441 {in: IPNet{IP: v6addr, Mask: v4mask}}, 442 {in: IPNet{IP: v4addr, Mask: badmask}}, 443 {in: IPNet{IP: v4mappedv6addr, Mask: badmask}}, 444 {in: IPNet{IP: v6addr, Mask: badmask}}, 445 {in: IPNet{IP: badaddr, Mask: v4mask}}, 446 {in: IPNet{IP: badaddr, Mask: v4mappedv6mask}}, 447 {in: IPNet{IP: badaddr, Mask: v6mask}}, 448 {in: IPNet{IP: badaddr, Mask: badmask}}, 449 } 450 451 func TestNetworkNumberAndMask(t *testing.T) { 452 for _, tt := range networkNumberAndMaskTests { 453 ip, m := networkNumberAndMask(&tt.in) 454 out := &IPNet{IP: ip, Mask: m} 455 if !reflect.DeepEqual(&tt.out, out) { 456 t.Errorf("networkNumberAndMask(%v) = %v, want %v", tt.in, out, &tt.out) 457 } 458 } 459 } 460 461 var splitJoinTests = []struct { 462 host string 463 port string 464 join string 465 }{ 466 {"www.google.com", "80", "www.google.com:80"}, 467 {"127.0.0.1", "1234", "127.0.0.1:1234"}, 468 {"::1", "80", "[::1]:80"}, 469 {"fe80::1%lo0", "80", "[fe80::1%lo0]:80"}, 470 {"localhost%lo0", "80", "[localhost%lo0]:80"}, 471 {"", "0", ":0"}, 472 473 {"google.com", "https%foo", "google.com:https%foo"}, // Go 1.0 behavior 474 {"127.0.0.1", "", "127.0.0.1:"}, // Go 1.0 behavior 475 {"www.google.com", "", "www.google.com:"}, // Go 1.0 behavior 476 } 477 478 var splitFailureTests = []struct { 479 hostPort string 480 err string 481 }{ 482 {"www.google.com", "missing port in address"}, 483 {"127.0.0.1", "missing port in address"}, 484 {"[::1]", "missing port in address"}, 485 {"[fe80::1%lo0]", "missing port in address"}, 486 {"[localhost%lo0]", "missing port in address"}, 487 {"localhost%lo0", "missing port in address"}, 488 489 {"::1", "too many colons in address"}, 490 {"fe80::1%lo0", "too many colons in address"}, 491 {"fe80::1%lo0:80", "too many colons in address"}, 492 493 {"localhost%lo0:80", "missing brackets in address"}, 494 495 // Test cases that didn't fail in Go 1.0 496 497 {"[foo:bar]", "missing port in address"}, 498 {"[foo:bar]baz", "missing port in address"}, 499 {"[foo]bar:baz", "missing port in address"}, 500 501 {"[foo]:[bar]:baz", "too many colons in address"}, 502 503 {"[foo]:[bar]baz", "unexpected '[' in address"}, 504 {"foo[bar]:baz", "unexpected '[' in address"}, 505 506 {"foo]bar:baz", "unexpected ']' in address"}, 507 } 508 509 func TestSplitHostPort(t *testing.T) { 510 for _, tt := range splitJoinTests { 511 if host, port, err := SplitHostPort(tt.join); host != tt.host || port != tt.port || err != nil { 512 t.Errorf("SplitHostPort(%q) = %q, %q, %v; want %q, %q, nil", tt.join, host, port, err, tt.host, tt.port) 513 } 514 } 515 for _, tt := range splitFailureTests { 516 if host, port, err := SplitHostPort(tt.hostPort); err == nil { 517 t.Errorf("SplitHostPort(%q) should have failed", tt.hostPort) 518 } else { 519 e := err.(*AddrError) 520 if e.Err != tt.err { 521 t.Errorf("SplitHostPort(%q) = _, _, %q; want %q", tt.hostPort, e.Err, tt.err) 522 } 523 if host != "" || port != "" { 524 t.Errorf("SplitHostPort(%q) = %q, %q, err; want %q, %q, err on failure", tt.hostPort, host, port, "", "") 525 } 526 } 527 } 528 } 529 530 func TestJoinHostPort(t *testing.T) { 531 for _, tt := range splitJoinTests { 532 if join := JoinHostPort(tt.host, tt.port); join != tt.join { 533 t.Errorf("JoinHostPort(%q, %q) = %q; want %q", tt.host, tt.port, join, tt.join) 534 } 535 } 536 } 537 538 var ipAddrFamilyTests = []struct { 539 in IP 540 af4 bool 541 af6 bool 542 }{ 543 {IPv4bcast, true, false}, 544 {IPv4allsys, true, false}, 545 {IPv4allrouter, true, false}, 546 {IPv4zero, true, false}, 547 {IPv4(224, 0, 0, 1), true, false}, 548 {IPv4(127, 0, 0, 1), true, false}, 549 {IPv4(240, 0, 0, 1), true, false}, 550 {IPv6unspecified, false, true}, 551 {IPv6loopback, false, true}, 552 {IPv6interfacelocalallnodes, false, true}, 553 {IPv6linklocalallnodes, false, true}, 554 {IPv6linklocalallrouters, false, true}, 555 {ParseIP("ff05::a:b:c:d"), false, true}, 556 {ParseIP("fe80::1:2:3:4"), false, true}, 557 {ParseIP("2001:db8::123:12:1"), false, true}, 558 } 559 560 func TestIPAddrFamily(t *testing.T) { 561 for _, tt := range ipAddrFamilyTests { 562 if af := tt.in.To4() != nil; af != tt.af4 { 563 t.Errorf("verifying IPv4 address family for %q = %v, want %v", tt.in, af, tt.af4) 564 } 565 if af := len(tt.in) == IPv6len && tt.in.To4() == nil; af != tt.af6 { 566 t.Errorf("verifying IPv6 address family for %q = %v, want %v", tt.in, af, tt.af6) 567 } 568 } 569 } 570 571 var ipAddrScopeTests = []struct { 572 scope func(IP) bool 573 in IP 574 ok bool 575 }{ 576 {IP.IsUnspecified, IPv4zero, true}, 577 {IP.IsUnspecified, IPv4(127, 0, 0, 1), false}, 578 {IP.IsUnspecified, IPv6unspecified, true}, 579 {IP.IsUnspecified, IPv6interfacelocalallnodes, false}, 580 {IP.IsUnspecified, nil, false}, 581 {IP.IsLoopback, IPv4(127, 0, 0, 1), true}, 582 {IP.IsLoopback, IPv4(127, 255, 255, 254), true}, 583 {IP.IsLoopback, IPv4(128, 1, 2, 3), false}, 584 {IP.IsLoopback, IPv6loopback, true}, 585 {IP.IsLoopback, IPv6linklocalallrouters, false}, 586 {IP.IsLoopback, nil, false}, 587 {IP.IsMulticast, IPv4(224, 0, 0, 0), true}, 588 {IP.IsMulticast, IPv4(239, 0, 0, 0), true}, 589 {IP.IsMulticast, IPv4(240, 0, 0, 0), false}, 590 {IP.IsMulticast, IPv6linklocalallnodes, true}, 591 {IP.IsMulticast, IP{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true}, 592 {IP.IsMulticast, IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false}, 593 {IP.IsMulticast, nil, false}, 594 {IP.IsInterfaceLocalMulticast, IPv4(224, 0, 0, 0), false}, 595 {IP.IsInterfaceLocalMulticast, IPv4(0xff, 0x01, 0, 0), false}, 596 {IP.IsInterfaceLocalMulticast, IPv6interfacelocalallnodes, true}, 597 {IP.IsInterfaceLocalMulticast, nil, false}, 598 {IP.IsLinkLocalMulticast, IPv4(224, 0, 0, 0), true}, 599 {IP.IsLinkLocalMulticast, IPv4(239, 0, 0, 0), false}, 600 {IP.IsLinkLocalMulticast, IPv4(0xff, 0x02, 0, 0), false}, 601 {IP.IsLinkLocalMulticast, IPv6linklocalallrouters, true}, 602 {IP.IsLinkLocalMulticast, IP{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false}, 603 {IP.IsLinkLocalMulticast, nil, false}, 604 {IP.IsLinkLocalUnicast, IPv4(169, 254, 0, 0), true}, 605 {IP.IsLinkLocalUnicast, IPv4(169, 255, 0, 0), false}, 606 {IP.IsLinkLocalUnicast, IPv4(0xfe, 0x80, 0, 0), false}, 607 {IP.IsLinkLocalUnicast, IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true}, 608 {IP.IsLinkLocalUnicast, IP{0xfe, 0xc0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false}, 609 {IP.IsLinkLocalUnicast, nil, false}, 610 {IP.IsGlobalUnicast, IPv4(240, 0, 0, 0), true}, 611 {IP.IsGlobalUnicast, IPv4(232, 0, 0, 0), false}, 612 {IP.IsGlobalUnicast, IPv4(169, 254, 0, 0), false}, 613 {IP.IsGlobalUnicast, IPv4bcast, false}, 614 {IP.IsGlobalUnicast, IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, true}, 615 {IP.IsGlobalUnicast, IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false}, 616 {IP.IsGlobalUnicast, IP{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false}, 617 {IP.IsGlobalUnicast, nil, false}, 618 } 619 620 func name(f interface{}) string { 621 return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name() 622 } 623 624 func TestIPAddrScope(t *testing.T) { 625 for _, tt := range ipAddrScopeTests { 626 if ok := tt.scope(tt.in); ok != tt.ok { 627 t.Errorf("%s(%q) = %v, want %v", name(tt.scope), tt.in, ok, tt.ok) 628 } 629 ip := tt.in.To4() 630 if ip == nil { 631 continue 632 } 633 if ok := tt.scope(ip); ok != tt.ok { 634 t.Errorf("%s(%q) = %v, want %v", name(tt.scope), ip, ok, tt.ok) 635 } 636 } 637 }