1889 lines
39 KiB
Go
1889 lines
39 KiB
Go
package redisUtil
|
||
|
||
import (
|
||
"testing"
|
||
"time"
|
||
)
|
||
|
||
var (
|
||
redisPoolObj_list *RedisPool
|
||
)
|
||
|
||
func init() {
|
||
redisPoolObj_list = NewRedisPool("testPool", "10.1.0.21:6379", "redis_pwd", 5, 500, 200, 10*time.Second, 5*time.Second)
|
||
}
|
||
|
||
func TestLPush(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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> LPUSH languages python
|
||
(integer) 1
|
||
*/
|
||
key := "languages"
|
||
value := "python"
|
||
expected := 1
|
||
got, err := redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
/*
|
||
# 加入重复元素
|
||
|
||
redis> LPUSH languages python
|
||
(integer) 2
|
||
*/
|
||
value = "python"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
/*
|
||
redis> LRANGE languages 0 -1 # 列表允许重复元素
|
||
1) "python"
|
||
2) "python"
|
||
*/
|
||
expected2 := []string{"python", "python"}
|
||
got2_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got2, err := redisPoolObj_list.Strings(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected2, got2) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected2, got2)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 加入多个元素
|
||
|
||
redis> LPUSH mylist a b c
|
||
(integer) 3
|
||
*/
|
||
key3 := "mylist"
|
||
expected3 := 3
|
||
got3, err := redisPoolObj_list.LPush(key3, "a", "b", "c")
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got3 != expected3 {
|
||
t.Errorf("Expected length %d, but got %d", expected3, got3)
|
||
return
|
||
}
|
||
deleteKeys = append(deleteKeys, key3)
|
||
|
||
/*
|
||
redis> LRANGE mylist 0 -1
|
||
1) "c"
|
||
2) "b"
|
||
3) "a"
|
||
*/
|
||
expected4 := []string{"c", "b", "a"}
|
||
got4_interface, err := redisPoolObj_list.LRange(key3, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got4, err := redisPoolObj_list.Strings(got4_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected4, got4) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected4, got4)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLPushX(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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
|
||
}
|
||
}()
|
||
|
||
/*
|
||
# 对空列表执行 LPUSHX
|
||
|
||
redis> LLEN greet # greet 是一个空列表
|
||
(integer) 0
|
||
*/
|
||
key := "greet"
|
||
expected := 0
|
||
got, err := redisPoolObj_list.LLen(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LPUSHX greet "hello" # 尝试 LPUSHX，失败，因为列表为空
|
||
(integer) 0
|
||
*/
|
||
value := "hello"
|
||
expected = 0
|
||
got, err = redisPoolObj_list.LPushX(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 对非空列表执行 LPUSHX
|
||
|
||
redis> LPUSH greet "hello" # 先用 LPUSH 创建一个有一个元素的列表
|
||
(integer) 1
|
||
*/
|
||
expected = 1
|
||
got, err = redisPoolObj_list.LPush(key, 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> LPUSHX greet "good morning" # 这次 LPUSHX 执行成功
|
||
(integer) 2
|
||
*/
|
||
value = "good morning"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.LPushX(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE greet 0 -1
|
||
1) "good morning"
|
||
2) "hello"
|
||
*/
|
||
expected2 := []string{"good morning", "hello"}
|
||
got2_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got2, err := redisPoolObj_list.Strings(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected2, got2) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected2, got2)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestRPush(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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> RPUSH languages c
|
||
(integer) 1
|
||
*/
|
||
key := "languages"
|
||
value := "c"
|
||
expected := 1
|
||
got, err := redisPoolObj_list.RPush(key, 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> RPUSH languages c
|
||
(integer) 2
|
||
*/
|
||
key = "languages"
|
||
value = "c"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.RPush(key, 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> LRANGE languages 0 -1 # 列表允许重复元素
|
||
1) "c"
|
||
2) "c"
|
||
*/
|
||
expected2 := []string{"c", "c"}
|
||
got2_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got2, err := redisPoolObj_list.Strings(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected2, got2) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected2, got2)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 添加多个元素
|
||
|
||
redis> RPUSH mylist a b c
|
||
(integer) 3
|
||
*/
|
||
key3 := "mylist"
|
||
expected3 := 3
|
||
got3, err := redisPoolObj_list.RPush(key3, "a", "b", "c")
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got3 != expected3 {
|
||
t.Errorf("Expected length %d, but got %d", expected3, got3)
|
||
return
|
||
}
|
||
deleteKeys = append(deleteKeys, key3)
|
||
|
||
/*
|
||
redis> LRANGE mylist 0 -1
|
||
1) "a"
|
||
2) "b"
|
||
3) "c"
|
||
*/
|
||
expected4 := []string{"a", "b", "c"}
|
||
got4_interface, err := redisPoolObj_list.LRange(key3, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got4, err := redisPoolObj_list.Strings(got4_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected4, got4) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected4, got4)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestRPushX(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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不存在
|
||
|
||
redis> LLEN greet
|
||
(integer) 0
|
||
*/
|
||
key := "greet"
|
||
expected := 0
|
||
got, err := redisPoolObj_list.LLen(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPUSHX greet "hello" # 对不存在的 key 进行 RPUSHX，PUSH 失败。
|
||
(integer) 0
|
||
*/
|
||
value := "hello"
|
||
expected = 0
|
||
got, err = redisPoolObj_list.RPushX(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# key 存在且是一个非空列表
|
||
|
||
redis> RPUSH greet "hi" # 先用 RPUSH 插入一个元素
|
||
(integer) 1
|
||
*/
|
||
value = "hi"
|
||
expected = 1
|
||
got, err = redisPoolObj_list.RPush(key, 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> RPUSHX greet "hello" # greet 现在是一个列表类型，RPUSHX 操作成功。
|
||
(integer) 2
|
||
*/
|
||
value = "hello"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.RPushX(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE greet 0 -1
|
||
1) "hi"
|
||
2) "hello"
|
||
*/
|
||
expected2 := []string{"hi", "hello"}
|
||
got2_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got2, err := redisPoolObj_list.Strings(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected2, got2) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected2, got2)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLPop(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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> LLEN course
|
||
(integer) 0
|
||
*/
|
||
key := "course"
|
||
expected := 0
|
||
got, err := redisPoolObj_list.LLen(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPUSH course algorithm001
|
||
(integer) 1
|
||
*/
|
||
value := "algorithm001"
|
||
expected = 1
|
||
got, err = redisPoolObj_list.RPush(key, 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> RPUSH course c++101
|
||
(integer) 2
|
||
*/
|
||
value = "c++101"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.RPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LPOP course # 移除头元素
|
||
"algorithm001"
|
||
*/
|
||
expected2 := "algorithm001"
|
||
got2_interface, exist, err := redisPoolObj_list.LPop(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if !exist {
|
||
t.Errorf("The key:%s should have item, but now it doesn't.", key)
|
||
return
|
||
}
|
||
got2, err := redisPoolObj_list.String(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got2 != expected2 {
|
||
t.Errorf("Expected to get %s, but now got %s", expected2, got2)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestRPop(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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> RPUSH mylist "one"
|
||
(integer) 1
|
||
*/
|
||
key := "mylist"
|
||
value := "one"
|
||
expected := 1
|
||
got, err := redisPoolObj_list.RPush(key, 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> RPUSH mylist "two"
|
||
(integer) 2
|
||
*/
|
||
value = "two"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.RPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPUSH mylist "three"
|
||
(integer) 3
|
||
*/
|
||
value = "three"
|
||
expected = 3
|
||
got, err = redisPoolObj_list.RPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPOP mylist # 返回被弹出的元素
|
||
"three"
|
||
*/
|
||
expected2 := "three"
|
||
got2_interface, exist, err := redisPoolObj_list.RPop(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if !exist {
|
||
t.Errorf("The key:%s should have item, but now it doesn't.", key)
|
||
return
|
||
}
|
||
got2, err := redisPoolObj_list.String(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got2 != expected2 {
|
||
t.Errorf("Expected to get %s, but now got %s", expected2, got2)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE mylist 0 -1 # 列表剩下的元素
|
||
1) "one"
|
||
2) "two"
|
||
*/
|
||
expected3 := []string{"one", "two"}
|
||
got3_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got3, err := redisPoolObj_list.Strings(got3_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected3, got3) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected3, got3)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestRPopLPush(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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
|
||
}
|
||
}()
|
||
|
||
/*
|
||
# source 和 destination 不同
|
||
|
||
redis> LRANGE alpha 0 -1 # 查看所有元素
|
||
1) "a"
|
||
2) "b"
|
||
3) "c"
|
||
4) "d"
|
||
*/
|
||
key := "alpha"
|
||
redisPoolObj_list.RPush(key, "a")
|
||
redisPoolObj_list.RPush(key, "b")
|
||
redisPoolObj_list.RPush(key, "c")
|
||
redisPoolObj_list.RPush(key, "d")
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
expected := []string{"a", "b", "c", "d"}
|
||
got_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got, err := redisPoolObj_list.Strings(got_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected, got) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPOPLPUSH alpha reciver # 执行一次 RPOPLPUSH 看看
|
||
"d"
|
||
*/
|
||
source := "alpha"
|
||
destination := "receiver"
|
||
expected2 := "d"
|
||
got2_interface, err := redisPoolObj_list.RPopLPush(source, destination)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got2, err := redisPoolObj_list.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, source)
|
||
deleteKeys = append(deleteKeys, destination)
|
||
|
||
/*
|
||
redis> LRANGE alpha 0 -1
|
||
1) "a"
|
||
2) "b"
|
||
3) "c"
|
||
*/
|
||
expected3 := []string{"a", "b", "c"}
|
||
got3_interface, err := redisPoolObj_list.LRange(source, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got3, err := redisPoolObj_list.Strings(got3_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected3, got3) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected3, got3)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE reciver 0 -1
|
||
1) "d"
|
||
*/
|
||
expected4 := []string{"d"}
|
||
got4_interface, err := redisPoolObj_list.LRange(destination, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got4, err := redisPoolObj_list.Strings(got4_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected4, got4) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected4, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPOPLPUSH alpha reciver # 再执行一次，证实 RPOP 和 LPUSH 的位置正确
|
||
"c"
|
||
*/
|
||
expected5 := "c"
|
||
got5_interface, err := redisPoolObj_list.RPopLPush(source, destination)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got5, err := redisPoolObj_list.String(got5_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got5 != expected5 {
|
||
t.Errorf("Expected to get %s, but now got %s", expected5, got5)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE alpha 0 -1
|
||
1) "a"
|
||
2) "b"
|
||
*/
|
||
expected6 := []string{"a", "b"}
|
||
got6_interface, err := redisPoolObj_list.LRange(source, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got6, err := redisPoolObj_list.Strings(got6_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected6, got6) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected6, got6)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE reciver 0 -1
|
||
1) "c"
|
||
2) "d"
|
||
*/
|
||
expected7 := []string{"c", "d"}
|
||
got7_interface, err := redisPoolObj_list.LRange(destination, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got7, err := redisPoolObj_list.Strings(got7_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected7, got7) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected7, got7)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# source 和 destination 相同
|
||
|
||
redis> LRANGE number 0 -1
|
||
1) "1"
|
||
2) "2"
|
||
3) "3"
|
||
4) "4"
|
||
*/
|
||
source = "number"
|
||
destination = "number"
|
||
|
||
redisPoolObj_list.RPush(source, "1")
|
||
redisPoolObj_list.RPush(source, "2")
|
||
redisPoolObj_list.RPush(source, "3")
|
||
redisPoolObj_list.RPush(source, "4")
|
||
|
||
deleteKeys = append(deleteKeys, source)
|
||
deleteKeys = append(deleteKeys, destination)
|
||
|
||
expected8 := []string{"1", "2", "3", "4"}
|
||
got8_interface, err := redisPoolObj_list.LRange(source, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got8, err := redisPoolObj_list.Strings(got8_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected8, got8) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected8, got8)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPOPLPUSH number number
|
||
"4"
|
||
*/
|
||
expected9 := 4
|
||
got9_interface, err := redisPoolObj_list.RPopLPush(source, destination)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got9, err := redisPoolObj_list.Int(got9_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got9 != expected9 {
|
||
t.Errorf("Expected to get %d, but now got %d", expected9, got9)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE number 0 -1 # 4 被旋转到了表头
|
||
1) "4"
|
||
2) "1"
|
||
3) "2"
|
||
4) "3"
|
||
*/
|
||
expected10 := []string{"4", "1", "2", "3"}
|
||
got10_interface, err := redisPoolObj_list.LRange(source, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got10, err := redisPoolObj_list.Strings(got10_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected10, got10) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected10, got10)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPOPLPUSH number number
|
||
"3"
|
||
*/
|
||
expected11 := 3
|
||
got11_interface, err := redisPoolObj_list.RPopLPush(source, destination)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got11, err := redisPoolObj_list.Int(got11_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got11 != expected11 {
|
||
t.Errorf("Expected to get %d, but now got %d", expected11, got11)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE number 0 -1 # 这次是 3 被旋转到了表头
|
||
1) "3"
|
||
2) "4"
|
||
3) "1"
|
||
4) "2"
|
||
*/
|
||
expected12 := []string{"3", "4", "1", "2"}
|
||
got12_interface, err := redisPoolObj_list.LRange(source, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got12, err := redisPoolObj_list.Strings(got12_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected12, got12) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected12, got12)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLRem(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
// defer func() {
|
||
// // Delete the test keys
|
||
// distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
// count, err := redisPoolObj_list.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
|
||
// }
|
||
// }()
|
||
|
||
/*
|
||
# 先创建一个表，内容排列是
|
||
# morning hello morning helllo morning
|
||
|
||
redis> LPUSH greet "morning"
|
||
(integer) 1
|
||
redis> LPUSH greet "hello"
|
||
(integer) 2
|
||
redis> LPUSH greet "morning"
|
||
(integer) 3
|
||
redis> LPUSH greet "hello"
|
||
(integer) 4
|
||
redis> LPUSH greet "morning"
|
||
(integer) 5
|
||
*/
|
||
key := "greet"
|
||
value := "morning"
|
||
expected := 1
|
||
got, err := redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
value = "hello"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
value = "morning"
|
||
expected = 3
|
||
got, err = redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
value = "hello"
|
||
expected = 4
|
||
got, err = redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
value = "morning"
|
||
expected = 5
|
||
got, err = redisPoolObj_list.LPush(key, 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> LRANGE greet 0 4 # 查看所有元素
|
||
1) "morning"
|
||
2) "hello"
|
||
3) "morning"
|
||
4) "hello"
|
||
5) "morning"
|
||
*/
|
||
expected2 := []string{"morning", "hello", "morning", "hello", "morning"}
|
||
got2_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got2, err := redisPoolObj_list.Strings(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected2, got2) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected2, got2)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LREM greet 2 morning # 移除从表头到表尾，最先发现的两个 morning
|
||
(integer) 2 # 两个元素被移除
|
||
*/
|
||
value3 := "morning"
|
||
expected3 := 2
|
||
got3, err := redisPoolObj_list.LRem(key, 2, value3)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got3 != expected3 {
|
||
t.Errorf("Expected to get %d, but now got %d", expected3, got3)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LLEN greet # 还剩 3 个元素
|
||
(integer) 3
|
||
*/
|
||
expected4 := 3
|
||
got4, err := redisPoolObj_list.LLen(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got4 != expected4 {
|
||
t.Errorf("Expected to get %d, but now got %d", expected4, got4)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE greet 0 2
|
||
1) "hello"
|
||
2) "hello"
|
||
3) "morning"
|
||
*/
|
||
expected5 := []string{"hello", "hello", "morning"}
|
||
got5_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got5, err := redisPoolObj_list.Strings(got5_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected5, got5) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected5, got5)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LREM greet -1 morning # 移除从表尾到表头，第一个 morning
|
||
(integer) 1
|
||
*/
|
||
|
||
value6 := "morning"
|
||
expected6 := 1
|
||
got6, err := redisPoolObj_list.LRem(key, -1, value6)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got6 != expected6 {
|
||
t.Errorf("Expected to get %d, but now got %d", expected6, got6)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LLEN greet # 剩下两个元素
|
||
(integer) 2
|
||
*/
|
||
expected7 := 2
|
||
got7, err := redisPoolObj_list.LLen(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got7 != expected7 {
|
||
t.Errorf("Expected to get %d, but now got %d", expected7, got7)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE greet 0 1
|
||
1) "hello"
|
||
2) "hello"
|
||
*/
|
||
expected8 := []string{"hello", "hello"}
|
||
got8_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got8, err := redisPoolObj_list.Strings(got8_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected8, got8) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected8, got8)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LREM greet 0 hello # 移除表中所有 hello
|
||
(integer) 2 # 两个 hello 被移除
|
||
*/
|
||
value9 := "hello"
|
||
expected9 := 2
|
||
got9, err := redisPoolObj_list.LRem(key, 0, value9)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got9 != expected9 {
|
||
t.Errorf("Expected to get %d, but now got %d", expected9, got9)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LLEN greet
|
||
(integer) 0
|
||
*/
|
||
expected10 := 0
|
||
got10, err := redisPoolObj_list.LLen(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got10 != expected10 {
|
||
t.Errorf("Expected to get %d, but now got %d", expected10, got10)
|
||
return
|
||
}
|
||
|
||
expected11 := false
|
||
got11, err := redisPoolObj_list.Exists(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got11 != expected11 {
|
||
t.Errorf("Expected to get %t, but now got %t", expected11, got11)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLLen(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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> LLEN job
|
||
(integer) 0
|
||
*/
|
||
key := "job"
|
||
expected := 0
|
||
got, err := redisPoolObj_list.LLen(key)
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 非空列表
|
||
|
||
redis> LPUSH job "cook food"
|
||
(integer) 1
|
||
*/
|
||
value := "cook food"
|
||
expected = 1
|
||
got, err = redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
/*
|
||
redis> LPUSH job "have lunch"
|
||
(integer) 2
|
||
*/
|
||
value = "have lunch"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
/*
|
||
redis> LLEN job
|
||
(integer) 2
|
||
*/
|
||
expected = 2
|
||
got, err = redisPoolObj_list.LLen(key)
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLIndex(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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> LPUSH mylist "World"
|
||
(integer) 1
|
||
*/
|
||
key := "mylist"
|
||
value := "World"
|
||
expected := 1
|
||
got, err := redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
/*
|
||
redis> LPUSH mylist "Hello"
|
||
(integer) 2
|
||
*/
|
||
value = "Hello"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LINDEX mylist 0
|
||
"Hello"
|
||
*/
|
||
expected2 := "Hello"
|
||
index := 0
|
||
got2_interface, exist, err := redisPoolObj_list.LIndex(key, index)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if !exist {
|
||
t.Errorf("The key:%s, index:%d should exist, but now it doesn't.", key, index)
|
||
return
|
||
}
|
||
got2, err := redisPoolObj_list.String(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got2 != expected2 {
|
||
t.Errorf("Expected length %s, but got %s", expected2, got2)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LINDEX mylist -1
|
||
"World"
|
||
*/
|
||
expected3 := "World"
|
||
index = -1
|
||
got3_interface, exist, err := redisPoolObj_list.LIndex(key, index)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if !exist {
|
||
t.Errorf("The key:%s, index:%d should exist, but now it doesn't.", key, index)
|
||
return
|
||
}
|
||
got3, err := redisPoolObj_list.String(got3_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got3 != expected3 {
|
||
t.Errorf("Expected length %s, but got %s", expected3, got3)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LINDEX mylist 3 # index不在 mylist 的区间范围内
|
||
(nil)
|
||
*/
|
||
index = 3
|
||
_, exist, err = redisPoolObj_list.LIndex(key, index)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if exist {
|
||
t.Errorf("The key:%s, index:%d should not exist, but now it does.", key, index)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLInsert(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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> RPUSH mylist "Hello"
|
||
(integer) 1
|
||
|
||
redis> RPUSH mylist "World"
|
||
(integer) 2
|
||
*/
|
||
key := "mylist"
|
||
value := "Hello"
|
||
expected := 1
|
||
got, err := redisPoolObj_list.RPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
value = "World"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.RPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
/*
|
||
redis> LINSERT mylist BEFORE "World" "There"
|
||
(integer) 3
|
||
*/
|
||
pivot := "World"
|
||
value = "There"
|
||
expected = 3
|
||
got, err = redisPoolObj_list.LInsert(key, "BEFORE", pivot, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE mylist 0 -1
|
||
1) "Hello"
|
||
2) "There"
|
||
3) "World"
|
||
*/
|
||
expected2 := []string{"Hello", "There", "World"}
|
||
got2_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got2, err := redisPoolObj_list.Strings(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected2, got2) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected2, got2)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 对一个非空列表插入，查找一个不存在的 pivot
|
||
|
||
redis> LINSERT mylist BEFORE "go" "let's"
|
||
(integer) -1 # 失败
|
||
*/
|
||
pivot = "go"
|
||
value = "let's"
|
||
expected = -1
|
||
got, err = redisPoolObj_list.LInsert(key, "BEFORE", pivot, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %d, but got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 对一个空列表执行 LINSERT 命令
|
||
|
||
redis> EXISTS fake_list
|
||
(integer) 0
|
||
*/
|
||
key3 := "fake_list"
|
||
expected3 := false
|
||
got3, err := redisPoolObj_list.Exists(key3)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got3 != expected3 {
|
||
t.Errorf("Expected length %t, but got %t", expected3, got3)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LINSERT fake_list BEFORE "nono" "gogogog"
|
||
(integer) 0 # 失败
|
||
*/
|
||
pivot = "nono"
|
||
value = "gogogog"
|
||
expected4 := 0
|
||
got4, err := redisPoolObj_list.LInsert(key3, "BEFORE", pivot, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got4 != expected4 {
|
||
t.Errorf("Expected to get %d, but got %d", expected4, got4)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLSet(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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 不存在)进行 LSET
|
||
|
||
redis> EXISTS list
|
||
(integer) 0
|
||
*/
|
||
key := "list"
|
||
expected := false
|
||
got, err := redisPoolObj_list.Exists(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected length %t, but got %t", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LSET list 0 item
|
||
(error) ERR no such key
|
||
*/
|
||
index := 0
|
||
value := "item"
|
||
err = redisPoolObj_list.LSet(key, index, value)
|
||
if err == nil {
|
||
t.Errorf("There should be an error, but now there isn't.")
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 对非空列表进行 LSET
|
||
|
||
redis> LPUSH job "cook food"
|
||
(integer) 1
|
||
*/
|
||
key = "job"
|
||
value = "cook food"
|
||
expected2 := 1
|
||
got2, err := redisPoolObj_list.LPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got2 != expected2 {
|
||
t.Errorf("Expected length %d, but got %d", expected2, got2)
|
||
return
|
||
}
|
||
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
/*
|
||
redis> LRANGE job 0 0
|
||
1) "cook food"
|
||
*/
|
||
expected3 := []string{"cook food"}
|
||
got3_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got3, err := redisPoolObj_list.Strings(got3_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected3, got3) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected3, got3)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LSET job 0 "play game"
|
||
OK
|
||
*/
|
||
index = 0
|
||
value = "play game"
|
||
err = redisPoolObj_list.LSet(key, index, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE job 0 0
|
||
1) "play game"
|
||
*/
|
||
expected4 := []string{"play game"}
|
||
got4_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got4, err := redisPoolObj_list.Strings(got4_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected4, got4) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected4, got4)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# index 超出范围
|
||
|
||
redis> LLEN list # 列表长度为 1
|
||
(integer) 1
|
||
*/
|
||
key = "list"
|
||
redisPoolObj_list.RPush(key, "init")
|
||
|
||
expected5 := 1
|
||
got5, err := redisPoolObj_list.LLen(key)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got5 != expected5 {
|
||
t.Errorf("Expected length %d, but got %d", expected5, got5)
|
||
return
|
||
}
|
||
|
||
deleteKeys = append(deleteKeys, key)
|
||
|
||
/*
|
||
redis> LSET list 3 'out of range'
|
||
(error) ERR index out of range
|
||
*/
|
||
index = 3
|
||
value = "out of range"
|
||
err = redisPoolObj_list.LSet(key, index, value)
|
||
if err == nil {
|
||
t.Errorf("There should be an error, but now there isn't.")
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLRange(t *testing.T) {
|
||
deleteKeys := make([]string, 0, 8)
|
||
defer func() {
|
||
// Delete the test keys
|
||
distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
count, err := redisPoolObj_list.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> RPUSH fp-language lisp
|
||
(integer) 1
|
||
*/
|
||
key := "fp-language"
|
||
value := "lisp"
|
||
expected := 1
|
||
got, err := redisPoolObj_list.RPush(key, 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> LRANGE fp-language 0 0
|
||
1) "lisp"
|
||
*/
|
||
expected2 := []string{"lisp"}
|
||
got2_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got2, err := redisPoolObj_list.Strings(got2_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected2, got2) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected2, got2)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> RPUSH fp-language scheme
|
||
(integer) 2
|
||
*/
|
||
value = "scheme"
|
||
expected = 2
|
||
got, err = redisPoolObj_list.RPush(key, value)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if got != expected {
|
||
t.Errorf("Expected to get %d, but now got %d", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LRANGE fp-language 0 1
|
||
1) "lisp"
|
||
2) "scheme"
|
||
*/
|
||
expected3 := []string{"lisp", "scheme"}
|
||
got3_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got3, err := redisPoolObj_list.Strings(got3_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected3, got3) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected3, got3)
|
||
return
|
||
}
|
||
}
|
||
|
||
func TestLTrim(t *testing.T) {
|
||
// deleteKeys := make([]string, 0, 8)
|
||
// defer func() {
|
||
// // Delete the test keys
|
||
// distinctKeyList := getDistinctKeyList(deleteKeys)
|
||
// count, err := redisPoolObj_list.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
|
||
// }
|
||
// }()
|
||
|
||
/*
|
||
# 情况 1： 常见情况， start 和 stop 都在列表的索引范围之内
|
||
*/
|
||
key := "alpha"
|
||
redisPoolObj_list.RPush(key, "h", "e", "l", "l", "o")
|
||
|
||
/*
|
||
redis> LRANGE alpha 0 -1 # alpha 是一个包含 5 个字符串的列表
|
||
1) "h"
|
||
2) "e"
|
||
3) "l"
|
||
4) "l"
|
||
5) "o"
|
||
*/
|
||
expected := []string{"h", "e", "l", "l", "o"}
|
||
got_interface, err := redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got, err := redisPoolObj_list.Strings(got_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected, got) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
redis> LTRIM alpha 1 -1 # 删除 alpha 列表索引为 0 的元素
|
||
OK
|
||
|
||
redis> LRANGE alpha 0 -1 # "h" 被删除了
|
||
1) "e"
|
||
2) "l"
|
||
3) "l"
|
||
4) "o"
|
||
*/
|
||
start := 1
|
||
stop := -1
|
||
err = redisPoolObj_list.LTrim(key, start, stop)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
|
||
expected = []string{"e", "l", "l", "o"}
|
||
got_interface, err = redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got, err = redisPoolObj_list.Strings(got_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected, got) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 情况 2： stop 比列表的最大下标还要大
|
||
|
||
redis> LTRIM alpha 1 10086 # 保留 alpha 列表索引 1 至索引 10086 上的元素
|
||
OK
|
||
|
||
redis> LRANGE alpha 0 -1 # 只有索引 0 上的元素 "e" 被删除了，其他元素还在
|
||
1) "l"
|
||
2) "l"
|
||
3) "o"
|
||
*/
|
||
start = 1
|
||
stop = 10086
|
||
err = redisPoolObj_list.LTrim(key, start, stop)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
|
||
expected = []string{"l", "l", "o"}
|
||
got_interface, err = redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got, err = redisPoolObj_list.Strings(got_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected, got) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 情况 3： start 和 stop 都比列表的最大下标要大，并且 start < stop
|
||
|
||
redis> LTRIM alpha 10086 123321
|
||
OK
|
||
|
||
redis> LRANGE alpha 0 -1 # 列表被清空
|
||
(empty list or set)
|
||
*/
|
||
start = 10086
|
||
stop = 123321
|
||
err = redisPoolObj_list.LTrim(key, start, stop)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
|
||
expected = []string{}
|
||
got_interface, err = redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got, err = redisPoolObj_list.Strings(got_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected, got) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected, got)
|
||
return
|
||
}
|
||
|
||
/*
|
||
# 情况 4： start 和 stop 都比列表的最大下标要大，并且 start > stop
|
||
|
||
redis> RPUSH new-alpha "h" "e" "l" "l" "o" # 重新建立一个新列表
|
||
(integer) 5
|
||
|
||
redis> LRANGE new-alpha 0 -1
|
||
1) "h"
|
||
2) "e"
|
||
3) "l"
|
||
4) "l"
|
||
5) "o"
|
||
|
||
redis> LTRIM new-alpha 123321 10086 # 执行 LTRIM
|
||
OK
|
||
|
||
redis> LRANGE new-alpha 0 -1 # 同样被清空
|
||
(empty list or set)
|
||
*/
|
||
key = "new-alpha"
|
||
redisPoolObj_list.RPush(key, "h", "e", "l", "l", "o")
|
||
expected = []string{"h", "e", "l", "l", "o"}
|
||
got_interface, err = redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got, err = redisPoolObj_list.Strings(got_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected, got) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected, got)
|
||
return
|
||
}
|
||
|
||
start = 123321
|
||
stop = 10086
|
||
err = redisPoolObj_list.LTrim(key, start, stop)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
|
||
expected = []string{}
|
||
got_interface, err = redisPoolObj_list.LRange(key, 0, -1)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
got, err = redisPoolObj_list.Strings(got_interface)
|
||
if err != nil {
|
||
t.Fail()
|
||
}
|
||
if isTwoOrderedSliceEqual(expected, got) == false {
|
||
t.Errorf("Expected to get %v, but got %v\n", expected, got)
|
||
return
|
||
}
|
||
}
|