763 lines
16 KiB
Go
763 lines
16 KiB
Go
/*
|
|
* Copyright 2020 The Dragonfly Authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package cache
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"runtime"
|
|
"strconv"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
testifyassert "github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
var (
|
|
v1 = "foo"
|
|
v2 = "bar"
|
|
v3 = "baz"
|
|
v4 = "yes"
|
|
)
|
|
|
|
type TestStruct struct {
|
|
Num int
|
|
Children []*TestStruct
|
|
}
|
|
|
|
func TestCache(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
|
|
a, found := tc.Get("a")
|
|
if found || a != nil {
|
|
t.Error("Getting A found value that shouldn't exist:", a)
|
|
}
|
|
|
|
b, found := tc.Get("b")
|
|
if found || b != nil {
|
|
t.Error("Getting B found value that shouldn't exist:", b)
|
|
}
|
|
|
|
c, found := tc.Get("c")
|
|
if found || c != nil {
|
|
t.Error("Getting C found value that shouldn't exist:", c)
|
|
}
|
|
|
|
tc.Set("a", 1, DefaultExpiration)
|
|
tc.Set("b", "b", DefaultExpiration)
|
|
tc.Set("c", 3.5, DefaultExpiration)
|
|
|
|
x, found := tc.Get("a")
|
|
if !found {
|
|
t.Error("a was not found while getting a2")
|
|
}
|
|
if x == nil {
|
|
t.Error("x for a is nil")
|
|
} else if a2 := x.(int); a2+2 != 3 {
|
|
t.Error("a2 (which should be 1) plus 2 does not equal 3; value:", a2)
|
|
}
|
|
|
|
x, found = tc.Get("b")
|
|
if !found {
|
|
t.Error("b was not found while getting b2")
|
|
}
|
|
if x == nil {
|
|
t.Error("x for b is nil")
|
|
} else if b2 := x.(string); b2+"B" != "bB" {
|
|
t.Error("b2 (which should be b) plus B does not equal bB; value:", b2)
|
|
}
|
|
|
|
x, found = tc.Get("c")
|
|
if !found {
|
|
t.Error("c was not found while getting c2")
|
|
}
|
|
if x == nil {
|
|
t.Error("x for c is nil")
|
|
} else if c2 := x.(float64); c2+1.2 != 4.7 {
|
|
t.Error("c2 (which should be 3.5) plus 1.2 does not equal 4.7; value:", c2)
|
|
}
|
|
}
|
|
|
|
func TestCacheTimes(t *testing.T) {
|
|
var found bool
|
|
|
|
tc := New(100*time.Millisecond, 1*time.Millisecond)
|
|
tc.Set("a", 1, DefaultExpiration)
|
|
tc.Set("b", 2, NoExpiration)
|
|
tc.Set("c", 3, 40*time.Millisecond)
|
|
tc.Set("d", 4, 140*time.Millisecond)
|
|
|
|
<-time.After(50 * time.Millisecond)
|
|
_, found = tc.Get("c")
|
|
if found {
|
|
t.Error("Found c when it should have been automatically deleted")
|
|
}
|
|
|
|
<-time.After(80 * time.Millisecond)
|
|
_, found = tc.Get("a")
|
|
if found {
|
|
t.Error("Found a when it should have been automatically deleted")
|
|
}
|
|
|
|
_, found = tc.Get("b")
|
|
if !found {
|
|
t.Error("Did not find b even though it was set to never expire")
|
|
}
|
|
|
|
_, found = tc.Get("d")
|
|
if !found {
|
|
t.Error("Did not find d even though it was set to expire later than the default")
|
|
}
|
|
|
|
<-time.After(40 * time.Millisecond)
|
|
_, found = tc.Get("d")
|
|
if found {
|
|
t.Error("Found d when it should have been automatically deleted (later than the default)")
|
|
}
|
|
}
|
|
|
|
func TestStorePointerToStruct(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
tc.Set(v1, &TestStruct{Num: 1}, DefaultExpiration)
|
|
x, found := tc.Get(v1)
|
|
if !found {
|
|
t.Fatal("*TestStruct was not found for foo")
|
|
}
|
|
foo := x.(*TestStruct)
|
|
foo.Num++
|
|
|
|
y, found := tc.Get(v1)
|
|
if !found {
|
|
t.Fatal("*TestStruct was not found for foo (second time)")
|
|
}
|
|
bar := y.(*TestStruct)
|
|
if bar.Num != 2 {
|
|
t.Fatal("TestStruct.Num is not 2")
|
|
}
|
|
}
|
|
|
|
func TestScan(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
tc.Set(v2, v1, DefaultExpiration)
|
|
tc.Set(v3, v1, DefaultExpiration)
|
|
keys, err := tc.Scan("^b", 1)
|
|
if err != nil {
|
|
t.Error("Couldn't parse a regular expression and returns")
|
|
}
|
|
|
|
if len(keys) != 1 {
|
|
t.Error("Invalid number of scaning cache keys")
|
|
}
|
|
|
|
keys, err = tc.Scan("^b", 2)
|
|
if err != nil {
|
|
t.Error("Couldn't parse a regular expression and returns")
|
|
}
|
|
|
|
if len(keys) != 2 {
|
|
t.Error("Invalid number of scaning cache keys")
|
|
}
|
|
|
|
keys, err = tc.Scan("^b", 4)
|
|
if err != nil {
|
|
t.Error("Couldn't parse a regular expression and returns")
|
|
}
|
|
|
|
if len(keys) != 2 {
|
|
t.Error("Invalid number of scaning cache keys")
|
|
}
|
|
|
|
keys, err = tc.Scan("^ba", 2)
|
|
if err != nil {
|
|
t.Error("Couldn't parse a regular expression and returns")
|
|
}
|
|
|
|
if len(keys) != 2 {
|
|
t.Error("Invalid number of scaning cache keys")
|
|
}
|
|
|
|
keys, err = tc.Scan("^a", 2)
|
|
if err != nil {
|
|
t.Error("Couldn't parse a regular expression and returns")
|
|
}
|
|
|
|
if len(keys) != 0 {
|
|
t.Error("Invalid number of scaning cache keys")
|
|
}
|
|
|
|
_, err = tc.Scan("(", 2)
|
|
if err == nil {
|
|
t.Error("Parse a fault regular expression")
|
|
}
|
|
}
|
|
|
|
func TestAdd(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
err := tc.Add(v1, v2, DefaultExpiration)
|
|
if err != nil {
|
|
t.Error("Couldn't add foo even though it shouldn't exist")
|
|
}
|
|
err = tc.Add(v1, v3, DefaultExpiration)
|
|
if err == nil {
|
|
t.Error("Successfully added another foo when it should have returned an error")
|
|
}
|
|
}
|
|
|
|
func TestDelete(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
tc.Set(v1, v2, DefaultExpiration)
|
|
tc.Delete(v1)
|
|
x, found := tc.Get(v1)
|
|
if found {
|
|
t.Error("foo was found, but it should have been deleted")
|
|
}
|
|
if x != nil {
|
|
t.Error("x is not nil:", x)
|
|
}
|
|
}
|
|
|
|
func TestCacheKeys(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
tc.Set(v1, 1, DefaultExpiration)
|
|
tc.Set(v2, 2, DefaultExpiration)
|
|
tc.Set(v3, 3, DefaultExpiration)
|
|
keys := tc.Keys()
|
|
if len(keys) != 3 {
|
|
t.Error("invalid number of cache keys received")
|
|
}
|
|
}
|
|
|
|
func TestItems(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
tc.Set(v1, "1", 1)
|
|
tc.Set(v2, "2", DefaultExpiration)
|
|
tc.Set(v3, "3", DefaultExpiration)
|
|
m := tc.Items()
|
|
assert := testifyassert.New(t)
|
|
assert.Equal(map[string]Item{"bar": {Object: "2", Expiration: 0}, "baz": {Object: "3", Expiration: 0}}, m)
|
|
}
|
|
|
|
func TestItemCount(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
tc.Set(v1, "1", DefaultExpiration)
|
|
tc.Set(v2, "2", DefaultExpiration)
|
|
tc.Set(v3, "3", DefaultExpiration)
|
|
if n := tc.ItemCount(); n != 3 {
|
|
t.Errorf("Item count is not 3: %d", n)
|
|
}
|
|
}
|
|
|
|
func TestFlush(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
tc.Set(v1, v2, DefaultExpiration)
|
|
tc.Set(v3, v4, DefaultExpiration)
|
|
tc.Flush()
|
|
x, found := tc.Get(v1)
|
|
if found {
|
|
t.Error("foo was found, but it should have been deleted")
|
|
}
|
|
if x != nil {
|
|
t.Error("x is not nil:", x)
|
|
}
|
|
x, found = tc.Get(v3)
|
|
if found {
|
|
t.Error("baz was found, but it should have been deleted")
|
|
}
|
|
if x != nil {
|
|
t.Error("x is not nil:", x)
|
|
}
|
|
}
|
|
|
|
func TestOnEvicted(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
tc.Set(v1, 3, DefaultExpiration)
|
|
works := false
|
|
tc.OnEvicted(func(k string, v any) {
|
|
if k == v1 && v.(int) == 3 {
|
|
works = true
|
|
}
|
|
tc.Set(v2, 4, DefaultExpiration)
|
|
})
|
|
tc.Delete(v1)
|
|
x, _ := tc.Get(v2)
|
|
if !works {
|
|
t.Error("works bool not true")
|
|
}
|
|
if x.(int) != 4 {
|
|
t.Error("bar was not 4")
|
|
}
|
|
}
|
|
|
|
func TestCacheSerialization(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
testFillAndSerialize(t, tc)
|
|
|
|
// Check if gob.Register behaves properly even after multiple gob.Register
|
|
// on c.Items (many of which will be the same type)
|
|
testFillAndSerialize(t, tc)
|
|
}
|
|
|
|
func testFillAndSerialize(t *testing.T, tc Cache) {
|
|
tc.Set("a", "a", DefaultExpiration)
|
|
tc.Set("b", "b", DefaultExpiration)
|
|
tc.Set("c", "c", DefaultExpiration)
|
|
tc.Set("expired", "foo", 1*time.Millisecond)
|
|
tc.Set("*struct", &TestStruct{Num: 1}, DefaultExpiration)
|
|
tc.Set("[]struct", []TestStruct{
|
|
{Num: 2},
|
|
{Num: 3},
|
|
}, DefaultExpiration)
|
|
|
|
fp := &bytes.Buffer{}
|
|
err := tc.Save(fp)
|
|
if err != nil {
|
|
t.Fatal("Couldn't save cache to fp:", err)
|
|
}
|
|
|
|
oc := New(DefaultExpiration, 0)
|
|
err = oc.Load(fp)
|
|
if err != nil {
|
|
t.Fatal("Couldn't load cache from fp:", err)
|
|
}
|
|
|
|
a, found := oc.Get("a")
|
|
if !found {
|
|
t.Error("a was not found")
|
|
}
|
|
if a.(string) != "a" {
|
|
t.Error("a is not a")
|
|
}
|
|
|
|
b, found := oc.Get("b")
|
|
if !found {
|
|
t.Error("b was not found")
|
|
}
|
|
if b.(string) != "b" {
|
|
t.Error("b is not b")
|
|
}
|
|
|
|
c, found := oc.Get("c")
|
|
if !found {
|
|
t.Error("c was not found")
|
|
}
|
|
if c.(string) != "c" {
|
|
t.Error("c is not c")
|
|
}
|
|
|
|
<-time.After(5 * time.Millisecond)
|
|
_, found = oc.Get("expired")
|
|
if !found {
|
|
t.Error("expired was not found")
|
|
}
|
|
|
|
s1, found := oc.Get("*struct")
|
|
if !found {
|
|
t.Error("*struct was not found")
|
|
}
|
|
if s1.(*TestStruct).Num != 1 {
|
|
t.Error("*struct.Num is not 1")
|
|
}
|
|
|
|
s2, found := oc.Get("[]struct")
|
|
if !found {
|
|
t.Error("[]struct was not found")
|
|
}
|
|
s2r := s2.([]TestStruct)
|
|
if len(s2r) != 2 {
|
|
t.Error("Length of s2r is not 2")
|
|
}
|
|
if s2r[0].Num != 2 {
|
|
t.Error("s2r[0].Num is not 2")
|
|
}
|
|
if s2r[1].Num != 3 {
|
|
t.Error("s2r[1].Num is not 3")
|
|
}
|
|
}
|
|
|
|
func TestFileSerialization(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
if err := tc.Add("a", "a", DefaultExpiration); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if err := tc.Add("b", "b", DefaultExpiration); err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
f, err := os.CreateTemp("", "go-cache-cache.dat")
|
|
if err != nil {
|
|
t.Fatal("Couldn't create cache file:", err)
|
|
}
|
|
fname := f.Name()
|
|
f.Close()
|
|
|
|
if err := tc.SaveFile(fname); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
oc := New(DefaultExpiration, 0)
|
|
// this should not be overwritten
|
|
if err := oc.Add("a", "aa", 0); err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if err := oc.LoadFile(fname); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
a, found := oc.Get("a")
|
|
if !found {
|
|
t.Error("a was not found")
|
|
}
|
|
|
|
astr := a.(string)
|
|
if astr != "aa" {
|
|
if astr == "a" {
|
|
t.Error("a was overwritten")
|
|
} else {
|
|
t.Error("a is not aa")
|
|
}
|
|
}
|
|
|
|
b, found := oc.Get("b")
|
|
if !found {
|
|
t.Error("b was not found")
|
|
}
|
|
|
|
if b.(string) != "b" {
|
|
t.Error("b is not b")
|
|
}
|
|
}
|
|
|
|
func TestSerializeUnserializable(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
ch := make(chan bool, 1)
|
|
ch <- true
|
|
tc.Set("chan", ch, DefaultExpiration)
|
|
fp := &bytes.Buffer{}
|
|
err := tc.Save(fp) // this should fail gracefully
|
|
if err.Error() != "gob NewTypeObject can't handle type: chan bool" {
|
|
t.Error("Error from Save was not gob NewTypeObject can't handle type chan bool:", err)
|
|
}
|
|
}
|
|
|
|
func BenchmarkCacheGetExpiring(b *testing.B) {
|
|
benchmarkCacheGet(b, 5*time.Minute)
|
|
}
|
|
|
|
func BenchmarkCacheGetNotExpiring(b *testing.B) {
|
|
benchmarkCacheGet(b, NoExpiration)
|
|
}
|
|
|
|
func benchmarkCacheGet(b *testing.B, exp time.Duration) {
|
|
b.StopTimer()
|
|
tc := New(exp, 0)
|
|
tc.Set(v1, v2, DefaultExpiration)
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
tc.Get(v1)
|
|
}
|
|
}
|
|
|
|
func BenchmarkRWMutexMapGet(b *testing.B) {
|
|
b.StopTimer()
|
|
m := map[string]string{
|
|
v1: v2,
|
|
}
|
|
var mu sync.RWMutex
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
mu.RLock()
|
|
_, _ = m[v1]
|
|
mu.RUnlock()
|
|
}
|
|
}
|
|
|
|
func BenchmarkRWMutexInterfaceMapGetStruct(b *testing.B) {
|
|
b.StopTimer()
|
|
s := struct{ name string }{name: v1}
|
|
m := map[any]string{
|
|
s: v2,
|
|
}
|
|
var mu sync.RWMutex
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
mu.RLock()
|
|
_, _ = m[s]
|
|
mu.RUnlock()
|
|
}
|
|
}
|
|
|
|
func BenchmarkRWMutexInterfaceMapGetString(b *testing.B) {
|
|
b.StopTimer()
|
|
m := map[any]string{
|
|
v1: v2,
|
|
}
|
|
var mu sync.RWMutex
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
mu.RLock()
|
|
_, _ = m[v1]
|
|
mu.RUnlock()
|
|
}
|
|
}
|
|
|
|
func BenchmarkCacheGetConcurrentExpiring(b *testing.B) {
|
|
benchmarkCacheGetConcurrent(b, 5*time.Minute)
|
|
}
|
|
|
|
func BenchmarkCacheGetConcurrentNotExpiring(b *testing.B) {
|
|
benchmarkCacheGetConcurrent(b, NoExpiration)
|
|
}
|
|
|
|
func benchmarkCacheGetConcurrent(b *testing.B, exp time.Duration) {
|
|
b.StopTimer()
|
|
tc := New(exp, 0)
|
|
tc.Set(v1, v2, DefaultExpiration)
|
|
wg := new(sync.WaitGroup)
|
|
workers := runtime.NumCPU()
|
|
each := b.N / workers
|
|
wg.Add(workers)
|
|
b.StartTimer()
|
|
for range workers {
|
|
go func() {
|
|
for range each {
|
|
tc.Get(v1)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func BenchmarkRWMutexMapGetConcurrent(b *testing.B) {
|
|
b.StopTimer()
|
|
m := map[string]string{
|
|
v1: v2,
|
|
}
|
|
mu := sync.RWMutex{}
|
|
wg := new(sync.WaitGroup)
|
|
workers := runtime.NumCPU()
|
|
each := b.N / workers
|
|
wg.Add(workers)
|
|
b.StartTimer()
|
|
for range workers {
|
|
go func() {
|
|
for range each {
|
|
mu.RLock()
|
|
_, _ = m[v1]
|
|
mu.RUnlock()
|
|
}
|
|
wg.Done()
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func BenchmarkCacheGetManyConcurrentExpiring(b *testing.B) {
|
|
benchmarkCacheGetManyConcurrent(b, 5*time.Minute)
|
|
}
|
|
|
|
func BenchmarkCacheGetManyConcurrentNotExpiring(b *testing.B) {
|
|
benchmarkCacheGetManyConcurrent(b, NoExpiration)
|
|
}
|
|
|
|
func benchmarkCacheGetManyConcurrent(b *testing.B, exp time.Duration) {
|
|
// This is the same as BenchmarkCacheGetConcurrent, but its result
|
|
// can be compared against BenchmarkShardedCacheGetManyConcurrent
|
|
// in sharded_test.go.
|
|
b.StopTimer()
|
|
n := 10000
|
|
tc := New(exp, 0)
|
|
keys := make([]string, n)
|
|
for i := range n {
|
|
k := v1 + strconv.Itoa(i)
|
|
keys[i] = k
|
|
tc.Set(k, v2, DefaultExpiration)
|
|
}
|
|
each := b.N / n
|
|
wg := new(sync.WaitGroup)
|
|
wg.Add(n)
|
|
for _, v := range keys {
|
|
go func(k string) {
|
|
for range each {
|
|
tc.Get(k)
|
|
}
|
|
wg.Done()
|
|
}(v)
|
|
}
|
|
b.StartTimer()
|
|
wg.Wait()
|
|
}
|
|
|
|
func BenchmarkCacheSetExpiring(b *testing.B) {
|
|
benchmarkCacheSet(b, 5*time.Minute)
|
|
}
|
|
|
|
func BenchmarkCacheSetNotExpiring(b *testing.B) {
|
|
benchmarkCacheSet(b, NoExpiration)
|
|
}
|
|
|
|
func benchmarkCacheSet(b *testing.B, exp time.Duration) {
|
|
b.StopTimer()
|
|
tc := New(exp, 0)
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
tc.Set(v1, v2, DefaultExpiration)
|
|
}
|
|
}
|
|
|
|
func BenchmarkRWMutexMapSet(b *testing.B) {
|
|
b.StopTimer()
|
|
m := map[string]string{}
|
|
mu := sync.RWMutex{}
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
mu.Lock()
|
|
m[v1] = v2
|
|
mu.Unlock()
|
|
}
|
|
}
|
|
|
|
func BenchmarkCacheSetDelete(b *testing.B) {
|
|
b.StopTimer()
|
|
tc := New(DefaultExpiration, 0)
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
tc.Set(v1, v2, DefaultExpiration)
|
|
tc.Delete(v1)
|
|
}
|
|
}
|
|
|
|
func BenchmarkRWMutexMapSetDelete(b *testing.B) {
|
|
b.StopTimer()
|
|
m := map[string]string{}
|
|
mu := sync.RWMutex{}
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
mu.Lock()
|
|
m[v1] = v2
|
|
mu.Unlock()
|
|
mu.Lock()
|
|
delete(m, v1)
|
|
mu.Unlock()
|
|
}
|
|
}
|
|
|
|
func BenchmarkRWMutexMapSetDeleteSingleLock(b *testing.B) {
|
|
b.StopTimer()
|
|
m := map[string]string{}
|
|
var mu sync.Mutex
|
|
b.StartTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
mu.Lock()
|
|
m[v1] = v2
|
|
delete(m, v1)
|
|
mu.Unlock()
|
|
}
|
|
}
|
|
|
|
func TestGetWithExpiration(t *testing.T) {
|
|
tc := New(DefaultExpiration, 0)
|
|
|
|
a, expiration, found := tc.GetWithExpiration("a")
|
|
if found || a != nil || !expiration.IsZero() {
|
|
t.Error("Getting A found value that shouldn't exist:", a)
|
|
}
|
|
|
|
b, expiration, found := tc.GetWithExpiration("b")
|
|
if found || b != nil || !expiration.IsZero() {
|
|
t.Error("Getting B found value that shouldn't exist:", b)
|
|
}
|
|
|
|
c, expiration, found := tc.GetWithExpiration("c")
|
|
if found || c != nil || !expiration.IsZero() {
|
|
t.Error("Getting C found value that shouldn't exist:", c)
|
|
}
|
|
|
|
tc.Set("a", 1, DefaultExpiration)
|
|
tc.Set("b", "b", DefaultExpiration)
|
|
tc.Set("c", 3.5, DefaultExpiration)
|
|
tc.Set("d", 1, NoExpiration)
|
|
tc.Set("e", 1, 50*time.Millisecond)
|
|
|
|
x, expiration, found := tc.GetWithExpiration("a")
|
|
if !found {
|
|
t.Error("a was not found while getting a2")
|
|
}
|
|
if x == nil {
|
|
t.Error("x for a is nil")
|
|
} else if a2 := x.(int); a2+2 != 3 {
|
|
t.Error("a2 (which should be 1) plus 2 does not equal 3; value:", a2)
|
|
}
|
|
if !expiration.IsZero() {
|
|
t.Error("expiration for a is not a zeroed time")
|
|
}
|
|
|
|
x, expiration, found = tc.GetWithExpiration("b")
|
|
if !found {
|
|
t.Error("b was not found while getting b2")
|
|
}
|
|
if x == nil {
|
|
t.Error("x for b is nil")
|
|
} else if b2 := x.(string); b2+"B" != "bB" {
|
|
t.Error("b2 (which should be b) plus B does not equal bB; value:", b2)
|
|
}
|
|
if !expiration.IsZero() {
|
|
t.Error("expiration for b is not a zeroed time")
|
|
}
|
|
|
|
x, expiration, found = tc.GetWithExpiration("c")
|
|
if !found {
|
|
t.Error("c was not found while getting c2")
|
|
}
|
|
if x == nil {
|
|
t.Error("x for c is nil")
|
|
} else if c2 := x.(float64); c2+1.2 != 4.7 {
|
|
t.Error("c2 (which should be 3.5) plus 1.2 does not equal 4.7; value:", c2)
|
|
}
|
|
if !expiration.IsZero() {
|
|
t.Error("expiration for c is not a zeroed time")
|
|
}
|
|
|
|
x, expiration, found = tc.GetWithExpiration("d")
|
|
if !found {
|
|
t.Error("d was not found while getting d2")
|
|
}
|
|
if x == nil {
|
|
t.Error("x for d is nil")
|
|
} else if d2 := x.(int); d2+2 != 3 {
|
|
t.Error("d (which should be 1) plus 2 does not equal 3; value:", d2)
|
|
}
|
|
if !expiration.IsZero() {
|
|
t.Error("expiration for d is not a zeroed time")
|
|
}
|
|
|
|
x, expiration, found = tc.GetWithExpiration("e")
|
|
if !found {
|
|
t.Error("e was not found while getting e2")
|
|
}
|
|
if x == nil {
|
|
t.Error("x for e is nil")
|
|
} else if e2 := x.(int); e2+2 != 3 {
|
|
t.Error("e (which should be 1) plus 2 does not equal 3; value:", e2)
|
|
}
|
|
if expiration.UnixNano() < time.Now().UnixNano() {
|
|
t.Error("expiration for e is in the past")
|
|
}
|
|
}
|