goProject/.svn/pristine/47/47e800dd36b3f0c082e6782f864014eb4e07d2a5.svn-base

1734 lines
36 KiB
Plaintext
Raw Normal View History

2025-01-06 16:21:36 +08:00
package redisUtil
import (
"testing"
"time"
)
var (
redisPoolObj_string *RedisPool
)
func init() {
redisPoolObj_string = NewRedisPool("testPool", "10.1.0.21:6379", "redis_pwd", 5, 500, 200, 10*time.Second, 5*time.Second)
}
func TestSet(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
对不存在的键进行设置:
redis> SET key "value"
OK
*/
key := "key"
value := "value"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET key
"value"
*/
got_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err := redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value {
t.Errorf("Expected to get %s, but now got %s.", value, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
对已存在的键进行设置:
redis> SET key "new-value"
OK
*/
value = "new-value"
successful, err = redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET key
"new-value"
*/
got_interface, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value {
t.Errorf("Expected to get %s, but now got %s.", value, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
使用 EX 选项:
redis> SET key-with-expire-time "hello" EX 10086
OK
*/
key = "key-with-expire-time"
value = "hello"
successful, err = redisPoolObj_string.Set(key, value, "EX", 10086, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET key-with-expire-time
"hello"
*/
got_interface, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", "key-with-expire-time")
return
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value {
t.Errorf("Expected to get %s, but now got %s.", value, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> TTL key-with-expire-time
(integer) 10069
*/
ttl, exist, _, err := redisPoolObj_string.TTL(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't", key)
return
}
if ttl < 10086-5 {
t.Errorf("The TTL of key:%s is wrong. Now it's %d", key, ttl)
return
}
deleteKeys = append(deleteKeys, key)
/*
使用 PX 选项:
redis> SET key-with-pexpire-time "moto" PX 123321
OK
*/
key = "key-with-pexpire-time"
value = "moto"
successful, err = redisPoolObj_string.Set(key, value, "PX", 123321, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET key-with-pexpire-time
"moto"
*/
got_interface, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value {
t.Errorf("Expected to get %s, but now got %s.", value, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> PTTL key-with-pexpire-time
(integer) 111939
*/
ttl, exist, _, err = redisPoolObj_string.PTTL(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't", key)
return
}
if ttl < 123321-5000 {
t.Errorf("The TTL of key:%s is wrong. Now it's %d", key, ttl)
return
}
deleteKeys = append(deleteKeys, key)
/*
使用 NX 选项:
redis> SET not-exists-key "value" NX
OK # 键不存在,设置成功
*/
key = "not-exists-key"
value = "value"
successful, err = redisPoolObj_string.Set(key, value, "", 0, "NX")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET not-exists-key
"value"
*/
got_interface, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value {
t.Errorf("Expected to get %s, but now got %s.", value, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> SET not-exists-key "new-value" NX
(nil) # 键已经存在,设置失败
*/
newValue := "new-value"
successful, err = redisPoolObj_string.Set(key, newValue, "", 0, "NX")
if err != nil {
t.Fail()
}
if successful {
t.Errorf("Seting key:%s should fail, but now it doesn't.", key)
}
deleteKeys = append(deleteKeys, key)
/*
redis> GEt not-exists-key
"value" # 维持原值不变
*/
got_interface, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value {
t.Errorf("Expected to get %s, but now got %s.", value, got)
return
}
/*
使用 XX 选项:
redis> EXISTS exists-key
(integer) 0
*/
key = "exists-key"
value = "value"
exist, err = redisPoolObj_string.Exists(key)
if err != nil {
t.Fail()
}
if exist {
t.Errorf("Key:%s should not exist, but now it does exist", key)
}
deleteKeys = append(deleteKeys, key)
/*
redis> SET exists-key "value" XX
(nil) # 因为键不存在,设置失败
*/
successful, err = redisPoolObj_string.Set(key, value, "", 0, "XX")
if err != nil {
t.Fail()
}
if successful {
t.Errorf("Seting key:%s should fail, but now it doesn't.", key)
}
deleteKeys = append(deleteKeys, key)
/*
redis> SET exists-key "value"
OK # 先给键设置一个值
*/
successful, err = redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Seting key:%s should succeed, but now it doesn't.", key)
}
deleteKeys = append(deleteKeys, key)
/*
redis> SET exists-key "new-value" XX
OK # 设置新值成功
*/
value = "new-value"
successful, err = redisPoolObj_string.Set(key, value, "", 0, "XX")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Seting key:%s should succeed, but now it doesn't.", key)
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET exists-key
"new-value"
*/
got_interface, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value {
t.Errorf("Expected to get %s, but now got %s.", value, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> SET int-key 5
OK # 设置新值成功
*/
key2 := "int-key"
value2 := 5
successful, err = redisPoolObj_string.Set(key2, value2, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Seting key:%s should succeed, but now it doesn't.", key)
}
deleteKeys = append(deleteKeys, key2)
/*
redis> GET int-key
5
*/
got_interface, exist, err = redisPoolObj_string.Get(key2)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got2, err := redisPoolObj_string.Int(got_interface)
if err != nil {
t.Fail()
}
if got2 != value2 {
t.Errorf("Expected to get %d, but now got %d.", value2, got2)
return
}
}
func TestGet(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
对不存在的键 key 或是字符串类型的键 key 执行 GET 命令:
redis> GET db
(nil)
*/
key := "db"
_, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if exist {
t.Errorf("The key:%s should not exist, but now it does.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> SET db redis
OK
*/
value := "redis"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET db
"redis"
*/
got_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err := redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value {
t.Errorf("Expected to get %s, but now got %s.", value, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
对不是字符串类型的键 key 执行 GET 命令:
redis> DEL db
(integer) 1
*/
count, err := redisPoolObj_string.Del(key)
if err != nil {
t.Fail()
}
if count != 1 {
t.Errorf("Expected to get 1, but now got %d", count)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> LPUSH db redis mongodb mysql
(integer) 3
*/
_, err = redisPoolObj_string.LPush(key, "redis", "mongodb", "mysql")
if err != nil {
t.Fail()
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET db
(error) ERR Operation against a key holding the wrong kind of value
*/
_, exist, err = redisPoolObj_string.Get(key)
if err == nil {
t.Fail()
}
deleteKeys = append(deleteKeys, key)
}
func TestGetSet(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
redis> GETSET db mongodb # 没有旧值,返回 nil
(nil)
*/
key := "db"
value1 := "mongodb"
got, exist, err := redisPoolObj_string.GetSet(key, value1)
if err != nil {
t.Fail()
}
if exist {
t.Errorf("There should be no old value, but now there is.")
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET db
"mongodb"
*/
got_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value1 {
t.Errorf("Expected to get %s, but now got %s.", value1, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GETSET db redis # 返回旧值 mongodb
"mongodb"
*/
value2 := "redis"
got_interface, exist, err = redisPoolObj_string.GetSet(key, value2)
if err != nil {
t.Fail()
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value1 {
t.Errorf("Expected to get %s, but now got %s.", value1, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET db
"redis"
*/
got_interface, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err = redisPoolObj_string.String(got_interface)
if err != nil {
t.Fail()
}
if got != value2 {
t.Errorf("Expected to get %s, but now got %s.", value2, got)
return
}
deleteKeys = append(deleteKeys, key)
}
func TestStrLen(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
获取字符串值的长度:
redis> SET mykey "Hello world"
OK
*/
key := "mykey"
value := "Hello world"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> STRLEN mykey
(integer) 11
不存在的键的长度为 0
*/
expectedLength := 11
got, err := redisPoolObj_string.StrLen(key)
if err != nil {
t.Fail()
}
if got != expectedLength {
t.Errorf("Expected length %d, but got %d", expectedLength, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> STRLEN nonexisting
(integer) 0
*/
key = "nonexisting"
expectedLength = 0
got, err = redisPoolObj_string.StrLen(key)
if err != nil {
t.Fail()
}
if got != expectedLength {
t.Errorf("Expected length %d, but got %d", expectedLength, got)
return
}
}
func TestAppend(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
示例代码
对不存在的 key 执行 APPEND
redis> EXISTS myphone # 确保 myphone 不存在
(integer) 0
*/
key := "myphone"
value := "value"
exist, err := redisPoolObj_string.Exists(key)
if err != nil {
t.Fail()
}
if exist {
t.Errorf("Key:%s should not exist, but now it does exist", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> APPEND myphone "nokia" # 对不存在的 key 进行 APPEND ,等同于 SET myphone "nokia"
(integer) 5 # 字符长度
对已存在的字符串进行 APPEND
*/
value = "nokia"
expected := 5
got, err := redisPoolObj_string.Append(key, value)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %d, but got %d", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> APPEND myphone " - 1110" # 长度从 5 个字符增加到 12 个字符
(integer) 12
*/
value = " - 1110"
expected = 12
got, err = redisPoolObj_string.Append(key, value)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %d, but got %d", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET myphone
"nokia - 1110"
*/
expected2 := "nokia - 1110"
got2_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("Key:%s should exist, but now it doesn't exist", key)
return
}
got2, err := redisPoolObj_string.String(got2_interface)
if err != nil {
t.Fail()
}
if got2 != expected2 {
t.Errorf("Expected to get %s, but now got %s", expected2, got2)
return
}
deleteKeys = append(deleteKeys, key)
}
func TestSetRange(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
对非空字符串执行 SETRANGE 命令:
redis> SET greeting "hello world"
OK
*/
key := "greeting"
value := "hello world"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> SETRANGE greeting 6 "Redis"
(integer) 11
*/
offset := 6
value = "Redis"
expected := 11
got, err := redisPoolObj_string.SetRange(key, offset, value)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %d, but now got %d", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET greeting
"hello Redis"
*/
expected2 := "hello Redis"
got2_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got2, err := redisPoolObj_string.String(got2_interface)
if err != nil {
t.Fail()
}
if got2 != expected2 {
t.Errorf("Expected to get %s, but now got %s", expected2, got2)
return
}
deleteKeys = append(deleteKeys, key)
/*
对空字符串/不存在的键执行 SETRANGE 命令:
redis> EXISTS empty_string
(integer) 0
redis> SETRANGE empty_string 5 "Redis!" # 对不存在的 key 使用 SETRANGE
(integer) 11
redis> GET empty_string # 空白处被"\x00"填充
"\x00\x00\x00\x00\x00Redis!"
*/
key = "empty_string"
_, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if exist {
t.Errorf("The key:%s should not exist, but now it does.", key)
return
}
deleteKeys = append(deleteKeys, key)
offset = 5
value = "Redis!"
expected3 := 11
got3, err := redisPoolObj_string.SetRange(key, offset, value)
if err != nil {
t.Fail()
}
if got3 != expected3 {
t.Errorf("Expected to get %d, but now got %d", expected3, got3)
return
}
deleteKeys = append(deleteKeys, key)
expected4 := "\x00\x00\x00\x00\x00Redis!"
got4_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got4, err := redisPoolObj_string.String(got4_interface)
if err != nil {
t.Fail()
}
if got4 != expected4 {
t.Errorf("Expected to get %s, but now got %s", expected4, got4)
return
}
deleteKeys = append(deleteKeys, key)
}
func TestGetRange(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
redis> SET greeting "hello, my friend"
OK
*/
key := "greeting"
value := "hello, my friend"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GETRANGE greeting 0 4 # 返回索引0-4的字符包括4。
"hello"
*/
start, end := 0, 4
expected := "hello"
got, err := redisPoolObj_string.GetRange(key, start, end)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %s, but now got %s", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GETRANGE greeting -1 -5 # 不支持回绕操作
""
*/
start, end = -1, -5
expected = ""
got, err = redisPoolObj_string.GetRange(key, start, end)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %s, but now got %s", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GETRANGE greeting -3 -1 # 负数索引
"end"
*/
start, end = -3, -1
expected = "end"
got, err = redisPoolObj_string.GetRange(key, start, end)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %s, but now got %s", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GETRANGE greeting 0 -1 # 从第一个到最后一个
"hello, my friend"
*/
start, end = 0, -1
expected = "hello, my friend"
got, err = redisPoolObj_string.GetRange(key, start, end)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %s, but now got %s", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GETRANGE greeting 0 1008611 # 值域范围不超过实际字符串,超过部分自动被符略
"hello, my friend"
*/
start, end = 0, 1008611
expected = "hello, my friend"
got, err = redisPoolObj_string.GetRange(key, start, end)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %s, but now got %s", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
}
func TestIncr(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
redis> SET page_view 20
OK
*/
key := "page_view"
value := "20"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> INCR page_view
(integer) 21
*/
expected := int64(21)
got, err := redisPoolObj_string.Incr(key)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %d, but now got %d", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET page_view # 数字值在 Redis 中以字符串的形式保存
"21"
*/
expected2 := 21
got2_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got2, err := redisPoolObj_string.Int(got2_interface)
if err != nil {
t.Fail()
}
if got2 != expected2 {
t.Errorf("Expected to get %d, but now got %d", expected2, got2)
return
}
deleteKeys = append(deleteKeys, key)
}
func TestIncrBy(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
键存在,并且值为数字:
redis> SET rank 50
OK
redis> INCRBY rank 20
(integer) 70
redis> GET rank
"70"
*/
key := "rank"
value := "50"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
increment := int64(20)
expected := int64(70)
got, err := redisPoolObj_string.IncrBy(key, increment)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %d, but now got %d", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
expected2 := 70
got2_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got2, err := redisPoolObj_string.Int(got2_interface)
if err != nil {
t.Fail()
}
if got2 != expected2 {
t.Errorf("Expected to get %d, but now got %d", expected2, got2)
return
}
deleteKeys = append(deleteKeys, key)
/*
键不存在:
redis> EXISTS counter
(integer) 0
*/
key = "counter"
_, exist, err = redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if exist {
t.Errorf("The key:%s should not exist, but now it does.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> INCRBY counter 30
(integer) 30
*/
increment = int64(30)
expected3 := int64(30)
got3, err := redisPoolObj_string.IncrBy(key, 30)
if err != nil {
t.Fail()
}
if got3 != expected3 {
t.Errorf("Expected to get %d, but now got %d", expected3, got3)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET counter
"30"
*/
expected4 := 30
got4_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got4, err := redisPoolObj_string.Int(got4_interface)
if err != nil {
t.Fail()
}
if got4 != expected4 {
t.Errorf("Expected to get %d, but now got %d", expected4, got4)
return
}
deleteKeys = append(deleteKeys, key)
/*
键存在,但值无法被解释为数字:
redis> SET book "long long ago..."
OK
redis> INCRBY book 200
(error) ERR value is not an integer or out of range
*/
// This feature can't be tested, because the IncrBy function needs an int64 parameter.
}
func TestIncrByFloat(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
redis> GET decimal
"3.0"
*/
key := "decimal"
value := "3.0"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
expected := 3.0
got_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got, err := redisPoolObj_string.Float64(got_interface)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %f, but now got %f", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> INCRBYFLOAT decimal 2.56
"5.56"
*/
increment := 2.56
expected2 := 5.56
got2, err := redisPoolObj_string.IncrByFloat(key, increment)
if err != nil {
t.Fail()
}
if got2 != expected2 {
t.Errorf("Expected to get %f, but now got %f", expected2, got2)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> GET decimal
"5.56"
*/
expected3 := 5.56
got3_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got3, err := redisPoolObj_string.Float64(got3_interface)
if err != nil {
t.Fail()
}
if got3 != expected3 {
t.Errorf("Expected to get %f, but now got %f", expected3, got3)
return
}
deleteKeys = append(deleteKeys, key)
}
func TestDecrBy(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
对已经存在的键执行 DECRBY 命令:
redis> SET count 100
OK
*/
key := "count"
value := 100
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> DECRBY count 20
(integer) 80
对不存在的键执行 DECRBY 命令:
*/
expected := int64(80)
decrement := int64(20)
got_interface, err := redisPoolObj_string.DecrBy(key, decrement)
if err != nil {
t.Fail()
}
got, err := redisPoolObj_string.Int64(got_interface)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %d, but now got %d", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> EXISTS pages
(integer) 0
*/
key = "pages"
exist, err := redisPoolObj_string.Exists(key)
if err != nil {
t.Fail()
}
if exist {
t.Errorf("The key:%s should not exist, but now it does", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> DECRBY pages 10
(integer) -10
*/
expected = int64(-10)
decrement = int64(10)
got, err = redisPoolObj_string.DecrBy(key, decrement)
if err != nil {
t.Fail()
}
if got != expected {
t.Errorf("Expected to get %d, but now got %d", expected, got)
return
}
deleteKeys = append(deleteKeys, key)
}
func TestMSet(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
同时对多个键进行设置:
redis> MSET date "2012.3.30" time "11:00 a.m." weather "sunny"
OK
*/
key_value_map := make(map[string]interface{})
key_value_map["date"] = "2012.3.30"
key_value_map["time"] = "11:00 a.m."
key_value_map["weather"] = "sunny"
err := redisPoolObj_string.MSet(key_value_map)
if err != nil {
t.Fail()
}
/*
redis> MGET date time weather
1) "2012.3.30"
2) "11:00 a.m."
3) "sunny"
*/
keyList := make([]string, 0, len(key_value_map))
expected := make([]string, 0, len(key_value_map))
for k, v := range key_value_map {
keyList = append(keyList, k)
if v_str, ok := v.(string); ok {
expected = append(expected, v_str)
}
}
got_interface, err := redisPoolObj_string.MGet(keyList)
if err != nil {
t.Fail()
}
got, err := redisPoolObj_string.Strings(got_interface)
if err != nil {
t.Fail()
}
if isTwoOrderedSliceEqual(got, expected) == false {
t.Errorf("Expected to get %v, but got %v", expected, got)
return
}
deleteKeys = append(deleteKeys, keyList...)
/*
覆盖已有的值:
redis> MGET k1 k2
1) "hello"
2) "world"
*/
key_value_map = make(map[string]interface{})
key_value_map["k1"] = "hello"
key_value_map["k2"] = "world"
err = redisPoolObj_string.MSet(key_value_map)
if err != nil {
t.Fail()
}
/*
redis> MSET k1 "good" k2 "bye"
OK
*/
key_value_map["k1"] = "good"
key_value_map["k2"] = "bye"
err = redisPoolObj_string.MSet(key_value_map)
if err != nil {
t.Fail()
}
/*
redis> MGET k1 k2
1) "good"
2) "bye"
*/
keyList = make([]string, 0, len(key_value_map))
expected = make([]string, 0, len(key_value_map))
for k, v := range key_value_map {
keyList = append(keyList, k)
if v_str, ok := v.(string); ok {
expected = append(expected, v_str)
}
}
got_interface, err = redisPoolObj_string.MGet(keyList)
if err != nil {
t.Fail()
}
got, err = redisPoolObj_string.Strings(got_interface)
if err != nil {
t.Fail()
}
if isTwoOrderedSliceEqual(got, expected) == false {
t.Errorf("Expected to get %v, but got %v", expected, got)
return
}
deleteKeys = append(deleteKeys, keyList...)
}
func TestMSetNX(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
对不存在的键执行 MSETNX 命令:
redis> MSETNX rmdbs "MySQL" nosql "MongoDB" key-value-store "redis"
(integer) 1
*/
key_value_map := make(map[string]interface{})
key_value_map["rmdbs"] = "MySQL"
key_value_map["nosql"] = "MongoDB"
key_value_map["key-value-store"] = "redis"
successful, err := redisPoolObj_string.MSetNX(key_value_map)
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("It should be successful, but now it's not.")
return
}
/*
redis> MGET rmdbs nosql key-value-store
1) "MySQL"
2) "MongoDB"
3) "redis"
对某个已经存在的键进行设置:
*/
keyList := make([]string, 0, len(key_value_map))
expected := make([]string, 0, len(key_value_map))
for k, v := range key_value_map {
keyList = append(keyList, k)
if v_str, ok := v.(string); ok {
expected = append(expected, v_str)
}
}
got_interface, err := redisPoolObj_string.MGet(keyList)
if err != nil {
t.Fail()
}
got, err := redisPoolObj_string.Strings(got_interface)
if err != nil {
t.Fail()
}
if isTwoOrderedSliceEqual(got, expected) == false {
t.Errorf("Expected to get %v, but got %v", expected, got)
return
}
deleteKeys = append(deleteKeys, keyList...)
/*
redis> MSETNX rmdbs "Sqlite" language "python" # rmdbs 键已经存在,操作失败
(integer) 0
*/
key_value_map = make(map[string]interface{})
key_value_map["rmdbs"] = "Sqlite"
key_value_map["language"] = "python"
successful, err = redisPoolObj_string.MSetNX(key_value_map)
if err != nil {
t.Fail()
}
if successful {
t.Errorf("It should be not successful, but now it is.")
return
}
/*
redis> EXISTS language # 因为 MSETNX 命令没有成功执行
(integer) 0 # 所以 language 键没有被设置
*/
key := "language"
exist, err := redisPoolObj_string.Exists(key)
if err != nil {
t.Fail()
}
if exist {
t.Errorf("The key:%s should not exist, but now it does.", key)
return
}
/*
redis> GET rmdbs # rmdbs 键也没有被修改
"MySQL"
*/
key = "rmdbs"
expected2 := "MySQL"
got2_interface, exist, err := redisPoolObj_string.Get(key)
if err != nil {
t.Fail()
}
if !exist {
t.Errorf("The key:%s should exist, but now it doesn't.", key)
return
}
got2, err := redisPoolObj_string.String(got2_interface)
if err != nil {
t.Fail()
}
if got2 != expected2 {
t.Errorf("Expected to get %v, but got %v", expected2, got2)
return
}
}
func TestMGet(t *testing.T) {
deleteKeys := make([]string, 0, 8)
defer func() {
// Delete the test keys
distinctKeyList := getDistinctKeyList(deleteKeys)
count, err := redisPoolObj_string.Del(distinctKeyList...)
if err != nil {
t.Fail()
}
if count != len(distinctKeyList) {
t.Errorf("Expected to get %d, but now got %d", len(distinctKeyList), count)
return
}
}()
/*
代码示例
redis> SET redis redis.com
OK
*/
key := "redis"
value := "redis.com"
successful, err := redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> SET mongodb mongodb.org
OK
*/
key = "mongodb"
value = "mongodb.org"
successful, err = redisPoolObj_string.Set(key, value, "", 0, "")
if err != nil {
t.Fail()
}
if !successful {
t.Errorf("Set key:%s should be successful, but now it's not.", key)
return
}
deleteKeys = append(deleteKeys, key)
/*
redis> MGET redis mongodb
1) "redis.com"
2) "mongodb.org"
*/
keys := []string{"redis", "mongodb"}
expected := []string{"redis.com", "mongodb.org"}
got_interface, err := redisPoolObj_string.MGet(keys)
if err != nil {
t.Fail()
}
got, err := redisPoolObj_string.Strings(got_interface)
if err != nil {
t.Fail()
}
if isTwoOrderedSliceEqual(got, expected) == false {
t.Errorf("Expected to get %v, but got %v", expected, got)
return
}
/*
redis> MGET redis mongodb mysql # 不存在的 mysql 返回 nil
1) "redis.com"
2) "mongodb.org"
3) (nil)
*/
keys = []string{"redis", "mongodb", "mysql"}
expected = []string{"redis.com", "mongodb.org", ""}
got_interface, err = redisPoolObj_string.MGet(keys)
if err != nil {
t.Fail()
}
got, err = redisPoolObj_string.Strings(got_interface)
if err != nil {
t.Fail()
}
if isTwoOrderedSliceEqual(got, expected) == false {
t.Errorf("Expected to get %v, but got %v", expected, got)
return
}
}