...
Run Format

Source file src/net/ip_test.go

Documentation: net

     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  }
   728  

View as plain text