added tests for WithReferenceCount

Author: Code-Hex

cache.go

@@ -79,6 +79,8 @@ func WithExpiration(exp time.Duration) ItemOption {
 // WithReferenceCount is an option to set reference count for any items.
 // This option is only applicable to cache policies that have a reference count (e.g., Clock, LFU).
 // referenceCount specifies the reference count value to set for the cache item.
+//
+// the default is 1.
 func WithReferenceCount(referenceCount int) ItemOption {
 	return func(o *itemOptions) {
 		o.referenceCount = referenceCount
@@ -102,7 +104,6 @@ func newItem[K comparable, V any](key K, val V, opts ...ItemOption) *Item[K, V]
 // Cache is a thread safe cache.
 type Cache[K comparable, V any] struct {
 	cache Interface[K, *Item[K, V]]
-	//expirations map[K]chan struct{}
 	// mu is used to do lock in some method process.
 	mu      sync.Mutex
 	janitor *janitor

example_test.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
+	"github.com/Code-Hex/go-generics-cache/policy/lfu"
 )
 
 func ExampleCache() {
@@ -77,21 +78,29 @@ func ExampleWithExpiration() {
 }
 
 func ExampleWithReferenceCount() {
-	c := cache.New(cache.AsLFU[string, int]())
-	c.Set("a", 1, cache.WithReferenceCount(2))
+	c := cache.New(cache.AsLFU[string, int](lfu.WithCapacity(2)))
+
+	// set item with reference count
+	c.Set("a", 1, cache.WithReferenceCount(5))
 
 	// check item is set.
 	gota, aok := c.Get("a")
 	fmt.Println(gota, aok)
 
-	c.Set("b", 2, cache.WithReferenceCount(3))
+	c.Set("b", 2)
+	c.Set("c", 3)
 
+	// evicted becauce the lowest reference count.
 	gotb, bok := c.Get("b")
 	fmt.Println(gotb, bok)
 
+	gotc, cok := c.Get("c")
+	fmt.Println(gotc, cok)
+
 	// Output:
 	// 1 true
-	// 2 true
+	// 0 false
+	// 3 true
 }
 
 func ExampleCache_Delete() {

policy/clock/clock.go

@@ -64,6 +64,9 @@ func NewCache[K comparable, V any](opts ...Option) *Cache[K, V] {
 }
 
 // Set sets any item to the cache. replacing any existing item.
+//
+// If value satisfies "interface{ GetReferenceCount() int }", the value of
+// the GetReferenceCount() method is used to set the initial value of reference count.
 func (c *Cache[K, V]) Set(key K, val V) {
 	if e, ok := c.items[key]; ok {
 		entry := e.Value.(*entry[K, V])

policy/clock/clock_test.go

@@ -8,6 +8,12 @@ import (
 	"github.com/Code-Hex/go-generics-cache/policy/clock"
 )
 
+type tmp struct {
+	i int
+}
+
+func (t *tmp) GetReferenceCount() int { return t.i }
+
 func TestSet(t *testing.T) {
 	// set capacity is 1
 	cache := clock.NewCache[string, int](clock.WithCapacity(1))
@@ -43,6 +49,25 @@ func TestSet(t *testing.T) {
 	if bar != 100 || !ok {
 		t.Fatalf("invalid replacing value bar %d, cachehit %v", bar, ok)
 	}
+
+	t.Run("with initilal reference count", func(t *testing.T) {
+		cache := clock.NewCache[string, *tmp](clock.WithCapacity(2))
+		cache.Set("foo", &tmp{i: 10}) // the highest reference count
+		cache.Set("foo2", &tmp{i: 2}) // expected eviction
+		if got := cache.Len(); got != 2 {
+			t.Fatalf("invalid length: %d", got)
+		}
+
+		cache.Set("foo3", &tmp{i: 3})
+
+		// checks deleted the lowest reference count
+		if _, ok := cache.Get("foo2"); ok {
+			t.Fatalf("invalid delete oldest value foo2 %v", ok)
+		}
+		if _, ok := cache.Get("foo"); !ok {
+			t.Fatalf("invalid value foo is not found")
+		}
+	})
 }
 
 func TestDelete(t *testing.T) {

policy/lfu/lfu.go

@@ -61,6 +61,9 @@ func (c *Cache[K, V]) Get(key K) (zero V, _ bool) {
 }
 
 // Set sets a value to the cache with key. replacing any existing value.
+//
+// If value satisfies "interface{ GetReferenceCount() int }", the value of
+// the GetReferenceCount() method is used to set the initial value of reference count.
 func (c *Cache[K, V]) Set(key K, val V) {
 	if e, ok := c.items[key]; ok {
 		c.queue.update(e, val)

policy/lfu/lfu_test.go

@@ -6,6 +6,12 @@ import (
 	"github.com/Code-Hex/go-generics-cache/policy/lfu"
 )
 
+type tmp struct {
+	i int
+}
+
+func (t *tmp) GetReferenceCount() int { return t.i }
+
 func TestSet(t *testing.T) {
 	// set capacity is 1
 	cache := lfu.NewCache[string, int](lfu.WithCapacity(1))
@@ -41,6 +47,25 @@ func TestSet(t *testing.T) {
 	if bar != 100 || !ok {
 		t.Fatalf("invalid replacing value bar %d, cachehit %v", bar, ok)
 	}
+
+	t.Run("with initilal reference count", func(t *testing.T) {
+		cache := lfu.NewCache[string, *tmp](lfu.WithCapacity(2))
+		cache.Set("foo", &tmp{i: 10}) // the highest reference count
+		cache.Set("foo2", &tmp{i: 2}) // expected eviction
+		if got := cache.Len(); got != 2 {
+			t.Fatalf("invalid length: %d", got)
+		}
+
+		cache.Set("foo3", &tmp{i: 3})
+
+		// checks deleted the lowest reference count
+		if _, ok := cache.Get("foo2"); ok {
+			t.Fatalf("invalid delete oldest value foo2 %v", ok)
+		}
+		if _, ok := cache.Get("foo"); !ok {
+			t.Fatalf("invalid value foo is not found")
+		}
+	})
 }
 
 func TestDelete(t *testing.T) {