mirror of
https://github.com/tailscale/tailscale.git
synced 2025-08-11 21:27:31 +00:00
all: use Go 1.22 range-over-int
Updates #11058 Change-Id: I35e7ef9b90e83cac04ca93fd964ad00ed5b48430 Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
This commit is contained in:

committed by
Brad Fitzpatrick

parent
068db1f972
commit
7c1d6e35a5
@@ -18,7 +18,7 @@ import (
|
||||
|
||||
func TestInversePrefix(t *testing.T) {
|
||||
t.Parallel()
|
||||
for i := 0; i < 256; i++ {
|
||||
for i := range 256 {
|
||||
for len := 0; len < 9; len++ {
|
||||
addr := i & (0xFF << (8 - len))
|
||||
idx := prefixIndex(uint8(addr), len)
|
||||
@@ -32,7 +32,7 @@ func TestInversePrefix(t *testing.T) {
|
||||
|
||||
func TestHostIndex(t *testing.T) {
|
||||
t.Parallel()
|
||||
for i := 0; i < 256; i++ {
|
||||
for i := range 256 {
|
||||
got := hostIndex(uint8(i))
|
||||
want := prefixIndex(uint8(i), 8)
|
||||
if got != want {
|
||||
@@ -63,7 +63,7 @@ func TestStrideTableInsert(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
for i := 0; i < 256; i++ {
|
||||
for i := range 256 {
|
||||
addr := uint8(i)
|
||||
slowVal, slowOK := slow.get(addr)
|
||||
fastVal, fastOK := fast.get(addr)
|
||||
@@ -103,7 +103,7 @@ func TestStrideTableInsertShuffled(t *testing.T) {
|
||||
|
||||
// Order of insertion should not affect the final shape of the stride table.
|
||||
routes2 := append([]slowEntry[int](nil), routes...) // dup so we can print both slices on fail
|
||||
for i := 0; i < 100; i++ {
|
||||
for range 100 {
|
||||
rand.Shuffle(len(routes2), func(i, j int) { routes2[i], routes2[j] = routes2[j], routes2[i] })
|
||||
rt2 := strideTable[int]{}
|
||||
for _, route := range routes2 {
|
||||
@@ -152,7 +152,7 @@ func TestStrideTableDelete(t *testing.T) {
|
||||
t.Fatalf("slowTable has %d entries after deletes, want 50", cnt)
|
||||
}
|
||||
|
||||
for i := 0; i < 256; i++ {
|
||||
for i := range 256 {
|
||||
addr := uint8(i)
|
||||
slowVal, slowOK := slow.get(addr)
|
||||
fastVal, fastOK := fast.get(addr)
|
||||
@@ -188,7 +188,7 @@ func TestStrideTableDeleteShuffle(t *testing.T) {
|
||||
|
||||
// Order of deletion should not affect the final shape of the stride table.
|
||||
toDelete2 := append([]slowEntry[int](nil), toDelete...) // dup so we can print both slices on fail
|
||||
for i := 0; i < 100; i++ {
|
||||
for range 100 {
|
||||
rand.Shuffle(len(toDelete2), func(i, j int) { toDelete2[i], toDelete2[j] = toDelete2[j], toDelete2[i] })
|
||||
rt2 := strideTable[int]{}
|
||||
for _, route := range routes {
|
||||
@@ -262,7 +262,7 @@ func forStrideCountAndOrdering(b *testing.B, fn func(b *testing.B, routes []slow
|
||||
func BenchmarkStrideTableInsertion(b *testing.B) {
|
||||
forStrideCountAndOrdering(b, func(b *testing.B, routes []slowEntry[int]) {
|
||||
val := 0
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
var rt strideTable[int]
|
||||
for _, route := range routes {
|
||||
rt.insert(route.addr, route.len, val)
|
||||
@@ -285,7 +285,7 @@ func BenchmarkStrideTableDeletion(b *testing.B) {
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
rt2 := rt
|
||||
for _, route := range routes {
|
||||
rt2.delete(route.addr, route.len)
|
||||
@@ -311,7 +311,7 @@ func BenchmarkStrideTableGet(b *testing.B) {
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for i := range b.N {
|
||||
writeSink, _ = rt.get(uint8(i))
|
||||
}
|
||||
gets := float64(b.N)
|
||||
|
@@ -594,7 +594,7 @@ func TestInsertCompare(t *testing.T) {
|
||||
|
||||
seenVals4 := map[int]bool{}
|
||||
seenVals6 := map[int]bool{}
|
||||
for i := 0; i < 10_000; i++ {
|
||||
for range 10_000 {
|
||||
a := randomAddr()
|
||||
slowVal, slowOK := slow.get(a)
|
||||
fastVal, fastOK := fast.Get(a)
|
||||
@@ -644,12 +644,12 @@ func TestInsertShuffled(t *testing.T) {
|
||||
}
|
||||
}()
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
for range 10 {
|
||||
pfxs2 := append([]slowPrefixEntry[int](nil), pfxs...)
|
||||
rand.Shuffle(len(pfxs2), func(i, j int) { pfxs2[i], pfxs2[j] = pfxs2[j], pfxs2[i] })
|
||||
|
||||
addrs := make([]netip.Addr, 0, 10_000)
|
||||
for i := 0; i < 10_000; i++ {
|
||||
for range 10_000 {
|
||||
addrs = append(addrs, randomAddr())
|
||||
}
|
||||
|
||||
@@ -723,7 +723,7 @@ func TestDeleteCompare(t *testing.T) {
|
||||
|
||||
seenVals4 := map[int]bool{}
|
||||
seenVals6 := map[int]bool{}
|
||||
for i := 0; i < numProbes; i++ {
|
||||
for range numProbes {
|
||||
a := randomAddr()
|
||||
slowVal, slowOK := slow.get(a)
|
||||
fastVal, fastOK := fast.Get(a)
|
||||
@@ -789,7 +789,7 @@ func TestDeleteShuffled(t *testing.T) {
|
||||
rt.Delete(pfx.pfx)
|
||||
}
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
for range 10 {
|
||||
pfxs2 := append([]slowPrefixEntry[int](nil), pfxs...)
|
||||
toDelete2 := append([]slowPrefixEntry[int](nil), toDelete...)
|
||||
rand.Shuffle(len(toDelete2), func(i, j int) { toDelete2[i], toDelete2[j] = toDelete2[j], toDelete2[i] })
|
||||
@@ -806,7 +806,7 @@ func TestDeleteShuffled(t *testing.T) {
|
||||
|
||||
// Diffing a deep tree of tables gives cmp.Diff a nervous breakdown, so
|
||||
// test for equivalence statistically with random probes instead.
|
||||
for i := 0; i < numProbes; i++ {
|
||||
for range numProbes {
|
||||
a := randomAddr()
|
||||
val1, ok1 := rt.Get(a)
|
||||
val2, ok2 := rt2.Get(a)
|
||||
@@ -909,7 +909,7 @@ func BenchmarkTableInsertion(b *testing.B) {
|
||||
var startMem, endMem runtime.MemStats
|
||||
runtime.ReadMemStats(&startMem)
|
||||
b.StartTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
var rt Table[int]
|
||||
for _, route := range routes {
|
||||
rt.Insert(route.pfx, route.val)
|
||||
@@ -944,7 +944,7 @@ func BenchmarkTableDelete(b *testing.B) {
|
||||
|
||||
var t runningTimer
|
||||
allocs, bytes := getMemCost(func() {
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
var rt Table[int]
|
||||
for _, route := range routes {
|
||||
rt.Insert(route.pfx, route.val)
|
||||
@@ -983,7 +983,7 @@ func BenchmarkTableGet(b *testing.B) {
|
||||
// cost is 16 bytes - presumably due to some amortized costs in
|
||||
// the memory allocator? Either way, empirically 100 iterations
|
||||
// reliably reports the correct cost.
|
||||
for i := 0; i < 100; i++ {
|
||||
for range 100 {
|
||||
_ = genAddr()
|
||||
}
|
||||
})
|
||||
@@ -991,7 +991,7 @@ func BenchmarkTableGet(b *testing.B) {
|
||||
addrBytes /= 100
|
||||
var t runningTimer
|
||||
allocs, bytes := getMemCost(func() {
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
addr := genAddr()
|
||||
t.Start()
|
||||
writeSink, _ = rt.Get(addr)
|
||||
|
@@ -169,7 +169,7 @@ func Benchmark(b *testing.B) {
|
||||
p := testPacketV4(ipproto.UDP, [4]byte{192, 168, 0, 1}, [4]byte{192, 168, 0, 2}, 123, 456, 789)
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
s := NewStatistics(0, 0, nil)
|
||||
for j := 0; j < 1e3; j++ {
|
||||
s.UpdateTxVirtual(p)
|
||||
@@ -180,7 +180,7 @@ func Benchmark(b *testing.B) {
|
||||
p := testPacketV4(ipproto.UDP, [4]byte{}, [4]byte{}, 0, 0, 789)
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
s := NewStatistics(0, 0, nil)
|
||||
for j := 0; j < 1e3; j++ {
|
||||
binary.BigEndian.PutUint32(p[20:], uint32(j)) // unique port combination
|
||||
@@ -192,7 +192,7 @@ func Benchmark(b *testing.B) {
|
||||
p := testPacketV4(ipproto.UDP, [4]byte{192, 168, 0, 1}, [4]byte{192, 168, 0, 2}, 123, 456, 789)
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
s := NewStatistics(0, 0, nil)
|
||||
var group sync.WaitGroup
|
||||
for j := 0; j < runtime.NumCPU(); j++ {
|
||||
@@ -214,7 +214,7 @@ func Benchmark(b *testing.B) {
|
||||
}
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
s := NewStatistics(0, 0, nil)
|
||||
var group sync.WaitGroup
|
||||
for j := 0; j < runtime.NumCPU(); j++ {
|
||||
|
@@ -115,7 +115,7 @@ func TestDNSOverTCP(t *testing.T) {
|
||||
}
|
||||
|
||||
results := map[dnsname.FQDN]string{}
|
||||
for i := 0; i < len(wantResults); i++ {
|
||||
for range len(wantResults) {
|
||||
var respLength uint16
|
||||
if err := binary.Read(c, binary.BigEndian, &respLength); err != nil {
|
||||
t.Fatalf("reading len: %v", err)
|
||||
|
@@ -198,7 +198,7 @@ func (m *windowsManager) setHosts(hosts []*HostEntry) error {
|
||||
|
||||
// This can fail spuriously with an access denied error, so retry it a
|
||||
// few times.
|
||||
for i := 0; i < 5; i++ {
|
||||
for range 5 {
|
||||
if err = atomicfile.WriteFile(hostsFile, outB, fileMode); err == nil {
|
||||
return nil
|
||||
}
|
||||
|
@@ -613,7 +613,7 @@ func TestRecursionLimit(t *testing.T) {
|
||||
// Fill out a CNAME chain equal to our recursion limit; we won't get
|
||||
// this far since each CNAME is more than 1 level "deep", but this
|
||||
// ensures that we have more than the limit.
|
||||
for i := 0; i < maxDepth+1; i++ {
|
||||
for i := range maxDepth + 1 {
|
||||
curr := fmt.Sprintf("%d-tailscale.com.", i)
|
||||
|
||||
tailscaleNameservers := &dns.Msg{
|
||||
|
@@ -67,7 +67,7 @@ func (fl *fwdLog) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
fmt.Fprintf(w, "<html><h1>DNS forwards</h1>")
|
||||
now := time.Now()
|
||||
for i := 0; i < len(fl.ent); i++ {
|
||||
for i := range len(fl.ent) {
|
||||
ent := fl.ent[(i+fl.pos)%len(fl.ent)]
|
||||
if ent.Domain == "" {
|
||||
continue
|
||||
|
@@ -199,7 +199,7 @@ func BenchmarkNameFromQuery(b *testing.B) {
|
||||
}
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
_, err := nameFromQuery(msg)
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
@@ -413,7 +413,7 @@ func makeLargeResponse(tb testing.TB, domain string) (request, response []byte)
|
||||
Class: dns.ClassINET,
|
||||
})
|
||||
builder.StartAnswers()
|
||||
for i := 0; i < 120; i++ {
|
||||
for i := range 120 {
|
||||
builder.AResource(dns.ResourceHeader{
|
||||
Name: name,
|
||||
Class: dns.ClassINET,
|
||||
|
@@ -976,7 +976,7 @@ func BenchmarkFull(b *testing.B) {
|
||||
for _, tt := range tests {
|
||||
b.Run(tt.name, func(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
syncRespond(r, tt.request)
|
||||
}
|
||||
})
|
||||
|
@@ -103,7 +103,7 @@ func likelyHomeRouterIPDarwinExec() (ret netip.Addr, netif string, ok bool) {
|
||||
|
||||
func TestFetchRoutingTable(t *testing.T) {
|
||||
// Issue 1345: this used to be flaky on darwin.
|
||||
for i := 0; i < 20; i++ {
|
||||
for range 20 {
|
||||
_, err := fetchRoutingTable()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
|
@@ -97,7 +97,7 @@ func TestAwsAppRunnerDefaultRouteInterface(t *testing.T) {
|
||||
|
||||
func BenchmarkDefaultRouteInterface(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
if _, err := DefaultRouteInterface(); err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@ import "testing"
|
||||
|
||||
func BenchmarkGetPACWindows(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for i := range b.N {
|
||||
v := getPACWindows()
|
||||
if i == 0 {
|
||||
b.Logf("Got: %q", v)
|
||||
|
@@ -512,7 +512,7 @@ func BenchmarkDecode(b *testing.B) {
|
||||
for _, bench := range benches {
|
||||
b.Run(bench.name, func(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
var p Parsed
|
||||
p.Decode(bench.buf)
|
||||
}
|
||||
@@ -624,7 +624,7 @@ func BenchmarkString(b *testing.B) {
|
||||
var p Parsed
|
||||
p.Decode(bench.buf)
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
sinkString = p.String()
|
||||
}
|
||||
})
|
||||
|
@@ -21,7 +21,7 @@ func TestCreateOrGetMapping(t *testing.T) {
|
||||
c := NewClient(t.Logf, nil, nil, new(controlknobs.Knobs), nil)
|
||||
defer c.Close()
|
||||
c.SetLocalPort(1234)
|
||||
for i := 0; i < 2; i++ {
|
||||
for i := range 2 {
|
||||
if i > 0 {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
@@ -36,7 +36,7 @@ func TestClientProbe(t *testing.T) {
|
||||
}
|
||||
c := NewClient(t.Logf, nil, nil, new(controlknobs.Knobs), nil)
|
||||
defer c.Close()
|
||||
for i := 0; i < 3; i++ {
|
||||
for i := range 3 {
|
||||
if i > 0 {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
|
@@ -597,7 +597,7 @@ func TestGetUPnPPortMapping(t *testing.T) {
|
||||
firstResponse netip.AddrPort
|
||||
prevPort uint16
|
||||
)
|
||||
for i := 0; i < 2; i++ {
|
||||
for i := range 2 {
|
||||
sawRequestWithLease.Store(false)
|
||||
res, err := c.Probe(ctx)
|
||||
if err != nil {
|
||||
|
@@ -62,7 +62,7 @@ func TestRadioMonitor(t *testing.T) {
|
||||
"400 iterations: 2 sec active, 1 min idle",
|
||||
func(tt *testTime, rm *radioMonitor) {
|
||||
// 400 iterations to ensure values loop back around rm.usage array
|
||||
for i := 0; i < 400; i++ {
|
||||
for range 400 {
|
||||
rm.active()
|
||||
tt.Add(1 * time.Second)
|
||||
rm.active()
|
||||
|
@@ -76,7 +76,7 @@ func BenchmarkServerSTUN(b *testing.B) {
|
||||
|
||||
tx := stun.NewTxID()
|
||||
req := stun.Request(tx)
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
if _, err := cc.WriteToUDP(req, addr); err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
|
@@ -45,7 +45,7 @@ func TestRTT(t *testing.T) {
|
||||
// Write a bunch of data to the conn to force TCP session establishment
|
||||
// and a few packets.
|
||||
junkData := bytes.Repeat([]byte("hello world\n"), 1024*1024)
|
||||
for i := 0; i < 10; i++ {
|
||||
for i := range 10 {
|
||||
if _, err := conn.Write(junkData); err != nil {
|
||||
t.Fatalf("error writing junk data [%d]: %v", i, err)
|
||||
}
|
||||
|
@@ -99,7 +99,7 @@ var sinkIP netip.Addr
|
||||
|
||||
func BenchmarkTailscaleServiceAddr(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
sinkIP = TailscaleServiceIP()
|
||||
}
|
||||
}
|
||||
|
@@ -64,7 +64,7 @@ func TestProxyFromEnvironment_setNoProxyUntil(t *testing.T) {
|
||||
os.Setenv("HTTPS_PROXY", fakeProxyEnv)
|
||||
|
||||
req := &http.Request{URL: must.Get(url.Parse("https://example.com/"))}
|
||||
for i := 0; i < 3; i++ {
|
||||
for i := range 3 {
|
||||
switch i {
|
||||
case 1:
|
||||
setNoProxyUntil(time.Minute)
|
||||
|
@@ -222,7 +222,7 @@ func TestReadAndInject(t *testing.T) {
|
||||
var seen = make(map[string]bool)
|
||||
sizes := make([]int, 1)
|
||||
// We expect the same packets back, in no particular order.
|
||||
for i := 0; i < len(written)+len(injected); i++ {
|
||||
for i := range len(written) + len(injected) {
|
||||
packet := buf[:]
|
||||
buffs := [][]byte{packet}
|
||||
numPackets, err := tun.Read(buffs, sizes, 0)
|
||||
@@ -283,7 +283,7 @@ func TestWriteAndInject(t *testing.T) {
|
||||
|
||||
seen := make(map[string]bool)
|
||||
// We expect the same packets back, in no particular order.
|
||||
for i := 0; i < len(written)+len(injected); i++ {
|
||||
for i := range len(written) + len(injected) {
|
||||
packet := <-chtun.Inbound
|
||||
got := string(packet)
|
||||
t.Logf("read %d: got %s", i, got)
|
||||
@@ -470,7 +470,7 @@ func BenchmarkWrite(b *testing.B) {
|
||||
defer tun.Close()
|
||||
|
||||
packet := [][]byte{udp4("5.6.7.8", "1.2.3.4", 89, 89)}
|
||||
for i := 0; i < b.N; i++ {
|
||||
for range b.N {
|
||||
_, err := ftun.Write(packet, 0)
|
||||
if err != nil {
|
||||
b.Errorf("err = %v; want nil", err)
|
||||
@@ -902,7 +902,7 @@ func TestCaptureHook(t *testing.T) {
|
||||
pkt: []byte("InjectOutboundPacketBuffer"),
|
||||
},
|
||||
}
|
||||
for i := 0; i < len(want); i++ {
|
||||
for i := range len(want) {
|
||||
want[i].now = now
|
||||
}
|
||||
if !reflect.DeepEqual(captured, want) {
|
||||
|
Reference in New Issue
Block a user