libgo/go/net/ip_test.go

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