Add clear to cache with mutex lock when clearing (#28)

cache/basic.go

@@ -11,7 +11,7 @@ type Basic[K comparable, V any] struct {
 // NewBasic creates a new non-thread safe cache.
 func NewBasic[K comparable, V any]() *Basic[K, V] {
 	return &Basic[K, V]{
-		items:   make(map[K]V, 0),
+		items:   make(map[K]V),
 		RWMutex: &sync.RWMutex{},
 	}
 }
@@ -61,3 +61,10 @@ func (c *Basic[K, V]) Delete(key K) {
 
 	delete(c.items, key)
 }
+
+func (c *Basic[K, V]) Clear() {
+	c.Lock()
+	defer c.Unlock()
+
+	c.items = make(map[K]V)
+}

cache/basic_test.go

@@ -1,15 +1,17 @@
 package cache_test
 
 import (
+	crand "crypto/rand"
 	"encoding/base32"
 	"fmt"
 	"math/rand"
 	"sort"
 	"sync"
 	"testing"
 
-	"github.com/bir/iken/cache"
 	"github.com/stretchr/testify/assert"
+
+	"github.com/bir/iken/cache"
 )
 
 func ExampleBasic() {
@@ -36,7 +38,7 @@ func ExampleBasic() {
 
 func randString(length int) string {
 	randBytes := make([]byte, length)
-	_, err := rand.Read(randBytes)
+	_, err := crand.Read(randBytes)
 	if err != nil {
 		panic(err)
 	}
@@ -96,19 +98,25 @@ func TestCache(t *testing.T) {
 	assert.Equal(t, []string{"b"}, kk)
 }
 
+type foo struct {
+	c cache.Cache[int, string]
+}
+
 func TestMultiThread(t *testing.T) {
-	c := cache.NewBasic[int, string]()
+	f := foo{}
+	f.c = cache.NewBasic[int, string]()
 	var wg sync.WaitGroup
-	for i := int64(0); i < 100; i++ {
+	for i := int64(0); i < 1000; i++ {
 		wg.Add(1)
 		go func(i int64) {
 			defer wg.Done()
+			f.c.Clear()
 			m := rand.New(rand.NewSource(i))
-			for n := 0; n < 10000; n++ {
+			for n := 0; n < 1000; n++ {
 				key := m.Intn(100)
 				value := randString(10)
-				c.Set(key, value)
-				c.Get(key)
+				f.c.Set(key, value)
+				f.c.Get(key)
 			}
 		}(i)
 	}

cache/cache.go

@@ -10,4 +10,6 @@ type Cache[K comparable, V any] interface {
 	Delete(key K)
 	// Keys returns existing keys, the order is indeterminate.
 	Keys() []K
+	// Clear resets the cache.
+	Clear()
 }

cache/noop.go

@@ -26,3 +26,7 @@ func (c *NoOp[K, _]) Keys() []K {
 // Delete no-op.
 func (c *NoOp[K, V]) Delete(_ K) {
 }
+
+// Clear no-op.
+func (c *NoOp[K, V]) Clear() {
+}

cache/noop_test.go

@@ -3,8 +3,9 @@ package cache_test
 import (
 	"testing"
 
-	"github.com/bir/iken/cache"
 	"github.com/stretchr/testify/assert"
+
+	"github.com/bir/iken/cache"
 )
 
 // Type assertion
@@ -53,4 +54,6 @@ func TestNoOpCache(t *testing.T) {
 
 	kk = c.Keys()
 	assert.Equal(t, 0, len(kk))
+
+	c.Clear()
 }