Fix backend realloc test

internal/backend/backend.go

@@ -11,6 +11,9 @@ import (
 	"github.com/mgnsk/list"
 )
 
+// If cap is 0, map hits this size and then shrinks by half, it is reallocated.
+const reallocThreshold = 100000
+
 type record[V any] struct {
 	value       V
 	deadline    int64
@@ -42,7 +45,6 @@ type Backend[K comparable, V any] struct {
 	pool             sync.Pool
 	earliestExpireAt int64
 	cap              int
-	reallocThreshold int // if map hits this size and then shrinks by half, it is reallocated
 	largestLen       int // the map has at least this capacity
 	needRealloc      bool
 	once             sync.Once
@@ -55,11 +57,10 @@ func NewBackend[K comparable, V any](capacity int) *Backend[K, V] {
 	<-t.C
 
 	return &Backend[K, V]{
-		timer:            t,
-		done:             make(chan struct{}),
-		xmap:             make(RecordMap[K, V], capacity),
-		cap:              capacity,
-		reallocThreshold: 100000, // 100000 * pointer size
+		timer: t,
+		done:  make(chan struct{}),
+		xmap:  make(RecordMap[K, V], capacity),
+		cap:   capacity,
 	}
 }
 
@@ -201,6 +202,7 @@ func (b *Backend[K, V]) Evict(key K) (Element[V], bool) {
 }
 
 // Delete an element from the backend map.
+// The element must be uninitialized.
 func (b *Backend[K, V]) Delete(key K) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
@@ -210,7 +212,7 @@ func (b *Backend[K, V]) Delete(key K) {
 
 func (b *Backend[K, V]) deleteLocked(key K) {
 	if b.cap == 0 {
-		if n := len(b.xmap); n >= b.reallocThreshold || b.largestLen > 0 && n > b.largestLen {
+		if n := len(b.xmap); n >= reallocThreshold || b.largestLen > 0 && n > b.largestLen {
 			b.largestLen = n
 		}
 	}

internal/backend/backend_test.go

@@ -8,50 +8,7 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-func TestUnlimitedCapacityMapShrink(t *testing.T) {
-	t.Run("no realloc", func(t *testing.T) {
-		g := NewWithT(t)
-
-		b := newBackend(size)
-		g.Expect(b.Len()).To(Equal(size))
-		g.Expect(getInitializedMapLen(b)).To(Equal(size))
-
-		// Evict half-1 of records.
-		for i := 0; i < size/2-1; i++ {
-			b.Evict(i)
-		}
-
-		b.RunGC(time.Now().UnixNano())
-
-		g.Expect(b.Len()).To(Equal((size / 2) + 1))
-		g.Expect(getInitializedMapLen(b)).To(Equal((size / 2) + 1))
-
-		// TODO: assert that map is the same
-	})
-
-	t.Run("realloc", func(t *testing.T) {
-		g := NewWithT(t)
-
-		b := newBackend(size)
-		g.Expect(b.Len()).To(Equal(size))
-		g.Expect(getInitializedMapLen(b)).To(Equal(size))
-
-		// Evict half of records.
-		for i := 0; i < size/2; i++ {
-			b.Evict(i)
-		}
-
-		b.RunGC(time.Now().UnixNano())
-
-		g.Expect(b.Len()).To(Equal(size / 2))
-		g.Expect(getInitializedMapLen(b)).To(Equal(size / 2))
-
-		// TODO: assert that map is new
-	})
-}
-
-// TODO: map len does not contain uninitialized elements
-func TestUnlimitedCapacityMapShrinkUninitializedRecords(t *testing.T) {
+func TestMapShrinkUninitializedRecords(t *testing.T) {
 	t.Run("realloc", func(t *testing.T) {
 		g := NewWithT(t)
 
@@ -62,7 +19,6 @@ func TestUnlimitedCapacityMapShrinkUninitializedRecords(t *testing.T) {
 		// Store uninitialized record.
 		elem := b.Reserve()
 		b.LoadOrStore(size-1, elem)
-		b.Release(elem)
 
 		g.Expect(b.Len()).To(Equal(size-1), "list len only initialized elements")
 		g.Expect(getInitializedMapLen(b)).To(Equal(size-1), "map len only initialized elements")
@@ -74,12 +30,15 @@ func TestUnlimitedCapacityMapShrinkUninitializedRecords(t *testing.T) {
 
 		b.RunGC(time.Now().UnixNano())
 
-		g.Expect(b.Len()).To(Equal((size/2)-1), "list len only initialized elements")
-		g.Expect(getInitializedMapLen(b)).To(Equal((size/2)-1), "map len only initialized elements")
+		// Initialize the record.
+		b.Initialize(size-1, 0, 0)
+
+		g.Expect(b.Len()).To(Equal((size / 2)), "list len only initialized elements")
+		g.Expect(getInitializedMapLen(b)).To(Equal((size / 2)), "map len only initialized elements")
 	})
 }
 
-// Note: hardcoded realloc threshold value in the backend.
+// Note: backend constant.
 const size = 100000
 
 func newBackend(size int) *backend.Backend[int, int] {