From e9d1155d74e6e2d5a73356f0c073e370aa61acf6 Mon Sep 17 00:00:00 2001 From: JimChenWYU Date: Tue, 27 Aug 2024 12:54:06 +0800 Subject: [PATCH] fix lru-k --- internal/list/fifo.go | 18 +++ internal/list/fifo_test.go | 19 +++ lru.go | 93 +++++++------- lru_deepcopy_test.go | 16 ++- lru_test.go | 246 +++++++++++-------------------------- 5 files changed, 167 insertions(+), 225 deletions(-) diff --git a/internal/list/fifo.go b/internal/list/fifo.go index f5395e6..af286cf 100644 --- a/internal/list/fifo.go +++ b/internal/list/fifo.go @@ -49,6 +49,11 @@ func (l *FIFO[K, V]) Init() *FIFO[K, V] { return l } +func (l *FIFO[K, V]) Contains(key K) bool { + _, ok := l.items[key] + return ok +} + // Get returns the element with the given key from the list. func (l *FIFO[K, V]) Get(key K) (e *Entry[K, V], ok bool) { e, ok = l.items[key] @@ -108,3 +113,16 @@ func (l *FIFO[K, V]) delete(e *Entry[K, V]) { e.prev = nil // avoid memory leaks l.len-- } + +// Resize changes the list size. +func (c *FIFO[K, V]) Resize(size int) (evicted int) { + diff := c.Len() - size + if diff < 0 { + diff = 0 + } + for i := 0; i < diff; i++ { + c.Pop() + } + c.size = size + return diff +} diff --git a/internal/list/fifo_test.go b/internal/list/fifo_test.go index d223d5f..455529a 100644 --- a/internal/list/fifo_test.go +++ b/internal/list/fifo_test.go @@ -17,6 +17,25 @@ func TestFIFO(t *testing.T) { list.lazyInit() } +func TestFIFO_Resize(t *testing.T) { + list := NewFIFOList[int, int](10) + assert.EqualValues(t, 10, list.Size()) + assert.EqualValues(t, 0, list.Len()) + assert.EqualValues(t, 0, list.Resize(4)) + assert.EqualValues(t, 4, list.Size()) + + list.Push(1, 1) + list.Push(2, 2) + list.Push(3, 3) + list.Push(4, 4) + + assert.True(t, list.Contains(1)) + assert.EqualValues(t, 1, list.Resize(3)) + assert.EqualValues(t, 3, list.Size()) + assert.EqualValues(t, 3, list.Len()) + assert.False(t, list.Contains(1)) +} + func TestFIFO_Push(t *testing.T) { list := NewFIFOList[int, int](3) list.Push(1, 1) diff --git a/lru.go b/lru.go index 1a14016..f2cbfdd 100644 --- a/lru.go +++ b/lru.go @@ -1,7 +1,6 @@ package lru import ( - "slices" "sync" "github.com/lovelysunlight/lru-go/internal/list" @@ -60,7 +59,7 @@ func (c *Cache[K, V]) Get(key K) (value V, ok bool) { if value, ok = c.lru.Get(key); ok { return c.OptionalCopyValue(value), ok } - if c.IsUpgradeToLRUK() { + if c.IsEnableLRUK() { if value, ok = c.visit.Get(key); ok { visits, _ := c.visit.PeekVisits(key) if c.isExpectedVisits(visits) { @@ -69,7 +68,7 @@ func (c *Cache[K, V]) Get(key K) (value V, ok bool) { return c.OptionalCopyValue(value), true } } - } else if c.IsUpgradeTo2Q() { + } else if c.IsEnable2Q() { if e, ok := c.fifo.Remove(key); ok { c.lru.Put(key, e.Value) return c.OptionalCopyValue(e.Value), true @@ -93,7 +92,7 @@ func (c *Cache[K, V]) Peek(key K) (value V, ok bool) { if value, ok = c.lru.Peek(key); ok { return c.OptionalCopyValue(value), ok } - if c.IsUpgradeToLRUK() { + if c.IsEnableLRUK() { if value, ok = c.visit.Peek(key); ok { return c.OptionalCopyValue(value), ok } @@ -111,7 +110,7 @@ func (c *Cache[K, V]) Contains(key K) (ok bool) { c.mux.RLock() defer c.mux.RUnlock() - return c.lru.Contains(key) || c.visit.Contains(key) + return c.lru.Contains(key) } // Returns the oldest entry without updating the "recently used"-ness of the key. @@ -146,9 +145,6 @@ func (c *Cache[K, V]) Remove(key K) (value V, ok bool) { if value, ok = c.lru.Remove(key); ok { return value, true } - if c.IsUpgradeToLRUK() { - return c.visit.Remove(key) - } return } @@ -163,18 +159,14 @@ func (c *Cache[K, V]) Push(key K, value V) (oldKey K, oldValue V, ok bool) { defer c.mux.Unlock() if !c.lru.Contains(key) { - if c.IsUpgradeToLRUK() { - oldKey, oldValue, ok = c.visit.Push(key, value) - visits, _ := c.visit.PeekVisits(key) - if c.isExpectedVisits(visits) { - c.moveToLru(key) - } + if c.IsEnableLRUK() { + c.visit.Push(key, value) return - } else if c.IsUpgradeTo2Q() { - if _, ok := c.fifo.Get(key); !ok { + } else if c.IsEnable2Q() { + if !c.fifo.Contains(key) { c.fifo.Push(key, value) } - return oldKey, oldValue, false + return } } @@ -192,14 +184,10 @@ func (c *Cache[K, V]) Put(key K, value V) (oldValue V, ok bool) { defer c.mux.Unlock() if !c.lru.Contains(key) { - if c.IsUpgradeToLRUK() { - oldValue, ok = c.visit.Put(key, value) - visits, _ := c.visit.PeekVisits(key) - if c.isExpectedVisits(visits) { - c.moveToLru(key) - } + if c.IsEnableLRUK() { + c.visit.Put(key, value) return - } else if c.IsUpgradeTo2Q() { + } else if c.IsEnable2Q() { if _, ok := c.fifo.Get(key); !ok { c.fifo.Push(key, value) } @@ -231,9 +219,7 @@ func (c *Cache[K, V]) Keys() []K { c.mux.RLock() defer c.mux.RUnlock() - return c.OptionalCopyKeyN( - slices.Concat(c.lru.Keys(), c.visit.Keys()), - ) + return c.OptionalCopyKeyN(c.lru.Keys()) } // Values returns a slice of the values in the cache, from oldest to newest. @@ -246,9 +232,7 @@ func (c *Cache[K, V]) Values() []V { c.mux.RLock() defer c.mux.RUnlock() - return c.OptionalCopyValueN( - slices.Concat(c.lru.Values(), c.visit.Values()), - ) + return c.OptionalCopyValueN(c.lru.Values()) } // Clears all cache entries. @@ -261,9 +245,6 @@ func (c *Cache[K, V]) Values() []V { func (c *Cache[K, V]) Clear() { c.mux.Lock() c.lru.Clear() - if c.IsUpgradeToLRUK() { - c.visit.Clear() - } c.mux.Unlock() } @@ -283,37 +264,61 @@ func (c *Cache[K, V]) Resize(size int) (evicted int) { var _ simplelru.LRUCache[any, any] = (*Cache[any, any])(nil) -// VisitCacheCap returns the size of LFU cache. -func (c *Cache[K, V]) VisitCacheCap() int { +// VisitsCap returns the size of LFU cache. +func (c *Cache[K, V]) VisitsCap() int { c.mux.RLock() defer c.mux.RUnlock() return c.visit.Cap() } -// VisitCacheLen returns the number of items in the LFU cache. -func (c *Cache[K, V]) VisitCacheLen() int { +// VisitsLen returns the number of items in the LFU cache. +func (c *Cache[K, V]) VisitsLen() int { c.mux.RLock() defer c.mux.RUnlock() return c.visit.Len() } -// Resize changes the LFU cache size. -func (c *Cache[K, V]) VisitCacheResize(size int) int { +// VisitsResize changes the LFU cache size. +func (c *Cache[K, V]) VisitsResize(size int) int { c.mux.Lock() defer c.mux.Unlock() return c.visit.Resize(size) } +// FIFOCap returns the size of fifo-list. +func (c *Cache[K, V]) FIFOCap() int { + c.mux.RLock() + defer c.mux.RUnlock() + + return c.fifo.Size() +} + +// FIFOLen returns the number of items in the fifo-list +func (c *Cache[K, V]) FIFOLen() int { + c.mux.RLock() + defer c.mux.RUnlock() + + return c.fifo.Len() +} + +// FIFOResize changes the fifo-list size. +func (c *Cache[K, V]) FIFOResize(size int) int { + c.mux.Lock() + defer c.mux.Unlock() + + return c.fifo.Resize(size) +} + // whether or not enable LRU-K algorithm -func (c *Cache[K, V]) IsUpgradeToLRUK() bool { +func (c *Cache[K, V]) IsEnableLRUK() bool { return c.visitThreshold > 1 } // whether or not enable 2Q algorithm -func (c *Cache[K, V]) IsUpgradeTo2Q() bool { +func (c *Cache[K, V]) IsEnable2Q() bool { return c.fifo != nil && c.fifo.Size() > 0 } @@ -321,12 +326,6 @@ func (c *Cache[K, V]) isExpectedVisits(visits uint64) bool { return visits >= c.visitThreshold } -func (c *Cache[K, V]) moveToLru(key K) { - if value, ok := c.visit.Remove(key); ok { - c.lru.Push(key, value) - } -} - type cacheOptionFunc[K comparable, V any] func(*Cache[K, V]) // Enable to return a deep copy of the value in `Get`, `Peek`, `PeekOldest`, `Keys` and `Values`. diff --git a/lru_deepcopy_test.go b/lru_deepcopy_test.go index 1a249db..968977e 100644 --- a/lru_deepcopy_test.go +++ b/lru_deepcopy_test.go @@ -602,6 +602,7 @@ func TestCacheUpgradeToLRUK_enable_deepcopy_Values(t *testing.T) { cache.Put("a", map[string]string{ "a": "a", }) + cache.Get("a") v := cache.Values() assert.EqualValues(t, []map[string]string{ @@ -617,7 +618,7 @@ func TestCacheUpgradeToLRUK_enable_deepcopy_Values(t *testing.T) { t.Run("slice", func(t *testing.T) { cache, _ := New[string, []int](2, EnableDeepCopy[string, []int](), EnableLRUK[string, []int](2)) cache.Put("a", []int{1, 2, 3}) - + cache.Get("a") v := cache.Values() assert.EqualValues(t, [][]int{{1, 2, 3}}, v) v[0][0] = 4 @@ -631,7 +632,7 @@ func TestCacheUpgradeToLRUK_enable_deepcopy_Values(t *testing.T) { } cache, _ := New[string, *TestCase](2, EnableDeepCopy[string, *TestCase](), EnableLRUK[string, *TestCase](2)) cache.Put("a", &TestCase{Name: "a"}) - + cache.Get("a") v := cache.Values() assert.EqualValues(t, []*TestCase{{Name: "a"}}, v) v[0].Name = "b" @@ -647,6 +648,7 @@ func TestCacheUpgradeToLRUK_disable_deepcopy_Values(t *testing.T) { cache.Put("a", map[string]string{ "a": "a", }) + cache.Get("a") v := cache.Values() assert.EqualValues(t, []map[string]string{ @@ -668,6 +670,7 @@ func TestCacheUpgradeToLRUK_disable_deepcopy_Values(t *testing.T) { t.Run("slice", func(t *testing.T) { cache, _ := New[string, []int](2, DisableDeepCopy[string, []int](), EnableLRUK[string, []int](2)) cache.Put("a", []int{1, 2, 3}) + cache.Get("a") v := cache.Values() assert.EqualValues(t, [][]int{{1, 2, 3}}, v) @@ -686,6 +689,7 @@ func TestCacheUpgradeToLRUK_disable_deepcopy_Values(t *testing.T) { } cache, _ := New[string, *TestCase](2, DisableDeepCopy[string, *TestCase](), EnableLRUK[string, *TestCase](2)) cache.Put("a", &TestCase{Name: "a"}) + cache.Get("a") v := cache.Values() assert.EqualValues(t, []*TestCase{{Name: "a"}}, v) @@ -706,7 +710,9 @@ func TestCacheUpgradeToLRUK_enable_deepcopy_Keys(t *testing.T) { Name string } cache, _ := New[*TestCase, *TestCase](2, EnableDeepCopy[*TestCase, *TestCase](), EnableLRUK[*TestCase, *TestCase](2)) - cache.Put(&TestCase{Name: "b"}, &TestCase{Name: "a"}) + key := &TestCase{Name: "b"} + cache.Put(key, &TestCase{Name: "a"}) + cache.Get(key) v := cache.Keys() assert.EqualValues(t, []*TestCase{{Name: "b"}}, v) @@ -723,7 +729,9 @@ func TestCacheUpgradeToLRUK_disable_deepcopy_Keys(t *testing.T) { Name string } cache, _ := New[*TestCase, *TestCase](2, DisableDeepCopy[*TestCase, *TestCase](), EnableLRUK[*TestCase, *TestCase](2)) - cache.Put(&TestCase{Name: "b"}, &TestCase{Name: "a"}) + key := &TestCase{Name: "b"} + cache.Put(key, &TestCase{Name: "a"}) + cache.Get(key) v := cache.Keys() assert.EqualValues(t, []*TestCase{{Name: "b"}}, v) diff --git a/lru_test.go b/lru_test.go index 5f4e8a8..ad5f2a0 100644 --- a/lru_test.go +++ b/lru_test.go @@ -305,61 +305,53 @@ func TestCache_Contains(t *testing.T) { func TestCacheUpgradeToLRUK_Push(t *testing.T) { var ( - k, v int - ok bool + // k, v int + ok bool ) cache, _ := New(3, WithVisitCacheSize[int, int](4), EnableLRUK[int, int](3), ) assert.EqualValues(t, 3, cache.Cap()) - assert.EqualValues(t, 4, cache.VisitCacheCap()) + assert.EqualValues(t, 4, cache.VisitsCap()) assert.EqualValues(t, 3, cache.visitThreshold) - t.Run("move to lru", func(t *testing.T) { - cache.Push(1, 1) - cache.Push(2, 2) - _, _, ok = cache.Push(3, 3) - assert.False(t, ok) - - k, v, ok = cache.Push(1, 11) - assert.True(t, ok) - assert.EqualValues(t, 1, k) - assert.EqualValues(t, 1, v) - - k, v, ok = cache.Push(1, 1) // move to lru - assert.True(t, ok) - assert.EqualValues(t, 1, k) - assert.EqualValues(t, 11, v) - - k, v, ok = cache.Push(1, 1) - assert.True(t, ok) - assert.EqualValues(t, 1, k) - assert.EqualValues(t, 1, v) - - assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 2, cache.VisitCacheLen()) - }) - t.Run("push to lfu and evict", func(t *testing.T) { - cache.Clear() - cache.VisitCacheResize(3) + cache.VisitsResize(3) _, _, ok = cache.Push(1, 1) assert.False(t, ok) _, _, ok = cache.Push(2, 2) assert.False(t, ok) _, _, ok = cache.Push(3, 3) assert.False(t, ok) - k, v, ok = cache.Push(4, 4) - assert.True(t, ok) - assert.EqualValues(t, k, 1) - assert.EqualValues(t, v, 1) + _, _, ok = cache.Push(4, 4) + assert.False(t, ok) + }) + + t.Run("incr visits", func(t *testing.T) { + cache, _ := New(3, + WithVisitCacheSize[int, int](4), + EnableLRUK[int, int](3), + ) + + cache.VisitsResize(3) + cache.Push(1, 1) + v, _ := cache.visit.PeekVisits(1) + assert.EqualValues(t, 1, v) + + cache.Push(1, 1) + v, _ = cache.visit.PeekVisits(1) + assert.EqualValues(t, 2, v) + + cache.Push(1, 1) + v, _ = cache.visit.PeekVisits(1) + assert.EqualValues(t, 3, v) }) } func TestCacheUpgradeToLRUK_Put(t *testing.T) { var ( - v int + // v int ok bool ) cache, _ := New(3, @@ -367,34 +359,12 @@ func TestCacheUpgradeToLRUK_Put(t *testing.T) { EnableLRUK[int, int](3), ) assert.EqualValues(t, 3, cache.Cap()) - assert.EqualValues(t, 4, cache.VisitCacheCap()) + assert.EqualValues(t, 4, cache.VisitsCap()) assert.EqualValues(t, 3, cache.visitThreshold) - t.Run("move to lru", func(t *testing.T) { - cache.Put(1, 1) - cache.Put(2, 2) - _, ok = cache.Put(3, 3) - assert.False(t, ok) - - v, ok = cache.Put(1, 11) - assert.True(t, ok) - assert.EqualValues(t, 1, v) - - v, ok = cache.Put(1, 1) // move to lru - assert.True(t, ok) - assert.EqualValues(t, 11, v) - - v, ok = cache.Put(1, 1) - assert.True(t, ok) - assert.EqualValues(t, 1, v) - - assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 2, cache.VisitCacheLen()) - }) - - t.Run("push to lfu and evict", func(t *testing.T) { + t.Run("put to lfu and evict", func(t *testing.T) { cache.Clear() - cache.VisitCacheResize(3) + cache.VisitsResize(3) _, ok = cache.Put(1, 1) assert.False(t, ok) _, ok = cache.Put(2, 2) @@ -404,51 +374,26 @@ func TestCacheUpgradeToLRUK_Put(t *testing.T) { _, ok = cache.Put(4, 4) assert.False(t, ok) }) -} - -func TestCacheUpgradeToLRUK_Remove(t *testing.T) { - var ( - v int - ok bool - ) - cache, _ := New(3, - WithVisitCacheSize[int, int](3), - EnableLRUK[int, int](2), - ) - cache.Push(1, 1) - cache.Push(2, 2) - cache.Push(1, 1) - assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 1, cache.VisitCacheLen()) - - v, ok = cache.Remove(1) - assert.True(t, ok) - assert.EqualValues(t, 1, v) - assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 1, cache.VisitCacheLen()) - - v, ok = cache.Remove(2) - assert.True(t, ok) - assert.EqualValues(t, 2, v) - assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 0, cache.VisitCacheLen()) -} + t.Run("incr visits", func(t *testing.T) { + cache, _ := New(3, + WithVisitCacheSize[int, int](4), + EnableLRUK[int, int](3), + ) -func TestCacheUpgradeToLRUK_Contains(t *testing.T) { - cache, _ := New(3, - WithVisitCacheSize[int, int](3), - EnableLRUK[int, int](2), - ) - cache.Push(1, 1) - cache.Push(2, 2) - cache.Push(1, 1) + cache.VisitsResize(3) + cache.Put(1, 1) + v, _ := cache.visit.PeekVisits(1) + assert.EqualValues(t, 1, v) - assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 1, cache.VisitCacheLen()) + cache.Put(1, 1) + v, _ = cache.visit.PeekVisits(1) + assert.EqualValues(t, 2, v) - assert.True(t, cache.Contains(1)) - assert.True(t, cache.Contains(2)) + cache.Put(1, 1) + v, _ = cache.visit.PeekVisits(1) + assert.EqualValues(t, 3, v) + }) } func TestCacheUpgradeToLRUK_Get(t *testing.T) { @@ -468,77 +413,29 @@ func TestCacheUpgradeToLRUK_Get(t *testing.T) { assert.True(t, ok) assert.EqualValues(t, 1, v) assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 2, cache.VisitCacheLen()) + assert.EqualValues(t, 2, cache.VisitsLen()) v, ok = cache.Get(1) // move to lru assert.True(t, ok) assert.EqualValues(t, 1, v) assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 1, cache.VisitCacheLen()) + assert.EqualValues(t, 1, cache.VisitsLen()) v, ok = cache.Get(2) // move to lru assert.True(t, ok) assert.EqualValues(t, 2, v) assert.EqualValues(t, 2, cache.Len()) - assert.EqualValues(t, 0, cache.VisitCacheLen()) -} - -func TestCacheUpgradeToLRUK_Peek(t *testing.T) { - var ( - v int - ok bool - ) - cache, _ := New(3, - WithVisitCacheSize[int, int](3), - EnableLRUK[int, int](2), - ) - cache.Push(1, 1) - cache.Push(2, 2) - - v, ok = cache.Peek(1) - assert.True(t, ok) - assert.EqualValues(t, 1, v) - assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 2, cache.VisitCacheLen()) - - v, ok = cache.Peek(1) - assert.True(t, ok) - assert.EqualValues(t, 1, v) - assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 2, cache.VisitCacheLen()) - - v, ok = cache.Peek(2) - assert.True(t, ok) - assert.EqualValues(t, 2, v) - assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 2, cache.VisitCacheLen()) - - cache.Get(1) - for i := 0; i < 2; i++ { - v, ok = cache.Peek(1) - assert.True(t, ok) - assert.EqualValues(t, 1, v) - assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 1, cache.VisitCacheLen()) - } + assert.EqualValues(t, 0, cache.VisitsLen()) } -func TestCacheUpgradeToLRUK_Keys_Values(t *testing.T) { +func TestCacheUpgradeTo2Q_FIFOResize(t *testing.T) { cache, _ := New(4, WithVisitCacheSize[int, int](4), - EnableLRUK[int, int](2), + Enable2Q[int, int](2), ) - cache.Put(1, 10) - cache.Put(2, 20) - cache.Put(3, 30) - cache.Put(4, 40) - cache.Put(2, 20) - cache.Put(3, 30) - assert.EqualValues(t, 2, cache.Len()) - assert.EqualValues(t, 2, cache.VisitCacheLen()) - - assert.EqualValues(t, []int{2, 3, 1, 4}, cache.Keys()) - assert.EqualValues(t, []int{20, 30, 10, 40}, cache.Values()) + assert.EqualValues(t, 2, cache.FIFOCap()) + cache.FIFOResize(3) + assert.EqualValues(t, 3, cache.FIFOCap()) } func TestCacheUpgradeTo2Q_Get(t *testing.T) { @@ -546,6 +443,7 @@ func TestCacheUpgradeTo2Q_Get(t *testing.T) { WithVisitCacheSize[int, int](4), Enable2Q[int, int](2), ) + var ( v int ok bool @@ -553,7 +451,7 @@ func TestCacheUpgradeTo2Q_Get(t *testing.T) { cache.Push(1, 1) cache.Push(2, 2) assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 2, cache.fifo.Len()) + assert.EqualValues(t, 2, cache.FIFOLen()) _, ok = cache.Peek(1) assert.False(t, ok) @@ -565,13 +463,13 @@ func TestCacheUpgradeTo2Q_Get(t *testing.T) { assert.True(t, ok) assert.EqualValues(t, 1, v) assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 1, cache.fifo.Len()) + assert.EqualValues(t, 1, cache.FIFOLen()) v, ok = cache.Get(2) assert.True(t, ok) assert.EqualValues(t, 2, v) assert.EqualValues(t, 2, cache.Len()) - assert.EqualValues(t, 0, cache.fifo.Len()) + assert.EqualValues(t, 0, cache.FIFOLen()) } func TestCacheUpgradeTo2Q_Push_Put(t *testing.T) { @@ -587,25 +485,25 @@ func TestCacheUpgradeTo2Q_Push_Put(t *testing.T) { cache.Push(1, 1) cache.Push(2, 2) assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 2, cache.fifo.Len()) - + assert.EqualValues(t, 2, cache.FIFOLen()) + _, ok = cache.Peek(1) assert.False(t, ok) - + _, ok = cache.Peek(2) assert.False(t, ok) - + v, ok = cache.Get(1) assert.True(t, ok) assert.EqualValues(t, 1, v) assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 1, cache.fifo.Len()) - + assert.EqualValues(t, 1, cache.FIFOLen()) + v, ok = cache.Get(2) assert.True(t, ok) assert.EqualValues(t, 2, v) assert.EqualValues(t, 2, cache.Len()) - assert.EqualValues(t, 0, cache.fifo.Len()) + assert.EqualValues(t, 0, cache.FIFOLen()) }) t.Run("put", func(t *testing.T) { @@ -620,24 +518,24 @@ func TestCacheUpgradeTo2Q_Push_Put(t *testing.T) { cache.Put(1, 1) cache.Put(2, 2) assert.EqualValues(t, 0, cache.Len()) - assert.EqualValues(t, 2, cache.fifo.Len()) - + assert.EqualValues(t, 2, cache.FIFOLen()) + _, ok = cache.Peek(1) assert.False(t, ok) - + _, ok = cache.Peek(2) assert.False(t, ok) - + v, ok = cache.Get(1) assert.True(t, ok) assert.EqualValues(t, 1, v) assert.EqualValues(t, 1, cache.Len()) - assert.EqualValues(t, 1, cache.fifo.Len()) - + assert.EqualValues(t, 1, cache.FIFOLen()) + v, ok = cache.Get(2) assert.True(t, ok) assert.EqualValues(t, 2, v) assert.EqualValues(t, 2, cache.Len()) - assert.EqualValues(t, 0, cache.fifo.Len()) + assert.EqualValues(t, 0, cache.FIFOLen()) }) }