...
Run Format

Source file src/net/addrselect_test.go

Documentation: net

  // Copyright 2015 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  // +build darwin dragonfly freebsd linux netbsd openbsd solaris
  
  package net
  
  import (
  	"reflect"
  	"testing"
  )
  
  func TestSortByRFC6724(t *testing.T) {
  	tests := []struct {
  		in      []IPAddr
  		srcs    []IP
  		want    []IPAddr
  		reverse bool // also test it starting backwards
  	}{
  		// Examples from RFC 6724 section 10.2:
  
  		// Prefer matching scope.
  		{
  			in: []IPAddr{
  				{IP: ParseIP("2001:db8:1::1")},
  				{IP: ParseIP("198.51.100.121")},
  			},
  			srcs: []IP{
  				ParseIP("2001:db8:1::2"),
  				ParseIP("169.254.13.78"),
  			},
  			want: []IPAddr{
  				{IP: ParseIP("2001:db8:1::1")},
  				{IP: ParseIP("198.51.100.121")},
  			},
  			reverse: true,
  		},
  
  		// Prefer matching scope.
  		{
  			in: []IPAddr{
  				{IP: ParseIP("2001:db8:1::1")},
  				{IP: ParseIP("198.51.100.121")},
  			},
  			srcs: []IP{
  				ParseIP("fe80::1"),
  				ParseIP("198.51.100.117"),
  			},
  			want: []IPAddr{
  				{IP: ParseIP("198.51.100.121")},
  				{IP: ParseIP("2001:db8:1::1")},
  			},
  			reverse: true,
  		},
  
  		// Prefer higher precedence.
  		{
  			in: []IPAddr{
  				{IP: ParseIP("2001:db8:1::1")},
  				{IP: ParseIP("10.1.2.3")},
  			},
  			srcs: []IP{
  				ParseIP("2001:db8:1::2"),
  				ParseIP("10.1.2.4"),
  			},
  			want: []IPAddr{
  				{IP: ParseIP("2001:db8:1::1")},
  				{IP: ParseIP("10.1.2.3")},
  			},
  			reverse: true,
  		},
  
  		// Prefer smaller scope.
  		{
  			in: []IPAddr{
  				{IP: ParseIP("2001:db8:1::1")},
  				{IP: ParseIP("fe80::1")},
  			},
  			srcs: []IP{
  				ParseIP("2001:db8:1::2"),
  				ParseIP("fe80::2"),
  			},
  			want: []IPAddr{
  				{IP: ParseIP("fe80::1")},
  				{IP: ParseIP("2001:db8:1::1")},
  			},
  			reverse: true,
  		},
  
  		// Issue 13283.  Having a 10/8 source address does not
  		// mean we should prefer 23/8 destination addresses.
  		{
  			in: []IPAddr{
  				{IP: ParseIP("54.83.193.112")},
  				{IP: ParseIP("184.72.238.214")},
  				{IP: ParseIP("23.23.172.185")},
  				{IP: ParseIP("75.101.148.21")},
  				{IP: ParseIP("23.23.134.56")},
  				{IP: ParseIP("23.21.50.150")},
  			},
  			srcs: []IP{
  				ParseIP("10.2.3.4"),
  				ParseIP("10.2.3.4"),
  				ParseIP("10.2.3.4"),
  				ParseIP("10.2.3.4"),
  				ParseIP("10.2.3.4"),
  				ParseIP("10.2.3.4"),
  			},
  			want: []IPAddr{
  				{IP: ParseIP("54.83.193.112")},
  				{IP: ParseIP("184.72.238.214")},
  				{IP: ParseIP("23.23.172.185")},
  				{IP: ParseIP("75.101.148.21")},
  				{IP: ParseIP("23.23.134.56")},
  				{IP: ParseIP("23.21.50.150")},
  			},
  			reverse: false,
  		},
  	}
  	for i, tt := range tests {
  		inCopy := make([]IPAddr, len(tt.in))
  		copy(inCopy, tt.in)
  		srcCopy := make([]IP, len(tt.in))
  		copy(srcCopy, tt.srcs)
  		sortByRFC6724withSrcs(inCopy, srcCopy)
  		if !reflect.DeepEqual(inCopy, tt.want) {
  			t.Errorf("test %d:\nin = %s\ngot: %s\nwant: %s\n", i, tt.in, inCopy, tt.want)
  		}
  		if tt.reverse {
  			copy(inCopy, tt.in)
  			copy(srcCopy, tt.srcs)
  			for j := 0; j < len(inCopy)/2; j++ {
  				k := len(inCopy) - j - 1
  				inCopy[j], inCopy[k] = inCopy[k], inCopy[j]
  				srcCopy[j], srcCopy[k] = srcCopy[k], srcCopy[j]
  			}
  			sortByRFC6724withSrcs(inCopy, srcCopy)
  			if !reflect.DeepEqual(inCopy, tt.want) {
  				t.Errorf("test %d, starting backwards:\nin = %s\ngot: %s\nwant: %s\n", i, tt.in, inCopy, tt.want)
  			}
  		}
  
  	}
  
  }
  
  func TestRFC6724PolicyTableClassify(t *testing.T) {
  	tests := []struct {
  		ip   IP
  		want policyTableEntry
  	}{
  		{
  			ip: ParseIP("127.0.0.1"),
  			want: policyTableEntry{
  				Prefix:     &IPNet{IP: ParseIP("::ffff:0:0"), Mask: CIDRMask(96, 128)},
  				Precedence: 35,
  				Label:      4,
  			},
  		},
  		{
  			ip: ParseIP("2601:645:8002:a500:986f:1db8:c836:bd65"),
  			want: policyTableEntry{
  				Prefix:     &IPNet{IP: ParseIP("::"), Mask: CIDRMask(0, 128)},
  				Precedence: 40,
  				Label:      1,
  			},
  		},
  		{
  			ip: ParseIP("::1"),
  			want: policyTableEntry{
  				Prefix:     &IPNet{IP: ParseIP("::1"), Mask: CIDRMask(128, 128)},
  				Precedence: 50,
  				Label:      0,
  			},
  		},
  		{
  			ip: ParseIP("2002::ab12"),
  			want: policyTableEntry{
  				Prefix:     &IPNet{IP: ParseIP("2002::"), Mask: CIDRMask(16, 128)},
  				Precedence: 30,
  				Label:      2,
  			},
  		},
  	}
  	for i, tt := range tests {
  		got := rfc6724policyTable.Classify(tt.ip)
  		if !reflect.DeepEqual(got, tt.want) {
  			t.Errorf("%d. Classify(%s) = %v; want %v", i, tt.ip, got, tt.want)
  		}
  	}
  }
  
  func TestRFC6724ClassifyScope(t *testing.T) {
  	tests := []struct {
  		ip   IP
  		want scope
  	}{
  		{ParseIP("127.0.0.1"), scopeLinkLocal},   // rfc6724#section-3.2
  		{ParseIP("::1"), scopeLinkLocal},         // rfc4007#section-4
  		{ParseIP("169.254.1.2"), scopeLinkLocal}, // rfc6724#section-3.2
  		{ParseIP("fec0::1"), scopeSiteLocal},
  		{ParseIP("8.8.8.8"), scopeGlobal},
  
  		{ParseIP("ff02::"), scopeLinkLocal},  // IPv6 multicast
  		{ParseIP("ff05::"), scopeSiteLocal},  // IPv6 multicast
  		{ParseIP("ff04::"), scopeAdminLocal}, // IPv6 multicast
  		{ParseIP("ff0e::"), scopeGlobal},     // IPv6 multicast
  
  		{IPv4(0xe0, 0, 0, 0), scopeGlobal},       // IPv4 link-local multicast as 16 bytes
  		{IPv4(0xe0, 2, 2, 2), scopeGlobal},       // IPv4 global multicast as 16 bytes
  		{IPv4(0xe0, 0, 0, 0).To4(), scopeGlobal}, // IPv4 link-local multicast as 4 bytes
  		{IPv4(0xe0, 2, 2, 2).To4(), scopeGlobal}, // IPv4 global multicast as 4 bytes
  	}
  	for i, tt := range tests {
  		got := classifyScope(tt.ip)
  		if got != tt.want {
  			t.Errorf("%d. classifyScope(%s) = %x; want %x", i, tt.ip, got, tt.want)
  		}
  	}
  }
  
  func TestRFC6724CommonPrefixLength(t *testing.T) {
  	tests := []struct {
  		a, b IP
  		want int
  	}{
  		{ParseIP("fe80::1"), ParseIP("fe80::2"), 64},
  		{ParseIP("fe81::1"), ParseIP("fe80::2"), 15},
  		{ParseIP("127.0.0.1"), ParseIP("fe80::1"), 0}, // diff size
  		{IPv4(1, 2, 3, 4), IP{1, 2, 3, 4}, 32},
  		{IP{1, 2, 255, 255}, IP{1, 2, 0, 0}, 16},
  		{IP{1, 2, 127, 255}, IP{1, 2, 0, 0}, 17},
  		{IP{1, 2, 63, 255}, IP{1, 2, 0, 0}, 18},
  		{IP{1, 2, 31, 255}, IP{1, 2, 0, 0}, 19},
  		{IP{1, 2, 15, 255}, IP{1, 2, 0, 0}, 20},
  		{IP{1, 2, 7, 255}, IP{1, 2, 0, 0}, 21},
  		{IP{1, 2, 3, 255}, IP{1, 2, 0, 0}, 22},
  		{IP{1, 2, 1, 255}, IP{1, 2, 0, 0}, 23},
  		{IP{1, 2, 0, 255}, IP{1, 2, 0, 0}, 24},
  	}
  	for i, tt := range tests {
  		got := commonPrefixLen(tt.a, tt.b)
  		if got != tt.want {
  			t.Errorf("%d. commonPrefixLen(%s, %s) = %d; want %d", i, tt.a, tt.b, got, tt.want)
  		}
  	}
  
  }
  

View as plain text