github.com/reiver/go@v0.0.0-20150109200633-1d0c7792f172/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  	"reflect"
     9  	"runtime"
    10  	"testing"
    11  )
    12  
    13  var parseIPTests = []struct {
    14  	in  string
    15  	out IP
    16  }{
    17  	{"127.0.1.2", IPv4(127, 0, 1, 2)},
    18  	{"127.0.0.1", IPv4(127, 0, 0, 1)},
    19  	{"127.001.002.003", IPv4(127, 1, 2, 3)},
    20  	{"::ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
    21  	{"::ffff:127.001.002.003", IPv4(127, 1, 2, 3)},
    22  	{"::ffff:7f01:0203", IPv4(127, 1, 2, 3)},
    23  	{"0:0:0:0:0000:ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
    24  	{"0:0:0:0:000000:ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
    25  	{"0:0:0:0::ffff:127.1.2.3", IPv4(127, 1, 2, 3)},
    26  
    27  	{"2001:4860:0:2001::68", IP{0x20, 0x01, 0x48, 0x60, 0, 0, 0x20, 0x01, 0, 0, 0, 0, 0, 0, 0x00, 0x68}},
    28  	{"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}},
    29  
    30  	{"127.0.0.256", nil},
    31  	{"abc", nil},
    32  	{"123:", nil},
    33  	{"fe80::1%lo0", nil},
    34  	{"fe80::1%911", nil},
    35  	{"", nil},
    36  	{"a1:a2:a3:a4::b1:b2:b3:b4", nil}, // Issue 6628
    37  }
    38  
    39  func TestParseIP(t *testing.T) {
    40  	for _, tt := range parseIPTests {
    41  		if out := ParseIP(tt.in); !reflect.DeepEqual(out, tt.out) {
    42  			t.Errorf("ParseIP(%q) = %v, want %v", tt.in, out, tt.out)
    43  		}
    44  		if tt.in == "" {
    45  			// Tested in TestMarshalEmptyIP below.
    46  			continue
    47  		}
    48  		var out IP
    49  		if err := out.UnmarshalText([]byte(tt.in)); !reflect.DeepEqual(out, tt.out) || (tt.out == nil) != (err != nil) {
    50  			t.Errorf("IP.UnmarshalText(%q) = %v, %v, want %v", tt.in, out, err, tt.out)
    51  		}
    52  	}
    53  }
    54  
    55  func BenchmarkParseIP(b *testing.B) {
    56  	for i := 0; i < b.N; i++ {
    57  		for _, tt := range parseIPTests {
    58  			ParseIP(tt.in)
    59  		}
    60  	}
    61  }
    62  
    63  // Issue 6339
    64  func TestMarshalEmptyIP(t *testing.T) {
    65  	for _, in := range [][]byte{nil, []byte("")} {
    66  		var out = IP{1, 2, 3, 4}
    67  		if err := out.UnmarshalText(in); err != nil || out != nil {
    68  			t.Errorf("UnmarshalText(%v) = %v, %v; want nil, nil", in, out, err)
    69  		}
    70  	}
    71  	var ip IP
    72  	got, err := ip.MarshalText()
    73  	if err != nil {
    74  		t.Fatal(err)
    75  	}
    76  	if !reflect.DeepEqual(got, []byte("")) {
    77  		t.Errorf(`got %#v, want []byte("")`, got)
    78  	}
    79  }
    80  
    81  var ipStringTests = []struct {
    82  	in  IP
    83  	out string // see RFC 5952
    84  }{
    85  	{IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, "2001:db8::123:12:1"},
    86  	{IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1}, "2001:db8::1"},
    87  	{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"},
    88  	{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"},
    89  	{IP{0x20, 0x1, 0, 0, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1}, "2001::1:0:0:1"},
    90  	{IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0}, "2001:db8:0:0:1::"},
    91  	{IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x1}, "2001:db8::1:0:0:1"},
    92  	{IP{0x20, 0x1, 0xD, 0xB8, 0, 0, 0, 0, 0, 0xA, 0, 0xB, 0, 0xC, 0, 0xD}, "2001:db8::a:b:c:d"},
    93  	{IPv4(192, 168, 0, 1), "192.168.0.1"},
    94  	{nil, ""},
    95  }
    96  
    97  func TestIPString(t *testing.T) {
    98  	for _, tt := range ipStringTests {
    99  		if tt.in != nil {
   100  			if out := tt.in.String(); out != tt.out {
   101  				t.Errorf("IP.String(%v) = %q, want %q", tt.in, out, tt.out)
   102  			}
   103  		}
   104  		if out, err := tt.in.MarshalText(); string(out) != tt.out || err != nil {
   105  			t.Errorf("IP.MarshalText(%v) = %q, %v, want %q, nil", tt.in, out, err, tt.out)
   106  		}
   107  	}
   108  }
   109  
   110  func BenchmarkIPString(b *testing.B) {
   111  	for i := 0; i < b.N; i++ {
   112  		for _, tt := range ipStringTests {
   113  			if tt.in != nil {
   114  				tt.in.String()
   115  			}
   116  		}
   117  	}
   118  }
   119  
   120  var ipMaskTests = []struct {
   121  	in   IP
   122  	mask IPMask
   123  	out  IP
   124  }{
   125  	{IPv4(192, 168, 1, 127), IPv4Mask(255, 255, 255, 128), IPv4(192, 168, 1, 0)},
   126  	{IPv4(192, 168, 1, 127), IPMask(ParseIP("255.255.255.192")), IPv4(192, 168, 1, 64)},
   127  	{IPv4(192, 168, 1, 127), IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffe0")), IPv4(192, 168, 1, 96)},
   128  	{IPv4(192, 168, 1, 127), IPv4Mask(255, 0, 255, 0), IPv4(192, 0, 1, 0)},
   129  	{ParseIP("2001:db8::1"), IPMask(ParseIP("ffff:ff80::")), ParseIP("2001:d80::")},
   130  	{ParseIP("2001:db8::1"), IPMask(ParseIP("f0f0:0f0f::")), ParseIP("2000:d08::")},
   131  }
   132  
   133  func TestIPMask(t *testing.T) {
   134  	for _, tt := range ipMaskTests {
   135  		if out := tt.in.Mask(tt.mask); out == nil || !tt.out.Equal(out) {
   136  			t.Errorf("IP(%v).Mask(%v) = %v, want %v", tt.in, tt.mask, out, tt.out)
   137  		}
   138  	}
   139  }
   140  
   141  var ipMaskStringTests = []struct {
   142  	in  IPMask
   143  	out string
   144  }{
   145  	{IPv4Mask(255, 255, 255, 240), "fffffff0"},
   146  	{IPv4Mask(255, 0, 128, 0), "ff008000"},
   147  	{IPMask(ParseIP("ffff:ff80::")), "ffffff80000000000000000000000000"},
   148  	{IPMask(ParseIP("ef00:ff80::cafe:0")), "ef00ff800000000000000000cafe0000"},
   149  	{nil, "<nil>"},
   150  }
   151  
   152  func TestIPMaskString(t *testing.T) {
   153  	for _, tt := range ipMaskStringTests {
   154  		if out := tt.in.String(); out != tt.out {
   155  			t.Errorf("IPMask.String(%v) = %q, want %q", tt.in, out, tt.out)
   156  		}
   157  	}
   158  }
   159  
   160  func BenchmarkIPMaskString(b *testing.B) {
   161  	for i := 0; i < b.N; i++ {
   162  		for _, tt := range ipMaskStringTests {
   163  			tt.in.String()
   164  		}
   165  	}
   166  }
   167  
   168  var parseCIDRTests = []struct {
   169  	in  string
   170  	ip  IP
   171  	net *IPNet
   172  	err error
   173  }{
   174  	{"135.104.0.0/32", IPv4(135, 104, 0, 0), &IPNet{IP: IPv4(135, 104, 0, 0), Mask: IPv4Mask(255, 255, 255, 255)}, nil},
   175  	{"0.0.0.0/24", IPv4(0, 0, 0, 0), &IPNet{IP: IPv4(0, 0, 0, 0), Mask: IPv4Mask(255, 255, 255, 0)}, nil},
   176  	{"135.104.0.0/24", IPv4(135, 104, 0, 0), &IPNet{IP: IPv4(135, 104, 0, 0), Mask: IPv4Mask(255, 255, 255, 0)}, nil},
   177  	{"135.104.0.1/32", IPv4(135, 104, 0, 1), &IPNet{IP: IPv4(135, 104, 0, 1), Mask: IPv4Mask(255, 255, 255, 255)}, nil},
   178  	{"135.104.0.1/24", IPv4(135, 104, 0, 1), &IPNet{IP: IPv4(135, 104, 0, 0), Mask: IPv4Mask(255, 255, 255, 0)}, nil},
   179  	{"::1/128", ParseIP("::1"), &IPNet{IP: ParseIP("::1"), Mask: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))}, nil},
   180  	{"abcd:2345::/127", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"))}, nil},
   181  	{"abcd:2345::/65", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:ffff:ffff:8000::"))}, nil},
   182  	{"abcd:2345::/64", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:ffff:ffff::"))}, nil},
   183  	{"abcd:2345::/63", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:ffff:fffe::"))}, nil},
   184  	{"abcd:2345::/33", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff:8000::"))}, nil},
   185  	{"abcd:2345::/32", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2345::"), Mask: IPMask(ParseIP("ffff:ffff::"))}, nil},
   186  	{"abcd:2344::/31", ParseIP("abcd:2344::"), &IPNet{IP: ParseIP("abcd:2344::"), Mask: IPMask(ParseIP("ffff:fffe::"))}, nil},
   187  	{"abcd:2300::/24", ParseIP("abcd:2300::"), &IPNet{IP: ParseIP("abcd:2300::"), Mask: IPMask(ParseIP("ffff:ff00::"))}, nil},
   188  	{"abcd:2345::/24", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2300::"), Mask: IPMask(ParseIP("ffff:ff00::"))}, nil},
   189  	{"2001:DB8::/48", ParseIP("2001:DB8::"), &IPNet{IP: ParseIP("2001:DB8::"), Mask: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
   190  	{"2001:DB8::1/48", ParseIP("2001:DB8::1"), &IPNet{IP: ParseIP("2001:DB8::"), Mask: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
   191  	{"192.168.1.1/255.255.255.0", nil, nil, &ParseError{"CIDR address", "192.168.1.1/255.255.255.0"}},
   192  	{"192.168.1.1/35", nil, nil, &ParseError{"CIDR address", "192.168.1.1/35"}},
   193  	{"2001:db8::1/-1", nil, nil, &ParseError{"CIDR address", "2001:db8::1/-1"}},
   194  	{"", nil, nil, &ParseError{"CIDR address", ""}},
   195  }
   196  
   197  func TestParseCIDR(t *testing.T) {
   198  	for _, tt := range parseCIDRTests {
   199  		ip, net, err := ParseCIDR(tt.in)
   200  		if !reflect.DeepEqual(err, tt.err) {
   201  			t.Errorf("ParseCIDR(%q) = %v, %v; want %v, %v", tt.in, ip, net, tt.ip, tt.net)
   202  		}
   203  		if err == nil && (!tt.ip.Equal(ip) || !tt.net.IP.Equal(net.IP) || !reflect.DeepEqual(net.Mask, tt.net.Mask)) {
   204  			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)
   205  		}
   206  	}
   207  }
   208  
   209  var ipNetContainsTests = []struct {
   210  	ip  IP
   211  	net *IPNet
   212  	ok  bool
   213  }{
   214  	{IPv4(172, 16, 1, 1), &IPNet{IP: IPv4(172, 16, 0, 0), Mask: CIDRMask(12, 32)}, true},
   215  	{IPv4(172, 24, 0, 1), &IPNet{IP: IPv4(172, 16, 0, 0), Mask: CIDRMask(13, 32)}, false},
   216  	{IPv4(192, 168, 0, 3), &IPNet{IP: IPv4(192, 168, 0, 0), Mask: IPv4Mask(0, 0, 255, 252)}, true},
   217  	{IPv4(192, 168, 0, 4), &IPNet{IP: IPv4(192, 168, 0, 0), Mask: IPv4Mask(0, 255, 0, 252)}, false},
   218  	{ParseIP("2001:db8:1:2::1"), &IPNet{IP: ParseIP("2001:db8:1::"), Mask: CIDRMask(47, 128)}, true},
   219  	{ParseIP("2001:db8:1:2::1"), &IPNet{IP: ParseIP("2001:db8:2::"), Mask: CIDRMask(47, 128)}, false},
   220  	{ParseIP("2001:db8:1:2::1"), &IPNet{IP: ParseIP("2001:db8:1::"), Mask: IPMask(ParseIP("ffff:0:ffff::"))}, true},
   221  	{ParseIP("2001:db8:1:2::1"), &IPNet{IP: ParseIP("2001:db8:1::"), Mask: IPMask(ParseIP("0:0:0:ffff::"))}, false},
   222  }
   223  
   224  func TestIPNetContains(t *testing.T) {
   225  	for _, tt := range ipNetContainsTests {
   226  		if ok := tt.net.Contains(tt.ip); ok != tt.ok {
   227  			t.Errorf("IPNet(%v).Contains(%v) = %v, want %v", tt.net, tt.ip, ok, tt.ok)
   228  		}
   229  	}
   230  }
   231  
   232  var ipNetStringTests = []struct {
   233  	in  *IPNet
   234  	out string
   235  }{
   236  	{&IPNet{IP: IPv4(192, 168, 1, 0), Mask: CIDRMask(26, 32)}, "192.168.1.0/26"},
   237  	{&IPNet{IP: IPv4(192, 168, 1, 0), Mask: IPv4Mask(255, 0, 255, 0)}, "192.168.1.0/ff00ff00"},
   238  	{&IPNet{IP: ParseIP("2001:db8::"), Mask: CIDRMask(55, 128)}, "2001:db8::/55"},
   239  	{&IPNet{IP: ParseIP("2001:db8::"), Mask: IPMask(ParseIP("8000:f123:0:cafe::"))}, "2001:db8::/8000f1230000cafe0000000000000000"},
   240  }
   241  
   242  func TestIPNetString(t *testing.T) {
   243  	for _, tt := range ipNetStringTests {
   244  		if out := tt.in.String(); out != tt.out {
   245  			t.Errorf("IPNet.String(%v) = %q, want %q", tt.in, out, tt.out)
   246  		}
   247  	}
   248  }
   249  
   250  var cidrMaskTests = []struct {
   251  	ones int
   252  	bits int
   253  	out  IPMask
   254  }{
   255  	{0, 32, IPv4Mask(0, 0, 0, 0)},
   256  	{12, 32, IPv4Mask(255, 240, 0, 0)},
   257  	{24, 32, IPv4Mask(255, 255, 255, 0)},
   258  	{32, 32, IPv4Mask(255, 255, 255, 255)},
   259  	{0, 128, IPMask{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
   260  	{4, 128, IPMask{0xf0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
   261  	{48, 128, IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
   262  	{128, 128, IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
   263  	{33, 32, nil},
   264  	{32, 33, nil},
   265  	{-1, 128, nil},
   266  	{128, -1, nil},
   267  }
   268  
   269  func TestCIDRMask(t *testing.T) {
   270  	for _, tt := range cidrMaskTests {
   271  		if out := CIDRMask(tt.ones, tt.bits); !reflect.DeepEqual(out, tt.out) {
   272  			t.Errorf("CIDRMask(%v, %v) = %v, want %v", tt.ones, tt.bits, out, tt.out)
   273  		}
   274  	}
   275  }
   276  
   277  var (
   278  	v4addr         = IP{192, 168, 0, 1}
   279  	v4mappedv6addr = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 168, 0, 1}
   280  	v6addr         = IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}
   281  	v4mask         = IPMask{255, 255, 255, 0}
   282  	v4mappedv6mask = IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 255, 255, 255, 0}
   283  	v6mask         = IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0}
   284  	badaddr        = IP{192, 168, 0}
   285  	badmask        = IPMask{255, 255, 0}
   286  	v4maskzero     = IPMask{0, 0, 0, 0}
   287  )
   288  
   289  var networkNumberAndMaskTests = []struct {
   290  	in  IPNet
   291  	out IPNet
   292  }{
   293  	{IPNet{IP: v4addr, Mask: v4mask}, IPNet{IP: v4addr, Mask: v4mask}},
   294  	{IPNet{IP: v4addr, Mask: v4mappedv6mask}, IPNet{IP: v4addr, Mask: v4mask}},
   295  	{IPNet{IP: v4mappedv6addr, Mask: v4mappedv6mask}, IPNet{IP: v4addr, Mask: v4mask}},
   296  	{IPNet{IP: v4mappedv6addr, Mask: v6mask}, IPNet{IP: v4addr, Mask: v4maskzero}},
   297  	{IPNet{IP: v4addr, Mask: v6mask}, IPNet{IP: v4addr, Mask: v4maskzero}},
   298  	{IPNet{IP: v6addr, Mask: v6mask}, IPNet{IP: v6addr, Mask: v6mask}},
   299  	{IPNet{IP: v6addr, Mask: v4mappedv6mask}, IPNet{IP: v6addr, Mask: v4mappedv6mask}},
   300  	{in: IPNet{IP: v6addr, Mask: v4mask}},
   301  	{in: IPNet{IP: v4addr, Mask: badmask}},
   302  	{in: IPNet{IP: v4mappedv6addr, Mask: badmask}},
   303  	{in: IPNet{IP: v6addr, Mask: badmask}},
   304  	{in: IPNet{IP: badaddr, Mask: v4mask}},
   305  	{in: IPNet{IP: badaddr, Mask: v4mappedv6mask}},
   306  	{in: IPNet{IP: badaddr, Mask: v6mask}},
   307  	{in: IPNet{IP: badaddr, Mask: badmask}},
   308  }
   309  
   310  func TestNetworkNumberAndMask(t *testing.T) {
   311  	for _, tt := range networkNumberAndMaskTests {
   312  		ip, m := networkNumberAndMask(&tt.in)
   313  		out := &IPNet{IP: ip, Mask: m}
   314  		if !reflect.DeepEqual(&tt.out, out) {
   315  			t.Errorf("networkNumberAndMask(%v) = %v, want %v", tt.in, out, &tt.out)
   316  		}
   317  	}
   318  }
   319  
   320  var splitJoinTests = []struct {
   321  	host string
   322  	port string
   323  	join string
   324  }{
   325  	{"www.google.com", "80", "www.google.com:80"},
   326  	{"127.0.0.1", "1234", "127.0.0.1:1234"},
   327  	{"::1", "80", "[::1]:80"},
   328  	{"fe80::1%lo0", "80", "[fe80::1%lo0]:80"},
   329  	{"localhost%lo0", "80", "[localhost%lo0]:80"},
   330  	{"", "0", ":0"},
   331  
   332  	{"google.com", "https%foo", "google.com:https%foo"}, // Go 1.0 behavior
   333  	{"127.0.0.1", "", "127.0.0.1:"},                     // Go 1.0 behaviour
   334  	{"www.google.com", "", "www.google.com:"},           // Go 1.0 behaviour
   335  }
   336  
   337  var splitFailureTests = []struct {
   338  	hostPort string
   339  	err      string
   340  }{
   341  	{"www.google.com", "missing port in address"},
   342  	{"127.0.0.1", "missing port in address"},
   343  	{"[::1]", "missing port in address"},
   344  	{"[fe80::1%lo0]", "missing port in address"},
   345  	{"[localhost%lo0]", "missing port in address"},
   346  	{"localhost%lo0", "missing port in address"},
   347  
   348  	{"::1", "too many colons in address"},
   349  	{"fe80::1%lo0", "too many colons in address"},
   350  	{"fe80::1%lo0:80", "too many colons in address"},
   351  
   352  	{"localhost%lo0:80", "missing brackets in address"},
   353  
   354  	// Test cases that didn't fail in Go 1.0
   355  
   356  	{"[foo:bar]", "missing port in address"},
   357  	{"[foo:bar]baz", "missing port in address"},
   358  	{"[foo]bar:baz", "missing port in address"},
   359  
   360  	{"[foo]:[bar]:baz", "too many colons in address"},
   361  
   362  	{"[foo]:[bar]baz", "unexpected '[' in address"},
   363  	{"foo[bar]:baz", "unexpected '[' in address"},
   364  
   365  	{"foo]bar:baz", "unexpected ']' in address"},
   366  }
   367  
   368  func TestSplitHostPort(t *testing.T) {
   369  	for _, tt := range splitJoinTests {
   370  		if host, port, err := SplitHostPort(tt.join); host != tt.host || port != tt.port || err != nil {
   371  			t.Errorf("SplitHostPort(%q) = %q, %q, %v; want %q, %q, nil", tt.join, host, port, err, tt.host, tt.port)
   372  		}
   373  	}
   374  	for _, tt := range splitFailureTests {
   375  		if _, _, err := SplitHostPort(tt.hostPort); err == nil {
   376  			t.Errorf("SplitHostPort(%q) should have failed", tt.hostPort)
   377  		} else {
   378  			e := err.(*AddrError)
   379  			if e.Err != tt.err {
   380  				t.Errorf("SplitHostPort(%q) = _, _, %q; want %q", tt.hostPort, e.Err, tt.err)
   381  			}
   382  		}
   383  	}
   384  }
   385  
   386  func TestJoinHostPort(t *testing.T) {
   387  	for _, tt := range splitJoinTests {
   388  		if join := JoinHostPort(tt.host, tt.port); join != tt.join {
   389  			t.Errorf("JoinHostPort(%q, %q) = %q; want %q", tt.host, tt.port, join, tt.join)
   390  		}
   391  	}
   392  }
   393  
   394  var ipAddrFamilyTests = []struct {
   395  	in  IP
   396  	af4 bool
   397  	af6 bool
   398  }{
   399  	{IPv4bcast, true, false},
   400  	{IPv4allsys, true, false},
   401  	{IPv4allrouter, true, false},
   402  	{IPv4zero, true, false},
   403  	{IPv4(224, 0, 0, 1), true, false},
   404  	{IPv4(127, 0, 0, 1), true, false},
   405  	{IPv4(240, 0, 0, 1), true, false},
   406  	{IPv6unspecified, false, true},
   407  	{IPv6loopback, false, true},
   408  	{IPv6interfacelocalallnodes, false, true},
   409  	{IPv6linklocalallnodes, false, true},
   410  	{IPv6linklocalallrouters, false, true},
   411  	{ParseIP("ff05::a:b:c:d"), false, true},
   412  	{ParseIP("fe80::1:2:3:4"), false, true},
   413  	{ParseIP("2001:db8::123:12:1"), false, true},
   414  }
   415  
   416  func TestIPAddrFamily(t *testing.T) {
   417  	for _, tt := range ipAddrFamilyTests {
   418  		if af := tt.in.To4() != nil; af != tt.af4 {
   419  			t.Errorf("verifying IPv4 address family for %q = %v, want %v", tt.in, af, tt.af4)
   420  		}
   421  		if af := len(tt.in) == IPv6len && tt.in.To4() == nil; af != tt.af6 {
   422  			t.Errorf("verifying IPv6 address family for %q = %v, want %v", tt.in, af, tt.af6)
   423  		}
   424  	}
   425  }
   426  
   427  var ipAddrScopeTests = []struct {
   428  	scope func(IP) bool
   429  	in    IP
   430  	ok    bool
   431  }{
   432  	{IP.IsUnspecified, IPv4zero, true},
   433  	{IP.IsUnspecified, IPv4(127, 0, 0, 1), false},
   434  	{IP.IsUnspecified, IPv6unspecified, true},
   435  	{IP.IsUnspecified, IPv6interfacelocalallnodes, false},
   436  	{IP.IsLoopback, IPv4(127, 0, 0, 1), true},
   437  	{IP.IsLoopback, IPv4(127, 255, 255, 254), true},
   438  	{IP.IsLoopback, IPv4(128, 1, 2, 3), false},
   439  	{IP.IsLoopback, IPv6loopback, true},
   440  	{IP.IsLoopback, IPv6linklocalallrouters, false},
   441  	{IP.IsMulticast, IPv4(224, 0, 0, 0), true},
   442  	{IP.IsMulticast, IPv4(239, 0, 0, 0), true},
   443  	{IP.IsMulticast, IPv4(240, 0, 0, 0), false},
   444  	{IP.IsMulticast, IPv6linklocalallnodes, true},
   445  	{IP.IsMulticast, IP{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
   446  	{IP.IsMulticast, IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
   447  	{IP.IsLinkLocalMulticast, IPv4(224, 0, 0, 0), true},
   448  	{IP.IsLinkLocalMulticast, IPv4(239, 0, 0, 0), false},
   449  	{IP.IsLinkLocalMulticast, IPv6linklocalallrouters, true},
   450  	{IP.IsLinkLocalMulticast, IP{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
   451  	{IP.IsLinkLocalUnicast, IPv4(169, 254, 0, 0), true},
   452  	{IP.IsLinkLocalUnicast, IPv4(169, 255, 0, 0), false},
   453  	{IP.IsLinkLocalUnicast, IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, true},
   454  	{IP.IsLinkLocalUnicast, IP{0xfe, 0xc0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
   455  	{IP.IsGlobalUnicast, IPv4(240, 0, 0, 0), true},
   456  	{IP.IsGlobalUnicast, IPv4(232, 0, 0, 0), false},
   457  	{IP.IsGlobalUnicast, IPv4(169, 254, 0, 0), false},
   458  	{IP.IsGlobalUnicast, IP{0x20, 0x1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0x1, 0x23, 0, 0x12, 0, 0x1}, true},
   459  	{IP.IsGlobalUnicast, IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
   460  	{IP.IsGlobalUnicast, IP{0xff, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false},
   461  }
   462  
   463  func name(f interface{}) string {
   464  	return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
   465  }
   466  
   467  func TestIPAddrScope(t *testing.T) {
   468  	for _, tt := range ipAddrScopeTests {
   469  		if ok := tt.scope(tt.in); ok != tt.ok {
   470  			t.Errorf("%s(%q) = %v, want %v", name(tt.scope), tt.in, ok, tt.ok)
   471  		}
   472  	}
   473  }