mirror of
https://gitee.com/johng/gf
synced 2026-06-30 02:51:56 +08:00
ee24da4e72
This pull request standardizes the use of the Go 1.18+ `any` type alias
instead of `interface{}` throughout the codebase. The change improves
code readability and aligns with modern Go best practices. The update
touches many files, including core data structures, code generation
templates, logging utilities, and test data, ensuring consistency across
all usages.
**Type alias migration to `any`:**
* Replaced all instances of `interface{}` with `any` in core data
structures such as `garray` and in generated model structs (e.g.,
`TableUser`, `User1`, `User2`) to modernize type usage.
[[1]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L31-R31)
[[2]](diffhunk://#diff-6c19859cb32c7516ea95ddc8f8235460818eb2f24d2204308e0d9e1b19e7d90fL15-R19)
[[3]](diffhunk://#diff-a15ba2f5e830b4833c47b902515a4f9e5a4f83a3707698f3229b307ec3776b41L15-R18)
[[4]](diffhunk://#diff-52e0837e84d49221d1b810d88fdf78221f36cffcd664fb42f8aba49a79b974dcL15-R19)
[[5]](diffhunk://#diff-11c3457d1a23a4ca6ecd00d6b856289774936b6a708384cf03aff164044e7546L15-R19)
[[6]](diffhunk://#diff-2cff9cf8e6a0cc34087326d8c8149c3bbaf74c76fdbdf5a73daed13cc04249e1L15-R19)
* Updated function signatures, method parameters, and return types from
`interface{}` to `any` in various parts of the codebase, including code
generation, service logic, and logging utilities (e.g., `mlog`).
[[1]](diffhunk://#diff-175edfeea54490b8fe4e18ffcbea5835efaf8f0b8acf623359073987cae7eb76L48-R55)
[[2]](diffhunk://#diff-2b1953fb78cf3593d8c2c7d911e95b65fd0b847c30ed0b4d167d16fe6d781235L54-R74)
[[3]](diffhunk://#diff-e001b7a4b63603b9b14f00de78a4d570bb76c5f57d856a24643f071032e12356L66-R73)
[[4]](diffhunk://#diff-5582954e8a9983988dc8854ad82067fb2ac6269b988e07357ad8db1dfec5f1a0L39-R41)
[[5]](diffhunk://#diff-c5d51d56f487779a2b6207c7ad26c7a20bbadcc846ce094fe60ab4cabff58c51L107-R107)
[[6]](diffhunk://#diff-f96e6a9fdb416eb1804ceaba1fe0ac637bff22c43837f8bb849c2366ce72d4a1L116-R121)
[[7]](diffhunk://#diff-f94c83a1b08ae060d9346f4a6031fc4a7b9a0b894e02d9afaa09018b6598eac0L112-R112)
[[8]](diffhunk://#diff-748b11dbe8828dd4c040ec23cae0b8fe57ecf0a2d1b7694ea39102294e633c64L36-R36)
[[9]](diffhunk://#diff-748b11dbe8828dd4c040ec23cae0b8fe57ecf0a2d1b7694ea39102294e633c64L74-R74)
[[10]](diffhunk://#diff-748b11dbe8828dd4c040ec23cae0b8fe57ecf0a2d1b7694ea39102294e633c64L96-R96)
**Generated code and templates:**
* Adjusted generated files and code generation templates to output `any`
instead of `interface{}` for relevant struct fields and function
signatures, ensuring that new code generation aligns with the updated
convention.
[[1]](diffhunk://#diff-6c19859cb32c7516ea95ddc8f8235460818eb2f24d2204308e0d9e1b19e7d90fL15-R19)
[[2]](diffhunk://#diff-a15ba2f5e830b4833c47b902515a4f9e5a4f83a3707698f3229b307ec3776b41L15-R18)
[[3]](diffhunk://#diff-52e0837e84d49221d1b810d88fdf78221f36cffcd664fb42f8aba49a79b974dcL15-R19)
[[4]](diffhunk://#diff-11c3457d1a23a4ca6ecd00d6b856289774936b6a708384cf03aff164044e7546L15-R19)
[[5]](diffhunk://#diff-2cff9cf8e6a0cc34087326d8c8149c3bbaf74c76fdbdf5a73daed13cc04249e1L15-R19)
[[6]](diffhunk://#diff-175edfeea54490b8fe4e18ffcbea5835efaf8f0b8acf623359073987cae7eb76L48-R55)
[[7]](diffhunk://#diff-e001b7a4b63603b9b14f00de78a4d570bb76c5f57d856a24643f071032e12356L66-R73)
[[8]](diffhunk://#diff-5582954e8a9983988dc8854ad82067fb2ac6269b988e07357ad8db1dfec5f1a0L39-R41)
**Container and utility updates:**
* Refactored the `garray` container implementation and related
constructors/methods to use `[]any` instead of `[]interface{}`, along
with corresponding function signatures.
[[1]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L31-R31)
[[2]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L52-R52)
[[3]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L62-R62)
[[4]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L73-R86)
[[5]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L96-R97)
[[6]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L107-R114)
[[7]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L124-R124)
[[8]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L135-R143)
[[9]](diffhunk://#diff-3a1259e160a4dfa5fe49dfe739fbdb986c0d0a2220a709882ea48d3ae1b8f911L167-R167)
These changes collectively modernize the codebase and prepare it for
future Go developments by using the idiomatic `any` type.
625 lines
15 KiB
Go
625 lines
15 KiB
Go
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
// If a copy of the MIT was not distributed with this file,
|
|
// You can obtain one at https://github.com/gogf/gf.
|
|
|
|
// go test *.go -bench=".*" -benchmem
|
|
|
|
package gcache_test
|
|
|
|
import (
|
|
"context"
|
|
"math"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gogf/gf/v2/container/gset"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
"github.com/gogf/gf/v2/os/gcache"
|
|
"github.com/gogf/gf/v2/os/grpool"
|
|
"github.com/gogf/gf/v2/test/gtest"
|
|
"github.com/gogf/gf/v2/util/guid"
|
|
)
|
|
|
|
var (
|
|
ctx = context.Background()
|
|
)
|
|
|
|
func TestCache_GCache_Set(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
t.AssertNil(gcache.Set(ctx, 1, 11, 0))
|
|
defer gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
v, _ := gcache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
b, _ := gcache.Contains(ctx, 1)
|
|
t.Assert(b, true)
|
|
})
|
|
}
|
|
|
|
func TestCache_Set(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
c := gcache.New()
|
|
defer c.Close(ctx)
|
|
t.Assert(c.Set(ctx, 1, 11, 0), nil)
|
|
v, _ := c.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
b, _ := c.Contains(ctx, 1)
|
|
t.Assert(b, true)
|
|
})
|
|
}
|
|
|
|
func TestCache_Set_Expire(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
t.Assert(cache.Set(ctx, 2, 22, 100*time.Millisecond), nil)
|
|
v, _ := cache.Get(ctx, 2)
|
|
t.Assert(v, 22)
|
|
time.Sleep(200 * time.Millisecond)
|
|
v, _ = cache.Get(ctx, 2)
|
|
t.Assert(v, nil)
|
|
time.Sleep(3 * time.Second)
|
|
n, _ := cache.Size(ctx)
|
|
t.Assert(n, 0)
|
|
t.Assert(cache.Close(ctx), nil)
|
|
})
|
|
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
t.Assert(cache.Set(ctx, 1, 11, 100*time.Millisecond), nil)
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
time.Sleep(200 * time.Millisecond)
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, nil)
|
|
})
|
|
}
|
|
|
|
func TestCache_Update(t *testing.T) {
|
|
// gcache
|
|
gtest.C(t, func(t *gtest.T) {
|
|
key := guid.S()
|
|
t.AssertNil(gcache.Set(ctx, key, 11, 3*time.Second))
|
|
expire1, _ := gcache.GetExpire(ctx, key)
|
|
oldValue, exist, err := gcache.Update(ctx, key, 12)
|
|
t.AssertNil(err)
|
|
t.Assert(oldValue, 11)
|
|
t.Assert(exist, true)
|
|
|
|
expire2, _ := gcache.GetExpire(ctx, key)
|
|
v, _ := gcache.Get(ctx, key)
|
|
t.Assert(v, 12)
|
|
t.Assert(math.Ceil(expire1.Seconds()), math.Ceil(expire2.Seconds()))
|
|
})
|
|
// gcache.Cache
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
t.AssertNil(cache.Set(ctx, 1, 11, 3*time.Second))
|
|
|
|
oldValue, exist, err := cache.Update(ctx, 1, 12)
|
|
t.AssertNil(err)
|
|
t.Assert(oldValue, 11)
|
|
t.Assert(exist, true)
|
|
|
|
expire1, _ := cache.GetExpire(ctx, 1)
|
|
expire2, _ := cache.GetExpire(ctx, 1)
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 12)
|
|
t.Assert(math.Ceil(expire1.Seconds()), math.Ceil(expire2.Seconds()))
|
|
})
|
|
}
|
|
|
|
func TestCache_UpdateExpire(t *testing.T) {
|
|
// gcache
|
|
gtest.C(t, func(t *gtest.T) {
|
|
key := guid.S()
|
|
t.AssertNil(gcache.Set(ctx, key, 11, 3*time.Second))
|
|
defer gcache.Remove(ctx, key)
|
|
oldExpire, _ := gcache.GetExpire(ctx, key)
|
|
newExpire := 10 * time.Second
|
|
oldExpire2, err := gcache.UpdateExpire(ctx, key, newExpire)
|
|
t.AssertNil(err)
|
|
t.AssertIN(oldExpire2, g.Slice{oldExpire, `2.999s`})
|
|
|
|
e, _ := gcache.GetExpire(ctx, key)
|
|
t.AssertNE(e, oldExpire)
|
|
e, _ = gcache.GetExpire(ctx, key)
|
|
t.Assert(math.Ceil(e.Seconds()), 10)
|
|
})
|
|
// gcache.Cache
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
t.AssertNil(cache.Set(ctx, 1, 11, 3*time.Second))
|
|
oldExpire, _ := cache.GetExpire(ctx, 1)
|
|
newExpire := 10 * time.Second
|
|
oldExpire2, err := cache.UpdateExpire(ctx, 1, newExpire)
|
|
t.AssertNil(err)
|
|
t.AssertIN(oldExpire2, g.Slice{oldExpire, `2.999s`})
|
|
|
|
e, _ := cache.GetExpire(ctx, 1)
|
|
t.AssertNE(e, oldExpire)
|
|
|
|
e, _ = cache.GetExpire(ctx, 1)
|
|
t.Assert(math.Ceil(e.Seconds()), 10)
|
|
})
|
|
}
|
|
|
|
func TestCache_Keys_Values(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
c := gcache.New()
|
|
for i := 0; i < 10; i++ {
|
|
t.Assert(c.Set(ctx, i, i*10, 0), nil)
|
|
}
|
|
var (
|
|
keys, _ = c.Keys(ctx)
|
|
values, _ = c.Values(ctx)
|
|
)
|
|
t.Assert(len(keys), 10)
|
|
t.Assert(len(values), 10)
|
|
t.AssertIN(0, keys)
|
|
t.AssertIN(90, values)
|
|
})
|
|
}
|
|
|
|
func TestCache_LRU(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New(2)
|
|
for i := 0; i < 10; i++ {
|
|
t.AssertNil(cache.Set(ctx, i, i, 0))
|
|
}
|
|
n, _ := cache.Size(ctx)
|
|
t.Assert(n, 2)
|
|
v, _ := cache.Get(ctx, 6)
|
|
t.AssertNil(v)
|
|
v, _ = cache.Get(ctx, 9)
|
|
t.Assert(v, 9)
|
|
})
|
|
}
|
|
|
|
func TestCache_LRU_expire(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New(2)
|
|
t.Assert(cache.Set(ctx, 1, nil, 50*time.Millisecond), nil)
|
|
|
|
n, _ := cache.Size(ctx)
|
|
t.Assert(n, 1)
|
|
|
|
time.Sleep(time.Millisecond * 100)
|
|
|
|
n, _ = cache.Size(ctx)
|
|
t.Assert(n, 0)
|
|
})
|
|
}
|
|
|
|
func TestCache_SetIfNotExist(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
ok, err := cache.SetIfNotExist(ctx, 1, 11, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, true)
|
|
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
ok, err = cache.SetIfNotExist(ctx, 1, 22, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, false)
|
|
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
ok, err = cache.SetIfNotExist(ctx, 2, 22, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, true)
|
|
|
|
v, _ = cache.Get(ctx, 2)
|
|
t.Assert(v, 22)
|
|
|
|
gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
ok, err = gcache.SetIfNotExist(ctx, 1, 11, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, true)
|
|
|
|
v, _ = gcache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
ok, err = gcache.SetIfNotExist(ctx, 1, 22, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, false)
|
|
|
|
v, _ = gcache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
}
|
|
|
|
func TestCache_SetIfNotExistFunc(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
exist, err := cache.SetIfNotExistFunc(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 11, nil
|
|
}, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(exist, true)
|
|
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
exist, err = cache.SetIfNotExistFunc(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 22, nil
|
|
}, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(exist, false)
|
|
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
gtest.C(t, func(t *gtest.T) {
|
|
gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
|
|
ok, err := gcache.SetIfNotExistFunc(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 11, nil
|
|
}, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, true)
|
|
|
|
v, _ := gcache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
ok, err = gcache.SetIfNotExistFunc(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 22, nil
|
|
}, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, false)
|
|
|
|
v, _ = gcache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
}
|
|
|
|
func TestCache_SetIfNotExistFuncLock(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
exist, err := cache.SetIfNotExistFuncLock(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 11, nil
|
|
}, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(exist, true)
|
|
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
exist, err = cache.SetIfNotExistFuncLock(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 22, nil
|
|
}, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(exist, false)
|
|
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
gtest.C(t, func(t *gtest.T) {
|
|
gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
|
|
exist, err := gcache.SetIfNotExistFuncLock(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 11, nil
|
|
}, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(exist, true)
|
|
|
|
v, _ := gcache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
exist, err = gcache.SetIfNotExistFuncLock(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 22, nil
|
|
}, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(exist, false)
|
|
|
|
v, _ = gcache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
}
|
|
|
|
func TestCache_SetMap(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
t.AssertNil(cache.SetMap(ctx, g.MapAnyAny{1: 11, 2: 22}, 0))
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
t.AssertNil(gcache.SetMap(ctx, g.MapAnyAny{1: 11, 2: 22}, 0))
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
}
|
|
|
|
func TestCache_GetOrSet(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
value, err := cache.GetOrSet(ctx, 1, 11, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(value, 11)
|
|
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
value, err = cache.GetOrSet(ctx, 1, 111, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(value, 11)
|
|
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
|
|
gtest.C(t, func(t *gtest.T) {
|
|
gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
value, err := gcache.GetOrSet(ctx, 1, 11, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(value, 11)
|
|
|
|
v, err := gcache.Get(ctx, 1)
|
|
t.AssertNil(err)
|
|
t.Assert(v, 11)
|
|
|
|
value, err = gcache.GetOrSet(ctx, 1, 111, 0)
|
|
t.AssertNil(err)
|
|
t.Assert(value, 11)
|
|
|
|
v, err = gcache.Get(ctx, 1)
|
|
t.AssertNil(err)
|
|
t.Assert(v, 11)
|
|
})
|
|
}
|
|
|
|
func TestCache_GetOrSetFunc(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
cache.GetOrSetFunc(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 11, nil
|
|
}, 0)
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
cache.GetOrSetFunc(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 111, nil
|
|
}, 0)
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
|
|
gcache.GetOrSetFunc(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 11, nil
|
|
}, 0)
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
gcache.GetOrSetFunc(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 111, nil
|
|
}, 0)
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
}
|
|
|
|
func TestCache_GetOrSetFuncLock(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
cache.GetOrSetFuncLock(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 11, nil
|
|
}, 0)
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
cache.GetOrSetFuncLock(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 111, nil
|
|
}, 0)
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
gcache.GetOrSetFuncLock(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 11, nil
|
|
}, 0)
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
|
|
gcache.GetOrSetFuncLock(ctx, 1, func(ctx context.Context) (value any, err error) {
|
|
return 111, nil
|
|
}, 0)
|
|
v, _ = cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
})
|
|
}
|
|
|
|
func TestCache_Clear(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
cache.SetMap(ctx, g.MapAnyAny{1: 11, 2: 22}, 0)
|
|
cache.Clear(ctx)
|
|
n, _ := cache.Size(ctx)
|
|
t.Assert(n, 0)
|
|
})
|
|
}
|
|
|
|
func TestCache_SetConcurrency(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
pool := grpool.New(4)
|
|
go func() {
|
|
for {
|
|
pool.Add(ctx, func(ctx context.Context) {
|
|
cache.SetIfNotExist(ctx, 1, 11, 10)
|
|
})
|
|
}
|
|
}()
|
|
select {
|
|
case <-time.After(2 * time.Second):
|
|
// t.Log("first part end")
|
|
}
|
|
|
|
go func() {
|
|
for {
|
|
pool.Add(ctx, func(ctx context.Context) {
|
|
cache.SetIfNotExist(ctx, 1, nil, 10)
|
|
})
|
|
}
|
|
}()
|
|
select {
|
|
case <-time.After(2 * time.Second):
|
|
// t.Log("second part end")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCache_Basic(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
{
|
|
cache := gcache.New()
|
|
cache.SetMap(ctx, g.MapAnyAny{
|
|
1: 11,
|
|
2: 22,
|
|
}, 0)
|
|
b, _ := cache.Contains(ctx, 1)
|
|
t.Assert(b, true)
|
|
v, _ := cache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
data, _ := cache.Data(ctx)
|
|
t.Assert(data[1], 11)
|
|
t.Assert(data[2], 22)
|
|
t.Assert(data[3], nil)
|
|
n, _ := cache.Size(ctx)
|
|
t.Assert(n, 2)
|
|
keys, _ := cache.Keys(ctx)
|
|
t.Assert(gset.NewFrom(g.Slice{1, 2}).Equal(gset.NewFrom(keys)), true)
|
|
keyStrs, _ := cache.KeyStrings(ctx)
|
|
t.Assert(gset.NewFrom(g.Slice{"1", "2"}).Equal(gset.NewFrom(keyStrs)), true)
|
|
values, _ := cache.Values(ctx)
|
|
t.Assert(gset.NewFrom(g.Slice{11, 22}).Equal(gset.NewFrom(values)), true)
|
|
removeData1, _ := cache.Remove(ctx, 1)
|
|
t.Assert(removeData1, 11)
|
|
n, _ = cache.Size(ctx)
|
|
t.Assert(n, 1)
|
|
|
|
cache.Remove(ctx, 2)
|
|
n, _ = cache.Size(ctx)
|
|
t.Assert(n, 0)
|
|
}
|
|
|
|
gcache.Remove(ctx, g.Slice{1, 2, 3}...)
|
|
{
|
|
gcache.SetMap(ctx, g.MapAnyAny{1: 11, 2: 22}, 0)
|
|
b, _ := gcache.Contains(ctx, 1)
|
|
t.Assert(b, true)
|
|
v, _ := gcache.Get(ctx, 1)
|
|
t.Assert(v, 11)
|
|
data, _ := gcache.Data(ctx)
|
|
t.Assert(data[1], 11)
|
|
t.Assert(data[2], 22)
|
|
t.Assert(data[3], nil)
|
|
n, _ := gcache.Size(ctx)
|
|
t.Assert(n, 2)
|
|
|
|
keys, _ := gcache.Keys(ctx)
|
|
t.Assert(gset.NewFrom(g.Slice{1, 2}).Equal(gset.NewFrom(keys)), true)
|
|
keyStrs, _ := gcache.KeyStrings(ctx)
|
|
t.Assert(gset.NewFrom(g.Slice{"1", "2"}).Equal(gset.NewFrom(keyStrs)), true)
|
|
values, _ := gcache.Values(ctx)
|
|
t.Assert(gset.NewFrom(g.Slice{11, 22}).Equal(gset.NewFrom(values)), true)
|
|
removeData1, _ := gcache.Remove(ctx, 1)
|
|
t.Assert(removeData1, 11)
|
|
n, _ = gcache.Size(ctx)
|
|
t.Assert(n, 1)
|
|
gcache.Remove(ctx, 2)
|
|
n, _ = gcache.Size(ctx)
|
|
t.Assert(n, 0)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCache_Removes(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.New()
|
|
t.AssertNil(cache.Set(ctx, 1, 11, 0))
|
|
t.AssertNil(cache.Set(ctx, 2, 22, 0))
|
|
t.AssertNil(cache.Set(ctx, 3, 33, 0))
|
|
t.AssertNil(cache.Removes(ctx, g.Slice{2, 3}))
|
|
|
|
ok, err := cache.Contains(ctx, 1)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, true)
|
|
|
|
ok, err = cache.Contains(ctx, 2)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, false)
|
|
})
|
|
|
|
gtest.C(t, func(t *gtest.T) {
|
|
t.AssertNil(gcache.Set(ctx, 1, 11, 0))
|
|
t.AssertNil(gcache.Set(ctx, 2, 22, 0))
|
|
t.AssertNil(gcache.Set(ctx, 3, 33, 0))
|
|
t.AssertNil(gcache.Removes(ctx, g.Slice{2, 3}))
|
|
|
|
ok, err := gcache.Contains(ctx, 1)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, true)
|
|
|
|
ok, err = gcache.Contains(ctx, 2)
|
|
t.AssertNil(err)
|
|
t.Assert(ok, false)
|
|
})
|
|
}
|
|
|
|
func TestCache_Basic_Must(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
defer gcache.Remove(ctx, g.Slice{1, 2, 3, 4}...)
|
|
|
|
t.AssertNil(gcache.Set(ctx, 1, 11, 0))
|
|
v := gcache.MustGet(ctx, 1)
|
|
t.Assert(v, 11)
|
|
gcache.MustGetOrSet(ctx, 2, 22, 0)
|
|
v = gcache.MustGet(ctx, 2)
|
|
t.Assert(v, 22)
|
|
|
|
gcache.MustGetOrSetFunc(ctx, 3, func(ctx context.Context) (value any, err error) {
|
|
return 33, nil
|
|
}, 0)
|
|
v = gcache.MustGet(ctx, 3)
|
|
t.Assert(v, 33)
|
|
|
|
gcache.GetOrSetFuncLock(ctx, 4, func(ctx context.Context) (value any, err error) {
|
|
return 44, nil
|
|
}, 0)
|
|
v = gcache.MustGet(ctx, 4)
|
|
t.Assert(v, 44)
|
|
|
|
t.Assert(gcache.MustContains(ctx, 1), true)
|
|
|
|
t.AssertNil(gcache.Set(ctx, 1, 11, 3*time.Second))
|
|
expire := gcache.MustGetExpire(ctx, 1)
|
|
t.AssertGE(expire, 0)
|
|
|
|
n := gcache.MustSize(ctx)
|
|
t.Assert(n, 4)
|
|
|
|
data := gcache.MustData(ctx)
|
|
t.Assert(len(data), 4)
|
|
|
|
keys := gcache.MustKeys(ctx)
|
|
t.Assert(len(keys), 4)
|
|
|
|
keyStrings := gcache.MustKeyStrings(ctx)
|
|
t.Assert(len(keyStrings), 4)
|
|
|
|
values := gcache.MustValues(ctx)
|
|
t.Assert(len(values), 4)
|
|
})
|
|
}
|
|
|
|
func TestCache_NewWithAdapter(t *testing.T) {
|
|
gtest.C(t, func(t *gtest.T) {
|
|
cache := gcache.NewWithAdapter(gcache.NewAdapterMemory())
|
|
t.AssertNE(cache, nil)
|
|
})
|
|
}
|