lint

Author: Thomas Stromberg

benchmarks/benchmark_comparison_test.go

@@ -31,7 +31,7 @@ func generateWorkload(n int) []string {
 	keys := make([]string, n)
 	oneHitIndex := 0
 
-	for i := 0; i < n; i++ {
+	for i := range n {
 		if i%4 == 0 {
 			// 25% one-hit wonders (cache pollution)
 			idx := oneHitIndex % oneHitWonders
@@ -58,10 +58,12 @@ func BenchmarkHitRate_bdcache(b *testing.B) {
 	workload := generateWorkload(totalOps)
 
 	// Warmup phase - not measured
-	for i := 0; i < 50000; i++ {
+	for i := range 50000 {
 		key := workload[i]
-		if _, found, _ := cache.Get(ctx, key); !found {
-			_ = cache.Set(ctx, key, i, 0)
+		if _, found, err := cache.Get(ctx, key); err == nil && !found {
+			if err := cache.Set(ctx, key, i, 0); err != nil {
+				b.Fatalf("Set failed: %v", err)
+			}
 		}
 	}
 
@@ -70,14 +72,17 @@ func BenchmarkHitRate_bdcache(b *testing.B) {
 	misses := 0
 
 	b.ResetTimer()
+	//nolint:intrange // b.N is dynamic and cannot use range
 	for i := 0; i < b.N; i++ {
 		key := workload[50000+i]
 
-		if _, found, _ := cache.Get(ctx, key); found {
+		if _, found, err := cache.Get(ctx, key); err == nil && found {
 			hits++
 		} else {
 			misses++
-			_ = cache.Set(ctx, key, i, 0)
+			if err := cache.Set(ctx, key, i, 0); err != nil {
+				b.Fatalf("Set failed: %v", err)
+			}
 		}
 	}
 	b.StopTimer()
@@ -98,7 +103,7 @@ func BenchmarkHitRate_LRU(b *testing.B) {
 	workload := generateWorkload(totalOps)
 
 	// Warmup phase - not measured
-	for i := 0; i < 50000; i++ {
+	for i := range 50000 {
 		key := workload[i]
 		if _, found := cache.Get(key); !found {
 			cache.Add(key, i)
@@ -110,6 +115,7 @@ func BenchmarkHitRate_LRU(b *testing.B) {
 	misses := 0
 
 	b.ResetTimer()
+	//nolint:intrange // b.N is dynamic and cannot use range
 	for i := 0; i < b.N; i++ {
 		key := workload[50000+i]
 
@@ -143,7 +149,7 @@ func BenchmarkHitRate_ristretto(b *testing.B) {
 	workload := generateWorkload(totalOps)
 
 	// Warmup phase - not measured
-	for i := 0; i < 50000; i++ {
+	for i := range 50000 {
 		key := workload[i]
 		if _, found := cache.Get(key); !found {
 			cache.Set(key, i, 1)
@@ -156,6 +162,7 @@ func BenchmarkHitRate_ristretto(b *testing.B) {
 	misses := 0
 
 	b.ResetTimer()
+	//nolint:intrange // b.N is dynamic and cannot use range
 	for i := 0; i < b.N; i++ {
 		key := workload[50000+i]
 
@@ -181,13 +188,18 @@ func BenchmarkSpeed_bdcache(b *testing.B) {
 	}
 
 	// Pre-populate
-	for i := 0; i < 1000; i++ {
-		_ = cache.Set(ctx, i, i, 0)
+	for i := range 1000 {
+		if err := cache.Set(ctx, i, i, 0); err != nil {
+			b.Fatalf("Set failed: %v", err)
+		}
 	}
 
 	b.ResetTimer()
+	//nolint:intrange // b.N is dynamic and cannot use range
 	for i := 0; i < b.N; i++ {
-		_, _, _ = cache.Get(ctx, i%1000)
+		if _, _, err := cache.Get(ctx, i%1000); err != nil {
+			b.Fatalf("Get failed: %v", err)
+		}
 	}
 }
 
@@ -199,11 +211,12 @@ func BenchmarkSpeed_LRU(b *testing.B) {
 	}
 
 	// Pre-populate
-	for i := 0; i < 1000; i++ {
+	for i := range 1000 {
 		cache.Add(i, i)
 	}
 
 	b.ResetTimer()
+	//nolint:intrange // b.N is dynamic and cannot use range
 	for i := 0; i < b.N; i++ {
 		_, _ = cache.Get(i % 1000)
 	}
@@ -222,12 +235,13 @@ func BenchmarkSpeed_ristretto(b *testing.B) {
 	defer cache.Close()
 
 	// Pre-populate
-	for i := 0; i < 1000; i++ {
+	for i := range 1000 {
 		cache.Set(i, i, 1)
 	}
 	cache.Wait() // Ristretto sets are async
 
 	b.ResetTimer()
+	//nolint:intrange // b.N is dynamic and cannot use range
 	for i := 0; i < b.N; i++ {
 		_, _ = cache.Get(i % 1000)
 	}
@@ -240,11 +254,12 @@ func BenchmarkSpeed_otter(b *testing.B) {
 	})
 
 	// Pre-populate
-	for i := 0; i < 1000; i++ {
+	for i := range 1000 {
 		cache.Set(i, i)
 	}
 
 	b.ResetTimer()
+	//nolint:intrange // b.N is dynamic and cannot use range
 	for i := 0; i < b.N; i++ {
 		_, _ = cache.GetIfPresent(i % 1000)
 	}

benchmarks/fifo_vs_lru_test.go

@@ -23,50 +23,66 @@ func TestFIFOvsLRU_ScanResistance(t *testing.T) {
 
 	// Test S3-FIFO
 	ctx := context.Background()
-	s3Cache, _ := bdcache.New[int, int](ctx, bdcache.WithMemorySize(cacheSize))
+	s3Cache, err := bdcache.New[int, int](ctx, bdcache.WithMemorySize(cacheSize))
+	if err != nil {
+		fmt.Printf("Failed to create cache: %v\n", err)
+		return
+	}
 
 	// Phase 1: Build working set
 	fmt.Println("Phase 1: Build working set (both caches)")
-	for i := 0; i < workingSetSize; i++ {
-		_ = s3Cache.Set(ctx, i, i, 0)
+	for i := range workingSetSize {
+		if err := s3Cache.Set(ctx, i, i, 0); err != nil {
+			fmt.Printf("Set error: %v\n", err)
+		}
 	}
 
 	// Phase 2: Access working set once (marks as hot in S3-FIFO)
 	fmt.Println("Phase 2: Access working set (marks as hot)")
-	for i := 0; i < workingSetSize; i++ {
-		_, _, _ = s3Cache.Get(ctx, i)
+	for i := range workingSetSize {
+		if _, _, err := s3Cache.Get(ctx, i); err != nil {
+			fmt.Printf("Get error: %v\n", err)
+		}
 	}
 
 	fmt.Printf("  S3-FIFO after warmup: items=%d\n", s3Cache.Len())
 
 	// Phase 3: One-time scan through large dataset
 	fmt.Println("Phase 3: One-time scan through cold data")
 	for i := 100000; i < 100000+scanSize; i++ {
-		_ = s3Cache.Set(ctx, i, i, 0)
+		if err := s3Cache.Set(ctx, i, i, 0); err != nil {
+			fmt.Printf("Set error: %v\n", err)
+		}
 	}
 	fmt.Printf("  S3-FIFO after scan: items=%d\n", s3Cache.Len())
 
 	// Phase 4: Re-access working set
 	fmt.Println("Phase 4: Re-access working set")
 	s3Hits := 0
-	for i := 0; i < workingSetSize; i++ {
-		if _, found, _ := s3Cache.Get(ctx, i); found {
+	for i := range workingSetSize {
+		if _, found, err := s3Cache.Get(ctx, i); err != nil {
+			fmt.Printf("Get error: %v\n", err)
+		} else if found {
 			s3Hits++
 		}
 	}
 
 	fmt.Printf("  S3-FIFO hits: %d/%d (%.1f%%)\n", s3Hits, workingSetSize, float64(s3Hits)/float64(workingSetSize)*100)
 
 	// Now test LRU with same workload
-	lruCache, _ := lru.New[int, int](cacheSize)
+	lruCache, err := lru.New[int, int](cacheSize)
+	if err != nil {
+		fmt.Printf("Failed to create LRU cache: %v\n", err)
+		return
+	}
 
 	// Phase 1: Build working set
-	for i := 0; i < workingSetSize; i++ {
+	for i := range workingSetSize {
 		lruCache.Add(i, i)
 	}
 
 	// Phase 2: Access working set once
-	for i := 0; i < workingSetSize; i++ {
+	for i := range workingSetSize {
 		_, _ = lruCache.Get(i)
 	}
 
@@ -77,7 +93,7 @@ func TestFIFOvsLRU_ScanResistance(t *testing.T) {
 
 	// Phase 4: Re-access working set
 	lruHits := 0
-	for i := 0; i < workingSetSize; i++ {
+	for i := range workingSetSize {
 		if _, found := lruCache.Get(i); found {
 			lruHits++
 		}

benchmarks/hitrate_comparison_test.go

@@ -3,9 +3,10 @@ package benchmarks
 import (
 	"context"
 	"fmt"
-	"github.com/codeGROOVE-dev/bdcache"
 	"testing"
 
+	"github.com/codeGROOVE-dev/bdcache"
+
 	lru "github.com/hashicorp/golang-lru/v2"
 )
 
@@ -22,7 +23,7 @@ func generateOneHitWonderWorkload(n int) []int {
 	hotSetSize := 5000 // Fits in cache
 	oneHitWonderID := 100000
 
-	for i := 0; i < n; i++ {
+	for i := range n {
 		if i%3 == 0 {
 			// 33% one-hit wonders - each unique, accessed once
 			keys[i] = oneHitWonderID
@@ -44,7 +45,7 @@ func generateScanWorkload(n int) []int {
 	scanSize := 50000  // Large scan that would evict everything in LRU
 
 	scanCounter := 0
-	for i := 0; i < n; i++ {
+	for i := range n {
 		if i%100 < 90 {
 			// 90% working set access
 			keys[i] = i % workingSet
@@ -65,7 +66,7 @@ func generateLoopWorkload(n int) []int {
 	loopSize := 6000 // Fits in cache
 
 	pollutionID := 200000
-	for i := 0; i < n; i++ {
+	for i := range n {
 		if i%10 < 8 {
 			// 80% loop through working set
 			keys[i] = i % loopSize
@@ -93,11 +94,13 @@ func runCacheWorkload(b *testing.B, workload []int, cacheName string) float64 {
 		}
 
 		for _, key := range workload {
-			if _, found, _ := cache.Get(ctx, key); found {
+			if _, found, err := cache.Get(ctx, key); err == nil && found {
 				hits++
 			} else {
 				misses++
-				_ = cache.Set(ctx, key, key, 0)
+				if err := cache.Set(ctx, key, key, 0); err != nil {
+					b.Fatalf("Set failed: %v", err)
+				}
 			}
 		}
 
@@ -185,11 +188,12 @@ func TestHitRateComparison(t *testing.T) {
 		fmt.Printf("\n%s:\n", name)
 		fmt.Printf("  bdcache (S3-FIFO): %.2f%%\n", bdcacheRate)
 		fmt.Printf("  golang-lru (LRU): %.2f%%\n", lruRate)
-		if diff > 0 {
+		switch {
+		case diff > 0:
 			fmt.Printf("  ✅ bdcache wins by %.2f percentage points\n", diff)
-		} else if diff < 0 {
+		case diff < 0:
 			fmt.Printf("  ❌ LRU wins by %.2f percentage points\n", -diff)
-		} else {
+		default:
 			fmt.Printf("  🤝 Tie\n")
 		}
 	}

cache.go

@@ -79,7 +79,7 @@ func (c *Cache[K, V]) warmup(ctx context.Context) {
 
 	loaded := 0
 	for entry := range entryCh {
-		c.memory.set(entry.Key, entry.Value, entry.Expiry)
+		c.memory.setToMemory(entry.Key, entry.Value, entry.Expiry)
 		loaded++
 	}
 
@@ -99,9 +99,11 @@ func (c *Cache[K, V]) warmup(ctx context.Context) {
 
 // Get retrieves a value from the cache.
 // It first checks the memory cache, then falls back to persistence if available.
+//
+//nolint:gocritic // unnamedResult - public API signature is intentionally clear without named returns
 func (c *Cache[K, V]) Get(ctx context.Context, key K) (V, bool, error) {
 	// Check memory first
-	if val, ok := c.memory.get(key); ok {
+	if val, ok := c.memory.getFromMemory(key); ok {
 		return val, true, nil
 	}
 
@@ -131,7 +133,7 @@ func (c *Cache[K, V]) Get(ctx context.Context, key K) (V, bool, error) {
 	}
 
 	// Add to memory cache for future hits
-	c.memory.set(key, val, expiry)
+	c.memory.setToMemory(key, val, expiry)
 
 	return val, true, nil
 }
@@ -157,7 +159,7 @@ func (c *Cache[K, V]) Set(ctx context.Context, key K, value V, ttl time.Duration
 	}
 
 	// ALWAYS update memory first - reliability guarantee
-	c.memory.set(key, value, expiry)
+	c.memory.setToMemory(key, value, expiry)
 
 	// Update persistence if available
 	if c.persist != nil {
@@ -170,9 +172,11 @@ func (c *Cache[K, V]) Set(ctx context.Context, key K, value V, ttl time.Duration
 }
 
 // Delete removes a value from the cache.
+//
+//nolint:revive // confusing-naming - standard cache operation
 func (c *Cache[K, V]) Delete(ctx context.Context, key K) {
 	// Remove from memory
-	c.memory.delete(key)
+	c.memory.deleteFromMemory(key)
 
 	// Remove from persistence if available
 	if c.persist != nil {
@@ -190,16 +194,20 @@ func (c *Cache[K, V]) Delete(ctx context.Context, key K) {
 
 // Cleanup removes expired entries from the cache.
 // Returns the number of entries removed.
+//
+//nolint:revive // confusing-naming - standard cache operation
 func (c *Cache[K, V]) Cleanup() int {
-	return c.memory.cleanup()
+	return c.memory.cleanupMemory()
 }
 
 // Len returns the number of items in the memory cache.
 func (c *Cache[K, V]) Len() int {
-	return c.memory.len()
+	return c.memory.memoryLen()
 }
 
 // Close releases resources held by the cache.
+//
+//nolint:revive // confusing-naming - standard cache operation
 func (c *Cache[K, V]) Close() error {
 	if c.persist != nil {
 		if err := c.persist.Close(); err != nil {