Skip to content

Name key/value loop variables consistently. #33

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
phiryll merged 1 commit into from
Jul 5, 2025
Merged

Name key/value loop variables consistently. #33

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
56 changes: 28 additions & 28 deletions bench_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)
}
})
})
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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)
Expand All @@ -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)
}
}
})
Expand All @@ -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)
Expand All @@ -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)
}
}
})
Expand Down
12 changes: 6 additions & 6 deletions bounds_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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++
}
})
Expand Down
12 changes: 6 additions & 6 deletions kv.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
}
Expand Down
62 changes: 31 additions & 31 deletions kv_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -315,30 +315,30 @@ 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),
forward,
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)
}
Expand Down Expand Up @@ -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)))
Expand Down Expand Up @@ -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)
})
}
}
Expand Down Expand Up @@ -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)
Expand Down
14 changes: 7 additions & 7 deletions reference_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -69,18 +69,18 @@ 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 {
slices.SortFunc(keys, negCompare)
} 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
}
}
Expand All @@ -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()
Expand Down