libgo/go/net/addrselect_test.go

   1 // Copyright 2015 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 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
   6
   7 package net
   8
   9 import (
  10         "reflect"
  11         "testing"
  12 )
  13
  14 func TestSortByRFC6724(t *testing.T) {
  15         tests := []struct {
  16                 in      []IPAddr
  17                 srcs    []IP
  18                 want    []IPAddr
  19                 reverse bool // also test it starting backwards
  20         }{
  21                 // Examples from RFC 6724 section 10.2:
  22
  23                 // Prefer matching scope.
  24                 {
  25                         in: []IPAddr{
  26                                 {IP: ParseIP("2001:db8:1::1")},
  27                                 {IP: ParseIP("198.51.100.121")},
  28                         },
  29                         srcs: []IP{
  30                                 ParseIP("2001:db8:1::2"),
  31                                 ParseIP("169.254.13.78"),
  32                         },
  33                         want: []IPAddr{
  34                                 {IP: ParseIP("2001:db8:1::1")},
  35                                 {IP: ParseIP("198.51.100.121")},
  36                         },
  37                         reverse: true,
  38                 },
  39
  40                 // Prefer matching scope.
  41                 {
  42                         in: []IPAddr{
  43                                 {IP: ParseIP("2001:db8:1::1")},
  44                                 {IP: ParseIP("198.51.100.121")},
  45                         },
  46                         srcs: []IP{
  47                                 ParseIP("fe80::1"),
  48                                 ParseIP("198.51.100.117"),
  49                         },
  50                         want: []IPAddr{
  51                                 {IP: ParseIP("198.51.100.121")},
  52                                 {IP: ParseIP("2001:db8:1::1")},
  53                         },
  54                         reverse: true,
  55                 },
  56
  57                 // Prefer higher precedence.
  58                 {
  59                         in: []IPAddr{
  60                                 {IP: ParseIP("2001:db8:1::1")},
  61                                 {IP: ParseIP("10.1.2.3")},
  62                         },
  63                         srcs: []IP{
  64                                 ParseIP("2001:db8:1::2"),
  65                                 ParseIP("10.1.2.4"),
  66                         },
  67                         want: []IPAddr{
  68                                 {IP: ParseIP("2001:db8:1::1")},
  69                                 {IP: ParseIP("10.1.2.3")},
  70                         },
  71                         reverse: true,
  72                 },
  73
  74                 // Prefer smaller scope.
  75                 {
  76                         in: []IPAddr{
  77                                 {IP: ParseIP("2001:db8:1::1")},
  78                                 {IP: ParseIP("fe80::1")},
  79                         },
  80                         srcs: []IP{
  81                                 ParseIP("2001:db8:1::2"),
  82                                 ParseIP("fe80::2"),
  83                         },
  84                         want: []IPAddr{
  85                                 {IP: ParseIP("fe80::1")},
  86                                 {IP: ParseIP("2001:db8:1::1")},
  87                         },
  88                         reverse: true,
  89                 },
  90
  91                 // Issue 13283.  Having a 10/8 source address does not
  92                 // mean we should prefer 23/8 destination addresses.
  93                 {
  94                         in: []IPAddr{
  95                                 {IP: ParseIP("54.83.193.112")},
  96                                 {IP: ParseIP("184.72.238.214")},
  97                                 {IP: ParseIP("23.23.172.185")},
  98                                 {IP: ParseIP("75.101.148.21")},
  99                                 {IP: ParseIP("23.23.134.56")},
 100                                 {IP: ParseIP("23.21.50.150")},
 101                         },
 102                         srcs: []IP{
 103                                 ParseIP("10.2.3.4"),
 104                                 ParseIP("10.2.3.4"),
 105                                 ParseIP("10.2.3.4"),
 106                                 ParseIP("10.2.3.4"),
 107                                 ParseIP("10.2.3.4"),
 108                                 ParseIP("10.2.3.4"),
 109                         },
 110                         want: []IPAddr{
 111                                 {IP: ParseIP("54.83.193.112")},
 112                                 {IP: ParseIP("184.72.238.214")},
 113                                 {IP: ParseIP("23.23.172.185")},
 114                                 {IP: ParseIP("75.101.148.21")},
 115                                 {IP: ParseIP("23.23.134.56")},
 116                                 {IP: ParseIP("23.21.50.150")},
 117                         },
 118                         reverse: false,
 119                 },
 120         }
 121         for i, tt := range tests {
 122                 inCopy := make([]IPAddr, len(tt.in))
 123                 copy(inCopy, tt.in)
 124                 srcCopy := make([]IP, len(tt.in))
 125                 copy(srcCopy, tt.srcs)
 126                 sortByRFC6724withSrcs(inCopy, srcCopy)
 127                 if !reflect.DeepEqual(inCopy, tt.want) {
 128                         t.Errorf("test %d:\nin = %s\ngot: %s\nwant: %s\n", i, tt.in, inCopy, tt.want)
 129                 }
 130                 if tt.reverse {
 131                         copy(inCopy, tt.in)
 132                         copy(srcCopy, tt.srcs)
 133                         for j := 0; j < len(inCopy)/2; j++ {
 134                                 k := len(inCopy) - j - 1
 135                                 inCopy[j], inCopy[k] = inCopy[k], inCopy[j]
 136                                 srcCopy[j], srcCopy[k] = srcCopy[k], srcCopy[j]
 137                         }
 138                         sortByRFC6724withSrcs(inCopy, srcCopy)
 139                         if !reflect.DeepEqual(inCopy, tt.want) {
 140                                 t.Errorf("test %d, starting backwards:\nin = %s\ngot: %s\nwant: %s\n", i, tt.in, inCopy, tt.want)
 141                         }
 142                 }
 143
 144         }
 145
 146 }
 147
 148 func TestRFC6724PolicyTableClassify(t *testing.T) {
 149         tests := []struct {
 150                 ip   IP
 151                 want policyTableEntry
 152         }{
 153                 {
 154                         ip: ParseIP("127.0.0.1"),
 155                         want: policyTableEntry{
 156                                 Prefix:     &IPNet{IP: ParseIP("::ffff:0:0"), Mask: CIDRMask(96, 128)},
 157                                 Precedence: 35,
 158                                 Label:      4,
 159                         },
 160                 },
 161                 {
 162                         ip: ParseIP("2601:645:8002:a500:986f:1db8:c836:bd65"),
 163                         want: policyTableEntry{
 164                                 Prefix:     &IPNet{IP: ParseIP("::"), Mask: CIDRMask(0, 128)},
 165                                 Precedence: 40,
 166                                 Label:      1,
 167                         },
 168                 },
 169                 {
 170                         ip: ParseIP("::1"),
 171                         want: policyTableEntry{
 172                                 Prefix:     &IPNet{IP: ParseIP("::1"), Mask: CIDRMask(128, 128)},
 173                                 Precedence: 50,
 174                                 Label:      0,
 175                         },
 176                 },
 177                 {
 178                         ip: ParseIP("2002::ab12"),
 179                         want: policyTableEntry{
 180                                 Prefix:     &IPNet{IP: ParseIP("2002::"), Mask: CIDRMask(16, 128)},
 181                                 Precedence: 30,
 182                                 Label:      2,
 183                         },
 184                 },
 185         }
 186         for i, tt := range tests {
 187                 got := rfc6724policyTable.Classify(tt.ip)
 188                 if !reflect.DeepEqual(got, tt.want) {
 189                         t.Errorf("%d. Classify(%s) = %v; want %v", i, tt.ip, got, tt.want)
 190                 }
 191         }
 192 }
 193
 194 func TestRFC6724ClassifyScope(t *testing.T) {
 195         tests := []struct {
 196                 ip   IP
 197                 want scope
 198         }{
 199                 {ParseIP("127.0.0.1"), scopeLinkLocal},   // rfc6724#section-3.2
 200                 {ParseIP("::1"), scopeLinkLocal},         // rfc4007#section-4
 201                 {ParseIP("169.254.1.2"), scopeLinkLocal}, // rfc6724#section-3.2
 202                 {ParseIP("fec0::1"), scopeSiteLocal},
 203                 {ParseIP("8.8.8.8"), scopeGlobal},
 204
 205                 {ParseIP("ff02::"), scopeLinkLocal},  // IPv6 multicast
 206                 {ParseIP("ff05::"), scopeSiteLocal},  // IPv6 multicast
 207                 {ParseIP("ff04::"), scopeAdminLocal}, // IPv6 multicast
 208                 {ParseIP("ff0e::"), scopeGlobal},     // IPv6 multicast
 209
 210                 {IPv4(0xe0, 0, 0, 0), scopeGlobal},       // IPv4 link-local multicast as 16 bytes
 211                 {IPv4(0xe0, 2, 2, 2), scopeGlobal},       // IPv4 global multicast as 16 bytes
 212                 {IPv4(0xe0, 0, 0, 0).To4(), scopeGlobal}, // IPv4 link-local multicast as 4 bytes
 213                 {IPv4(0xe0, 2, 2, 2).To4(), scopeGlobal}, // IPv4 global multicast as 4 bytes
 214         }
 215         for i, tt := range tests {
 216                 got := classifyScope(tt.ip)
 217                 if got != tt.want {
 218                         t.Errorf("%d. classifyScope(%s) = %x; want %x", i, tt.ip, got, tt.want)
 219                 }
 220         }
 221 }
 222
 223 func TestRFC6724CommonPrefixLength(t *testing.T) {
 224         tests := []struct {
 225                 a, b IP
 226                 want int
 227         }{
 228                 {ParseIP("fe80::1"), ParseIP("fe80::2"), 64},
 229                 {ParseIP("fe81::1"), ParseIP("fe80::2"), 15},
 230                 {ParseIP("127.0.0.1"), ParseIP("fe80::1"), 0}, // diff size
 231                 {IPv4(1, 2, 3, 4), IP{1, 2, 3, 4}, 32},
 232                 {IP{1, 2, 255, 255}, IP{1, 2, 0, 0}, 16},
 233                 {IP{1, 2, 127, 255}, IP{1, 2, 0, 0}, 17},
 234                 {IP{1, 2, 63, 255}, IP{1, 2, 0, 0}, 18},
 235                 {IP{1, 2, 31, 255}, IP{1, 2, 0, 0}, 19},
 236                 {IP{1, 2, 15, 255}, IP{1, 2, 0, 0}, 20},
 237                 {IP{1, 2, 7, 255}, IP{1, 2, 0, 0}, 21},
 238                 {IP{1, 2, 3, 255}, IP{1, 2, 0, 0}, 22},
 239                 {IP{1, 2, 1, 255}, IP{1, 2, 0, 0}, 23},
 240                 {IP{1, 2, 0, 255}, IP{1, 2, 0, 0}, 24},
 241         }
 242         for i, tt := range tests {
 243                 got := commonPrefixLen(tt.a, tt.b)
 244                 if got != tt.want {
 245                         t.Errorf("%d. commonPrefixLen(%s, %s) = %d; want %d", i, tt.a, tt.b, got, tt.want)
 246                 }
 247         }
 248
 249 }