mirror of
https://github.com/tailscale/tailscale.git
synced 2024-11-25 11:05:45 +00:00
1023b2a82c
Fix regression from bd93c3067e where I didn't notice the
32-bit test failure was real and not its usual slowness-related
regression. Yay failure blindness.
Updates #12526
Change-Id: I00e33bba697e2cdb61a0d76a71b62406f6c2eeb9
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
1141 lines
35 KiB
Go
1141 lines
35 KiB
Go
// Copyright (c) Tailscale Inc & AUTHORS
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
package deephash
|
|
|
|
import (
|
|
"archive/tar"
|
|
"crypto/sha256"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"hash"
|
|
"math"
|
|
"math/bits"
|
|
"math/rand"
|
|
"net/netip"
|
|
"reflect"
|
|
"runtime"
|
|
"testing"
|
|
"testing/quick"
|
|
"time"
|
|
|
|
qt "github.com/frankban/quicktest"
|
|
"go4.org/mem"
|
|
"go4.org/netipx"
|
|
"tailscale.com/tailcfg"
|
|
"tailscale.com/types/dnstype"
|
|
"tailscale.com/types/ipproto"
|
|
"tailscale.com/types/key"
|
|
"tailscale.com/types/ptr"
|
|
"tailscale.com/types/views"
|
|
"tailscale.com/util/deephash/testtype"
|
|
"tailscale.com/util/dnsname"
|
|
"tailscale.com/util/hashx"
|
|
"tailscale.com/version"
|
|
"tailscale.com/wgengine/filter"
|
|
"tailscale.com/wgengine/router"
|
|
"tailscale.com/wgengine/wgcfg"
|
|
)
|
|
|
|
type appendBytes []byte
|
|
|
|
func (p appendBytes) AppendTo(b []byte) []byte {
|
|
return append(b, p...)
|
|
}
|
|
|
|
type selfHasherValueRecv struct {
|
|
emit uint64
|
|
}
|
|
|
|
func (s selfHasherValueRecv) Hash(h *hashx.Block512) {
|
|
h.HashUint64(s.emit)
|
|
}
|
|
|
|
type selfHasherPointerRecv struct {
|
|
emit uint64
|
|
}
|
|
|
|
func (s *selfHasherPointerRecv) Hash(h *hashx.Block512) {
|
|
h.HashUint64(s.emit)
|
|
}
|
|
|
|
func TestHash(t *testing.T) {
|
|
type tuple [2]any
|
|
type iface struct{ X any }
|
|
type scalars struct {
|
|
I8 int8
|
|
I16 int16
|
|
I32 int32
|
|
I64 int64
|
|
I int
|
|
U8 uint8
|
|
U16 uint16
|
|
U32 uint32
|
|
U64 uint64
|
|
U uint
|
|
UP uintptr
|
|
F32 float32
|
|
F64 float64
|
|
C64 complex64
|
|
C128 complex128
|
|
}
|
|
type MyBool bool
|
|
type MyHeader tar.Header
|
|
var zeroFloat64 float64
|
|
tests := []struct {
|
|
in tuple
|
|
wantEq bool
|
|
}{
|
|
{in: tuple{false, true}, wantEq: false},
|
|
{in: tuple{true, true}, wantEq: true},
|
|
{in: tuple{false, false}, wantEq: true},
|
|
{
|
|
in: tuple{
|
|
scalars{-8, -16, -32, -64, -1234, 8, 16, 32, 64, 1234, 5678, 32.32, 64.64, 32 + 32i, 64 + 64i},
|
|
scalars{-8, -16, -32, -64, -1234, 8, 16, 32, 64, 1234, 5678, 32.32, 64.64, 32 + 32i, 64 + 64i},
|
|
},
|
|
wantEq: true,
|
|
},
|
|
{in: tuple{scalars{I8: math.MinInt8}, scalars{I8: math.MinInt8 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{I16: math.MinInt16}, scalars{I16: math.MinInt16 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{I32: math.MinInt32}, scalars{I32: math.MinInt32 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{I64: math.MinInt64}, scalars{I64: math.MinInt64 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{I: -1234}, scalars{I: -1234 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{U8: math.MaxUint8}, scalars{U8: math.MaxUint8 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{U16: math.MaxUint16}, scalars{U16: math.MaxUint16 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{U32: math.MaxUint32}, scalars{U32: math.MaxUint32 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{U64: math.MaxUint64}, scalars{U64: math.MaxUint64 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{U: 1234}, scalars{U: 1234 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{UP: 5678}, scalars{UP: 5678 / 2}}, wantEq: false},
|
|
{in: tuple{scalars{F32: 32.32}, scalars{F32: math.Nextafter32(32.32, 0)}}, wantEq: false},
|
|
{in: tuple{scalars{F64: 64.64}, scalars{F64: math.Nextafter(64.64, 0)}}, wantEq: false},
|
|
{in: tuple{scalars{F32: float32(math.NaN())}, scalars{F32: float32(math.NaN())}}, wantEq: true},
|
|
{in: tuple{scalars{F64: float64(math.NaN())}, scalars{F64: float64(math.NaN())}}, wantEq: true},
|
|
{in: tuple{scalars{C64: 32 + 32i}, scalars{C64: complex(math.Nextafter32(32, 0), 32)}}, wantEq: false},
|
|
{in: tuple{scalars{C128: 64 + 64i}, scalars{C128: complex(math.Nextafter(64, 0), 64)}}, wantEq: false},
|
|
{in: tuple{[]int(nil), []int(nil)}, wantEq: true},
|
|
{in: tuple{[]int{}, []int(nil)}, wantEq: false},
|
|
{in: tuple{[]int{}, []int{}}, wantEq: true},
|
|
{in: tuple{[]string(nil), []string(nil)}, wantEq: true},
|
|
{in: tuple{[]string{}, []string(nil)}, wantEq: false},
|
|
{in: tuple{[]string{}, []string{}}, wantEq: true},
|
|
{in: tuple{[]appendBytes{{}, {0, 0, 0, 0, 0, 0, 0, 1}}, []appendBytes{{}, {0, 0, 0, 0, 0, 0, 0, 1}}}, wantEq: true},
|
|
{in: tuple{[]appendBytes{{}, {0, 0, 0, 0, 0, 0, 0, 1}}, []appendBytes{{0, 0, 0, 0, 0, 0, 0, 1}, {}}}, wantEq: false},
|
|
{in: tuple{iface{MyBool(true)}, iface{MyBool(true)}}, wantEq: true},
|
|
{in: tuple{iface{true}, iface{MyBool(true)}}, wantEq: false},
|
|
{in: tuple{iface{MyHeader{}}, iface{MyHeader{}}}, wantEq: true},
|
|
{in: tuple{iface{MyHeader{}}, iface{tar.Header{}}}, wantEq: false},
|
|
{in: tuple{iface{&MyHeader{}}, iface{&MyHeader{}}}, wantEq: true},
|
|
{in: tuple{iface{&MyHeader{}}, iface{&tar.Header{}}}, wantEq: false},
|
|
{in: tuple{iface{[]map[string]MyBool{}}, iface{[]map[string]MyBool{}}}, wantEq: true},
|
|
{in: tuple{iface{[]map[string]bool{}}, iface{[]map[string]MyBool{}}}, wantEq: false},
|
|
{in: tuple{zeroFloat64, -zeroFloat64}, wantEq: false}, // Issue 4883 (false alarm)
|
|
{in: tuple{[]any(nil), 0.0}, wantEq: false}, // Issue 4883
|
|
{in: tuple{[]any(nil), uint8(0)}, wantEq: false}, // Issue 4883
|
|
{in: tuple{nil, nil}, wantEq: true}, // Issue 4883
|
|
{
|
|
in: func() tuple {
|
|
i1 := 1
|
|
i2 := 2
|
|
v1 := [3]*int{&i1, &i2, &i1}
|
|
v2 := [3]*int{&i1, &i2, &i2}
|
|
return tuple{v1, v2}
|
|
}(),
|
|
wantEq: false,
|
|
},
|
|
{in: tuple{netip.Addr{}, netip.Addr{}}, wantEq: true},
|
|
{in: tuple{netip.Addr{}, netip.AddrFrom4([4]byte{})}, wantEq: false},
|
|
{in: tuple{netip.AddrFrom4([4]byte{}), netip.AddrFrom4([4]byte{})}, wantEq: true},
|
|
{in: tuple{netip.AddrFrom4([4]byte{192, 168, 0, 1}), netip.AddrFrom4([4]byte{192, 168, 0, 1})}, wantEq: true},
|
|
{in: tuple{netip.AddrFrom4([4]byte{192, 168, 0, 1}), netip.AddrFrom4([4]byte{192, 168, 0, 2})}, wantEq: false},
|
|
{in: tuple{netip.AddrFrom4([4]byte{}), netip.AddrFrom16([16]byte{})}, wantEq: false},
|
|
{in: tuple{netip.AddrFrom16([16]byte{}), netip.AddrFrom16([16]byte{})}, wantEq: true},
|
|
{in: tuple{netip.AddrPort{}, netip.AddrPort{}}, wantEq: true},
|
|
{in: tuple{netip.AddrPort{}, netip.AddrPortFrom(netip.AddrFrom4([4]byte{}), 0)}, wantEq: false},
|
|
{in: tuple{netip.AddrPortFrom(netip.AddrFrom4([4]byte{}), 0), netip.AddrPortFrom(netip.AddrFrom4([4]byte{}), 0)}, wantEq: true},
|
|
{in: tuple{netip.AddrPortFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1234), netip.AddrPortFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1234)}, wantEq: true},
|
|
{in: tuple{netip.AddrPortFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1234), netip.AddrPortFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1235)}, wantEq: false},
|
|
{in: tuple{netip.AddrPortFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1234), netip.AddrPortFrom(netip.AddrFrom4([4]byte{192, 168, 0, 2}), 1234)}, wantEq: false},
|
|
{in: tuple{netip.Prefix{}, netip.Prefix{}}, wantEq: true},
|
|
{in: tuple{netip.Prefix{}, netip.PrefixFrom(netip.Addr{}, 1)}, wantEq: true},
|
|
{in: tuple{netip.Prefix{}, netip.PrefixFrom(netip.AddrFrom4([4]byte{}), 0)}, wantEq: false},
|
|
{in: tuple{netip.PrefixFrom(netip.AddrFrom4([4]byte{}), 1), netip.PrefixFrom(netip.AddrFrom4([4]byte{}), 1)}, wantEq: true},
|
|
{in: tuple{netip.PrefixFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1), netip.PrefixFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1)}, wantEq: true},
|
|
{in: tuple{netip.PrefixFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1), netip.PrefixFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 0)}, wantEq: false},
|
|
{in: tuple{netip.PrefixFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), 1), netip.PrefixFrom(netip.AddrFrom4([4]byte{192, 168, 0, 2}), 1)}, wantEq: false},
|
|
{in: tuple{netipx.IPRange{}, netipx.IPRange{}}, wantEq: true},
|
|
{in: tuple{netipx.IPRange{}, netipx.IPRangeFrom(netip.AddrFrom4([4]byte{}), netip.AddrFrom16([16]byte{}))}, wantEq: false},
|
|
{in: tuple{netipx.IPRangeFrom(netip.AddrFrom4([4]byte{}), netip.AddrFrom16([16]byte{})), netipx.IPRangeFrom(netip.AddrFrom4([4]byte{}), netip.AddrFrom16([16]byte{}))}, wantEq: true},
|
|
{in: tuple{netipx.IPRangeFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), netip.AddrFrom4([4]byte{192, 168, 0, 100})), netipx.IPRangeFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), netip.AddrFrom4([4]byte{192, 168, 0, 100}))}, wantEq: true},
|
|
{in: tuple{netipx.IPRangeFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), netip.AddrFrom4([4]byte{192, 168, 0, 100})), netipx.IPRangeFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), netip.AddrFrom4([4]byte{192, 168, 0, 101}))}, wantEq: false},
|
|
{in: tuple{netipx.IPRangeFrom(netip.AddrFrom4([4]byte{192, 168, 0, 1}), netip.AddrFrom4([4]byte{192, 168, 0, 100})), netipx.IPRangeFrom(netip.AddrFrom4([4]byte{192, 168, 0, 2}), netip.AddrFrom4([4]byte{192, 168, 0, 100}))}, wantEq: false},
|
|
{in: tuple{key.DiscoPublic{}, key.DiscoPublic{}}, wantEq: true},
|
|
{in: tuple{key.DiscoPublic{}, key.DiscoPublicFromRaw32(mem.B(func() []byte {
|
|
b := make([]byte, 32)
|
|
b[0] = 1
|
|
return b
|
|
}()))}, wantEq: false},
|
|
{in: tuple{key.NodePublic{}, key.NodePublic{}}, wantEq: true},
|
|
{in: tuple{key.NodePublic{}, key.NodePublicFromRaw32(mem.B(func() []byte {
|
|
b := make([]byte, 32)
|
|
b[0] = 1
|
|
return b
|
|
}()))}, wantEq: false},
|
|
{in: tuple{&selfHasherPointerRecv{}, &selfHasherPointerRecv{}}, wantEq: true},
|
|
{in: tuple{(*selfHasherPointerRecv)(nil), (*selfHasherPointerRecv)(nil)}, wantEq: true},
|
|
{in: tuple{(*selfHasherPointerRecv)(nil), &selfHasherPointerRecv{}}, wantEq: false},
|
|
{in: tuple{&selfHasherPointerRecv{emit: 1}, &selfHasherPointerRecv{emit: 2}}, wantEq: false},
|
|
{in: tuple{selfHasherValueRecv{emit: 1}, selfHasherValueRecv{emit: 2}}, wantEq: false},
|
|
{in: tuple{selfHasherValueRecv{emit: 2}, selfHasherValueRecv{emit: 2}}, wantEq: true},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
gotEq := Hash(&tt.in[0]) == Hash(&tt.in[1])
|
|
if gotEq != tt.wantEq {
|
|
t.Errorf("(Hash(%T %v) == Hash(%T %v)) = %v, want %v", tt.in[0], tt.in[0], tt.in[1], tt.in[1], gotEq, tt.wantEq)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDeepHash(t *testing.T) {
|
|
// v contains the types of values we care about for our current callers.
|
|
// Mostly we're just testing that we don't panic on handled types.
|
|
v := getVal()
|
|
hash1 := Hash(v)
|
|
t.Logf("hash: %v", hash1)
|
|
for range 20 {
|
|
v := getVal()
|
|
hash2 := Hash(v)
|
|
if hash1 != hash2 {
|
|
t.Error("second hash didn't match")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tests that we actually hash map elements. Whoops.
|
|
func TestIssue4868(t *testing.T) {
|
|
m1 := map[int]string{1: "foo"}
|
|
m2 := map[int]string{1: "bar"}
|
|
if Hash(&m1) == Hash(&m2) {
|
|
t.Error("bogus")
|
|
}
|
|
}
|
|
|
|
func TestIssue4871(t *testing.T) {
|
|
m1 := map[string]string{"": "", "x": "foo"}
|
|
m2 := map[string]string{}
|
|
if h1, h2 := Hash(&m1), Hash(&m2); h1 == h2 {
|
|
t.Errorf("bogus: h1=%x, h2=%x", h1, h2)
|
|
}
|
|
}
|
|
|
|
func TestNilVsEmptymap(t *testing.T) {
|
|
m1 := map[string]string(nil)
|
|
m2 := map[string]string{}
|
|
if h1, h2 := Hash(&m1), Hash(&m2); h1 == h2 {
|
|
t.Errorf("bogus: h1=%x, h2=%x", h1, h2)
|
|
}
|
|
}
|
|
|
|
func TestMapFraming(t *testing.T) {
|
|
m1 := map[string]string{"foo": "", "fo": "o"}
|
|
m2 := map[string]string{}
|
|
if h1, h2 := Hash(&m1), Hash(&m2); h1 == h2 {
|
|
t.Errorf("bogus: h1=%x, h2=%x", h1, h2)
|
|
}
|
|
}
|
|
|
|
func TestQuick(t *testing.T) {
|
|
initSeed()
|
|
err := quick.Check(func(v, w map[string]string) bool {
|
|
return (Hash(&v) == Hash(&w)) == reflect.DeepEqual(v, w)
|
|
}, &quick.Config{MaxCount: 1000, Rand: rand.New(rand.NewSource(int64(seed)))})
|
|
if err != nil {
|
|
t.Fatalf("seed=%v, err=%v", seed, err)
|
|
}
|
|
}
|
|
|
|
type tailscaleTypes struct {
|
|
WGConfig *wgcfg.Config
|
|
RouterConfig *router.Config
|
|
MapFQDNAddrs map[dnsname.FQDN][]netip.Addr
|
|
MapFQDNAddrPorts map[dnsname.FQDN][]netip.AddrPort
|
|
MapDiscoPublics map[key.DiscoPublic]bool
|
|
MapResponse *tailcfg.MapResponse
|
|
FilterMatch filter.Match
|
|
}
|
|
|
|
func getVal() *tailscaleTypes {
|
|
return &tailscaleTypes{
|
|
&wgcfg.Config{
|
|
Name: "foo",
|
|
Addresses: []netip.Prefix{netip.PrefixFrom(netip.AddrFrom16([16]byte{3: 3}).Unmap(), 5)},
|
|
Peers: []wgcfg.Peer{
|
|
{
|
|
PublicKey: key.NodePublic{},
|
|
},
|
|
},
|
|
},
|
|
&router.Config{
|
|
Routes: []netip.Prefix{
|
|
netip.MustParsePrefix("1.2.3.0/24"),
|
|
netip.MustParsePrefix("1234::/64"),
|
|
},
|
|
},
|
|
map[dnsname.FQDN][]netip.Addr{
|
|
dnsname.FQDN("a."): {netip.MustParseAddr("1.2.3.4"), netip.MustParseAddr("4.3.2.1")},
|
|
dnsname.FQDN("b."): {netip.MustParseAddr("8.8.8.8"), netip.MustParseAddr("9.9.9.9")},
|
|
dnsname.FQDN("c."): {netip.MustParseAddr("6.6.6.6"), netip.MustParseAddr("7.7.7.7")},
|
|
dnsname.FQDN("d."): {netip.MustParseAddr("6.7.6.6"), netip.MustParseAddr("7.7.7.8")},
|
|
dnsname.FQDN("e."): {netip.MustParseAddr("6.8.6.6"), netip.MustParseAddr("7.7.7.9")},
|
|
dnsname.FQDN("f."): {netip.MustParseAddr("6.9.6.6"), netip.MustParseAddr("7.7.7.0")},
|
|
},
|
|
map[dnsname.FQDN][]netip.AddrPort{
|
|
dnsname.FQDN("a."): {netip.MustParseAddrPort("1.2.3.4:11"), netip.MustParseAddrPort("4.3.2.1:22")},
|
|
dnsname.FQDN("b."): {netip.MustParseAddrPort("8.8.8.8:11"), netip.MustParseAddrPort("9.9.9.9:22")},
|
|
dnsname.FQDN("c."): {netip.MustParseAddrPort("8.8.8.8:12"), netip.MustParseAddrPort("9.9.9.9:23")},
|
|
dnsname.FQDN("d."): {netip.MustParseAddrPort("8.8.8.8:13"), netip.MustParseAddrPort("9.9.9.9:24")},
|
|
dnsname.FQDN("e."): {netip.MustParseAddrPort("8.8.8.8:14"), netip.MustParseAddrPort("9.9.9.9:25")},
|
|
},
|
|
map[key.DiscoPublic]bool{
|
|
key.DiscoPublicFromRaw32(mem.B([]byte{1: 1, 31: 0})): true,
|
|
key.DiscoPublicFromRaw32(mem.B([]byte{1: 2, 31: 0})): false,
|
|
key.DiscoPublicFromRaw32(mem.B([]byte{1: 3, 31: 0})): true,
|
|
key.DiscoPublicFromRaw32(mem.B([]byte{1: 4, 31: 0})): false,
|
|
},
|
|
&tailcfg.MapResponse{
|
|
DERPMap: &tailcfg.DERPMap{
|
|
Regions: map[int]*tailcfg.DERPRegion{
|
|
1: {
|
|
RegionID: 1,
|
|
RegionCode: "foo",
|
|
Nodes: []*tailcfg.DERPNode{
|
|
{
|
|
Name: "n1",
|
|
RegionID: 1,
|
|
HostName: "foo.com",
|
|
},
|
|
{
|
|
Name: "n2",
|
|
RegionID: 1,
|
|
HostName: "bar.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
DNSConfig: &tailcfg.DNSConfig{
|
|
Resolvers: []*dnstype.Resolver{
|
|
{Addr: "10.0.0.1"},
|
|
},
|
|
},
|
|
PacketFilter: []tailcfg.FilterRule{
|
|
{
|
|
SrcIPs: []string{"1.2.3.4"},
|
|
DstPorts: []tailcfg.NetPortRange{
|
|
{
|
|
IP: "1.2.3.4/32",
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Peers: []*tailcfg.Node{
|
|
{
|
|
ID: 1,
|
|
},
|
|
{
|
|
ID: 2,
|
|
},
|
|
},
|
|
UserProfiles: []tailcfg.UserProfile{
|
|
{ID: 1, LoginName: "foo@bar.com"},
|
|
{ID: 2, LoginName: "bar@foo.com"},
|
|
},
|
|
},
|
|
filter.Match{
|
|
IPProto: views.SliceOf([]ipproto.Proto{1, 2, 3}),
|
|
},
|
|
}
|
|
}
|
|
|
|
type IntThenByte struct {
|
|
_ int
|
|
_ byte
|
|
}
|
|
|
|
type TwoInts struct{ _, _ int }
|
|
|
|
type IntIntByteInt struct {
|
|
i1, i2 int32
|
|
b byte // padding after
|
|
i3 int32
|
|
}
|
|
|
|
func u8(n uint8) string { return string([]byte{n}) }
|
|
func u32(n uint32) string { return string(binary.LittleEndian.AppendUint32(nil, n)) }
|
|
func u64(n uint64) string { return string(binary.LittleEndian.AppendUint64(nil, n)) }
|
|
func ux(n uint) string {
|
|
if bits.UintSize == 32 {
|
|
return u32(uint32(n))
|
|
} else {
|
|
return u64(uint64(n))
|
|
}
|
|
}
|
|
|
|
func TestGetTypeHasher(t *testing.T) {
|
|
switch runtime.GOARCH {
|
|
case "amd64", "arm64", "arm", "386", "riscv64":
|
|
default:
|
|
// Test outputs below are specifically for little-endian machines.
|
|
// Just skip everything else for now. Feel free to add more above if
|
|
// you have the hardware to test and it's little-endian.
|
|
t.Skipf("skipping on %v", runtime.GOARCH)
|
|
}
|
|
type typedString string
|
|
var (
|
|
someInt = int('A')
|
|
someComplex128 = complex128(1 + 2i)
|
|
someIP = netip.MustParseAddr("1.2.3.4")
|
|
)
|
|
tests := []struct {
|
|
name string
|
|
val any
|
|
out string
|
|
out32 string // overwrites out if 32-bit
|
|
}{
|
|
{
|
|
name: "int",
|
|
val: int(1),
|
|
out: ux(1),
|
|
},
|
|
{
|
|
name: "int_negative",
|
|
val: int(-1),
|
|
out: ux(math.MaxUint),
|
|
},
|
|
{
|
|
name: "int8",
|
|
val: int8(1),
|
|
out: "\x01",
|
|
},
|
|
{
|
|
name: "float64",
|
|
val: float64(1.0),
|
|
out: "\x00\x00\x00\x00\x00\x00\xf0?",
|
|
},
|
|
{
|
|
name: "float32",
|
|
val: float32(1.0),
|
|
out: "\x00\x00\x80?",
|
|
},
|
|
{
|
|
name: "string",
|
|
val: "foo",
|
|
out: "\x03\x00\x00\x00\x00\x00\x00\x00foo",
|
|
},
|
|
{
|
|
name: "typedString",
|
|
val: typedString("foo"),
|
|
out: "\x03\x00\x00\x00\x00\x00\x00\x00foo",
|
|
},
|
|
{
|
|
name: "string_slice",
|
|
val: []string{"foo", "bar"},
|
|
out: "\x01\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00foo\x03\x00\x00\x00\x00\x00\x00\x00bar",
|
|
},
|
|
{
|
|
name: "int_slice",
|
|
val: []int{1, 0, -1},
|
|
out: "\x01\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff",
|
|
out32: "\x01\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff",
|
|
},
|
|
{
|
|
name: "struct",
|
|
val: struct {
|
|
a, b int
|
|
c uint16
|
|
}{1, -1, 2},
|
|
out: "\x01\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00",
|
|
out32: "\x01\x00\x00\x00\xff\xff\xff\xff\x02\x00",
|
|
},
|
|
{
|
|
name: "nil_int_ptr",
|
|
val: (*int)(nil),
|
|
out: "\x00",
|
|
},
|
|
{
|
|
name: "int_ptr",
|
|
val: &someInt,
|
|
out: "\x01A\x00\x00\x00\x00\x00\x00\x00",
|
|
out32: "\x01A\x00\x00\x00",
|
|
},
|
|
{
|
|
name: "nil_uint32_ptr",
|
|
val: (*uint32)(nil),
|
|
out: "\x00",
|
|
},
|
|
{
|
|
name: "complex128_ptr",
|
|
val: &someComplex128,
|
|
out: "\x01\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@",
|
|
},
|
|
{
|
|
name: "packet_filter",
|
|
val: filterRules,
|
|
out: "\x01\x04\x00\x00\x00\x00\x00\x00\x00\x01\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00*\v\x00\x00\x00\x00\x00\x00\x0010.1.3.4/32\v\x00\x00\x00\x00\x00\x00\x0010.0.0.0/24\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x001.2.3.4/32\x01 \x00\x00\x00\x00\x00\x00\x00\x01\x00\x02\x00\x01\x04\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04!\x01\x01\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00foo\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00",
|
|
out32: "\x01\x04\x00\x00\x00\x00\x00\x00\x00\x01\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00*\v\x00\x00\x00\x00\x00\x00\x0010.1.3.4/32\v\x00\x00\x00\x00\x00\x00\x0010.0.0.0/24\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x001.2.3.4/32\x01 \x00\x00\x00\x01\x00\x02\x00\x01\x04\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04!\x01\x01\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00foo\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00",
|
|
},
|
|
{
|
|
name: "netip.Addr",
|
|
val: netip.MustParseAddr("fe80::123%foo"),
|
|
out: u64(16+3) + u64(0x80fe) + u64(0x2301<<48) + "foo",
|
|
},
|
|
{
|
|
name: "ptr-netip.Addr",
|
|
val: &someIP,
|
|
out: u8(1) + u64(4) + u32(0x04030201),
|
|
},
|
|
{
|
|
name: "ptr-nil-netip.Addr",
|
|
val: (*netip.Addr)(nil),
|
|
out: "\x00",
|
|
},
|
|
{
|
|
name: "time",
|
|
val: time.Unix(1234, 5678).In(time.UTC),
|
|
out: u64(1234) + u32(5678) + u32(0),
|
|
},
|
|
{
|
|
name: "time_ptr", // addressable, as opposed to "time" test above
|
|
val: ptr.To(time.Unix(1234, 5678).In(time.UTC)),
|
|
out: u8(1) + u64(1234) + u32(5678) + u32(0),
|
|
},
|
|
{
|
|
name: "time_ptr_via_unexported",
|
|
val: testtype.NewUnexportedAddressableTime(time.Unix(1234, 5678).In(time.UTC)),
|
|
out: u8(1) + u64(1234) + u32(5678) + u32(0),
|
|
},
|
|
{
|
|
name: "time_ptr_via_unexported_value",
|
|
val: *testtype.NewUnexportedAddressableTime(time.Unix(1234, 5678).In(time.UTC)),
|
|
out: u64(1234) + u32(5678) + u32(0),
|
|
},
|
|
{
|
|
name: "time_custom_zone",
|
|
val: time.Unix(1655311822, 0).In(time.FixedZone("FOO", -60*60)),
|
|
out: u64(1655311822) + u32(0) + u32(math.MaxUint32-60*60+1),
|
|
},
|
|
{
|
|
name: "time_nil",
|
|
val: (*time.Time)(nil),
|
|
out: "\x00",
|
|
},
|
|
{
|
|
name: "array_memhash",
|
|
val: [4]byte{1, 2, 3, 4},
|
|
out: "\x01\x02\x03\x04",
|
|
},
|
|
{
|
|
name: "array_ptr_memhash",
|
|
val: ptr.To([4]byte{1, 2, 3, 4}),
|
|
out: "\x01\x01\x02\x03\x04",
|
|
},
|
|
{
|
|
name: "ptr_to_struct_partially_memhashable",
|
|
val: &struct {
|
|
A int16
|
|
B int16
|
|
C *int
|
|
}{5, 6, nil},
|
|
out: "\x01\x05\x00\x06\x00\x00",
|
|
},
|
|
{
|
|
name: "struct_partially_memhashable_but_cant_addr",
|
|
val: struct {
|
|
A int16
|
|
B int16
|
|
C *int
|
|
}{5, 6, nil},
|
|
out: "\x05\x00\x06\x00\x00",
|
|
},
|
|
{
|
|
name: "array_elements",
|
|
val: [4]byte{1, 2, 3, 4},
|
|
out: "\x01\x02\x03\x04",
|
|
},
|
|
{
|
|
name: "bool",
|
|
val: true,
|
|
out: "\x01",
|
|
},
|
|
{
|
|
name: "IntIntByteInt",
|
|
val: IntIntByteInt{1, 2, 3, 4},
|
|
out: "\x01\x00\x00\x00\x02\x00\x00\x00\x03\x04\x00\x00\x00",
|
|
},
|
|
{
|
|
name: "IntIntByteInt-canaddr",
|
|
val: &IntIntByteInt{1, 2, 3, 4},
|
|
out: "\x01\x01\x00\x00\x00\x02\x00\x00\x00\x03\x04\x00\x00\x00",
|
|
},
|
|
{
|
|
name: "array-IntIntByteInt",
|
|
val: [2]IntIntByteInt{
|
|
{1, 2, 3, 4},
|
|
{5, 6, 7, 8},
|
|
},
|
|
out: "\x01\x00\x00\x00\x02\x00\x00\x00\x03\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\a\b\x00\x00\x00",
|
|
},
|
|
{
|
|
name: "array-IntIntByteInt-canaddr",
|
|
val: &[2]IntIntByteInt{
|
|
{1, 2, 3, 4},
|
|
{5, 6, 7, 8},
|
|
},
|
|
out: "\x01\x01\x00\x00\x00\x02\x00\x00\x00\x03\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\a\b\x00\x00\x00",
|
|
},
|
|
{
|
|
name: "tailcfg.Node",
|
|
val: &tailcfg.Node{},
|
|
out: "ANY", // magic value; just check it doesn't fail to hash
|
|
out32: "ANY",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
rv := reflect.ValueOf(tt.val)
|
|
va := reflect.New(rv.Type()).Elem()
|
|
va.Set(rv)
|
|
fn := lookupTypeHasher(va.Type())
|
|
hb := &hashBuffer{Hash: sha256.New()}
|
|
h := new(hasher)
|
|
h.Block512.Hash = hb
|
|
fn(h, pointerOf(va.Addr()))
|
|
const ptrSize = 32 << uintptr(^uintptr(0)>>63)
|
|
if tt.out32 != "" && ptrSize == 32 {
|
|
tt.out = tt.out32
|
|
}
|
|
h.sum()
|
|
if got := string(hb.B); got != tt.out && tt.out != "ANY" {
|
|
t.Fatalf("got %q; want %q", got, tt.out)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSliceCycle(t *testing.T) {
|
|
type S []S
|
|
c := qt.New(t)
|
|
|
|
a := make(S, 1) // cyclic graph of 1 node
|
|
a[0] = a
|
|
b := make(S, 1) // cyclic graph of 1 node
|
|
b[0] = b
|
|
ha := Hash(&a)
|
|
hb := Hash(&b)
|
|
c.Assert(ha, qt.Equals, hb)
|
|
|
|
c1 := make(S, 1) // cyclic graph of 2 nodes
|
|
c2 := make(S, 1) // cyclic graph of 2 nodes
|
|
c1[0] = c2
|
|
c2[0] = c1
|
|
hc1 := Hash(&c1)
|
|
hc2 := Hash(&c2)
|
|
c.Assert(hc1, qt.Equals, hc2)
|
|
c.Assert(ha, qt.Not(qt.Equals), hc1)
|
|
c.Assert(hb, qt.Not(qt.Equals), hc2)
|
|
|
|
c3 := make(S, 1) // graph of 1 node pointing to cyclic graph of 2 nodes
|
|
c3[0] = c1
|
|
hc3 := Hash(&c3)
|
|
c.Assert(hc1, qt.Not(qt.Equals), hc3)
|
|
|
|
c4 := make(S, 2) // cyclic graph of 3 nodes
|
|
c5 := make(S, 2) // cyclic graph of 3 nodes
|
|
c4[0] = nil
|
|
c4[1] = c4
|
|
c5[0] = c5
|
|
c5[1] = nil
|
|
hc4 := Hash(&c4)
|
|
hc5 := Hash(&c5)
|
|
c.Assert(hc4, qt.Not(qt.Equals), hc5) // cycle occurs through different indexes
|
|
}
|
|
|
|
func TestMapCycle(t *testing.T) {
|
|
type M map[string]M
|
|
c := qt.New(t)
|
|
|
|
a := make(M) // cyclic graph of 1 node
|
|
a["self"] = a
|
|
b := make(M) // cyclic graph of 1 node
|
|
b["self"] = b
|
|
ha := Hash(&a)
|
|
hb := Hash(&b)
|
|
c.Assert(ha, qt.Equals, hb)
|
|
|
|
c1 := make(M) // cyclic graph of 2 nodes
|
|
c2 := make(M) // cyclic graph of 2 nodes
|
|
c1["peer"] = c2
|
|
c2["peer"] = c1
|
|
hc1 := Hash(&c1)
|
|
hc2 := Hash(&c2)
|
|
c.Assert(hc1, qt.Equals, hc2)
|
|
c.Assert(ha, qt.Not(qt.Equals), hc1)
|
|
c.Assert(hb, qt.Not(qt.Equals), hc2)
|
|
|
|
c3 := make(M) // graph of 1 node pointing to cyclic graph of 2 nodes
|
|
c3["child"] = c1
|
|
hc3 := Hash(&c3)
|
|
c.Assert(hc1, qt.Not(qt.Equals), hc3)
|
|
|
|
c4 := make(M) // cyclic graph of 3 nodes
|
|
c5 := make(M) // cyclic graph of 3 nodes
|
|
c4["0"] = nil
|
|
c4["1"] = c4
|
|
c5["0"] = c5
|
|
c5["1"] = nil
|
|
hc4 := Hash(&c4)
|
|
hc5 := Hash(&c5)
|
|
c.Assert(hc4, qt.Not(qt.Equals), hc5) // cycle occurs through different keys
|
|
}
|
|
|
|
func TestPointerCycle(t *testing.T) {
|
|
type P *P
|
|
c := qt.New(t)
|
|
|
|
a := new(P) // cyclic graph of 1 node
|
|
*a = a
|
|
b := new(P) // cyclic graph of 1 node
|
|
*b = b
|
|
ha := Hash(&a)
|
|
hb := Hash(&b)
|
|
c.Assert(ha, qt.Equals, hb)
|
|
|
|
c1 := new(P) // cyclic graph of 2 nodes
|
|
c2 := new(P) // cyclic graph of 2 nodes
|
|
*c1 = c2
|
|
*c2 = c1
|
|
hc1 := Hash(&c1)
|
|
hc2 := Hash(&c2)
|
|
c.Assert(hc1, qt.Equals, hc2)
|
|
c.Assert(ha, qt.Not(qt.Equals), hc1)
|
|
c.Assert(hb, qt.Not(qt.Equals), hc2)
|
|
|
|
c3 := new(P) // graph of 1 node pointing to cyclic graph of 2 nodes
|
|
*c3 = c1
|
|
hc3 := Hash(&c3)
|
|
c.Assert(hc1, qt.Not(qt.Equals), hc3)
|
|
}
|
|
|
|
func TestInterfaceCycle(t *testing.T) {
|
|
type I struct{ v any }
|
|
c := qt.New(t)
|
|
|
|
a := new(I) // cyclic graph of 1 node
|
|
a.v = a
|
|
b := new(I) // cyclic graph of 1 node
|
|
b.v = b
|
|
ha := Hash(&a)
|
|
hb := Hash(&b)
|
|
c.Assert(ha, qt.Equals, hb)
|
|
|
|
c1 := new(I) // cyclic graph of 2 nodes
|
|
c2 := new(I) // cyclic graph of 2 nodes
|
|
c1.v = c2
|
|
c2.v = c1
|
|
hc1 := Hash(&c1)
|
|
hc2 := Hash(&c2)
|
|
c.Assert(hc1, qt.Equals, hc2)
|
|
c.Assert(ha, qt.Not(qt.Equals), hc1)
|
|
c.Assert(hb, qt.Not(qt.Equals), hc2)
|
|
|
|
c3 := new(I) // graph of 1 node pointing to cyclic graph of 2 nodes
|
|
c3.v = c1
|
|
hc3 := Hash(&c3)
|
|
c.Assert(hc1, qt.Not(qt.Equals), hc3)
|
|
}
|
|
|
|
var sink Sum
|
|
|
|
func BenchmarkHash(b *testing.B) {
|
|
b.ReportAllocs()
|
|
v := getVal()
|
|
for range b.N {
|
|
sink = Hash(v)
|
|
}
|
|
}
|
|
|
|
// filterRules is a packet filter that has both everything populated (in its
|
|
// first element) and also a few entries that are the typical shape for regular
|
|
// packet filters as sent to clients.
|
|
var filterRules = []tailcfg.FilterRule{
|
|
{
|
|
SrcIPs: []string{"*", "10.1.3.4/32", "10.0.0.0/24"},
|
|
DstPorts: []tailcfg.NetPortRange{{
|
|
IP: "1.2.3.4/32",
|
|
Bits: ptr.To(32),
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
}},
|
|
IPProto: []int{1, 2, 3, 4},
|
|
CapGrant: []tailcfg.CapGrant{{
|
|
Dsts: []netip.Prefix{netip.MustParsePrefix("1.2.3.4/32")},
|
|
Caps: []tailcfg.PeerCapability{"foo"},
|
|
}},
|
|
},
|
|
{
|
|
SrcIPs: []string{"foooooooooo"},
|
|
DstPorts: []tailcfg.NetPortRange{{
|
|
IP: "baaaaaarrrrr",
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
}},
|
|
},
|
|
{
|
|
SrcIPs: []string{"foooooooooo"},
|
|
DstPorts: []tailcfg.NetPortRange{{
|
|
IP: "baaaaaarrrrr",
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
}},
|
|
},
|
|
{
|
|
SrcIPs: []string{"foooooooooo"},
|
|
DstPorts: []tailcfg.NetPortRange{{
|
|
IP: "baaaaaarrrrr",
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
}},
|
|
},
|
|
}
|
|
|
|
func BenchmarkHashPacketFilter(b *testing.B) {
|
|
b.ReportAllocs()
|
|
|
|
for range b.N {
|
|
sink = Hash(&filterRules)
|
|
}
|
|
}
|
|
|
|
func TestHashMapAcyclic(t *testing.T) {
|
|
m := map[int]string{}
|
|
for i := range 100 {
|
|
m[i] = fmt.Sprint(i)
|
|
}
|
|
got := map[string]bool{}
|
|
|
|
hb := &hashBuffer{Hash: sha256.New()}
|
|
|
|
hash := lookupTypeHasher(reflect.TypeFor[map[int]string]())
|
|
for range 20 {
|
|
va := reflect.ValueOf(&m).Elem()
|
|
hb.Reset()
|
|
h := new(hasher)
|
|
h.Block512.Hash = hb
|
|
hash(h, pointerOf(va.Addr()))
|
|
h.sum()
|
|
if got[string(hb.B)] {
|
|
continue
|
|
}
|
|
got[string(hb.B)] = true
|
|
}
|
|
if len(got) != 1 {
|
|
t.Errorf("got %d results; want 1", len(got))
|
|
}
|
|
}
|
|
|
|
func TestPrintArray(t *testing.T) {
|
|
type T struct {
|
|
X [32]byte
|
|
}
|
|
x := T{X: [32]byte{1: 1, 31: 31}}
|
|
hb := &hashBuffer{Hash: sha256.New()}
|
|
h := new(hasher)
|
|
h.Block512.Hash = hb
|
|
va := reflect.ValueOf(&x).Elem()
|
|
hash := lookupTypeHasher(va.Type())
|
|
hash(h, pointerOf(va.Addr()))
|
|
h.sum()
|
|
const want = "\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f"
|
|
if got := hb.B; string(got) != want {
|
|
t.Errorf("wrong:\n got: %q\nwant: %q\n", got, want)
|
|
}
|
|
}
|
|
|
|
func BenchmarkHashMapAcyclic(b *testing.B) {
|
|
b.ReportAllocs()
|
|
m := map[int]string{}
|
|
for i := range 100 {
|
|
m[i] = fmt.Sprint(i)
|
|
}
|
|
|
|
hb := &hashBuffer{Hash: sha256.New()}
|
|
va := reflect.ValueOf(&m).Elem()
|
|
hash := lookupTypeHasher(va.Type())
|
|
|
|
h := new(hasher)
|
|
h.Block512.Hash = hb
|
|
|
|
for range b.N {
|
|
h.Reset()
|
|
hash(h, pointerOf(va.Addr()))
|
|
}
|
|
}
|
|
|
|
func BenchmarkTailcfgNode(b *testing.B) {
|
|
b.ReportAllocs()
|
|
|
|
node := new(tailcfg.Node)
|
|
for range b.N {
|
|
sink = Hash(node)
|
|
}
|
|
}
|
|
|
|
func TestExhaustive(t *testing.T) {
|
|
seen := make(map[Sum]bool)
|
|
for i := range 100000 {
|
|
s := Hash(&i)
|
|
if seen[s] {
|
|
t.Fatalf("hash collision %v", i)
|
|
}
|
|
seen[s] = true
|
|
}
|
|
}
|
|
|
|
// verify this doesn't loop forever, as it used to (Issue 2340)
|
|
func TestMapCyclicFallback(t *testing.T) {
|
|
type T struct {
|
|
M map[string]any
|
|
}
|
|
v := &T{
|
|
M: map[string]any{},
|
|
}
|
|
v.M["m"] = v.M
|
|
Hash(v)
|
|
}
|
|
|
|
func TestArrayAllocs(t *testing.T) {
|
|
if version.IsRace() {
|
|
t.Skip("skipping test under race detector")
|
|
}
|
|
|
|
// In theory, there should be no allocations. However, escape analysis on
|
|
// certain architectures fails to detect that certain cases do not escape.
|
|
// This discrepancy currently affects sha256.digest.Sum.
|
|
// Measure the number of allocations in sha256 to ensure that Hash does
|
|
// not allocate on top of its usage of sha256.
|
|
// See https://golang.org/issue/48055.
|
|
var b []byte
|
|
h := sha256.New()
|
|
want := int(testing.AllocsPerRun(1000, func() {
|
|
b = h.Sum(b[:0])
|
|
}))
|
|
switch runtime.GOARCH {
|
|
case "amd64", "arm64":
|
|
want = 0 // ensure no allocations on popular architectures
|
|
}
|
|
|
|
type T struct {
|
|
X [32]byte
|
|
}
|
|
x := &T{X: [32]byte{1: 1, 2: 2, 3: 3, 4: 4}}
|
|
got := int(testing.AllocsPerRun(1000, func() {
|
|
sink = Hash(x)
|
|
}))
|
|
if got > want {
|
|
t.Errorf("allocs = %v; want %v", got, want)
|
|
}
|
|
}
|
|
|
|
// Test for http://go/corp/6311 issue.
|
|
func TestHashThroughView(t *testing.T) {
|
|
type sshPolicyOut struct {
|
|
Rules []tailcfg.SSHRuleView
|
|
}
|
|
type mapResponseOut struct {
|
|
SSHPolicy *sshPolicyOut
|
|
}
|
|
// Just test we don't panic:
|
|
_ = Hash(&mapResponseOut{
|
|
SSHPolicy: &sshPolicyOut{
|
|
Rules: []tailcfg.SSHRuleView{
|
|
(&tailcfg.SSHRule{
|
|
RuleExpires: ptr.To(time.Unix(123, 0)),
|
|
}).View(),
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func BenchmarkHashArray(b *testing.B) {
|
|
b.ReportAllocs()
|
|
type T struct {
|
|
X [32]byte
|
|
}
|
|
x := &T{X: [32]byte{1: 1, 2: 2, 3: 3, 4: 4}}
|
|
|
|
for range b.N {
|
|
sink = Hash(x)
|
|
}
|
|
}
|
|
|
|
// hashBuffer is a hash.Hash that buffers all written data.
|
|
type hashBuffer struct {
|
|
hash.Hash
|
|
B []byte
|
|
}
|
|
|
|
func (h *hashBuffer) Write(b []byte) (int, error) {
|
|
n, err := h.Hash.Write(b)
|
|
h.B = append(h.B, b[:n]...)
|
|
return n, err
|
|
}
|
|
func (h *hashBuffer) Reset() {
|
|
h.Hash.Reset()
|
|
h.B = h.B[:0]
|
|
}
|
|
|
|
func FuzzTime(f *testing.F) {
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(0), false, "", 0)
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(0), true, "", 0)
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(0), true, "hello", 0)
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(0), true, "", 1234)
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(0), true, "hello", 1234)
|
|
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(1), false, "", 0)
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(1), true, "", 0)
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(1), true, "hello", 0)
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(1), true, "", 1234)
|
|
f.Add(int64(0), int64(0), false, "", 0, int64(0), int64(1), true, "hello", 1234)
|
|
|
|
f.Add(int64(math.MaxInt64), int64(math.MaxInt64), false, "", 0, int64(math.MaxInt64), int64(math.MaxInt64), false, "", 0)
|
|
f.Add(int64(math.MaxInt64), int64(math.MaxInt64), false, "", 0, int64(math.MaxInt64), int64(math.MaxInt64), true, "", 0)
|
|
f.Add(int64(math.MaxInt64), int64(math.MaxInt64), false, "", 0, int64(math.MaxInt64), int64(math.MaxInt64), true, "hello", 0)
|
|
f.Add(int64(math.MaxInt64), int64(math.MaxInt64), false, "", 0, int64(math.MaxInt64), int64(math.MaxInt64), true, "", 1234)
|
|
f.Add(int64(math.MaxInt64), int64(math.MaxInt64), false, "", 0, int64(math.MaxInt64), int64(math.MaxInt64), true, "hello", 1234)
|
|
|
|
f.Add(int64(math.MinInt64), int64(math.MinInt64), false, "", 0, int64(math.MinInt64), int64(math.MinInt64), false, "", 0)
|
|
f.Add(int64(math.MinInt64), int64(math.MinInt64), false, "", 0, int64(math.MinInt64), int64(math.MinInt64), true, "", 0)
|
|
f.Add(int64(math.MinInt64), int64(math.MinInt64), false, "", 0, int64(math.MinInt64), int64(math.MinInt64), true, "hello", 0)
|
|
f.Add(int64(math.MinInt64), int64(math.MinInt64), false, "", 0, int64(math.MinInt64), int64(math.MinInt64), true, "", 1234)
|
|
f.Add(int64(math.MinInt64), int64(math.MinInt64), false, "", 0, int64(math.MinInt64), int64(math.MinInt64), true, "hello", 1234)
|
|
|
|
f.Fuzz(func(t *testing.T,
|
|
s1, ns1 int64, loc1 bool, name1 string, off1 int,
|
|
s2, ns2 int64, loc2 bool, name2 string, off2 int,
|
|
) {
|
|
t1 := time.Unix(s1, ns1)
|
|
if loc1 {
|
|
_ = t1.In(time.FixedZone(name1, off1))
|
|
}
|
|
t2 := time.Unix(s2, ns2)
|
|
if loc2 {
|
|
_ = t2.In(time.FixedZone(name2, off2))
|
|
}
|
|
got := Hash(&t1) == Hash(&t2)
|
|
want := t1.Format(time.RFC3339Nano) == t2.Format(time.RFC3339Nano)
|
|
if got != want {
|
|
t.Errorf("time.Time(%s) == time.Time(%s) mismatches hash equivalent", t1.Format(time.RFC3339Nano), t2.Format(time.RFC3339Nano))
|
|
}
|
|
})
|
|
}
|
|
|
|
func FuzzAddr(f *testing.F) {
|
|
f.Fuzz(func(t *testing.T,
|
|
u1a, u1b uint64, zone1 string,
|
|
u2a, u2b uint64, zone2 string,
|
|
) {
|
|
var b1, b2 [16]byte
|
|
binary.LittleEndian.PutUint64(b1[:8], u1a)
|
|
binary.LittleEndian.PutUint64(b1[8:], u1b)
|
|
binary.LittleEndian.PutUint64(b2[:8], u2a)
|
|
binary.LittleEndian.PutUint64(b2[8:], u2b)
|
|
|
|
var ips [4]netip.Addr
|
|
ips[0] = netip.AddrFrom4(*(*[4]byte)(b1[:]))
|
|
ips[1] = netip.AddrFrom4(*(*[4]byte)(b2[:]))
|
|
ips[2] = netip.AddrFrom16(b1)
|
|
if zone1 != "" {
|
|
ips[2] = ips[2].WithZone(zone1)
|
|
}
|
|
ips[3] = netip.AddrFrom16(b2)
|
|
if zone2 != "" {
|
|
ips[3] = ips[2].WithZone(zone2)
|
|
}
|
|
|
|
for _, ip1 := range ips[:] {
|
|
for _, ip2 := range ips[:] {
|
|
got := Hash(&ip1) == Hash(&ip2)
|
|
want := ip1 == ip2
|
|
if got != want {
|
|
t.Errorf("netip.Addr(%s) == netip.Addr(%s) mismatches hash equivalent", ip1.String(), ip2.String())
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestAppendTo(t *testing.T) {
|
|
v := getVal()
|
|
h := Hash(v)
|
|
sum := h.AppendTo(nil)
|
|
|
|
if s := h.String(); s != string(sum) {
|
|
t.Errorf("hash sum mismatch; h.String()=%q h.AppendTo()=%q", s, string(sum))
|
|
}
|
|
}
|
|
|
|
func TestFilterFields(t *testing.T) {
|
|
type T struct {
|
|
A int
|
|
B int
|
|
C int
|
|
}
|
|
|
|
hashers := map[string]func(*T) Sum{
|
|
"all": HasherForType[T](),
|
|
"ac": HasherForType[T](IncludeFields[T]("A", "C")),
|
|
"b": HasherForType[T](ExcludeFields[T]("A", "C")),
|
|
}
|
|
|
|
tests := []struct {
|
|
hasher string
|
|
a, b T
|
|
wantEq bool
|
|
}{
|
|
{"all", T{1, 2, 3}, T{1, 2, 3}, true},
|
|
{"all", T{1, 2, 3}, T{0, 2, 3}, false},
|
|
{"all", T{1, 2, 3}, T{1, 0, 3}, false},
|
|
{"all", T{1, 2, 3}, T{1, 2, 0}, false},
|
|
|
|
{"ac", T{0, 0, 0}, T{0, 0, 0}, true},
|
|
{"ac", T{1, 0, 1}, T{1, 1, 1}, true},
|
|
{"ac", T{1, 1, 1}, T{1, 1, 0}, false},
|
|
|
|
{"b", T{0, 0, 0}, T{0, 0, 0}, true},
|
|
{"b", T{1, 0, 1}, T{1, 1, 1}, false},
|
|
{"b", T{1, 1, 1}, T{0, 1, 0}, true},
|
|
}
|
|
for _, tt := range tests {
|
|
f, ok := hashers[tt.hasher]
|
|
if !ok {
|
|
t.Fatalf("bad test: unknown hasher %q", tt.hasher)
|
|
}
|
|
sum1 := f(&tt.a)
|
|
sum2 := f(&tt.b)
|
|
got := sum1 == sum2
|
|
if got != tt.wantEq {
|
|
t.Errorf("hasher %q, for %+v and %v, got equal = %v; want %v", tt.hasher, tt.a, tt.b, got, tt.wantEq)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkAppendTo(b *testing.B) {
|
|
b.ReportAllocs()
|
|
v := getVal()
|
|
h := Hash(v)
|
|
|
|
hashBuf := make([]byte, 0, 100)
|
|
b.ResetTimer()
|
|
for range b.N {
|
|
hashBuf = h.AppendTo(hashBuf[:0])
|
|
}
|
|
}
|