added more tests for janitor

Author: Code-Hex

cache.go

@@ -91,14 +91,12 @@ type Cache[K comparable, V any] struct {
 type Option[K comparable, V any] func(*options[K, V])
 
 type options[K comparable, V any] struct {
-	ctx             context.Context
 	cache           Interface[K, *Item[K, V]]
 	janitorInterval time.Duration
 }
 
 func newOptions[K comparable, V any]() *options[K, V] {
 	return &options[K, V]{
-		ctx:             context.Background(),
 		cache:           simple.NewCache[K, *Item[K, V]](),
 		janitorInterval: time.Minute,
 	}
@@ -149,25 +147,23 @@ func WithJanitorInterval[K comparable, V any](d time.Duration) Option[K, V] {
 }
 
 // New creates a new thread safe Cache.
+// This function will be stopped an internal janitor when the cache is
+// no longer referenced anywhere.
 //
 // There are several Cache replacement policies available with you specified any options.
 func New[K comparable, V any](opts ...Option[K, V]) *Cache[K, V] {
 	o := newOptions[K, V]()
 	for _, optFunc := range opts {
 		optFunc(o)
 	}
+	ctx, cancel := context.WithCancel(context.Background())
 	cache := &Cache[K, V]{
-		cache: o.cache,
-	}
-	if o.ctx == context.Background() {
-		ctx, cancel := context.WithCancel(o.ctx)
-		cache.janitor = newJanitor(ctx, o.janitorInterval)
-		runtime.SetFinalizer(cache, func(self *Cache[K, V]) {
-			cancel()
-		})
-	} else {
-		cache.janitor = newJanitor(o.ctx, o.janitorInterval)
+		cache:   o.cache,
+		janitor: newJanitor(ctx, o.janitorInterval),
 	}
+	runtime.SetFinalizer(cache, func(self *Cache[K, V]) {
+		cancel()
+	})
 	return cache
 }
 
@@ -181,7 +177,7 @@ func NewContext[K comparable, V any](ctx context.Context, opts ...Option[K, V])
 	}
 	return &Cache[K, V]{
 		cache:   o.cache,
-		janitor: newJanitor(o.ctx, o.janitorInterval),
+		janitor: newJanitor(ctx, o.janitorInterval),
 	}
 }
 

cache_internal_test.go

@@ -0,0 +1,28 @@
+package cache
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestDeletedCache(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	nc := NewContext[string, int](ctx)
+	key := "key"
+	nc.Set(key, 1, WithExpiration(-time.Second))
+
+	_, ok := nc.cache.Get(key)
+	if !ok {
+		t.Fatal("want true")
+	}
+
+	nc.DeleteExpired()
+
+	_, ok = nc.cache.Get(key)
+	if ok {
+		t.Fatal("want false")
+	}
+}

cache_test.go

@@ -4,7 +4,6 @@ import (
 	"math/rand"
 	"sync"
 	"testing"
-	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
 	"github.com/Code-Hex/go-generics-cache/policy/clock"
@@ -14,23 +13,6 @@ import (
 	"github.com/Code-Hex/go-generics-cache/policy/mru"
 )
 
-func TestExpiration(t *testing.T) {
-	nc := cache.New[string, int]()
-	nc.Set("hello", 1, cache.WithExpiration(3*time.Second))
-
-	time.Sleep(time.Second * 1)
-	result, got := nc.Get("hello")
-	if !got || result != 1 {
-		t.Errorf("no, expiration must exists")
-	}
-
-	time.Sleep(time.Second * 3)
-	result, got = nc.Get("hello")
-	if got || result == 1 {
-		t.Errorf("no, expiration must not exists")
-	}
-}
-
 func TestMultiThreadIncr(t *testing.T) {
 	nc := cache.NewNumber[string, int]()
 	nc.Set("counter", 0)

example_test.go

@@ -1,6 +1,7 @@
 package cache_test
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -20,6 +21,23 @@ func ExampleCache() {
 	// 0 false
 }
 
+func ExampleNewContext() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// use simple cache algorithm without options.
+	// an internal janitor will be stopped if specified the context is cancelled.
+	c := cache.NewContext(ctx, cache.WithJanitorInterval[string, int](3*time.Second))
+	c.Set("a", 1)
+	gota, aok := c.Get("a")
+	gotb, bok := c.Get("b")
+	fmt.Println(gota, aok)
+	fmt.Println(gotb, bok)
+	// Output:
+	// 1 true
+	// 0 false
+}
+
 func ExampleAsClock() {
 	// use clock cache algorithm.
 	c := cache.New(cache.AsClock[string, int]())

janitor.go

@@ -36,6 +36,7 @@ func (j *janitor) run(cleanup func()) {
 			case <-ticker.C:
 				cleanup()
 			case <-j.done:
+				cleanup() // last call
 				return
 			case <-j.ctx.Done():
 				j.stop()