caj
/
go-cache
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add NoExpiration and DefaultExpiration constants and use them (thanks to Jason Mooberry)

Browse Source
master
Patrick Mylund Nielsen 10 years ago
parent 73a30b2033
commit 46827c6a61
2 changed files with 183 additions and 178 deletions
Show Stats Download Patch File Download Diff File

21
cache.go
Unescape Escape View File

@ -23,6 +23,11 @@ func (item *Item) Expired() bool {
return item.Expiration.Before(time.Now()) return item.Expiration.Before(time.Now())
} }
const (
NoExpiration time.Duration = -1
DefaultExpiration time.Duration = 0
)
type Cache struct { type Cache struct {
*cache *cache
// If this is confusing, see the comment at the bottom of New() // If this is confusing, see the comment at the bottom of New()
@ -35,9 +40,9 @@ type cache struct {
janitor *janitor janitor *janitor
} }
// Add an item to the cache, replacing any existing item. If the duration is 0, // Add an item to the cache, replacing any existing item. If the duration is 0
// the cache's default expiration time is used. If it is -1, the item never // (DefaultExpiration), the cache's default expiration time is used. If it is -1
// expires. // (NoExpiration), the item never expires.
func (c *cache) Set(k string, x interface{}, d time.Duration) { func (c *cache) Set(k string, x interface{}, d time.Duration) {
c.Lock() c.Lock()
c.set(k, x, d) c.set(k, x, d)
@ -48,7 +53,7 @@ func (c *cache) Set(k string, x interface{}, d time.Duration) {
func (c *cache) set(k string, x interface{}, d time.Duration) { func (c *cache) set(k string, x interface{}, d time.Duration) {
var e *time.Time var e *time.Time
if d == 0 { if d == DefaultExpiration {
d = c.defaultExpiration d = c.defaultExpiration
} }
if d > 0 { if d > 0 {
@ -982,10 +987,10 @@ func newCacheWithJanitor(de time.Duration, ci time.Duration, m map[string]*Item)
} }
// Return a new cache with a given default expiration duration and cleanup // Return a new cache with a given default expiration duration and cleanup
// interval. If the expiration duration is less than 1, the items in the cache // interval. If the expiration duration is less than one (or NoExpiration),
// never expire (by default), and must be deleted manually. If the cleanup // the items in the cache never expire (by default), and must be deleted
// interval is less than one, expired items are not deleted from the cache // manually. If the cleanup interval is less than one, expired items are not
// before calling DeleteExpired. // deleted from the cache before calling DeleteExpired.
func New(defaultExpiration, cleanupInterval time.Duration) *Cache { func New(defaultExpiration, cleanupInterval time.Duration) *Cache {
items := make(map[string]*Item) items := make(map[string]*Item)
return newCacheWithJanitor(defaultExpiration, cleanupInterval, items) return newCacheWithJanitor(defaultExpiration, cleanupInterval, items)

340
cache_test.go
Unescape Escape View File

@ -16,7 +16,7 @@ type TestStruct struct {
} }
func TestCache(t *testing.T) { func TestCache(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
a, found := tc.Get("a") a, found := tc.Get("a")
if found || a != nil { if found || a != nil {
@ -33,9 +33,9 @@ func TestCache(t *testing.T) {
t.Error("Getting C found value that shouldn't exist:", c) t.Error("Getting C found value that shouldn't exist:", c)
} }
tc.Set("a", 1, 0) tc.Set("a", 1, DefaultExpiration)
tc.Set("b", "b", 0) tc.Set("b", "b", DefaultExpiration)
tc.Set("c", 3.5, 0) tc.Set("c", 3.5, DefaultExpiration)
x, found := tc.Get("a") x, found := tc.Get("a")
if !found { if !found {
@ -72,8 +72,8 @@ func TestCacheTimes(t *testing.T) {
var found bool var found bool
tc := New(50*time.Millisecond, 1*time.Millisecond) tc := New(50*time.Millisecond, 1*time.Millisecond)
tc.Set("a", 1, 0) tc.Set("a", 1, DefaultExpiration)
tc.Set("b", 2, -1) tc.Set("b", 2, NoExpiration)
tc.Set("c", 3, 20*time.Millisecond) tc.Set("c", 3, 20*time.Millisecond)
tc.Set("d", 4, 70*time.Millisecond) tc.Set("d", 4, 70*time.Millisecond)
@ -117,7 +117,7 @@ func TestNewFrom(t *testing.T) {
Expiration: nil, Expiration: nil,
}, },
} }
tc := NewFrom(0, 0, m) tc := NewFrom(DefaultExpiration, 0, m)
a, found := tc.Get("a") a, found := tc.Get("a")
if !found { if !found {
t.Fatal("Did not find a") t.Fatal("Did not find a")
@ -135,8 +135,8 @@ func TestNewFrom(t *testing.T) {
} }
func TestStorePointerToStruct(t *testing.T) { func TestStorePointerToStruct(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("foo", &TestStruct{Num: 1}, 0) tc.Set("foo", &TestStruct{Num: 1}, DefaultExpiration)
x, found := tc.Get("foo") x, found := tc.Get("foo")
if !found { if !found {
t.Fatal("*TestStruct was not found for foo") t.Fatal("*TestStruct was not found for foo")
@ -155,8 +155,8 @@ func TestStorePointerToStruct(t *testing.T) {
} }
func TestIncrementWithInt(t *testing.T) { func TestIncrementWithInt(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint", 1, 0) tc.Set("tint", 1, DefaultExpiration)
err := tc.Increment("tint", 2) err := tc.Increment("tint", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -171,8 +171,8 @@ func TestIncrementWithInt(t *testing.T) {
} }
func TestIncrementWithInt8(t *testing.T) { func TestIncrementWithInt8(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint8", int8(1), 0) tc.Set("tint8", int8(1), DefaultExpiration)
err := tc.Increment("tint8", 2) err := tc.Increment("tint8", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -187,8 +187,8 @@ func TestIncrementWithInt8(t *testing.T) {
} }
func TestIncrementWithInt16(t *testing.T) { func TestIncrementWithInt16(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint16", int16(1), 0) tc.Set("tint16", int16(1), DefaultExpiration)
err := tc.Increment("tint16", 2) err := tc.Increment("tint16", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -203,8 +203,8 @@ func TestIncrementWithInt16(t *testing.T) {
} }
func TestIncrementWithInt32(t *testing.T) { func TestIncrementWithInt32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint32", int32(1), 0) tc.Set("tint32", int32(1), DefaultExpiration)
err := tc.Increment("tint32", 2) err := tc.Increment("tint32", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -219,8 +219,8 @@ func TestIncrementWithInt32(t *testing.T) {
} }
func TestIncrementWithInt64(t *testing.T) { func TestIncrementWithInt64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint64", int64(1), 0) tc.Set("tint64", int64(1), DefaultExpiration)
err := tc.Increment("tint64", 2) err := tc.Increment("tint64", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -235,8 +235,8 @@ func TestIncrementWithInt64(t *testing.T) {
} }
func TestIncrementWithUint(t *testing.T) { func TestIncrementWithUint(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint", uint(1), 0) tc.Set("tuint", uint(1), DefaultExpiration)
err := tc.Increment("tuint", 2) err := tc.Increment("tuint", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -251,8 +251,8 @@ func TestIncrementWithUint(t *testing.T) {
} }
func TestIncrementWithUintptr(t *testing.T) { func TestIncrementWithUintptr(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuintptr", uintptr(1), 0) tc.Set("tuintptr", uintptr(1), DefaultExpiration)
err := tc.Increment("tuintptr", 2) err := tc.Increment("tuintptr", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -268,8 +268,8 @@ func TestIncrementWithUintptr(t *testing.T) {
} }
func TestIncrementWithUint8(t *testing.T) { func TestIncrementWithUint8(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint8", uint8(1), 0) tc.Set("tuint8", uint8(1), DefaultExpiration)
err := tc.Increment("tuint8", 2) err := tc.Increment("tuint8", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -284,8 +284,8 @@ func TestIncrementWithUint8(t *testing.T) {
} }
func TestIncrementWithUint16(t *testing.T) { func TestIncrementWithUint16(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint16", uint16(1), 0) tc.Set("tuint16", uint16(1), DefaultExpiration)
err := tc.Increment("tuint16", 2) err := tc.Increment("tuint16", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -301,8 +301,8 @@ func TestIncrementWithUint16(t *testing.T) {
} }
func TestIncrementWithUint32(t *testing.T) { func TestIncrementWithUint32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint32", uint32(1), 0) tc.Set("tuint32", uint32(1), DefaultExpiration)
err := tc.Increment("tuint32", 2) err := tc.Increment("tuint32", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -317,8 +317,8 @@ func TestIncrementWithUint32(t *testing.T) {
} }
func TestIncrementWithUint64(t *testing.T) { func TestIncrementWithUint64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint64", uint64(1), 0) tc.Set("tuint64", uint64(1), DefaultExpiration)
err := tc.Increment("tuint64", 2) err := tc.Increment("tuint64", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -334,8 +334,8 @@ func TestIncrementWithUint64(t *testing.T) {
} }
func TestIncrementWithFloat32(t *testing.T) { func TestIncrementWithFloat32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float32", float32(1.5), 0) tc.Set("float32", float32(1.5), DefaultExpiration)
err := tc.Increment("float32", 2) err := tc.Increment("float32", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -350,8 +350,8 @@ func TestIncrementWithFloat32(t *testing.T) {
} }
func TestIncrementWithFloat64(t *testing.T) { func TestIncrementWithFloat64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float64", float64(1.5), 0) tc.Set("float64", float64(1.5), DefaultExpiration)
err := tc.Increment("float64", 2) err := tc.Increment("float64", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -366,8 +366,8 @@ func TestIncrementWithFloat64(t *testing.T) {
} }
func TestIncrementFloatWithFloat32(t *testing.T) { func TestIncrementFloatWithFloat32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float32", float32(1.5), 0) tc.Set("float32", float32(1.5), DefaultExpiration)
err := tc.IncrementFloat("float32", 2) err := tc.IncrementFloat("float32", 2)
if err != nil { if err != nil {
t.Error("Error incrementfloating:", err) t.Error("Error incrementfloating:", err)
@ -382,8 +382,8 @@ func TestIncrementFloatWithFloat32(t *testing.T) {
} }
func TestIncrementFloatWithFloat64(t *testing.T) { func TestIncrementFloatWithFloat64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float64", float64(1.5), 0) tc.Set("float64", float64(1.5), DefaultExpiration)
err := tc.IncrementFloat("float64", 2) err := tc.IncrementFloat("float64", 2)
if err != nil { if err != nil {
t.Error("Error incrementfloating:", err) t.Error("Error incrementfloating:", err)
@ -398,8 +398,8 @@ func TestIncrementFloatWithFloat64(t *testing.T) {
} }
func TestDecrementWithInt(t *testing.T) { func TestDecrementWithInt(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int", int(5), 0) tc.Set("int", int(5), DefaultExpiration)
err := tc.Decrement("int", 2) err := tc.Decrement("int", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -414,8 +414,8 @@ func TestDecrementWithInt(t *testing.T) {
} }
func TestDecrementWithInt8(t *testing.T) { func TestDecrementWithInt8(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int8", int8(5), 0) tc.Set("int8", int8(5), DefaultExpiration)
err := tc.Decrement("int8", 2) err := tc.Decrement("int8", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -430,8 +430,8 @@ func TestDecrementWithInt8(t *testing.T) {
} }
func TestDecrementWithInt16(t *testing.T) { func TestDecrementWithInt16(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int16", int16(5), 0) tc.Set("int16", int16(5), DefaultExpiration)
err := tc.Decrement("int16", 2) err := tc.Decrement("int16", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -446,8 +446,8 @@ func TestDecrementWithInt16(t *testing.T) {
} }
func TestDecrementWithInt32(t *testing.T) { func TestDecrementWithInt32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int32", int32(5), 0) tc.Set("int32", int32(5), DefaultExpiration)
err := tc.Decrement("int32", 2) err := tc.Decrement("int32", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -462,8 +462,8 @@ func TestDecrementWithInt32(t *testing.T) {
} }
func TestDecrementWithInt64(t *testing.T) { func TestDecrementWithInt64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int64", int64(5), 0) tc.Set("int64", int64(5), DefaultExpiration)
err := tc.Decrement("int64", 2) err := tc.Decrement("int64", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -478,8 +478,8 @@ func TestDecrementWithInt64(t *testing.T) {
} }
func TestDecrementWithUint(t *testing.T) { func TestDecrementWithUint(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint", uint(5), 0) tc.Set("uint", uint(5), DefaultExpiration)
err := tc.Decrement("uint", 2) err := tc.Decrement("uint", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -494,8 +494,8 @@ func TestDecrementWithUint(t *testing.T) {
} }
func TestDecrementWithUintptr(t *testing.T) { func TestDecrementWithUintptr(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uintptr", uintptr(5), 0) tc.Set("uintptr", uintptr(5), DefaultExpiration)
err := tc.Decrement("uintptr", 2) err := tc.Decrement("uintptr", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -510,8 +510,8 @@ func TestDecrementWithUintptr(t *testing.T) {
} }
func TestDecrementWithUint8(t *testing.T) { func TestDecrementWithUint8(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint8", uint8(5), 0) tc.Set("uint8", uint8(5), DefaultExpiration)
err := tc.Decrement("uint8", 2) err := tc.Decrement("uint8", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -526,8 +526,8 @@ func TestDecrementWithUint8(t *testing.T) {
} }
func TestDecrementWithUint16(t *testing.T) { func TestDecrementWithUint16(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint16", uint16(5), 0) tc.Set("uint16", uint16(5), DefaultExpiration)
err := tc.Decrement("uint16", 2) err := tc.Decrement("uint16", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -542,8 +542,8 @@ func TestDecrementWithUint16(t *testing.T) {
} }
func TestDecrementWithUint32(t *testing.T) { func TestDecrementWithUint32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint32", uint32(5), 0) tc.Set("uint32", uint32(5), DefaultExpiration)
err := tc.Decrement("uint32", 2) err := tc.Decrement("uint32", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -558,8 +558,8 @@ func TestDecrementWithUint32(t *testing.T) {
} }
func TestDecrementWithUint64(t *testing.T) { func TestDecrementWithUint64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint64", uint64(5), 0) tc.Set("uint64", uint64(5), DefaultExpiration)
err := tc.Decrement("uint64", 2) err := tc.Decrement("uint64", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -574,8 +574,8 @@ func TestDecrementWithUint64(t *testing.T) {
} }
func TestDecrementWithFloat32(t *testing.T) { func TestDecrementWithFloat32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float32", float32(5.5), 0) tc.Set("float32", float32(5.5), DefaultExpiration)
err := tc.Decrement("float32", 2) err := tc.Decrement("float32", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -590,8 +590,8 @@ func TestDecrementWithFloat32(t *testing.T) {
} }
func TestDecrementWithFloat64(t *testing.T) { func TestDecrementWithFloat64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float64", float64(5.5), 0) tc.Set("float64", float64(5.5), DefaultExpiration)
err := tc.Decrement("float64", 2) err := tc.Decrement("float64", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -606,8 +606,8 @@ func TestDecrementWithFloat64(t *testing.T) {
} }
func TestDecrementFloatWithFloat32(t *testing.T) { func TestDecrementFloatWithFloat32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float32", float32(5.5), 0) tc.Set("float32", float32(5.5), DefaultExpiration)
err := tc.DecrementFloat("float32", 2) err := tc.DecrementFloat("float32", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -622,8 +622,8 @@ func TestDecrementFloatWithFloat32(t *testing.T) {
} }
func TestDecrementFloatWithFloat64(t *testing.T) { func TestDecrementFloatWithFloat64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float64", float64(5.5), 0) tc.Set("float64", float64(5.5), DefaultExpiration)
err := tc.DecrementFloat("float64", 2) err := tc.DecrementFloat("float64", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -638,8 +638,8 @@ func TestDecrementFloatWithFloat64(t *testing.T) {
} }
func TestIncrementInt(t *testing.T) { func TestIncrementInt(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint", 1, 0) tc.Set("tint", 1, DefaultExpiration)
n, err := tc.IncrementInt("tint", 2) n, err := tc.IncrementInt("tint", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -657,8 +657,8 @@ func TestIncrementInt(t *testing.T) {
} }
func TestIncrementInt8(t *testing.T) { func TestIncrementInt8(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint8", int8(1), 0) tc.Set("tint8", int8(1), DefaultExpiration)
n, err := tc.IncrementInt8("tint8", 2) n, err := tc.IncrementInt8("tint8", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -676,8 +676,8 @@ func TestIncrementInt8(t *testing.T) {
} }
func TestIncrementInt16(t *testing.T) { func TestIncrementInt16(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint16", int16(1), 0) tc.Set("tint16", int16(1), DefaultExpiration)
n, err := tc.IncrementInt16("tint16", 2) n, err := tc.IncrementInt16("tint16", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -695,8 +695,8 @@ func TestIncrementInt16(t *testing.T) {
} }
func TestIncrementInt32(t *testing.T) { func TestIncrementInt32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint32", int32(1), 0) tc.Set("tint32", int32(1), DefaultExpiration)
n, err := tc.IncrementInt32("tint32", 2) n, err := tc.IncrementInt32("tint32", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -714,8 +714,8 @@ func TestIncrementInt32(t *testing.T) {
} }
func TestIncrementInt64(t *testing.T) { func TestIncrementInt64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tint64", int64(1), 0) tc.Set("tint64", int64(1), DefaultExpiration)
n, err := tc.IncrementInt64("tint64", 2) n, err := tc.IncrementInt64("tint64", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -733,8 +733,8 @@ func TestIncrementInt64(t *testing.T) {
} }
func TestIncrementUint(t *testing.T) { func TestIncrementUint(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint", uint(1), 0) tc.Set("tuint", uint(1), DefaultExpiration)
n, err := tc.IncrementUint("tuint", 2) n, err := tc.IncrementUint("tuint", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -752,8 +752,8 @@ func TestIncrementUint(t *testing.T) {
} }
func TestIncrementUintptr(t *testing.T) { func TestIncrementUintptr(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuintptr", uintptr(1), 0) tc.Set("tuintptr", uintptr(1), DefaultExpiration)
n, err := tc.IncrementUintptr("tuintptr", 2) n, err := tc.IncrementUintptr("tuintptr", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -771,8 +771,8 @@ func TestIncrementUintptr(t *testing.T) {
} }
func TestIncrementUint8(t *testing.T) { func TestIncrementUint8(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint8", uint8(1), 0) tc.Set("tuint8", uint8(1), DefaultExpiration)
n, err := tc.IncrementUint8("tuint8", 2) n, err := tc.IncrementUint8("tuint8", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -790,8 +790,8 @@ func TestIncrementUint8(t *testing.T) {
} }
func TestIncrementUint16(t *testing.T) { func TestIncrementUint16(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint16", uint16(1), 0) tc.Set("tuint16", uint16(1), DefaultExpiration)
n, err := tc.IncrementUint16("tuint16", 2) n, err := tc.IncrementUint16("tuint16", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -809,8 +809,8 @@ func TestIncrementUint16(t *testing.T) {
} }
func TestIncrementUint32(t *testing.T) { func TestIncrementUint32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint32", uint32(1), 0) tc.Set("tuint32", uint32(1), DefaultExpiration)
n, err := tc.IncrementUint32("tuint32", 2) n, err := tc.IncrementUint32("tuint32", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -828,8 +828,8 @@ func TestIncrementUint32(t *testing.T) {
} }
func TestIncrementUint64(t *testing.T) { func TestIncrementUint64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("tuint64", uint64(1), 0) tc.Set("tuint64", uint64(1), DefaultExpiration)
n, err := tc.IncrementUint64("tuint64", 2) n, err := tc.IncrementUint64("tuint64", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -847,8 +847,8 @@ func TestIncrementUint64(t *testing.T) {
} }
func TestIncrementFloat32(t *testing.T) { func TestIncrementFloat32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float32", float32(1.5), 0) tc.Set("float32", float32(1.5), DefaultExpiration)
n, err := tc.IncrementFloat32("float32", 2) n, err := tc.IncrementFloat32("float32", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -866,8 +866,8 @@ func TestIncrementFloat32(t *testing.T) {
} }
func TestIncrementFloat64(t *testing.T) { func TestIncrementFloat64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float64", float64(1.5), 0) tc.Set("float64", float64(1.5), DefaultExpiration)
n, err := tc.IncrementFloat64("float64", 2) n, err := tc.IncrementFloat64("float64", 2)
if err != nil { if err != nil {
t.Error("Error incrementing:", err) t.Error("Error incrementing:", err)
@ -885,8 +885,8 @@ func TestIncrementFloat64(t *testing.T) {
} }
func TestDecrementInt8(t *testing.T) { func TestDecrementInt8(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int8", int8(5), 0) tc.Set("int8", int8(5), DefaultExpiration)
n, err := tc.DecrementInt8("int8", 2) n, err := tc.DecrementInt8("int8", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -904,8 +904,8 @@ func TestDecrementInt8(t *testing.T) {
} }
func TestDecrementInt16(t *testing.T) { func TestDecrementInt16(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int16", int16(5), 0) tc.Set("int16", int16(5), DefaultExpiration)
n, err := tc.DecrementInt16("int16", 2) n, err := tc.DecrementInt16("int16", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -923,8 +923,8 @@ func TestDecrementInt16(t *testing.T) {
} }
func TestDecrementInt32(t *testing.T) { func TestDecrementInt32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int32", int32(5), 0) tc.Set("int32", int32(5), DefaultExpiration)
n, err := tc.DecrementInt32("int32", 2) n, err := tc.DecrementInt32("int32", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -942,8 +942,8 @@ func TestDecrementInt32(t *testing.T) {
} }
func TestDecrementInt64(t *testing.T) { func TestDecrementInt64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int64", int64(5), 0) tc.Set("int64", int64(5), DefaultExpiration)
n, err := tc.DecrementInt64("int64", 2) n, err := tc.DecrementInt64("int64", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -961,8 +961,8 @@ func TestDecrementInt64(t *testing.T) {
} }
func TestDecrementUint(t *testing.T) { func TestDecrementUint(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint", uint(5), 0) tc.Set("uint", uint(5), DefaultExpiration)
n, err := tc.DecrementUint("uint", 2) n, err := tc.DecrementUint("uint", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -980,8 +980,8 @@ func TestDecrementUint(t *testing.T) {
} }
func TestDecrementUintptr(t *testing.T) { func TestDecrementUintptr(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uintptr", uintptr(5), 0) tc.Set("uintptr", uintptr(5), DefaultExpiration)
n, err := tc.DecrementUintptr("uintptr", 2) n, err := tc.DecrementUintptr("uintptr", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -999,8 +999,8 @@ func TestDecrementUintptr(t *testing.T) {
} }
func TestDecrementUint8(t *testing.T) { func TestDecrementUint8(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint8", uint8(5), 0) tc.Set("uint8", uint8(5), DefaultExpiration)
n, err := tc.DecrementUint8("uint8", 2) n, err := tc.DecrementUint8("uint8", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -1018,8 +1018,8 @@ func TestDecrementUint8(t *testing.T) {
} }
func TestDecrementUint16(t *testing.T) { func TestDecrementUint16(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint16", uint16(5), 0) tc.Set("uint16", uint16(5), DefaultExpiration)
n, err := tc.DecrementUint16("uint16", 2) n, err := tc.DecrementUint16("uint16", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -1037,8 +1037,8 @@ func TestDecrementUint16(t *testing.T) {
} }
func TestDecrementUint32(t *testing.T) { func TestDecrementUint32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint32", uint32(5), 0) tc.Set("uint32", uint32(5), DefaultExpiration)
n, err := tc.DecrementUint32("uint32", 2) n, err := tc.DecrementUint32("uint32", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -1056,8 +1056,8 @@ func TestDecrementUint32(t *testing.T) {
} }
func TestDecrementUint64(t *testing.T) { func TestDecrementUint64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint64", uint64(5), 0) tc.Set("uint64", uint64(5), DefaultExpiration)
n, err := tc.DecrementUint64("uint64", 2) n, err := tc.DecrementUint64("uint64", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -1075,8 +1075,8 @@ func TestDecrementUint64(t *testing.T) {
} }
func TestDecrementFloat32(t *testing.T) { func TestDecrementFloat32(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float32", float32(5), 0) tc.Set("float32", float32(5), DefaultExpiration)
n, err := tc.DecrementFloat32("float32", 2) n, err := tc.DecrementFloat32("float32", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -1094,8 +1094,8 @@ func TestDecrementFloat32(t *testing.T) {
} }
func TestDecrementFloat64(t *testing.T) { func TestDecrementFloat64(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("float64", float64(5), 0) tc.Set("float64", float64(5), DefaultExpiration)
n, err := tc.DecrementFloat64("float64", 2) n, err := tc.DecrementFloat64("float64", 2)
if err != nil { if err != nil {
t.Error("Error decrementing:", err) t.Error("Error decrementing:", err)
@ -1113,33 +1113,33 @@ func TestDecrementFloat64(t *testing.T) {
} }
func TestAdd(t *testing.T) { func TestAdd(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
err := tc.Add("foo", "bar", 0) err := tc.Add("foo", "bar", DefaultExpiration)
if err != nil { if err != nil {
t.Error("Couldn't add foo even though it shouldn't exist") t.Error("Couldn't add foo even though it shouldn't exist")
} }
err = tc.Add("foo", "baz", 0) err = tc.Add("foo", "baz", DefaultExpiration)
if err == nil { if err == nil {
t.Error("Successfully added another foo when it should have returned an error") t.Error("Successfully added another foo when it should have returned an error")
} }
} }
func TestReplace(t *testing.T) { func TestReplace(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
err := tc.Replace("foo", "bar", 0) err := tc.Replace("foo", "bar", DefaultExpiration)
if err == nil { if err == nil {
t.Error("Replaced foo when it shouldn't exist") t.Error("Replaced foo when it shouldn't exist")
} }
tc.Set("foo", "bar", 0) tc.Set("foo", "bar", DefaultExpiration)
err = tc.Replace("foo", "bar", 0) err = tc.Replace("foo", "bar", DefaultExpiration)
if err != nil { if err != nil {
t.Error("Couldn't replace existing key foo") t.Error("Couldn't replace existing key foo")
} }
} }
func TestDelete(t *testing.T) { func TestDelete(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("foo", "bar", 0) tc.Set("foo", "bar", DefaultExpiration)
tc.Delete("foo") tc.Delete("foo")
x, found := tc.Get("foo") x, found := tc.Get("foo")
if found { if found {
@ -1151,19 +1151,19 @@ func TestDelete(t *testing.T) {
} }
func TestItemCount(t *testing.T) { func TestItemCount(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("foo", "1", 0) tc.Set("foo", "1", DefaultExpiration)
tc.Set("bar", "2", 0) tc.Set("bar", "2", DefaultExpiration)
tc.Set("baz", "3", 0) tc.Set("baz", "3", DefaultExpiration)
if n := tc.ItemCount(); n != 3 { if n := tc.ItemCount(); n != 3 {
t.Errorf("Item count is not 3: %d", n) t.Errorf("Item count is not 3: %d", n)
} }
} }
func TestFlush(t *testing.T) { func TestFlush(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("foo", "bar", 0) tc.Set("foo", "bar", DefaultExpiration)
tc.Set("baz", "yes", 0) tc.Set("baz", "yes", DefaultExpiration)
tc.Flush() tc.Flush()
x, found := tc.Get("foo") x, found := tc.Get("foo")
if found { if found {
@ -1182,8 +1182,8 @@ func TestFlush(t *testing.T) {
} }
func TestIncrementOverflowInt(t *testing.T) { func TestIncrementOverflowInt(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("int8", int8(127), 0) tc.Set("int8", int8(127), DefaultExpiration)
err := tc.Increment("int8", 1) err := tc.Increment("int8", 1)
if err != nil { if err != nil {
t.Error("Error incrementing int8:", err) t.Error("Error incrementing int8:", err)
@ -1197,8 +1197,8 @@ func TestIncrementOverflowInt(t *testing.T) {
} }
func TestIncrementOverflowUint(t *testing.T) { func TestIncrementOverflowUint(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint8", uint8(255), 0) tc.Set("uint8", uint8(255), DefaultExpiration)
err := tc.Increment("uint8", 1) err := tc.Increment("uint8", 1)
if err != nil { if err != nil {
t.Error("Error incrementing int8:", err) t.Error("Error incrementing int8:", err)
@ -1211,8 +1211,8 @@ func TestIncrementOverflowUint(t *testing.T) {
} }
func TestDecrementUnderflowUint(t *testing.T) { func TestDecrementUnderflowUint(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("uint8", uint8(0), 0) tc.Set("uint8", uint8(0), DefaultExpiration)
err := tc.Decrement("uint8", 1) err := tc.Decrement("uint8", 1)
if err != nil { if err != nil {
t.Error("Error decrementing int8:", err) t.Error("Error decrementing int8:", err)
@ -1225,7 +1225,7 @@ func TestDecrementUnderflowUint(t *testing.T) {
} }
func TestCacheSerialization(t *testing.T) { func TestCacheSerialization(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
testFillAndSerialize(t, tc) testFillAndSerialize(t, tc)
// Check if gob.Register behaves properly even after multiple gob.Register // Check if gob.Register behaves properly even after multiple gob.Register
@ -1234,26 +1234,26 @@ func TestCacheSerialization(t *testing.T) {
} }
func testFillAndSerialize(t *testing.T, tc *Cache) { func testFillAndSerialize(t *testing.T, tc *Cache) {
tc.Set("a", "a", 0) tc.Set("a", "a", DefaultExpiration)
tc.Set("b", "b", 0) tc.Set("b", "b", DefaultExpiration)
tc.Set("c", "c", 0) tc.Set("c", "c", DefaultExpiration)
tc.Set("expired", "foo", 1*time.Millisecond) tc.Set("expired", "foo", 1*time.Millisecond)
tc.Set("*struct", &TestStruct{Num: 1}, 0) tc.Set("*struct", &TestStruct{Num: 1}, DefaultExpiration)
tc.Set("[]struct", []TestStruct{ tc.Set("[]struct", []TestStruct{
{Num: 2}, {Num: 2},
{Num: 3}, {Num: 3},
}, 0) }, DefaultExpiration)
tc.Set("[]*struct", []*TestStruct{ tc.Set("[]*struct", []*TestStruct{
&TestStruct{Num: 4}, &TestStruct{Num: 4},
&TestStruct{Num: 5}, &TestStruct{Num: 5},
}, 0) }, DefaultExpiration)
tc.Set("structception", &TestStruct{ tc.Set("structception", &TestStruct{
Num: 42, Num: 42,
Children: []*TestStruct{ Children: []*TestStruct{
&TestStruct{Num: 6174}, &TestStruct{Num: 6174},
&TestStruct{Num: 4716}, &TestStruct{Num: 4716},
}, },
}, 0) }, DefaultExpiration)
fp := &bytes.Buffer{} fp := &bytes.Buffer{}
err := tc.Save(fp) err := tc.Save(fp)
@ -1261,7 +1261,7 @@ func testFillAndSerialize(t *testing.T, tc *Cache) {
t.Fatal("Couldn't save cache to fp:", err) t.Fatal("Couldn't save cache to fp:", err)
} }
oc := New(0, 0) oc := New(DefaultExpiration, 0)
err = oc.Load(fp) err = oc.Load(fp)
if err != nil { if err != nil {
t.Fatal("Couldn't load cache from fp:", err) t.Fatal("Couldn't load cache from fp:", err)
@ -1352,9 +1352,9 @@ func testFillAndSerialize(t *testing.T, tc *Cache) {
} }
func TestFileSerialization(t *testing.T) { func TestFileSerialization(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Add("a", "a", 0) tc.Add("a", "a", DefaultExpiration)
tc.Add("b", "b", 0) tc.Add("b", "b", DefaultExpiration)
f, err := ioutil.TempFile("", "go-cache-cache.dat") f, err := ioutil.TempFile("", "go-cache-cache.dat")
if err != nil { if err != nil {
t.Fatal("Couldn't create cache file:", err) t.Fatal("Couldn't create cache file:", err)
@ -1363,7 +1363,7 @@ func TestFileSerialization(t *testing.T) {
f.Close() f.Close()
tc.SaveFile(fname) tc.SaveFile(fname)
oc := New(0, 0) oc := New(DefaultExpiration, 0)
oc.Add("a", "aa", 0) // this should not be overwritten oc.Add("a", "aa", 0) // this should not be overwritten
err = oc.LoadFile(fname) err = oc.LoadFile(fname)
if err != nil { if err != nil {
@ -1391,10 +1391,10 @@ func TestFileSerialization(t *testing.T) {
} }
func TestSerializeUnserializable(t *testing.T) { func TestSerializeUnserializable(t *testing.T) {
tc := New(0, 0) tc := New(DefaultExpiration, 0)
ch := make(chan bool, 1) ch := make(chan bool, 1)
ch <- true ch <- true
tc.Set("chan", ch, 0) tc.Set("chan", ch, DefaultExpiration)
fp := &bytes.Buffer{} fp := &bytes.Buffer{}
err := tc.Save(fp) // this should fail gracefully err := tc.Save(fp) // this should fail gracefully
if err.Error() != "gob NewTypeObject can't handle type: chan bool" { if err.Error() != "gob NewTypeObject can't handle type: chan bool" {
@ -1404,8 +1404,8 @@ func TestSerializeUnserializable(t *testing.T) {
func BenchmarkCacheGet(b *testing.B) { func BenchmarkCacheGet(b *testing.B) {
b.StopTimer() b.StopTimer()
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("foo", "bar", 0) tc.Set("foo", "bar", DefaultExpiration)
b.StartTimer() b.StartTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
tc.Get("foo") tc.Get("foo")
@ -1428,8 +1428,8 @@ func BenchmarkRWMutexMapGet(b *testing.B) {
func BenchmarkCacheGetConcurrent(b *testing.B) { func BenchmarkCacheGetConcurrent(b *testing.B) {
b.StopTimer() b.StopTimer()
tc := New(0, 0) tc := New(DefaultExpiration, 0)
tc.Set("foo", "bar", 0) tc.Set("foo", "bar", DefaultExpiration)
wg := new(sync.WaitGroup) wg := new(sync.WaitGroup)
workers := runtime.NumCPU() workers := runtime.NumCPU()
each := b.N / workers each := b.N / workers
@ -1475,12 +1475,12 @@ func BenchmarkCacheGetManyConcurrent(b *testing.B) {
// can be compared against BenchmarkShardedCacheGetManyConcurrent. // can be compared against BenchmarkShardedCacheGetManyConcurrent.
b.StopTimer() b.StopTimer()
n := 10000 n := 10000
tc := New(0, 0) tc := New(DefaultExpiration, 0)
keys := make([]string, n) keys := make([]string, n)
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
k := "foo" + strconv.Itoa(n) k := "foo" + strconv.Itoa(n)
keys[i] = k keys[i] = k
tc.Set(k, "bar", 0) tc.Set(k, "bar", DefaultExpiration)
} }
each := b.N / n each := b.N / n
wg := new(sync.WaitGroup) wg := new(sync.WaitGroup)
@ -1500,12 +1500,12 @@ func BenchmarkCacheGetManyConcurrent(b *testing.B) {
func BenchmarkShardedCacheGetManyConcurrent(b *testing.B) { func BenchmarkShardedCacheGetManyConcurrent(b *testing.B) {
b.StopTimer() b.StopTimer()
n := 10000 n := 10000
tsc := unexportedNewSharded(20, 0, 0) tsc := unexportedNewSharded(20, DefaultExpiration, 0)
keys := make([]string, n) keys := make([]string, n)
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
k := "foo" + strconv.Itoa(n) k := "foo" + strconv.Itoa(n)
keys[i] = k keys[i] = k
tsc.Set(k, "bar", 0) tsc.Set(k, "bar", DefaultExpiration)
} }
each := b.N / n each := b.N / n
wg := new(sync.WaitGroup) wg := new(sync.WaitGroup)
@ -1524,10 +1524,10 @@ func BenchmarkShardedCacheGetManyConcurrent(b *testing.B) {
func BenchmarkCacheSet(b *testing.B) { func BenchmarkCacheSet(b *testing.B) {
b.StopTimer() b.StopTimer()
tc := New(0, 0) tc := New(DefaultExpiration, 0)
b.StartTimer() b.StartTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
tc.Set("foo", "bar", 0) tc.Set("foo", "bar", DefaultExpiration)
} }
} }
@ -1545,10 +1545,10 @@ func BenchmarkRWMutexMapSet(b *testing.B) {
func BenchmarkCacheSetDelete(b *testing.B) { func BenchmarkCacheSetDelete(b *testing.B) {
b.StopTimer() b.StopTimer()
tc := New(0, 0) tc := New(DefaultExpiration, 0)
b.StartTimer() b.StartTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
tc.Set("foo", "bar", 0) tc.Set("foo", "bar", DefaultExpiration)
tc.Delete("foo") tc.Delete("foo")
} }
} }
@ -1570,11 +1570,11 @@ func BenchmarkRWMutexMapSetDelete(b *testing.B) {
func BenchmarkCacheSetDeleteSingleLock(b *testing.B) { func BenchmarkCacheSetDeleteSingleLock(b *testing.B) {
b.StopTimer() b.StopTimer()
tc := New(0, 0) tc := New(DefaultExpiration, 0)
b.StartTimer() b.StartTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
tc.Lock() tc.Lock()
tc.set("foo", "bar", 0) tc.set("foo", "bar", DefaultExpiration)
tc.delete("foo") tc.delete("foo")
tc.Unlock() tc.Unlock()
} }

Write Preview
Loading…
Cancel
Save