From bd9a842cc6bbdd671e7078475612edd0316a3047 Mon Sep 17 00:00:00 2001 From: Jennifer Conner <2819667+phiryll@users.noreply.github.com> Date: Fri, 4 Jul 2025 17:30:29 -0700 Subject: [PATCH] Name key/value loop variables consistently. --- bench_test.go | 56 +++++++++++++++++++++--------------------- bounds_test.go | 12 ++++----- kv.go | 12 ++++----- kv_test.go | 62 +++++++++++++++++++++++------------------------ reference_test.go | 14 +++++------ 5 files changed, 78 insertions(+), 78 deletions(-) diff --git a/bench_test.go b/bench_test.go index 8d6ec48..05e6514 100644 --- a/bench_test.go +++ b/bench_test.go @@ -200,18 +200,18 @@ func BenchmarkChildBounds(b *testing.B) { b.Run(fmt.Sprintf("bounds=%s", tt.bounds), func(b *testing.B) { forward := tt.bounds reverse := From(tt.bounds.End).DownTo(tt.bounds.Begin) - for _, key := range tt.keys { - b.Run("key="+kv.KeyName(key), func(b *testing.B) { + for _, k := range tt.keys { + b.Run("key="+kv.KeyName(k), func(b *testing.B) { b.Run("dir=forward", func(b *testing.B) { b.ResetTimer() for range b.N { - kv.TestingChildBounds(forward, key) + kv.TestingChildBounds(forward, k) } }) b.Run("dir=reverse", func(b *testing.B) { b.ResetTimer() for range b.N { - kv.TestingChildBounds(reverse, key) + kv.TestingChildBounds(reverse, k) } }) }) @@ -253,12 +253,12 @@ func entriesFromFile(filename string) map[string]byte { func createPresent(entries map[string]byte, random *rand.Rand) []keySet { present := []keySet{} - for key := range entries { - keyLen := len(key) + for k := range entries { + keyLen := len(k) for i := len(present); i <= keyLen; i++ { present = append(present, keySet{}) } - present[keyLen] = append(present[keyLen], []byte(key)) + present[keyLen] = append(present[keyLen], []byte(k)) } for _, keys := range present { slices.SortFunc(keys, bytes.Compare) @@ -392,16 +392,16 @@ func TestBenchStoreConfigs(t *testing.T) { if i > 2 { assert.Len(t, config.absent[i], 1<<16) } - for _, key := range config.absent[i] { - assert.Len(t, key, i) - _, ok := present[string(key)] + for _, k := range config.absent[i] { + assert.Len(t, k, i) + _, ok := present[string(k)] assert.False(t, ok) } - for _, key := range config.present[i] { - assert.Len(t, key, i) - _, ok := present[string(key)] + for _, k := range config.present[i] { + assert.Len(t, k, i) + _, ok := present[string(k)] assert.True(t, ok) - delete(present, string(key)) + delete(present, string(k)) } } assert.Empty(t, present) @@ -465,8 +465,8 @@ func BenchmarkClone(b *testing.B) { func BenchmarkSparse(b *testing.B) { random := rand.New(rand.NewPCG(12337405, 432843980)) var keys keySet - for key := range 1 << 8 { - keyByte := byte(key) + for k := range 1 << 8 { + keyByte := byte(k) keys = append(keys, []byte{keyByte, keyByte, keyByte, keyByte}) } shuffle(keys, random) @@ -475,8 +475,8 @@ func BenchmarkSparse(b *testing.B) { b.ResetTimer() for range b.N { store := def.factory() - for _, key := range keys { - store.Set(key, 0) + for _, k := range keys { + store.Set(k, 0) } } }) @@ -490,16 +490,16 @@ func BenchmarkDense(b *testing.B) { oneKeys := make(keySet, 1<<8) twoKeys := make(keySet, 1<<16) threeKeys := make(keySet, 1<<24) - for key := range 1 << 8 { - oneKeys[key] = []byte{byte(key)} + for k := range 1 << 8 { + oneKeys[k] = []byte{byte(k)} } - for key := range 1 << 16 { - keyBytes := binary.LittleEndian.AppendUint16(nil, uint16(key)) - twoKeys[key] = []byte{keyBytes[0], keyBytes[1]} + for k := range 1 << 16 { + keyBytes := binary.LittleEndian.AppendUint16(nil, uint16(k)) + twoKeys[k] = []byte{keyBytes[0], keyBytes[1]} } - for key := range 1 << 24 { - keyBytes := binary.LittleEndian.AppendUint32(nil, uint32(key)) - threeKeys[key] = []byte{keyBytes[0], keyBytes[1], keyBytes[2]} + for k := range 1 << 24 { + keyBytes := binary.LittleEndian.AppendUint32(nil, uint32(k)) + threeKeys[k] = []byte{keyBytes[0], keyBytes[1], keyBytes[2]} } shuffle(oneKeys, random) shuffle(twoKeys, random) @@ -518,8 +518,8 @@ func BenchmarkDense(b *testing.B) { b.ResetTimer() for range b.N { store := def.factory() - for _, key := range tt.keys { - store.Set(key, 0) + for _, k := range tt.keys { + store.Set(k, 0) } } }) diff --git a/bounds_test.go b/bounds_test.go index afa8dd7..4d91703 100644 --- a/bounds_test.go +++ b/bounds_test.go @@ -217,16 +217,16 @@ func TestBoundsCompareKey(t *testing.T) { t.Run(tt.bounds.String(), func(t *testing.T) { t.Parallel() count := 0 - for _, key := range tt.before { - assert.Equal(t, -1, tt.bounds.CompareKey(key), "%s", kv.KeyName(key)) + for _, k := range tt.before { + assert.Equal(t, -1, tt.bounds.CompareKey(k), "%s", kv.KeyName(k)) count++ } - for _, key := range tt.within { - assert.Equal(t, 0, tt.bounds.CompareKey(key), "%s", kv.KeyName(key)) + for _, k := range tt.within { + assert.Equal(t, 0, tt.bounds.CompareKey(k), "%s", kv.KeyName(k)) count++ } - for _, key := range tt.after { - assert.Equal(t, +1, tt.bounds.CompareKey(key), "%s", kv.KeyName(key)) + for _, k := range tt.after { + assert.Equal(t, +1, tt.bounds.CompareKey(k), "%s", kv.KeyName(k)) count++ } }) diff --git a/kv.go b/kv.go index 6f45559..b732b2e 100644 --- a/kv.go +++ b/kv.go @@ -80,19 +80,19 @@ func indent(n int) string { func Fprint[V any](w io.Writer, seq iter.Seq2[[]byte, V]) (int, error) { n := 0 prevKey := []byte{} - for key, value := range seq { - limit := min(len(key), len(prevKey)) + for k, v := range seq { + limit := min(len(k), len(prevKey)) i := 0 - for i < limit && key[i] == prevKey[i] { + for i < limit && k[i] == prevKey[i] { i++ } - k, err := fmt.Fprintf(w, "%s%X: %v\n", indent(i), key[i:], value) - n += k + bytesWritten, err := fmt.Fprintf(w, "%s%X: %v\n", indent(i), k[i:], v) + n += bytesWritten if err != nil { //nolint:wrapcheck return n, err } - prevKey = key + prevKey = k } return n, nil } diff --git a/kv_test.go b/kv_test.go index 0340f3d..b37ac35 100644 --- a/kv_test.go +++ b/kv_test.go @@ -315,10 +315,10 @@ func createTestStoreConfigs() []*storeConfig { } // Every bit pattern of i defines which keys are present in that config. - for i := range 1 << len(testPresentKeys) { + for keyBits := range 1 << len(testPresentKeys) { config := storeConfig{ - fmt.Sprintf("sub-store=%0*b", len(testPresentKeys), i), - bits.OnesCount(uint(i)), + fmt.Sprintf("sub-store=%0*b", len(testPresentKeys), keyBits), + bits.OnesCount(uint(keyBits)), map[string]byte{}, make([]keySet, testMaxKeyLen+1), make([]keySet, testMaxKeyLen+1), @@ -326,19 +326,19 @@ func createTestStoreConfigs() []*storeConfig { reverse, } mask := 0x01 - for k, key := range testPresentKeys { - keyLen := len(key) - if i&mask != 0 { - config.entries[string(key)] = byte(k) - config.present[keyLen] = append(config.present[keyLen], key) + for i, k := range testPresentKeys { + keyLen := len(k) + if keyBits&mask != 0 { + config.entries[string(k)] = byte(i) + config.present[keyLen] = append(config.present[keyLen], k) } else { - config.absent[keyLen] = append(config.absent[keyLen], key) + config.absent[keyLen] = append(config.absent[keyLen], k) } mask <<= 1 } - for _, key := range testAbsentKeys { - keyLen := len(key) - config.absent[keyLen] = append(config.absent[keyLen], key) + for _, k := range testAbsentKeys { + keyLen := len(k) + config.absent[keyLen] = append(config.absent[keyLen], k) } result = append(result, &config) } @@ -414,11 +414,11 @@ func assertAbsent(t *testing.T, key []byte, store TestStore) { // and that Range(forward/reverse) returns them in the correct order. func assertSame(t *testing.T, entries map[string]byte, store TestStore) { sliceEntries := []entry{} - for key, expected := range entries { - actual, ok := store.Get([]byte(key)) + for k, expected := range entries { + actual, ok := store.Get([]byte(k)) assert.True(t, ok) assert.Equal(t, expected, actual) - sliceEntries = append(sliceEntries, entry{[]byte(key), expected}) + sliceEntries = append(sliceEntries, entry{[]byte(k), expected}) } slices.SortFunc(sliceEntries, cmpEntryForward) assert.Equal(t, sliceEntries, collect(store.Range(forwardAll))) @@ -578,23 +578,23 @@ func TestStores(t *testing.T) { // Build the store, testing along the way. store := test.def.factory() existing := map[string]byte{} - for key, value := range test.config.entries { - t.Run("op=set/key="+kv.KeyName([]byte(key)), func(t *testing.T) { - assertAbsent(t, []byte(key), store) + for k, v := range test.config.entries { + t.Run("op=set/key="+kv.KeyName([]byte(k)), func(t *testing.T) { + assertAbsent(t, []byte(k), store) assertSame(t, existing, store) - actual, ok := store.Set([]byte(key), value) + actual, ok := store.Set([]byte(k), v) assert.False(t, ok) assert.Equal(t, zero, actual) - existing[key] = value + existing[k] = v assertSame(t, existing, store) }) } for _, keys := range test.config.absent { - for _, key := range keys { - t.Run("op=absent/key="+kv.KeyName(key), func(t *testing.T) { - assertAbsent(t, key, store) + for _, k := range keys { + t.Run("op=absent/key="+kv.KeyName(k), func(t *testing.T) { + assertAbsent(t, k, store) }) } } @@ -643,26 +643,26 @@ func TestClone(t *testing.T) { assertSame(t, test.config.entries, store) // mutate the clone and test that original hasn't changed - for key := range test.config.entries { - store.Delete([]byte(key)) + for k := range test.config.entries { + store.Delete([]byte(k)) } assertSame(t, map[string]byte{}, store) for _, keys := range test.config.absent { - for i, key := range keys { - store.Set(key, byte(i)) + for i, k := range keys { + store.Set(k, byte(i)) } } assertSame(t, test.config.entries, original) // mutate the original and test that the clone hasn't changed store = original.Clone() - for key := range test.config.entries { - original.Delete([]byte(key)) + for k := range test.config.entries { + original.Delete([]byte(k)) } assertSame(t, map[string]byte{}, original) for _, keys := range test.config.absent { - for i, key := range keys { - original.Set(key, byte(i)) + for i, k := range keys { + original.Set(k, byte(i)) } } assertSame(t, test.config.entries, store) diff --git a/reference_test.go b/reference_test.go index 400b5aa..5066c4a 100644 --- a/reference_test.go +++ b/reference_test.go @@ -69,9 +69,9 @@ func (r reference) Range(bounds *Bounds) iter.Seq2[[]byte, byte] { bounds = bounds.Clone() return func(yield func([]byte, byte) bool) { var keys []string - for key := range r { - if bounds.CompareKey([]byte(key)) == 0 { - keys = append(keys, key) + for k := range r { + if bounds.CompareKey([]byte(k)) == 0 { + keys = append(keys, k) } } if bounds.IsReverse { @@ -79,8 +79,8 @@ func (r reference) Range(bounds *Bounds) iter.Seq2[[]byte, byte] { } else { slices.Sort(keys) } - for _, key := range keys { - if !yield([]byte(key), r[key]) { + for _, k := range keys { + if !yield([]byte(k), r[k]) { return } } @@ -90,8 +90,8 @@ func (r reference) Range(bounds *Bounds) iter.Seq2[[]byte, byte] { func (r reference) String() string { var s strings.Builder s.WriteString("{") - for _, key := range slices.Sorted(maps.Keys(r)) { - fmt.Fprintf(&s, "%s:%v, ", kv.KeyName([]byte(key)), r[key]) + for _, k := range slices.Sorted(maps.Keys(r)) { + fmt.Fprintf(&s, "%s:%v, ", kv.KeyName([]byte(k)), r[k]) } s.WriteString("}") return s.String()