package cache import (	"bytes"	"io/ioutil"	"runtime"	"strconv"	"sync"	"testing"	"time") 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(50*time.Millisecond, 1*time.Millisecond)	tc.Set("a", 1, DefaultExpiration)	tc.Set("b", 2, NoExpiration)	tc.Set("c", 3, 20*time.Millisecond)	tc.Set("d", 4, 70*time.Millisecond) 	<-time.After(25 * time.Millisecond)	_, found = tc.Get("c")	if found {		t.Error("Found c when it should have been automatically deleted")	} 	<-time.After(30 * 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(20 * time.Millisecond)	_, found = tc.Get("d")	if found {		t.Error("Found d when it should have been automatically deleted (later than the default)")	}} func TestNewFrom(t *testing.T) {	m := map[string]Item{		"a": Item{			Object:     1,			Expiration: 0,		},		"b": Item{			Object:     2,			Expiration: 0,		},	}	tc := NewFrom(DefaultExpiration, 0, m)	a, found := tc.Get("a")	if !found {		t.Fatal("Did not find a")	}	if a.(int) != 1 {		t.Fatal("a is not 1")	}	b, found := tc.Get("b")	if !found {		t.Fatal("Did not find b")	}	if b.(int) != 2 {		t.Fatal("b is not 2")	}} func TestStorePointerToStruct(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("foo", &TestStruct{Num: 1}, DefaultExpiration)	x, found := tc.Get("foo")	if !found {		t.Fatal("*TestStruct was not found for foo")	}	foo := x.(*TestStruct)	foo.Num++ 	y, found := tc.Get("foo")	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 TestIncrementWithInt(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tint", 1, DefaultExpiration)	err := tc.Increment("tint", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("tint")	if !found {		t.Error("tint was not found")	}	if x.(int) != 3 {		t.Error("tint is not 3:", x)	}} func TestIncrementWithInt8(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tint8", int8(1), DefaultExpiration)	err := tc.Increment("tint8", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("tint8")	if !found {		t.Error("tint8 was not found")	}	if x.(int8) != 3 {		t.Error("tint8 is not 3:", x)	}} func TestIncrementWithInt16(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tint16", int16(1), DefaultExpiration)	err := tc.Increment("tint16", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("tint16")	if !found {		t.Error("tint16 was not found")	}	if x.(int16) != 3 {		t.Error("tint16 is not 3:", x)	}} func TestIncrementWithInt32(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tint32", int32(1), DefaultExpiration)	err := tc.Increment("tint32", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("tint32")	if !found {		t.Error("tint32 was not found")	}	if x.(int32) != 3 {		t.Error("tint32 is not 3:", x)	}} func TestIncrementWithInt64(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tint64", int64(1), DefaultExpiration)	err := tc.Increment("tint64", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("tint64")	if !found {		t.Error("tint64 was not found")	}	if x.(int64) != 3 {		t.Error("tint64 is not 3:", x)	}} func TestIncrementWithUint(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tuint", uint(1), DefaultExpiration)	err := tc.Increment("tuint", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("tuint")	if !found {		t.Error("tuint was not found")	}	if x.(uint) != 3 {		t.Error("tuint is not 3:", x)	}} func TestIncrementWithUintptr(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tuintptr", uintptr(1), DefaultExpiration)	err := tc.Increment("tuintptr", 2)	if err != nil {		t.Error("Error incrementing:", err)	} 	x, found := tc.Get("tuintptr")	if !found {		t.Error("tuintptr was not found")	}	if x.(uintptr) != 3 {		t.Error("tuintptr is not 3:", x)	}} func TestIncrementWithUint8(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tuint8", uint8(1), DefaultExpiration)	err := tc.Increment("tuint8", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("tuint8")	if !found {		t.Error("tuint8 was not found")	}	if x.(uint8) != 3 {		t.Error("tuint8 is not 3:", x)	}} func TestIncrementWithUint16(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tuint16", uint16(1), DefaultExpiration)	err := tc.Increment("tuint16", 2)	if err != nil {		t.Error("Error incrementing:", err)	} 	x, found := tc.Get("tuint16")	if !found {		t.Error("tuint16 was not found")	}	if x.(uint16) != 3 {		t.Error("tuint16 is not 3:", x)	}} func TestIncrementWithUint32(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tuint32", uint32(1), DefaultExpiration)	err := tc.Increment("tuint32", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("tuint32")	if !found {		t.Error("tuint32 was not found")	}	if x.(uint32) != 3 {		t.Error("tuint32 is not 3:", x)	}} func TestIncrementWithUint64(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("tuint64", uint64(1), DefaultExpiration)	err := tc.Increment("tuint64", 2)	if err != nil {		t.Error("Error incrementing:", err)	} 	x, found := tc.Get("tuint64")	if !found {		t.Error("tuint64 was not found")	}	if x.(uint64) != 3 {		t.Error("tuint64 is not 3:", x)	}} func TestIncrementWithFloat32(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("float32", float32(1.5), DefaultExpiration)	err := tc.Increment("float32", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("float32")	if !found {		t.Error("float32 was not found")	}	if x.(float32) != 3.5 {		t.Error("float32 is not 3.5:", x)	}} func TestIncrementWithFloat64(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("float64", float64(1.5), DefaultExpiration)	err := tc.Increment("float64", 2)	if err != nil {		t.Error("Error incrementing:", err)	}	x, found := tc.Get("float64")	if !found {		t.Error("float64 was not found")	}	if x.(float64) != 3.5 {		t.Error("float64 is not 3.5:", x)	}} func TestIncrementFloatWithFloat32(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("float32", float32(1.5), DefaultExpiration)	err := tc.IncrementFloat("float32", 2)	if err != nil {		t.Error("Error incrementfloating:", err)	}	x, found := tc.Get("float32")	if !found {		t.Error("float32 was not found")	}	if x.(float32) != 3.5 {		t.Error("float32 is not 3.5:", x)	}} func TestIncrementFloatWithFloat64(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("float64", float64(1.5), DefaultExpiration)	err := tc.IncrementFloat("float64", 2)	if err != nil {		t.Error("Error incrementfloating:", err)	}	x, found := tc.Get("float64")	if !found {		t.Error("float64 was not found")	}	if x.(float64) != 3.5 {		t.Error("float64 is not 3.5:", x)	}} func TestDecrementWithInt(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("int", int(5), DefaultExpiration)	err := tc.Decrement("int", 2)	if err != nil {		t.Error("Error decrementing:", err)	}	x, found := tc.Get("int")	if !found {		t.Error("int was not found")	}	if x.(int) != 3 {		t.Error("int is not 3:", x)	}} func TestDecrementWithInt8(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("int8", int8(5), DefaultExpiration)	err := tc.Decrement("int8", 2)	if err != nil {		t.Error("Error decrementing:", err)	}	x, found := tc.Get("int8")	if !found {		t.Error("int8 was not found")	}	if x.(int8) != 3 {		t.Error("int8 is not 3:", x)	}} func TestDecrementWithInt16(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("int16", int16(5), DefaultExpiration)	err := tc.Decrement("int16", 2)	if err != nil {		t.Error("Error decrementing:", err)	}	x, found := tc.Get("int16")	if !found {		t.Error("int16 was not found")	}	if x.(int16) != 3 {		t.Error("int16 is not 3:", x)	}} func TestDecrementWithInt32(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("int32", int32(5), DefaultExpiration)	err := tc.Decrement("int32", 2)	if err != nil {		t.Error("Error decrementing:", err)	}	x, found := tc.Get("int32")	if !found {		t.Error("int32 was not found")	}	if x.(int32) != 3 {		t.Error("int32 is not 3:", x)	}} func TestDecrementWithInt64(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("int64", int64(5), DefaultExpiration)	err := tc.Decrement("int64", 2)	if err != nil {		t.Error("Error decrementing:", err)	}	x, found := tc.Get("int64")	if !found {		t.Error("int64 was not found")	}	if x.(int64) != 3 {		t.Error("int64 is not 3:", x)	}} func TestDecrementWithUint(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("uint", uint(5), DefaultExpiration)	err := tc.Decrement("uint", 2)	if err != nil {		t.Error("Error decrementing:", err)	}	x, found := tc.Get("uint")	if !found {		t.Error("uint was not found")	}	if x.(uint) != 3 {		t.Error("uint is not 3:", x)	}} func TestDecrementWithUintptr(t *testing.T) {	tc := New(DefaultExpiration, 0)	tc.Set("uintptr", uintptr(5), DefaultExpiration)	err := tc.Decrement("uintptr", 2)	if err != nil {

Lines 1–500 of 1771. Load more