func TestZSetRank(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("myzset")
if _, err := ledis.Int(c.Do("zadd", key, 1, "a", 2, "b", 3, "c", 4, "d")); err != nil {
t.Fatal(err)
}
if n, err := ledis.Int(c.Do("zrank", key, "c")); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if _, err := ledis.Int(c.Do("zrank", key, "e")); err != ledis.ErrNil {
t.Fatal(err)
}
if n, err := ledis.Int(c.Do("zrevrank", key, "c")); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if _, err := ledis.Int(c.Do("zrevrank", key, "e")); err != ledis.ErrNil {
t.Fatal(err)
}
}
func TestListMPush(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("b")
if n, err := ledis.Int(c.Do("rpush", key, 1, 2, 3)); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
if err := testListRange(key, 0, 3, 1, 2, 3); err != nil {
t.Fatal(err)
}
if n, err := ledis.Int(c.Do("lpush", key, 1, 2, 3)); err != nil {
t.Fatal(err)
} else if n != 6 {
t.Fatal(n)
}
if err := testListRange(key, 0, 6, 3, 2, 1, 1, 2, 3); err != nil {
t.Fatal(err)
}
}
func TestHashM(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("b")
if ok, err := ledis.String(c.Do("hmset", key, 1, 1, 2, 2, 3, 3)); err != nil {
t.Fatal(err)
} else if ok != OK {
t.Fatal(ok)
}
if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
if v, err := ledis.MultiBulk(c.Do("hmget", key, 1, 2, 3, 4)); err != nil {
t.Fatal(err)
} else {
if err := testHashArray(v, 1, 2, 3, 0); err != nil {
t.Fatal(err)
}
}
if n, err := ledis.Int(c.Do("hdel", key, 1, 2, 3, 4)); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if v, err := ledis.MultiBulk(c.Do("hmget", key, 1, 2, 3, 4)); err != nil {
t.Fatal(err)
} else {
if err := testHashArray(v, 0, 0, 0, 0); err != nil {
t.Fatal(err)
}
}
if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
}
func TestHashGetAll(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("d")
if ok, err := ledis.String(c.Do("hmset", key, 1, 1, 2, 2, 3, 3)); err != nil {
t.Fatal(err)
} else if ok != OK {
t.Fatal(ok)
}
if v, err := ledis.MultiBulk(c.Do("hgetall", key)); err != nil {
t.Fatal(err)
} else {
if err := testHashArray(v, 1, 1, 2, 2, 3, 3); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("hkeys", key)); err != nil {
t.Fatal(err)
} else {
if err := testHashArray(v, 1, 2, 3); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("hvals", key)); err != nil {
t.Fatal(err)
} else {
if err := testHashArray(v, 1, 2, 3); err != nil {
t.Fatal(err)
}
}
if n, err := ledis.Int(c.Do("hclear", key)); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
}
func benchZSetRead() {
c := client.Get()
defer c.Close()
wg.Add(*clients)
t1 := time.Now().UnixNano()
for i := 0; i < *clients; i++ {
go waitZrangeBench(i)
}
total, _ := ledis.Int(c.Do("zcard", "myzset"))
wg.Wait()
t2 := time.Now().UnixNano()
delta := float64(t2-t1) / float64(time.Second)
if *number < total {
total = *number
}
fmt.Printf("total %d zset members, consumed %f seconds\n", total, delta)
}
func testBitGetSet(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("test_cmd_bin_basic")
// get / set
if v, err := ledis.Int(c.Do("bgetbit", key, 1024)); err != nil {
t.Fatal(err)
} else if v != 0 {
t.Fatal(v)
}
if ori, err := ledis.Int(c.Do("bsetbit", key, 1024, 1)); err != nil {
t.Fatal(err)
} else if ori != 0 {
t.Fatal(ori)
}
if v, err := ledis.Int(c.Do("bgetbit", key, 1024)); err != nil {
t.Fatal(err)
} else if v != 1 {
t.Fatal(v)
}
// fetch from revert pos
c.Do("bsetbit", key, 1000, 1)
if v, err := ledis.Int(c.Do("bgetbit", key, -1)); err != nil {
t.Fatal(err)
} else if v != 1 {
t.Fatal(v)
}
if v, err := ledis.Int(c.Do("bgetbit", key, -25)); err != nil {
t.Fatal(err)
} else if v != 1 {
t.Fatal(v)
}
// delete
if drop, err := ledis.Int(c.Do("bdelete", key)); err != nil {
t.Fatal(err)
} else if drop != 1 {
t.Fatal(drop)
}
if drop, err := ledis.Int(c.Do("bdelete", key)); err != nil {
t.Fatal(err)
} else if drop != 0 {
t.Fatal(drop)
}
}
func TestHashIncr(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("c")
if n, err := ledis.Int(c.Do("hincrby", key, 1, 1)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(err)
}
if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hincrby", key, 1, 10)); err != nil {
t.Fatal(err)
} else if n != 11 {
t.Fatal(err)
}
if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hincrby", key, 1, -11)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(err)
}
}
func testBitMset(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("test_cmd_bin_mset")
if n, err := ledis.Int(
c.Do("bmsetbit", key,
500, 0,
100, 1,
200, 1,
1000, 1,
900, 0,
500000, 1,
600, 0,
300, 1,
100000, 1)); err != nil {
t.Fatal(err)
} else if n != 9 {
t.Fatal(n)
}
fillPos := []int{100, 200, 300, 1000, 100000, 500000}
for _, pos := range fillPos {
v, err := ledis.Int(c.Do("bgetbit", key, pos))
if err != nil || v != 1 {
t.Fatal(pos)
}
}
// err
if n, err := ledis.Int(
c.Do("bmsetbit", key, 3, 0, 2, 1, 3, 0, 1, 1)); err == nil || n != 0 {
t.Fatal(n) // duplication on pos
}
}
func testListIndex(key []byte, index int64, v int) error {
c := getTestConn()
defer c.Close()
n, err := ledis.Int(c.Do("lindex", key, index))
if err == ledis.ErrNil && v != 0 {
return fmt.Errorf("must nil")
} else if err != nil && err != ledis.ErrNil {
return err
} else if n != v {
return fmt.Errorf("index err number %d != %d", n, v)
}
return nil
}
func testBitCount(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("test_cmd_bin_count")
sum := 0
for pos := 1; pos < 1000000; pos += 10001 {
c.Do("bsetbit", key, pos, 1)
sum++
}
if n, err := ledis.Int(c.Do("bcount", key)); err != nil {
t.Fatal(err)
} else if n != sum {
t.Fatal(n)
}
}
func TestHash(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("a")
if n, err := ledis.Int(c.Do("hset", key, 1, 0)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hexists", key, 1)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hexists", key, -1)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hget", key, 1)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hset", key, 1, 1)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hget", key, 1)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
}
func TestZSetRange(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("myzset_range_rank")
if _, err := ledis.Int(c.Do("zadd", key, 1, "a", 2, "b", 3, "c", 4, "d")); err != nil {
t.Fatal(err)
}
if v, err := ledis.MultiBulk(c.Do("zrange", key, 0, 3, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "a", 1, "b", 2, "c", 3, "d", 4); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrange", key, 1, 4, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "b", 2, "c", 3, "d", 4); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrange", key, -2, -1, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "c", 3, "d", 4); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrange", key, 0, -1, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "a", 1, "b", 2, "c", 3, "d", 4); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrange", key, -1, -2, "withscores")); err != nil {
t.Fatal(err)
} else if len(v) != 0 {
t.Fatal(len(v))
}
if v, err := ledis.MultiBulk(c.Do("zrevrange", key, 0, 4, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "d", 4, "c", 3, "b", 2, "a", 1); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrevrange", key, 0, -1, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "d", 4, "c", 3, "b", 2, "a", 1); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrevrange", key, 2, 3, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "b", 2, "a", 1); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrevrange", key, -2, -1, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "b", 2, "a", 1); err != nil {
t.Fatal(err)
}
}
if n, err := ledis.Int(c.Do("zremrangebyrank", key, 2, 3)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if v, err := ledis.MultiBulk(c.Do("zrange", key, 0, 4)); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "a", "b"); err != nil {
t.Fatal(err)
}
}
if n, err := ledis.Int(c.Do("zclear", key)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
}
func TestZSet(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("myzset")
if n, err := ledis.Int(c.Do("zadd", key, 3, "a", 4, "b")); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(n)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zadd", key, 1, "a", 2, "b")); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(n)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zadd", key, 3, "c", 4, "d")); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
if s, err := ledis.Int(c.Do("zscore", key, "c")); err != nil {
t.Fatal(err)
} else if s != 3 {
t.Fatal(s)
}
if n, err := ledis.Int(c.Do("zrem", key, "d", "e")); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zincrby", key, 4, "c")); err != nil {
t.Fatal(err)
} else if n != 7 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zincrby", key, -4, "c")); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zincrby", key, 4, "d")); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zrem", key, "a", "b", "c", "d")); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
}
func TestList(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("a")
if n, err := ledis.Int(c.Do("lpush", key, 1)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("rpush", key, 2)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("rpush", key, 3)); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("llen", key)); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
//for ledis-cli a 1 2 3
// 127.0.0.1:6379> lrange a 0 0
// 1) "1"
if err := testListRange(key, 0, 0, 1); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a 0 1
// 1) "1"
// 2) "2"
if err := testListRange(key, 0, 1, 1, 2); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a 0 5
// 1) "1"
// 2) "2"
// 3) "3"
if err := testListRange(key, 0, 5, 1, 2, 3); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a -1 5
// 1) "3"
if err := testListRange(key, -1, 5, 3); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a -5 -1
// 1) "1"
// 2) "2"
// 3) "3"
if err := testListRange(key, -5, -1, 1, 2, 3); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a -2 -1
// 1) "2"
// 2) "3"
if err := testListRange(key, -2, -1, 2, 3); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a -1 -2
// (empty list or set)
if err := testListRange(key, -1, -2); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a -1 2
// 1) "3"
if err := testListRange(key, -1, 2, 3); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a -5 5
// 1) "1"
// 2) "2"
// 3) "3"
if err := testListRange(key, -5, 5, 1, 2, 3); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a -1 0
// (empty list or set)
if err := testListRange(key, -1, 0); err != nil {
t.Fatal(err)
}
if err := testListRange([]byte("empty list"), 0, 100); err != nil {
t.Fatal(err)
}
// 127.0.0.1:6379> lrange a -1 -1
// 1) "3"
if err := testListRange(key, -1, -1, 3); err != nil {
t.Fatal(err)
}
if err := testListIndex(key, -1, 3); err != nil {
t.Fatal(err)
}
if err := testListIndex(key, 0, 1); err != nil {
t.Fatal(err)
}
if err := testListIndex(key, 1, 2); err != nil {
t.Fatal(err)
}
if err := testListIndex(key, 2, 3); err != nil {
t.Fatal(err)
}
if err := testListIndex(key, 5, 0); err != nil {
t.Fatal(err)
}
if err := testListIndex(key, -1, 3); err != nil {
t.Fatal(err)
}
if err := testListIndex(key, -2, 2); err != nil {
t.Fatal(err)
}
if err := testListIndex(key, -3, 1); err != nil {
t.Fatal(err)
}
}
func TestZSetRangeScore(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("myzset_range")
if _, err := ledis.Int(c.Do("zadd", key, 1, "a", 2, "b", 3, "c", 4, "d")); err != nil {
t.Fatal(err)
}
if v, err := ledis.MultiBulk(c.Do("zrangebyscore", key, 1, 4, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "a", 1, "b", 2, "c", 3, "d", 4); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrangebyscore", key, 1, 4, "withscores", "limit", 1, 2)); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "b", 2, "c", 3); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrangebyscore", key, "-inf", "+inf", "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "a", 1, "b", 2, "c", 3, "d", 4); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrangebyscore", key, "(1", "(4")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "b", "c"); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrevrangebyscore", key, 4, 1, "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "d", 4, "c", 3, "b", 2, "a", 1); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrevrangebyscore", key, 4, 1, "withscores", "limit", 1, 2)); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "c", 3, "b", 2); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrevrangebyscore", key, "+inf", "-inf", "withscores")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "d", 4, "c", 3, "b", 2, "a", 1); err != nil {
t.Fatal(err)
}
}
if v, err := ledis.MultiBulk(c.Do("zrevrangebyscore", key, "(4", "(1")); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "c", "b"); err != nil {
t.Fatal(err)
}
}
if n, err := ledis.Int(c.Do("zremrangebyscore", key, 2, 3)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcard", key)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if v, err := ledis.MultiBulk(c.Do("zrangebyscore", key, 1, 4)); err != nil {
t.Fatal(err)
} else {
if err := testZSetRange(v, "a", "d"); err != nil {
t.Fatal(err)
}
}
}
func TestExpire(t *testing.T) {
// test for kv, list, hash, set, zset, bitmap in all
ttlType := []string{"k", "l", "h", "s", "z", "b"}
var (
expire string
expireat string
ttl string
persist string
key string
)
c := getTestConn()
defer c.Close()
idx := 1
for _, tt := range ttlType {
if tt == "k" {
expire = "expire"
expireat = "expireat"
ttl = "ttl"
persist = "persist"
} else {
expire = fmt.Sprintf("%sexpire", tt)
expireat = fmt.Sprintf("%sexpireat", tt)
ttl = fmt.Sprintf("%sttl", tt)
persist = fmt.Sprintf("%spersist", tt)
}
switch tt {
case "k":
key = "kv_ttl"
c.Do("set", key, "123")
case "l":
key = "list_ttl"
c.Do("rpush", key, "123")
case "h":
key = "hash_ttl"
c.Do("hset", key, "a", "123")
case "s":
key = "set_ttl"
c.Do("sadd", key, "123")
case "z":
key = "zset_ttl"
c.Do("zadd", key, 123, "a")
case "b":
key = "bitmap_ttl"
c.Do("bsetbit", key, 0, 1)
}
// expire + ttl
exp := int64(10)
if n, err := ledis.Int(c.Do(expire, key, exp)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if ttl, err := ledis.Int64(c.Do(ttl, key)); err != nil {
t.Fatal(err)
} else if ttl != exp {
t.Fatal(ttl)
}
// expireat + ttl
tm := now() + 3
if n, err := ledis.Int(c.Do(expireat, key, tm)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if ttl, err := ledis.Int64(c.Do(ttl, key)); err != nil {
t.Fatal(err)
} else if ttl != 3 {
t.Fatal(ttl)
}
kErr := "not_exist_ttl"
// err - expire, expireat
if n, err := ledis.Int(c.Do(expire, kErr, tm)); err != nil || n != 0 {
t.Fatal(false)
}
if n, err := ledis.Int(c.Do(expireat, kErr, tm)); err != nil || n != 0 {
t.Fatal(false)
}
if n, err := ledis.Int(c.Do(ttl, kErr)); err != nil || n != -1 {
t.Fatal(false)
}
if n, err := ledis.Int(c.Do(persist, key)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do(expire, key, 10)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do(persist, key)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
idx++
}
}
func TestZSetCount(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("myzset")
if _, err := ledis.Int(c.Do("zadd", key, 1, "a", 2, "b", 3, "c", 4, "d")); err != nil {
t.Fatal(err)
}
if n, err := ledis.Int(c.Do("zcount", key, 2, 4)); err != nil {
t.Fatal(err)
} else if n != 3 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcount", key, 4, 4)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcount", key, 4, 3)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcount", key, "(2", 4)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcount", key, "2", "(4")); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcount", key, "(2", "(4")); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("zcount", key, "-inf", "+inf")); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
c.Do("zadd", key, 3, "e")
if n, err := ledis.Int(c.Do("zcount", key, "(2", "(4")); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
c.Do("zrem", key, "a", "b", "c", "d", "e")
}
func testBitOpt(t *testing.T) {
c := getTestConn()
defer c.Close()
dstk := []byte("bin_op_res")
kmiss := []byte("bin_op_miss")
k0 := []byte("bin_op_0")
k1 := []byte("bin_op_1")
c.Do("bmsetbit", k0, 10, 1, 30, 1, 50, 1, 70, 1, 100, 1)
c.Do("bmsetbit", k1, 20, 1, 40, 1, 60, 1, 80, 1, 100, 1)
// case - lack of args
// todo ...
// case - 'not' on inexisting key
if blen, err := ledis.Int(
c.Do("bopt", "not", dstk, kmiss)); err != nil {
t.Fatal(err)
} else if blen != 0 {
t.Fatal(blen)
}
if v, _ := ledis.String(c.Do("bget", dstk)); v != "" {
t.Fatal(v)
}
// case - 'and', 'or', 'xor' with inexisting key
opts := []string{"and", "or", "xor"}
for _, op := range opts {
if blen, err := ledis.Int(
c.Do("bopt", op, dstk, kmiss, k0)); err != nil {
t.Fatal(err)
} else if blen != 0 {
t.Fatal(blen)
}
}
// case - 'and'
if blen, err := ledis.Int(
c.Do("bopt", "and", dstk, k0, k1)); err != nil {
t.Fatal(err)
} else if blen != 101 {
t.Fatal(blen)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 1 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 0 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 0 {
t.Fatal(v)
}
// case - 'or'
if blen, err := ledis.Int(
c.Do("bopt", "or", dstk, k0, k1)); err != nil {
t.Fatal(err)
} else if blen != 101 {
t.Fatal(blen)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 1 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 1 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 1 {
t.Fatal(v)
}
// case - 'xor'
if blen, err := ledis.Int(
c.Do("bopt", "xor", dstk, k0, k1)); err != nil {
t.Fatal(err)
} else if blen != 101 {
t.Fatal(blen)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 0 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 1 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 1 {
t.Fatal(v)
}
return
}
func TestKV(t *testing.T) {
c := getTestConn()
defer c.Close()
if ok, err := ledis.String(c.Do("set", "a", "1234")); err != nil {
t.Fatal(err)
} else if ok != OK {
t.Fatal(ok)
}
if n, err := ledis.Int(c.Do("setnx", "a", "123")); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("setnx", "b", "123")); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if v, err := ledis.String(c.Do("get", "a")); err != nil {
t.Fatal(err)
} else if v != "1234" {
t.Fatal(v)
}
if v, err := ledis.String(c.Do("getset", "a", "123")); err != nil {
t.Fatal(err)
} else if v != "1234" {
t.Fatal(v)
}
if v, err := ledis.String(c.Do("get", "a")); err != nil {
t.Fatal(err)
} else if v != "123" {
t.Fatal(v)
}
if n, err := ledis.Int(c.Do("exists", "a")); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("exists", "empty_key_test")); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if _, err := ledis.Int(c.Do("del", "a", "b")); err != nil {
t.Fatal(err)
}
if n, err := ledis.Int(c.Do("exists", "a")); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("exists", "b")); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
}
func TestSetExpire(t *testing.T) {
c := getTestConn()
defer c.Close()
k := "set_ttl"
c.Do("sadd", k, "123")
// expire + ttl
exp := int64(10)
if n, err := ledis.Int(c.Do("sexpire", k, exp)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if ttl, err := ledis.Int64(c.Do("sttl", k)); err != nil {
t.Fatal(err)
} else if ttl != exp {
t.Fatal(ttl)
}
// expireat + ttl
tm := now() + 3
if n, err := ledis.Int(c.Do("sexpireat", k, tm)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if ttl, err := ledis.Int64(c.Do("sttl", k)); err != nil {
t.Fatal(err)
} else if ttl != 3 {
t.Fatal(ttl)
}
kErr := "not_exist_ttl"
// err - expire, expireat
if n, err := ledis.Int(c.Do("sexpire", kErr, tm)); err != nil || n != 0 {
t.Fatal(false)
}
if n, err := ledis.Int(c.Do("sexpireat", kErr, tm)); err != nil || n != 0 {
t.Fatal(false)
}
if n, err := ledis.Int(c.Do("sttl", kErr)); err != nil || n != -1 {
t.Fatal(false)
}
if n, err := ledis.Int(c.Do("spersist", k)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("sexpire", k, 10)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("spersist", k)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
}
func TestSet(t *testing.T) {
c := getTestConn()
defer c.Close()
key1 := "testdb_cmd_set_1"
key2 := "testdb_cmd_set_2"
if n, err := ledis.Int(c.Do("sadd", key1, 0, 1)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("sadd", key2, 0, 1, 2, 3)); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("scard", key1)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.MultiBulk(c.Do("sdiff", key2, key1)); err != nil {
t.Fatal(err)
} else if len(n) != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("sdiffstore", []byte("cmd_set_em1"), key2, key1)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.MultiBulk(c.Do("sunion", key1, key2)); err != nil {
t.Fatal(err)
} else if len(n) != 4 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("sunionstore", []byte("cmd_set_em2"), key1, key2)); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
if n, err := ledis.MultiBulk(c.Do("sinter", key1, key2)); err != nil {
t.Fatal(err)
} else if len(n) != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("sinterstore", []byte("cmd_set_em3"), key1, key2)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("srem", key1, 0, 1)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("sismember", key2, 0)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.MultiBulk(c.Do("smembers", key2)); err != nil {
t.Fatal(err)
} else if len(n) != 4 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("sclear", key2)); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
c.Do("sadd", key1, 0)
c.Do("sadd", key2, 1)
if n, err := ledis.Int(c.Do("smclear", key1, key2)); err != nil {
t.Fatal(err)
} else if n != 2 {
t.Fatal(n)
}
}
func TestPop(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("c")
if n, err := ledis.Int(c.Do("rpush", key, 1, 2, 3, 4, 5, 6)); err != nil {
t.Fatal(err)
} else if n != 6 {
t.Fatal(n)
}
if v, err := ledis.Int(c.Do("lpop", key)); err != nil {
t.Fatal(err)
} else if v != 1 {
t.Fatal(v)
}
if v, err := ledis.Int(c.Do("rpop", key)); err != nil {
t.Fatal(err)
} else if v != 6 {
t.Fatal(v)
}
if n, err := ledis.Int(c.Do("lpush", key, 1)); err != nil {
t.Fatal(err)
} else if n != 5 {
t.Fatal(n)
}
if err := testListRange(key, 0, 5, 1, 2, 3, 4, 5); err != nil {
t.Fatal(err)
}
for i := 1; i <= 5; i++ {
if v, err := ledis.Int(c.Do("lpop", key)); err != nil {
t.Fatal(err)
} else if v != i {
t.Fatal(v)
}
}
if n, err := ledis.Int(c.Do("llen", key)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
c.Do("rpush", key, 1, 2, 3, 4, 5)
if n, err := ledis.Int(c.Do("lclear", key)); err != nil {
t.Fatal(err)
} else if n != 5 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("llen", key)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
}
