You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kvrocks.apache.org by ti...@apache.org on 2022/10/15 01:06:26 UTC
[incubator-kvrocks] branch unstable updated: Move TCL test unit/type/zset to Go case (#988)
This is an automated email from the ASF dual-hosted git repository.
tison pushed a commit to branch unstable
in repository https://gitbox.apache.org/repos/asf/incubator-kvrocks.git
The following commit(s) were added to refs/heads/unstable by this push:
new 9f462d0 Move TCL test unit/type/zset to Go case (#988)
9f462d0 is described below
commit 9f462d08a997d37b77c5391d4b9d87a2323c3e4f
Author: IoCing <39...@users.noreply.github.com>
AuthorDate: Sat Oct 15 09:06:20 2022 +0800
Move TCL test unit/type/zset to Go case (#988)
Co-authored-by: tison <wa...@gmail.com>
---
tests/gocase/unit/type/zset/zset_test.go | 951 +++++++++++++++++++++++++++
tests/gocase/util/assertions.go | 7 +
tests/gocase/util/random.go | 4 +
tests/tcl/tests/test_helper.tcl | 1 -
tests/tcl/tests/unit/type/zset.tcl | 1053 ------------------------------
5 files changed, 962 insertions(+), 1054 deletions(-)
diff --git a/tests/gocase/unit/type/zset/zset_test.go b/tests/gocase/unit/type/zset/zset_test.go
new file mode 100644
index 0000000..777f821
--- /dev/null
+++ b/tests/gocase/unit/type/zset/zset_test.go
@@ -0,0 +1,951 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package zset
+
+import (
+ "context"
+ "fmt"
+ "math"
+ "math/rand"
+ "sort"
+ "strconv"
+ "strings"
+ "testing"
+
+ "golang.org/x/exp/slices"
+
+ "github.com/apache/incubator-kvrocks/tests/gocase/util"
+ "github.com/go-redis/redis/v9"
+ "github.com/stretchr/testify/require"
+)
+
+func createZset(rdb *redis.Client, ctx context.Context, key string, items []redis.Z) {
+ rdb.Del(ctx, key)
+ for _, it := range items {
+ rdb.ZAdd(ctx, key, it)
+ }
+}
+
+func createDefaultZset(rdb *redis.Client, ctx context.Context) {
+ createZset(rdb, ctx, "zset", []redis.Z{
+ {math.Inf(-1), "a"},
+ {1, "b"},
+ {2, "c"},
+ {3, "d"},
+ {4, "e"},
+ {5, "f"},
+ {math.Inf(1), "g"}})
+}
+
+func createDefaultLexZset(rdb *redis.Client, ctx context.Context) {
+ createZset(rdb, ctx, "zset", []redis.Z{
+ {0, "alpha"},
+ {0, "bar"},
+ {0, "cool"},
+ {0, "down"},
+ {0, "elephant"},
+ {0, "foo"},
+ {0, "great"},
+ {0, "hill"},
+ {0, "omega"}})
+}
+
+func reverse(s []redis.Z) {
+ for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+ s[i], s[j] = s[j], s[i]
+ }
+}
+
+func basicTests(t *testing.T, rdb *redis.Client, ctx context.Context, encoding string) {
+ t.Run(fmt.Sprintf("Check encoding - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 10, Member: "x"})
+ })
+
+ t.Run(fmt.Sprintf("ZSET basic ZADD and score update - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 10, Member: "x"})
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 20, Member: "y"})
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 30, Member: "z"})
+ require.Equal(t, []string{"x", "y", "z"}, rdb.ZRange(ctx, "ztmp", 0, -1).Val())
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 1, Member: "y"})
+ require.Equal(t, []string{"y", "x", "z"}, rdb.ZRange(ctx, "ztmp", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZSET basic ZADD the same member with different scores - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ require.Equal(t, int64(1), rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 10, Member: "x"}, redis.Z{Score: 20, Member: "x"}).Val())
+ require.Equal(t, []string{"x"}, rdb.ZRange(ctx, "ztmp", 0, -1).Val())
+ require.Equal(t, float64(20), rdb.ZScore(ctx, "ztmp", "x").Val())
+
+ require.Equal(t, int64(2), rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 30, Member: "x"}, redis.Z{Score: 40, Member: "y"}, redis.Z{Score: 50, Member: "z"}).Val())
+ require.Equal(t, []string{"x", "y", "z"}, rdb.ZRange(ctx, "ztmp", 0, -1).Val())
+ require.Equal(t, float64(30), rdb.ZScore(ctx, "ztmp", "x").Val())
+ })
+
+ t.Run(fmt.Sprintf("ZSET element can't be set to NaN with ZADD - %s", encoding), func(t *testing.T) {
+ require.Contains(t, rdb.ZAdd(ctx, "myzset", redis.Z{Score: math.NaN(), Member: "abc"}).Err(), "float")
+ })
+
+ t.Run("ZSET element can't be set to NaN with ZINCRBY", func(t *testing.T) {
+ require.Contains(t, rdb.ZAdd(ctx, "myzset", redis.Z{Score: math.NaN(), Member: "abc"}).Err(), "float")
+ })
+
+ t.Run("ZINCRBY calls leading to NaN result in error", func(t *testing.T) {
+ rdb.ZIncrBy(ctx, "myzset", math.Inf(1), "abc")
+ util.ErrorRegexp(t, rdb.ZIncrBy(ctx, "myzset", math.Inf(-1), "abc").Err(), ".*NaN.*")
+ })
+
+ t.Run("ZADD - Variadic version base case", func(t *testing.T) {
+ rdb.Del(ctx, "myzset")
+ require.Equal(t, int64(3), rdb.ZAdd(ctx, "myzset", redis.Z{Score: 10, Member: "a"}, redis.Z{Score: 20, Member: "b"}, redis.Z{Score: 30, Member: "c"}).Val())
+ require.Equal(t, []redis.Z{{10, "a"}, {20, "b"}, {30, "c"}}, rdb.ZRangeWithScores(ctx, "myzset", 0, -1).Val())
+ })
+
+ t.Run("ZADD - Return value is the number of actually added items", func(t *testing.T) {
+ require.Equal(t, int64(1), rdb.ZAdd(ctx, "myzset", redis.Z{Score: 5, Member: "x"}, redis.Z{Score: 20, Member: "b"}, redis.Z{Score: 30, Member: "c"}).Val())
+ require.Equal(t, []redis.Z{{5, "x"}, {10, "a"}, {20, "b"}, {30, "c"}}, rdb.ZRangeWithScores(ctx, "myzset", 0, -1).Val())
+ })
+
+ t.Run("ZADD - Variadic version will raise error on missing arg", func(t *testing.T) {
+ rdb.Del(ctx, "myzset")
+ util.ErrorRegexp(t, rdb.Do(ctx, "zadd", "myzset", 10, "a", 20, "b", 30, "c", 40).Err(), ".*syntax.*")
+ })
+
+ t.Run("ZINCRBY does not work variadic even if shares ZADD implementation", func(t *testing.T) {
+ rdb.Del(ctx, "myzset")
+ util.ErrorRegexp(t, rdb.Do(ctx, "zincrby", "myzset", 10, "a", 20, "b", 30, "c").Err(), ".*ERR.*wrong.*number.*arg.*")
+ })
+
+ t.Run(fmt.Sprintf("ZCARD basics - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 10, Member: "a"}, redis.Z{Score: 20, Member: "b"}, redis.Z{Score: 30, Member: "c"})
+ require.Equal(t, int64(3), rdb.ZCard(ctx, "ztmp").Val())
+ require.Equal(t, int64(0), rdb.ZCard(ctx, "zdoesntexist").Val())
+ })
+
+ t.Run("ZREM removes key after last element is removed", func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 10, Member: "x"}, redis.Z{Score: 20, Member: "y"})
+ require.Equal(t, int64(1), rdb.Exists(ctx, "ztmp").Val())
+ require.Equal(t, int64(0), rdb.ZRem(ctx, "ztmp", "z").Val())
+ require.Equal(t, int64(1), rdb.ZRem(ctx, "ztmp", "y").Val())
+ require.Equal(t, int64(1), rdb.ZRem(ctx, "ztmp", "x").Val())
+ require.Equal(t, int64(0), rdb.Exists(ctx, "ztmp").Val())
+ })
+
+ t.Run("ZREM variadic version", func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 10, Member: "a"}, redis.Z{Score: 20, Member: "b"}, redis.Z{Score: 30, Member: "c"})
+ require.Equal(t, int64(2), rdb.ZRem(ctx, "ztmp", []string{"x", "y", "a", "b", "k"}).Val())
+ require.Equal(t, int64(0), rdb.ZRem(ctx, "ztmp", []string{"foo", "bar"}).Val())
+ require.Equal(t, int64(1), rdb.ZRem(ctx, "ztmp", []string{"c"}).Val())
+ require.Equal(t, int64(0), rdb.Exists(ctx, "ztmp").Val())
+ })
+
+ t.Run("ZREM variadic version -- remove elements after key deletion", func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 10, Member: "a"}, redis.Z{Score: 20, Member: "b"}, redis.Z{Score: 30, Member: "c"})
+ require.Equal(t, int64(3), rdb.ZRem(ctx, "ztmp", []string{"a", "b", "c", "d", "e", "f", "g"}).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZRANGE basics - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 1, Member: "a"})
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 2, Member: "b"})
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 3, Member: "c"})
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 4, Member: "d"})
+
+ require.Equal(t, []string{"a", "b", "c", "d"}, rdb.ZRange(ctx, "ztmp", 0, -1).Val())
+ require.Equal(t, []string{"a", "b", "c"}, rdb.ZRange(ctx, "ztmp", 0, -2).Val())
+ require.Equal(t, []string{"b", "c", "d"}, rdb.ZRange(ctx, "ztmp", 1, -1).Val())
+ require.Equal(t, []string{"b", "c"}, rdb.ZRange(ctx, "ztmp", 1, -2).Val())
+ require.Equal(t, []string{"c", "d"}, rdb.ZRange(ctx, "ztmp", -2, -1).Val())
+ require.Equal(t, []string{"c"}, rdb.ZRange(ctx, "ztmp", -2, -2).Val())
+
+ // out of range start index
+ require.Equal(t, []string{"a", "b", "c"}, rdb.ZRange(ctx, "ztmp", -5, 2).Val())
+ require.Equal(t, []string{"a", "b"}, rdb.ZRange(ctx, "ztmp", -5, 1).Val())
+ require.Equal(t, []string{}, rdb.ZRange(ctx, "ztmp", 5, -1).Val())
+ require.Equal(t, []string{}, rdb.ZRange(ctx, "ztmp", 5, -2).Val())
+
+ // out of range end index
+ require.Equal(t, []string{"a", "b", "c", "d"}, rdb.ZRange(ctx, "ztmp", 0, 5).Val())
+ require.Equal(t, []string{"b", "c", "d"}, rdb.ZRange(ctx, "ztmp", 1, 5).Val())
+ require.Equal(t, []string{}, rdb.ZRange(ctx, "ztmp", 0, -5).Val())
+ require.Equal(t, []string{}, rdb.ZRange(ctx, "ztmp", 1, -5).Val())
+
+ // withscores
+ require.Equal(t, []redis.Z{
+ {1, "a"},
+ {2, "b"},
+ {3, "c"},
+ {4, "d"},
+ }, rdb.ZRangeWithScores(ctx, "ztmp", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZREVRANGE basics - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 1, Member: "a"})
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 2, Member: "b"})
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 3, Member: "c"})
+ rdb.ZAdd(ctx, "ztmp", redis.Z{Score: 4, Member: "d"})
+
+ require.Equal(t, []string{"d", "c", "b", "a"}, rdb.ZRevRange(ctx, "ztmp", 0, -1).Val())
+ require.Equal(t, []string{"d", "c", "b"}, rdb.ZRevRange(ctx, "ztmp", 0, -2).Val())
+ require.Equal(t, []string{"c", "b", "a"}, rdb.ZRevRange(ctx, "ztmp", 1, -1).Val())
+ require.Equal(t, []string{"c", "b"}, rdb.ZRevRange(ctx, "ztmp", 1, -2).Val())
+ require.Equal(t, []string{"b", "a"}, rdb.ZRevRange(ctx, "ztmp", -2, -1).Val())
+ require.Equal(t, []string{"b"}, rdb.ZRevRange(ctx, "ztmp", -2, -2).Val())
+
+ // out of range start index
+ require.Equal(t, []string{"d", "c", "b"}, rdb.ZRevRange(ctx, "ztmp", -5, 2).Val())
+ require.Equal(t, []string{"d", "c"}, rdb.ZRevRange(ctx, "ztmp", -5, 1).Val())
+ require.Equal(t, []string{}, rdb.ZRevRange(ctx, "ztmp", 5, -1).Val())
+ require.Equal(t, []string{}, rdb.ZRevRange(ctx, "ztmp", 5, -2).Val())
+
+ // out of range end index
+ require.Equal(t, []string{"d", "c", "b", "a"}, rdb.ZRevRange(ctx, "ztmp", 0, 5).Val())
+ require.Equal(t, []string{"c", "b", "a"}, rdb.ZRevRange(ctx, "ztmp", 1, 5).Val())
+ require.Equal(t, []string{}, rdb.ZRevRange(ctx, "ztmp", 0, -5).Val())
+ require.Equal(t, []string{}, rdb.ZRevRange(ctx, "ztmp", 1, -5).Val())
+
+ // withscores
+ require.Equal(t, []redis.Z{
+ {4, "d"},
+ {3, "c"},
+ {2, "b"},
+ {1, "a"},
+ }, rdb.ZRevRangeWithScores(ctx, "ztmp", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZRANK/ZREVRANK basics - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zranktmp")
+ rdb.ZAdd(ctx, "zranktmp", redis.Z{Score: 10, Member: "x"})
+ rdb.ZAdd(ctx, "zranktmp", redis.Z{Score: 20, Member: "y"})
+ rdb.ZAdd(ctx, "zranktmp", redis.Z{Score: 30, Member: "z"})
+ require.Equal(t, int64(0), rdb.ZRank(ctx, "zranktmp", "x").Val())
+ require.Equal(t, int64(1), rdb.ZRank(ctx, "zranktmp", "y").Val())
+ require.Equal(t, int64(2), rdb.ZRank(ctx, "zranktmp", "z").Val())
+ require.Equal(t, int64(0), rdb.ZRank(ctx, "zranktmp", "foo").Val())
+ require.Equal(t, int64(2), rdb.ZRevRank(ctx, "zranktmp", "x").Val())
+ require.Equal(t, int64(1), rdb.ZRevRank(ctx, "zranktmp", "y").Val())
+ require.Equal(t, int64(0), rdb.ZRevRank(ctx, "zranktmp", "z").Val())
+ require.Equal(t, int64(0), rdb.ZRevRank(ctx, "zranktmp", "foo").Val())
+ })
+
+ t.Run(fmt.Sprintf("ZRANK - after deletion -%s", encoding), func(t *testing.T) {
+ rdb.ZRem(ctx, "zranktmp", "y")
+ require.Equal(t, int64(0), rdb.ZRank(ctx, "zranktmp", "x").Val())
+ require.Equal(t, int64(1), rdb.ZRank(ctx, "zranktmp", "z").Val())
+ })
+
+ t.Run(fmt.Sprintf("ZINCRBY - can create a new sorted set - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zset")
+ rdb.ZIncrBy(ctx, "zset", 1, "foo")
+ require.Equal(t, []string{"foo"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+ require.Equal(t, float64(1), rdb.ZScore(ctx, "zset", "foo").Val())
+ })
+
+ t.Run(fmt.Sprintf("ZINCRBY - increment and decrement - %s", encoding), func(t *testing.T) {
+ rdb.ZIncrBy(ctx, "zset", 2, "foo")
+ rdb.ZIncrBy(ctx, "zset", 1, "bar")
+ require.Equal(t, []string{"bar", "foo"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+ rdb.ZIncrBy(ctx, "zset", 10, "bar")
+ rdb.ZIncrBy(ctx, "zset", -5, "foo")
+ rdb.ZIncrBy(ctx, "zset", -5, "bar")
+ require.Equal(t, []string{"foo", "bar"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+ require.Equal(t, float64(-2), rdb.ZScore(ctx, "zset", "foo").Val())
+ require.Equal(t, float64(6), rdb.ZScore(ctx, "zset", "bar").Val())
+ })
+
+ t.Run("ZINCRBY return value", func(t *testing.T) {
+ rdb.Del(ctx, "ztmp")
+ require.Equal(t, float64(1), rdb.ZIncrBy(ctx, "ztmp", 1.0, "x").Val())
+ })
+
+ t.Run("ZRANGEBYSCORE/ZREVRANGEBYSCORE/ZCOUNT basics", func(t *testing.T) {
+ createDefaultZset(rdb, ctx)
+
+ // inclusive range
+ require.Equal(t, []string{"a", "b", "c"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "-inf", Max: "2"}).Val())
+ require.Equal(t, []string{"b", "c", "d"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "3"}).Val())
+ require.Equal(t, []string{"d", "e", "f"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "3", Max: "6"}).Val())
+ require.Equal(t, []string{"e", "f", "g"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "4", Max: "+inf"}).Val())
+ require.Equal(t, []string{"c", "b", "a"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "2", Min: "-inf"}).Val())
+ require.Equal(t, []string{"d", "c", "b"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "3", Min: "0"}).Val())
+ require.Equal(t, []string{"f", "e", "d"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "6", Min: "3"}).Val())
+ require.Equal(t, []string{"g", "f", "e"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "+inf", Min: "4"}).Val())
+ require.Equal(t, int64(3), rdb.ZCount(ctx, "zset", "0", "3").Val())
+
+ // exclusive range
+ require.Equal(t, []string{"b"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(-inf", Max: "(2"}).Val())
+ require.Equal(t, []string{"b", "c"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(0", Max: "(3"}).Val())
+ require.Equal(t, []string{"e", "f"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(3", Max: "(6"}).Val())
+ require.Equal(t, []string{"f"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(4", Max: "(+inf"}).Val())
+ require.Equal(t, []string{"b"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "(2", Min: "(-inf"}).Val())
+ require.Equal(t, []string{"c", "b"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "(3", Min: "(0"}).Val())
+ require.Equal(t, []string{"f", "e"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "(6", Min: "(3"}).Val())
+ require.Equal(t, []string{"f"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "(+inf", Min: "(4"}).Val())
+ require.Equal(t, int64(2), rdb.ZCount(ctx, "zset", "(0", "(3").Val())
+
+ // test empty ranges
+ rdb.ZRem(ctx, "zset", "a")
+ rdb.ZRem(ctx, "zset", "g")
+
+ // inclusive range
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "4", Max: "2"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "6", Max: "+inf"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "-inf", Max: "-6"}).Val())
+ require.Equal(t, []string{}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "+inf", Min: "6"}).Val())
+ require.Equal(t, []string{}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "-6", Min: "-inf"}).Val())
+
+ // exclusive range
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(4", Max: "(2"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "2", Max: "(2"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(2", Max: "2"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(6", Max: "(+inf"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(-inf", Max: "(-6"}).Val())
+ require.Equal(t, []string{}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "(+inf", Min: "(6"}).Val())
+ require.Equal(t, []string{}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Max: "(-6", Min: "(-inf"}).Val())
+
+ // empty inner range
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "2.4", Max: "2.6"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(2.4", Max: "2.6"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "2.4", Max: "(2.6"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "(2.4", Max: "(2.6"}).Val())
+ })
+
+ t.Run("ZRANGEBYSCORE with WITHSCORES", func(t *testing.T) {
+ createDefaultZset(rdb, ctx)
+ require.Equal(t, []redis.Z{{1, "b"}, {2, "c"}, {3, "d"}}, rdb.ZRangeByScoreWithScores(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "3"}).Val())
+ require.Equal(t, []redis.Z{{3, "d"}, {2, "c"}, {1, "b"}}, rdb.ZRevRangeByScoreWithScores(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "3"}).Val())
+ })
+
+ t.Run("ZRANGEBYSCORE with LIMIT", func(t *testing.T) {
+ createDefaultZset(rdb, ctx)
+ require.Equal(t, []string{"b", "c"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "10", Offset: 0, Count: 2}).Val())
+ require.Equal(t, []string{"d", "e", "f"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "10", Offset: 2, Count: 3}).Val())
+ require.Equal(t, []string{"d", "e", "f"}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "10", Offset: 2, Count: 10}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "10", Offset: 20, Count: 10}).Val())
+ require.Equal(t, []string{"f", "e"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "10", Offset: 0, Count: 2}).Val())
+ require.Equal(t, []string{"d", "c", "b"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "10", Offset: 2, Count: 3}).Val())
+ require.Equal(t, []string{"d", "c", "b"}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "10", Offset: 2, Count: 10}).Val())
+ require.Equal(t, []string{}, rdb.ZRevRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "0", Max: "10", Offset: 20, Count: 10}).Val())
+ })
+
+ t.Run("ZRANGEBYSCORE with LIMIT and WITHSCORES", func(t *testing.T) {
+ createDefaultZset(rdb, ctx)
+ require.Equal(t, []redis.Z{{4, "e"}, {5, "f"}}, rdb.ZRangeByScoreWithScores(ctx, "zset", &redis.ZRangeBy{Min: "2", Max: "5", Offset: 2, Count: 3}).Val())
+ require.Equal(t, []redis.Z{{3, "d"}, {2, "c"}}, rdb.ZRevRangeByScoreWithScores(ctx, "zset", &redis.ZRangeBy{Min: "2", Max: "5", Offset: 2, Count: 3}).Val())
+ })
+
+ t.Run("ZRANGEBYSCORE with non-value min or max", func(t *testing.T) {
+ util.ErrorRegexp(t, rdb.ZRangeByScore(ctx, "fooz", &redis.ZRangeBy{Min: "str", Max: "1"}).Err(), ".*double.*")
+ util.ErrorRegexp(t, rdb.ZRangeByScore(ctx, "fooz", &redis.ZRangeBy{Min: "1", Max: "str"}).Err(), ".*double.*")
+ util.ErrorRegexp(t, rdb.ZRangeByScore(ctx, "fooz", &redis.ZRangeBy{Min: "1", Max: "NaN"}).Err(), ".*double.*")
+ })
+
+ t.Run("ZRANGEBYSCORE for min/max score with multi member", func(t *testing.T) {
+ zsetInt := []redis.Z{
+ {math.Inf(-1), "a"},
+ {math.Inf(-1), "b"},
+ {-1, "c"},
+ {2, "d"},
+ {3, "e"},
+ {math.Inf(1), "f"},
+ {math.Inf(1), "g"}}
+ createZset(rdb, ctx, "mzset", zsetInt)
+ require.Equal(t, zsetInt, rdb.ZRangeByScoreWithScores(ctx, "mzset", &redis.ZRangeBy{Min: "-inf", Max: "+inf"}).Val())
+ reverse(zsetInt)
+ require.Equal(t, zsetInt, rdb.ZRevRangeByScoreWithScores(ctx, "mzset", &redis.ZRangeBy{Min: "-inf", Max: "+inf"}).Val())
+
+ zsetDouble := []redis.Z{
+ {-1.004, "a"},
+ {-1.004, "b"},
+ {-1.002, "c"},
+ {1.002, "d"},
+ {1.004, "e"},
+ {1.004, "f"}}
+ createZset(rdb, ctx, "mzset", zsetDouble)
+ require.Equal(t, zsetDouble, rdb.ZRangeByScoreWithScores(ctx, "mzset", &redis.ZRangeBy{Min: "-inf", Max: "+inf"}).Val())
+ reverse(zsetDouble)
+ require.Equal(t, zsetDouble, rdb.ZRevRangeByScoreWithScores(ctx, "mzset", &redis.ZRangeBy{Min: "-inf", Max: "+inf"}).Val())
+ })
+
+ t.Run("ZRANGEBYLEX/ZREVRANGEBYLEX/ZLEXCOUNT basics", func(t *testing.T) {
+ createDefaultLexZset(rdb, ctx)
+
+ // inclusive range
+ require.Equal(t, []string{"alpha", "bar", "cool"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "-", Max: "[cool"}).Val())
+ require.Equal(t, []string{"bar", "cool", "down"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[bar", Max: "[down"}).Val())
+ require.Equal(t, []string{"great", "hill", "omega"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[g", Max: "+"}).Val())
+ require.Equal(t, []string{"cool", "bar", "alpha"}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "-", Max: "[cool"}).Val())
+ require.Equal(t, []string{"down", "cool", "bar"}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[bar", Max: "[down"}).Val())
+ require.Equal(t, []string{"omega", "hill", "great", "foo", "elephant", "down"}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[d", Max: "+"}).Val())
+
+ // exclusive range
+ require.Equal(t, []string{"alpha", "bar"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "-", Max: "(cool"}).Val())
+ require.Equal(t, []string{"cool"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "(bar", Max: "(down"}).Val())
+ require.Equal(t, []string{"hill", "omega"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "(great", Max: "+"}).Val())
+ require.Equal(t, []string{"bar", "alpha"}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "-", Max: "(cool"}).Val())
+ require.Equal(t, []string{"cool"}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "(bar", Max: "(down"}).Val())
+ require.Equal(t, []string{"omega", "hill"}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "(great", Max: "+"}).Val())
+
+ // inclusive and exclusive
+ require.Equal(t, []string{}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "(az", Max: "(b"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "(z", Max: "+"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "-", Max: "[aaaa"}).Val())
+ require.Equal(t, []string{}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[elez", Max: "[elex"}).Val())
+ require.Equal(t, []string{}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "(hill", Max: "(omega"}).Val())
+ })
+
+ t.Run("ZRANGEBYLEX with LIMIT", func(t *testing.T) {
+ createDefaultLexZset(rdb, ctx)
+ require.Equal(t, []string{"alpha", "bar"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "-", Max: "[cool", Offset: 0, Count: 2}).Val())
+ require.Equal(t, []string{"bar", "cool"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "-", Max: "[cool", Offset: 1, Count: 2}).Val())
+ require.Equal(t, []interface{}{}, rdb.Do(ctx, "zrangebylex", "zset", "[bar", "[down", "limit", "0", "0").Val())
+ require.Equal(t, []string{}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[bar", Max: "[down", Offset: 2, Count: 0}).Val())
+ require.Equal(t, []string{"bar"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[bar", Max: "[down", Offset: 0, Count: 1}).Val())
+ require.Equal(t, []string{"cool"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[bar", Max: "[down", Offset: 1, Count: 1}).Val())
+ require.Equal(t, []string{"bar", "cool", "down"}, rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[bar", Max: "[down", Offset: 0, Count: 100}).Val())
+ require.Equal(t, []string{"omega", "hill", "great", "foo", "elephant"}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[d", Max: "+", Offset: 0, Count: 5}).Val())
+ require.Equal(t, []string{"omega", "hill", "great", "foo"}, rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: "[d", Max: "+", Offset: 0, Count: 4}).Val())
+ })
+
+ t.Run("ZRANGEBYLEX with invalid lex range specifiers", func(t *testing.T) {
+ util.ErrorRegexp(t, rdb.ZRangeByLex(ctx, "fooz", &redis.ZRangeBy{Min: "foo", Max: "bar"}).Err(), ".*illegal.*")
+ util.ErrorRegexp(t, rdb.ZRangeByLex(ctx, "fooz", &redis.ZRangeBy{Min: "[foo", Max: "bar"}).Err(), ".*illegal.*")
+ util.ErrorRegexp(t, rdb.ZRangeByLex(ctx, "fooz", &redis.ZRangeBy{Min: "foo", Max: "[bar"}).Err(), ".*illegal.*")
+ util.ErrorRegexp(t, rdb.ZRangeByLex(ctx, "fooz", &redis.ZRangeBy{Min: "+x", Max: "[bar"}).Err(), ".*illegal.*")
+ util.ErrorRegexp(t, rdb.ZRangeByLex(ctx, "fooz", &redis.ZRangeBy{Min: "-x", Max: "[bar"}).Err(), ".*illegal.*")
+ })
+
+ t.Run("ZREMRANGEBYSCORE basics", func(t *testing.T) {
+ remrangebyscore := func(min, max string) int64 {
+ createZset(rdb, ctx, "zset", []redis.Z{{1, "a"}, {2, "b"}, {3, "c"},
+ {4, "d"}, {5, "e"}})
+ require.Equal(t, int64(1), rdb.Exists(ctx, "zset").Val())
+ return rdb.ZRemRangeByScore(ctx, "zset", min, max).Val()
+ }
+
+ // inner range
+ require.Equal(t, int64(3), remrangebyscore("2", "4"))
+ require.Equal(t, []string{"a", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // start underflow
+ require.Equal(t, int64(1), remrangebyscore("-10", "1"))
+ require.Equal(t, []string{"b", "c", "d", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // end overflow
+ require.Equal(t, int64(1), remrangebyscore("5", "10"))
+ require.Equal(t, []string{"a", "b", "c", "d"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // switch min and max
+ require.Equal(t, int64(0), remrangebyscore("4", "2"))
+ require.Equal(t, []string{"a", "b", "c", "d", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // -inf to mid
+ require.Equal(t, int64(3), remrangebyscore("-inf", "3"))
+ require.Equal(t, []string{"d", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // mid to +inf
+ require.Equal(t, int64(3), remrangebyscore("3", "+inf"))
+ require.Equal(t, []string{"a", "b"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // -inf to +inf
+ require.Equal(t, int64(5), remrangebyscore("-inf", "+inf"))
+ require.Equal(t, []string{}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // exclusive min
+ require.Equal(t, int64(4), remrangebyscore("(1", "5"))
+ require.Equal(t, []string{"a"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+ require.Equal(t, int64(3), remrangebyscore("(2", "5"))
+ require.Equal(t, []string{"a", "b"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // exclusive max
+ require.Equal(t, int64(4), remrangebyscore("1", "(5"))
+ require.Equal(t, []string{"e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+ require.Equal(t, int64(3), remrangebyscore("1", "(4"))
+ require.Equal(t, []string{"d", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // exclusive min and max
+ require.Equal(t, int64(3), remrangebyscore("(1", "(5"))
+ require.Equal(t, []string{"a", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // destroy when empty
+ require.Equal(t, int64(5), remrangebyscore("1", "5"))
+ require.Equal(t, int64(0), rdb.Exists(ctx, "zset").Val())
+ })
+
+ t.Run("ZREMRANGEBYSCORE with non-value min or max", func(t *testing.T) {
+ util.ErrorRegexp(t, rdb.ZRemRangeByScore(ctx, "fooz", "str", "1").Err(), ".*double.*")
+ util.ErrorRegexp(t, rdb.ZRemRangeByScore(ctx, "fooz", "1", "str").Err(), ".*double.*")
+ util.ErrorRegexp(t, rdb.ZRemRangeByScore(ctx, "fooz", "1", "NaN").Err(), ".*double.*")
+ })
+
+ t.Run("ZREMRANGEBYRANK basics", func(t *testing.T) {
+ remrangebyrank := func(min, max int64) int64 {
+ createZset(rdb, ctx, "zset", []redis.Z{{1, "a"}, {2, "b"}, {3, "c"},
+ {4, "d"}, {5, "e"}})
+ require.Equal(t, int64(1), rdb.Exists(ctx, "zset").Val())
+ return rdb.ZRemRangeByRank(ctx, "zset", min, max).Val()
+ }
+
+ // inner range
+ require.Equal(t, int64(3), remrangebyrank(1, 3))
+ require.Equal(t, []string{"a", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // start underflow
+ require.Equal(t, int64(1), remrangebyrank(-10, 0))
+ require.Equal(t, []string{"b", "c", "d", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // start overflow
+ require.Equal(t, int64(0), remrangebyrank(10, -1))
+ require.Equal(t, []string{"a", "b", "c", "d", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // end underflow
+ require.Equal(t, int64(0), remrangebyrank(0, -10))
+ require.Equal(t, []string{"a", "b", "c", "d", "e"}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // end overflow
+ require.Equal(t, int64(5), remrangebyrank(0, 10))
+ require.Equal(t, []string{}, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ // destroy when empty
+ require.Equal(t, int64(5), remrangebyrank(0, 4))
+ require.Equal(t, int64(0), rdb.Exists(ctx, "zset").Val())
+ })
+
+ t.Run(fmt.Sprintf("ZUNIONSTORE against non-existing key doesn't set destination - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zseta")
+ require.Equal(t, int64(0), rdb.ZUnionStore(ctx, "dst_key", &redis.ZStore{Keys: []string{"zseta"}}).Val())
+ require.Equal(t, int64(0), rdb.Exists(ctx, "dst_key").Val())
+ })
+
+ t.Run(fmt.Sprintf("ZUNIONSTORE with empty set - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zseta", "zsetb")
+ rdb.ZAdd(ctx, "zseta", redis.Z{Score: 1, Member: "a"})
+ rdb.ZAdd(ctx, "zsetb", redis.Z{Score: 2, Member: "b"})
+ rdb.ZUnionStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}})
+ require.Equal(t, []redis.Z{{1, "a"}, {2, "b"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZUNIONSTORE basics - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zseta", "zsetb", "zsetc")
+ rdb.ZAdd(ctx, "zseta", redis.Z{Score: 1, Member: "a"})
+ rdb.ZAdd(ctx, "zseta", redis.Z{Score: 2, Member: "b"})
+ rdb.ZAdd(ctx, "zseta", redis.Z{Score: 3, Member: "c"})
+ rdb.ZAdd(ctx, "zsetb", redis.Z{Score: 1, Member: "b"})
+ rdb.ZAdd(ctx, "zsetb", redis.Z{Score: 2, Member: "c"})
+ rdb.ZAdd(ctx, "zsetb", redis.Z{Score: 3, Member: "d"})
+ require.Equal(t, int64(4), rdb.ZUnionStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}}).Val())
+ require.Equal(t, []redis.Z{{1, "a"}, {3, "b"}, {3, "d"}, {5, "c"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZUNIONSTORE with weights - %s", encoding), func(t *testing.T) {
+ require.Equal(t, int64(4), rdb.ZUnionStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}, Weights: []float64{2, 3}}).Val())
+ require.Equal(t, []redis.Z{{2, "a"}, {7, "b"}, {9, "d"}, {12, "c"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZUNIONSTORE with AGGREGATE MIN - %s", encoding), func(t *testing.T) {
+ require.Equal(t, int64(4), rdb.ZUnionStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}, Aggregate: "min"}).Val())
+ require.Equal(t, []redis.Z{{1, "a"}, {1, "b"}, {2, "c"}, {3, "d"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+
+ })
+
+ t.Run(fmt.Sprintf("ZUNIONSTORE with AGGREGATE MAX - %s", encoding), func(t *testing.T) {
+ require.Equal(t, int64(4), rdb.ZUnionStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}, Aggregate: "max"}).Val())
+ require.Equal(t, []redis.Z{{1, "a"}, {2, "b"}, {3, "c"}, {3, "d"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZINTERSTORE basics - %s", encoding), func(t *testing.T) {
+ require.Equal(t, int64(2), rdb.ZInterStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}}).Val())
+ require.Equal(t, []redis.Z{{3, "b"}, {5, "c"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZINTERSTORE with weights - %s", encoding), func(t *testing.T) {
+ require.Equal(t, int64(2), rdb.ZInterStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}, Weights: []float64{2, 3}}).Val())
+ require.Equal(t, []redis.Z{{7, "b"}, {12, "c"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZINTERSTORE with AGGREGATE MIN - %s", encoding), func(t *testing.T) {
+ require.Equal(t, int64(2), rdb.ZInterStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}, Aggregate: "min"}).Val())
+ require.Equal(t, []redis.Z{{1, "b"}, {2, "c"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+ })
+
+ t.Run(fmt.Sprintf("ZINTERSTORE with AGGREGATE MAX - %s", encoding), func(t *testing.T) {
+ require.Equal(t, int64(2), rdb.ZInterStore(ctx, "zsetc", &redis.ZStore{Keys: []string{"zseta", "zsetb"}, Aggregate: "max"}).Val())
+ require.Equal(t, []redis.Z{{2, "b"}, {3, "c"}}, rdb.ZRangeWithScores(ctx, "zsetc", 0, -1).Val())
+ })
+
+ for i, cmd := range []func(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd{rdb.ZInterStore, rdb.ZUnionStore} {
+ var funcName string
+ switch i {
+ case 0:
+ funcName = "ZINTERSTORE"
+ case 1:
+ funcName = "ZUNIONSTORE"
+ }
+
+ t.Run(fmt.Sprintf("%s with +inf/-inf scores - %s", funcName, encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zsetinf1", "zsetinf2")
+
+ rdb.ZAdd(ctx, "zsetinf1", redis.Z{Score: math.Inf(1), Member: "key"})
+ rdb.ZAdd(ctx, "zsetinf2", redis.Z{Score: math.Inf(1), Member: "key"})
+ cmd(ctx, "zsetinf3", &redis.ZStore{Keys: []string{"zsetinf1", "zsetinf2"}})
+ require.Equal(t, math.Inf(1), rdb.ZScore(ctx, "zsetinf3", "key").Val())
+
+ rdb.ZAdd(ctx, "zsetinf1", redis.Z{Score: math.Inf(-1), Member: "key"})
+ rdb.ZAdd(ctx, "zsetinf2", redis.Z{Score: math.Inf(1), Member: "key"})
+ cmd(ctx, "zsetinf3", &redis.ZStore{Keys: []string{"zsetinf1", "zsetinf2"}})
+ require.Equal(t, float64(0), rdb.ZScore(ctx, "zsetinf3", "key").Val())
+
+ rdb.ZAdd(ctx, "zsetinf1", redis.Z{Score: math.Inf(1), Member: "key"})
+ rdb.ZAdd(ctx, "zsetinf2", redis.Z{Score: math.Inf(-1), Member: "key"})
+ cmd(ctx, "zsetinf3", &redis.ZStore{Keys: []string{"zsetinf1", "zsetinf2"}})
+ require.Equal(t, float64(0), rdb.ZScore(ctx, "zsetinf3", "key").Val())
+
+ rdb.ZAdd(ctx, "zsetinf1", redis.Z{Score: math.Inf(-1), Member: "key"})
+ rdb.ZAdd(ctx, "zsetinf2", redis.Z{Score: math.Inf(-1), Member: "key"})
+ cmd(ctx, "zsetinf3", &redis.ZStore{Keys: []string{"zsetinf1", "zsetinf2"}})
+ require.Equal(t, math.Inf(-1), rdb.ZScore(ctx, "zsetinf3", "key").Val())
+ })
+
+ t.Run(fmt.Sprintf("%s with NaN weights - %s", funcName, encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zsetinf1", "zsetinf2")
+ rdb.ZAdd(ctx, "zsetinf1", redis.Z{Score: 1.0, Member: "key"})
+ rdb.ZAdd(ctx, "zsetinf2", redis.Z{Score: 1.0, Member: "key"})
+ util.ErrorRegexp(t, cmd(ctx, "zsetinf3", &redis.ZStore{
+ Keys: []string{"zsetinf1", "zsetinf2"},
+ Weights: []float64{math.NaN(), math.NaN()}},
+ ).Err(), ".*weight.*not.*double.*")
+ })
+ }
+}
+
+func stressTests(t *testing.T, rdb *redis.Client, ctx context.Context, encoding string) {
+ var elements int
+ if encoding == "ziplist" {
+ elements = 128
+ } else if encoding == "skiplist" {
+ elements = 100
+ } else {
+ fmt.Println("Unknown sorted set encoding")
+ return
+ }
+ t.Run(fmt.Sprintf("ZSCORE - %s", encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zscoretest")
+ aux := make([]float64, 0)
+ for i := 0; i < elements; i++ {
+ score := rand.Float64()
+ aux = append(aux, score)
+ rdb.ZAdd(ctx, "zscoretest", redis.Z{Score: score, Member: strconv.Itoa(i)})
+ }
+ for i := 0; i < elements; i++ {
+ require.Equal(t, aux[i], rdb.ZScore(ctx, "zscoretest", strconv.Itoa(i)).Val())
+ }
+ })
+
+ t.Run(fmt.Sprintf("ZSET sorting stresser - %s", encoding), func(t *testing.T) {
+ delta := 0
+ for test := 0; test < 2; test++ {
+ auxArray := make(map[string]float64)
+ auxList := make([]redis.Z, 0)
+ rdb.Del(ctx, "myzset")
+ var score float64
+ for i := 0; i < elements; i++ {
+ if test == 0 {
+ score = rand.Float64()
+ } else {
+ score = float64(rand.Intn(10))
+ }
+ auxArray[strconv.Itoa(i)] = score
+ rdb.ZAdd(ctx, "myzset", redis.Z{Score: score, Member: strconv.Itoa(i)})
+ if rand.Float64() < 0.2 {
+ j := rand.Intn(1000)
+ if test == 0 {
+ score = rand.Float64()
+ } else {
+ score = float64(rand.Intn(10))
+
+ }
+ auxArray[strconv.Itoa(j)] = score
+ rdb.ZAdd(ctx, "myzset", redis.Z{Score: score, Member: strconv.Itoa(j)})
+ }
+ }
+ for i, s := range auxArray {
+ auxList = append(auxList, redis.Z{Score: s, Member: i})
+ }
+ sort.Slice(auxList, func(i, j int) bool {
+ if auxList[i].Score < auxList[j].Score {
+ return true
+ } else if auxList[i].Score > auxList[j].Score {
+ return false
+ } else {
+ if strings.Compare(auxList[i].Member.(string), auxList[j].Member.(string)) == 1 {
+ return false
+ } else {
+ return true
+ }
+ }
+ })
+ var aux []string
+ for _, z := range auxList {
+ aux = append(aux, z.Member.(string))
+ }
+ fromRedis := rdb.ZRange(ctx, "myzset", 0, -1).Val()
+ for i := 0; i < len(fromRedis); i++ {
+ if aux[i] != fromRedis[i] {
+ delta++
+ }
+ }
+ require.Equal(t, 0, delta)
+ }
+ })
+
+ t.Run(fmt.Sprintf("ZRANGEBYSCORE fuzzy test, 100 ranges in %d element sorted set - %s", elements, encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zset")
+ for i := 0; i < elements; i++ {
+ rdb.ZAdd(ctx, "zset", redis.Z{Score: rand.Float64(), Member: strconv.Itoa(i)})
+ }
+
+ for i := 0; i < 100; i++ {
+ min, max := rand.Float64(), rand.Float64()
+ min, max = math.Min(min, max), math.Max(min, max)
+ low := rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "-inf", Max: fmt.Sprintf("%f", min)}).Val()
+ ok := rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: fmt.Sprintf("%f", min), Max: fmt.Sprintf("%f", max)}).Val()
+ high := rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: fmt.Sprintf("%f", max), Max: "+inf"}).Val()
+ lowEx := rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: "-inf", Max: fmt.Sprintf("(%f", min)}).Val()
+ okEx := rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: fmt.Sprintf("(%f", min), Max: fmt.Sprintf("(%f", max)}).Val()
+ highEx := rdb.ZRangeByScore(ctx, "zset", &redis.ZRangeBy{Min: fmt.Sprintf("(%f", max), Max: "+inf"}).Val()
+
+ require.Len(t, low, int(rdb.ZCount(ctx, "zset", "-inf", fmt.Sprintf("%f", min)).Val()))
+ require.Len(t, ok, int(rdb.ZCount(ctx, "zset", fmt.Sprintf("%f", min), fmt.Sprintf("%f", max)).Val()))
+ require.Len(t, high, int(rdb.ZCount(ctx, "zset", fmt.Sprintf("%f", max), "+inf").Val()))
+ require.Len(t, lowEx, int(rdb.ZCount(ctx, "zset", "-inf", fmt.Sprintf("(%f", min)).Val()))
+ require.Len(t, okEx, int(rdb.ZCount(ctx, "zset", fmt.Sprintf("(%f", min), fmt.Sprintf("(%f", max)).Val()))
+ require.Len(t, highEx, int(rdb.ZCount(ctx, "zset", fmt.Sprintf("(%f", max), "+inf").Val()))
+
+ for _, x := range low {
+ require.LessOrEqual(t, rdb.ZScore(ctx, "zset", x).Val(), min)
+ }
+ for _, x := range lowEx {
+ require.Less(t, rdb.ZScore(ctx, "zset", x).Val(), min)
+ }
+ for _, x := range ok {
+ util.BetweenValues(t, rdb.ZScore(ctx, "zset", x).Val(), min, max)
+ }
+ for _, x := range okEx {
+ util.BetweenValuesEx(t, rdb.ZScore(ctx, "zset", x).Val(), min, max)
+ }
+ for _, x := range high {
+ require.GreaterOrEqual(t, rdb.ZScore(ctx, "zset", x).Val(), min)
+ }
+ for _, x := range highEx {
+ require.Greater(t, rdb.ZScore(ctx, "zset", x).Val(), min)
+ }
+ }
+ })
+
+ t.Run(fmt.Sprintf("ZRANGEBYLEX fuzzy test, 100 ranges in %d element sorted set - %s", elements, encoding), func(t *testing.T) {
+ rdb.Del(ctx, "zset")
+
+ var lexSet []string
+ for i := 0; i < elements; i++ {
+ e := util.RandString(0, 30, util.Alpha)
+ lexSet = append(lexSet, e)
+ rdb.ZAdd(ctx, "zset", redis.Z{Member: e})
+ }
+ sort.Strings(lexSet)
+ lexSet = slices.Compact(lexSet)
+
+ for i := 0; i < 100; i++ {
+ min, max := util.RandString(0, 30, util.Alpha), util.RandString(0, 30, util.Alpha)
+ minInc, maxInc := util.RandomBool(), util.RandomBool()
+ cMin, cMax := "("+min, "("+max
+ if minInc {
+ cMin = "[" + min
+ }
+ if maxInc {
+ cMax = "[" + max
+ }
+ rev := util.RandomBool()
+
+ // make sure data is the same in both sides
+ require.Equal(t, lexSet, rdb.ZRange(ctx, "zset", 0, -1).Val())
+
+ var output []string
+ var outLen int64
+ if rev {
+ output = rdb.ZRevRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: cMax, Max: cMin}).Val()
+ outLen = rdb.ZLexCount(ctx, "zset", cMax, cMin).Val()
+ } else {
+ output = rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: cMin, Max: cMax}).Val()
+ outLen = rdb.ZLexCount(ctx, "zset", cMin, cMax).Val()
+ }
+
+ // compute the same output by programming
+ o := make([]string, 0)
+ c := lexSet
+ if (!rev && min > max) || (rev && max > min) {
+ // empty output when ranges are inverted
+ } else {
+ if rev {
+ c = rdb.ZRevRange(ctx, "zset", 0, -1).Val()
+ min, max, minInc, maxInc = max, min, maxInc, minInc
+ }
+
+ for _, e := range c {
+ if (minInc && e >= min || !minInc && e > min) && (maxInc && e <= max || !maxInc && e < max) {
+ o = append(o, e)
+ }
+ }
+ }
+ require.Equal(t, o, output)
+ require.Len(t, output, int(outLen))
+ }
+ })
+
+ t.Run(fmt.Sprintf("ZREMRANGEBYLEX fuzzy test, 100 ranges in %d element sorted set - %s", elements, encoding), func(t *testing.T) {
+ var lexSet []string
+ rdb.Del(ctx, "zset", "zsetcopy")
+ for i := 0; i < elements; i++ {
+ e := util.RandString(0, 30, util.Alpha)
+ lexSet = append(lexSet, e)
+ rdb.ZAdd(ctx, "zset", redis.Z{Member: e})
+ }
+ sort.Strings(lexSet)
+ lexSet = slices.Compact(lexSet)
+ for i := 0; i < 100; i++ {
+ rdb.ZUnionStore(ctx, "zsetcopy", &redis.ZStore{Keys: []string{"zset"}})
+ var lexSetCopy []string
+ lexSetCopy = append(lexSetCopy, lexSet...)
+ min, max := util.RandString(0, 30, util.Alpha), util.RandString(0, 30, util.Alpha)
+ minInc, maxInc := util.RandomBool(), util.RandomBool()
+ cMin, cMax := "("+min, "("+max
+ if minInc {
+ cMin = "[" + min
+ }
+ if maxInc {
+ cMax = "[" + max
+ }
+ require.Equal(t, lexSet, rdb.ZRange(ctx, "zset", 0, -1).Val())
+ toRem := rdb.ZRangeByLex(ctx, "zset", &redis.ZRangeBy{Min: cMin, Max: cMax}).Val()
+ toRemLen := rdb.ZLexCount(ctx, "zset", cMin, cMax).Val()
+ rdb.ZRemRangeByLex(ctx, "zsetcopy", cMin, cMax)
+ output := rdb.ZRange(ctx, "zsetcopy", 0, -1).Val()
+ if toRemLen > 0 {
+ var first, last int64
+ for idx, v := range lexSetCopy {
+ if v == toRem[0] {
+ first = int64(idx)
+ }
+ }
+ last = first + toRemLen - 1
+ lexSetCopy = append(lexSetCopy[:first], lexSetCopy[last+1:]...)
+ }
+ require.Equal(t, lexSetCopy, output)
+ }
+ })
+
+ t.Run(fmt.Sprintf("ZSETs skiplist implementation backlink consistency test - %s", encoding), func(t *testing.T) {
+ diff := 0
+ for i := 0; i < elements; i++ {
+ rdb.ZAdd(ctx, "zset", redis.Z{Score: rand.Float64(), Member: fmt.Sprintf("Element-%d", i)})
+ rdb.ZRem(ctx, "myzset", fmt.Sprintf("Element-%d", rand.Intn(elements)))
+ }
+ l1 := rdb.ZRange(ctx, "myzset", 0, -1).Val()
+ l2 := rdb.ZRevRange(ctx, "myzset", 0, -1).Val()
+ for j := 0; j < len(l1); j++ {
+ if l1[j] != l2[len(l1)-j-1] {
+ diff++
+ }
+ }
+ require.Equal(t, 0, diff)
+ })
+
+ t.Run(fmt.Sprintf("ZSETs ZRANK augmented skip list stress testing - %s", encoding), func(t *testing.T) {
+ var err error
+ rdb.Del(ctx, "myzset")
+ for k := 0; k < 2000; k++ {
+ i := k % elements
+ if rand.Float64() < 0.2 {
+ rdb.ZRem(ctx, "myzset", strconv.Itoa(i))
+ } else {
+ score := rand.Float64()
+ rdb.ZAdd(ctx, "myzset", redis.Z{Score: score, Member: strconv.Itoa(i)})
+ }
+ card := rdb.ZCard(ctx, "myzset").Val()
+ if card > 0 {
+ index := util.RandomInt(card)
+ ele := rdb.ZRange(ctx, "myzset", index, index).Val()[0]
+ rank := rdb.ZRank(ctx, "myzset", ele).Val()
+ if rank != index {
+ err = fmt.Errorf("%s RANK is wrong! (%d != %d)", ele, rank, index)
+ break
+ }
+ }
+ }
+ require.NoError(t, err)
+ })
+}
+
+func TestZset(t *testing.T) {
+ srv := util.StartServer(t, map[string]string{})
+ defer srv.Close()
+ ctx := context.Background()
+ rdb := srv.NewClient()
+ defer func() { require.NoError(t, rdb.Close()) }()
+
+ basicTests(t, rdb, ctx, "skiplist")
+
+ t.Run("ZUNIONSTORE regression, should not create NaN in scores", func(t *testing.T) {
+ rdb.ZAdd(ctx, "z", redis.Z{Score: math.Inf(-1), Member: "neginf"})
+ rdb.ZUnionStore(ctx, "out", &redis.ZStore{Keys: []string{"z"}, Weights: []float64{0}})
+ require.Equal(t, []redis.Z{{0, "neginf"}}, rdb.ZRangeWithScores(ctx, "out", 0, -1).Val())
+ })
+
+ t.Run("ZUNIONSTORE result is sorted", func(t *testing.T) {
+ rdb.Del(ctx, "one", "two", "dest")
+ var zset1 []redis.Z
+ var zset2 []redis.Z
+ for j := 0; j < 1000; j++ {
+ zset1 = append(zset1, redis.Z{Score: float64(util.RandomInt(1000)), Member: util.RandomValue()})
+ zset2 = append(zset2, redis.Z{Score: float64(util.RandomInt(1000)), Member: util.RandomValue()})
+ }
+ rdb.ZAdd(ctx, "one", zset1...)
+ rdb.ZAdd(ctx, "two", zset2...)
+ require.Greater(t, rdb.ZCard(ctx, "one").Val(), int64(100))
+ require.Greater(t, rdb.ZCard(ctx, "two").Val(), int64(100))
+ rdb.ZUnionStore(ctx, "dest", &redis.ZStore{Keys: []string{"one", "two"}})
+ oldScore := float64(0)
+ for _, z := range rdb.ZRangeWithScores(ctx, "dest", 0, -1).Val() {
+ require.GreaterOrEqual(t, z.Score, oldScore)
+ oldScore = z.Score
+ }
+ })
+
+ t.Run("ZSET commands don't accept the empty strings as valid score", func(t *testing.T) {
+ util.ErrorRegexp(t, rdb.Do(ctx, "zadd", "myzset", "", "abc").Err(), ".*not.*float.*")
+ })
+
+ stressTests(t, rdb, ctx, "skiplist")
+}
diff --git a/tests/gocase/util/assertions.go b/tests/gocase/util/assertions.go
index 32dccad..422f84c 100644
--- a/tests/gocase/util/assertions.go
+++ b/tests/gocase/util/assertions.go
@@ -31,11 +31,18 @@ func ErrorRegexp(t testing.TB, err error, rx interface{}, msgAndArgs ...interfac
require.Regexp(t, rx, err.Error(), msgAndArgs...)
}
+// BetweenValues asserts start <= d <= end
func BetweenValues[T constraints.Ordered](t testing.TB, d, start, end T, msgAndArgs ...interface{}) {
require.GreaterOrEqual(t, d, start, msgAndArgs...)
require.LessOrEqual(t, d, end, msgAndArgs...)
}
+// BetweenValuesEx asserts start < d < end
+func BetweenValuesEx[T constraints.Ordered](t testing.TB, d, start, end T, msgAndArgs ...interface{}) {
+ require.Greater(t, d, start, msgAndArgs...)
+ require.Less(t, d, end, msgAndArgs...)
+}
+
func RetryEventually(t testing.TB, condition func() bool, maxAttempts int, msgAndArgs ...interface{}) {
require.Greater(t, maxAttempts, 0, msgAndArgs...)
for i := 0; i < maxAttempts; i++ {
diff --git a/tests/gocase/util/random.go b/tests/gocase/util/random.go
index ad51d9a..0c290a6 100644
--- a/tests/gocase/util/random.go
+++ b/tests/gocase/util/random.go
@@ -45,6 +45,10 @@ func RandomInt(max int64) int64 {
return rand.Int63() % max
}
+func RandomBool() bool {
+ return RandomInt(2) != 0
+}
+
type RandStringType int
const (
diff --git a/tests/tcl/tests/test_helper.tcl b/tests/tcl/tests/test_helper.tcl
index f28a7b5..a8b70e7 100644
--- a/tests/tcl/tests/test_helper.tcl
+++ b/tests/tcl/tests/test_helper.tcl
@@ -34,7 +34,6 @@ source tests/support/util.tcl
set ::all_tests {
unit/type/list
- unit/type/zset
unit/type/stream
unit/geo
integration/slotmigrate
diff --git a/tests/tcl/tests/unit/type/zset.tcl b/tests/tcl/tests/unit/type/zset.tcl
deleted file mode 100644
index 7c0ddb8..0000000
--- a/tests/tcl/tests/unit/type/zset.tcl
+++ /dev/null
@@ -1,1053 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-# Copyright (c) 2006-2020, Salvatore Sanfilippo
-# See bundled license file licenses/LICENSE.redis for details.
-
-# This file is copied and modified from the Redis project,
-# which started out as: https://github.com/redis/redis/blob/dbcc0a8/tests/unit/type/zset.tcl
-
-start_server {tags {"zset"}} {
- proc create_zset {key items} {
- r del $key
- foreach {score entry} $items {
- r zadd $key $score $entry
- }
- }
-
- proc basics {encoding} {
- test "Check encoding - $encoding" {
- r del ztmp
- r zadd ztmp 10 x
- #assert_encoding $encoding ztmp
- }
-
- test "ZSET basic ZADD and score update - $encoding" {
- r del ztmp
- r zadd ztmp 10 x
- r zadd ztmp 20 y
- r zadd ztmp 30 z
- assert_equal {x y z} [r zrange ztmp 0 -1]
-
- r zadd ztmp 1 y
- assert_equal {y x z} [r zrange ztmp 0 -1]
- }
-
- test "ZSET basic ZADD the same member with different scores - $encoding" {
- r del ztmp
- assert_equal 1 [r zadd ztmp 10 x 20 x]
- assert_equal {x} [r zrange ztmp 0 -1]
- assert_equal 20 [r zscore ztmp x]
-
- assert_equal 2 [r zadd ztmp 30 x 40 y 50 z]
- assert_equal {x y z} [r zrange ztmp 0 -1]
- assert_equal 30 [r zscore ztmp x]
- }
-
- test "ZSET element can't be set to NaN with ZADD - $encoding" {
- assert_error "*float*" {r zadd myzset nan abc}
- }
-
- test "ZSET element can't be set to NaN with ZINCRBY" {
- assert_error "*float*" {r zadd myzset nan abc}
- }
-
- # test "ZADD with options syntax error with incomplete pair" {
- # r del ztmp
- # catch {r zadd ztmp xx 10 x 20} err
- # set err
- # } {ERR*}
-
- # test "ZADD XX option without key - $encoding" {
- # r del ztmp
- # assert {[r zadd ztmp xx 10 x] == 0}
- # assert {[r type ztmp] eq {none}}
- # }
-
- # test "ZADD XX existing key - $encoding" {
- # r del ztmp
- # r zadd ztmp 10 x
- # assert {[r zadd ztmp xx 20 y] == 0}
- # assert {[r zcard ztmp] == 1}
- # }
-
- # test "ZADD XX returns the number of elements actually added" {
- # r del ztmp
- # r zadd ztmp 10 x
- # set retval [r zadd ztmp 10 x 20 y 30 z]
- # assert {$retval == 2}
- # }
-
- # test "ZADD XX updates existing elements score" {
- # r del ztmp
- # r zadd ztmp 10 x 20 y 30 z
- # r zadd ztmp xx 5 foo 11 x 21 y 40 zap
- # assert {[r zcard ztmp] == 3}
- # assert {[r zscore ztmp x] == 11}
- # assert {[r zscore ztmp y] == 21}
- # }
-
- # test "ZADD XX and NX are not compatible" {
- # r del ztmp
- # catch {r zadd ztmp xx nx 10 x} err
- # set err
- # } {ERR*}
-
- # test "ZADD NX with non exisitng key" {
- # r del ztmp
- # r zadd ztmp nx 10 x 20 y 30 z
- # assert {[r zcard ztmp] == 3}
- # }
-
- # test "ZADD NX only add new elements without updating old ones" {
- # r del ztmp
- # r zadd ztmp 10 x 20 y 30 z
- # assert {[r zadd ztmp nx 11 x 21 y 100 a 200 b] == 2}
- # assert {[r zscore ztmp x] == 10}
- # assert {[r zscore ztmp y] == 20}
- # assert {[r zscore ztmp a] == 100}
- # assert {[r zscore ztmp b] == 200}
- # }
-
- # test "ZADD INCR works like ZINCRBY" {
- # r del ztmp
- # r zadd ztmp 10 x 20 y 30 z
- # r zadd ztmp INCR 15 x
- # assert {[r zscore ztmp x] == 25}
- # }
-
- # test "ZADD INCR works with a single score-elemenet pair" {
- # r del ztmp
- # r zadd ztmp 10 x 20 y 30 z
- # catch {r zadd ztmp INCR 15 x 10 y} err
- # set err
- # } {ERR*}
-
- # test "ZADD CH option changes return value to all changed elements" {
- # r del ztmp
- # r zadd ztmp 10 x 20 y 30 z
- # assert {[r zadd ztmp 11 x 21 y 30 z] == 0}
- # assert {[r zadd ztmp ch 12 x 22 y 30 z] == 2}
- # }
-
- test "ZINCRBY calls leading to NaN result in error" {
- r zincrby myzset +inf abc
- assert_error "*NaN*" {r zincrby myzset -inf abc}
- }
-
- test {ZADD - Variadic version base case} {
- r del myzset
- list [r zadd myzset 10 a 20 b 30 c] [r zrange myzset 0 -1 withscores]
- } {3 {a 10 b 20 c 30}}
-
- test {ZADD - Return value is the number of actually added items} {
- list [r zadd myzset 5 x 20 b 30 c] [r zrange myzset 0 -1 withscores]
- } {1 {x 5 a 10 b 20 c 30}}
-
- # TODO: Kvrocks should handle more info when call std::stoi/std::stol/std::stod
- # test {ZADD - Variadic version does not add nothing on single parsing err} {
- # r del myzset
- # catch {r zadd myzset 10 a 20 b 30.badscore c} e
- # assert_match {*ERR*not*float*} $e
- # r exists myzset
- # } {0}
-
- test {ZADD - Variadic version will raise error on missing arg} {
- r del myzset
- catch {r zadd myzset 10 a 20 b 30 c 40} e
- assert_match {*syntax*} $e
- }
-
- test {ZINCRBY does not work variadic even if shares ZADD implementation} {
- r del myzset
- catch {r zincrby myzset 10 a 20 b 30 c} e
- assert_match {*ERR*wrong*number*arg*} $e
- }
-
- test "ZCARD basics - $encoding" {
- r del ztmp
- r zadd ztmp 10 a 20 b 30 c
- assert_equal 3 [r zcard ztmp]
- assert_equal 0 [r zcard zdoesntexist]
- }
-
- test "ZREM removes key after last element is removed" {
- r del ztmp
- r zadd ztmp 10 x
- r zadd ztmp 20 y
-
- assert_equal 1 [r exists ztmp]
- assert_equal 0 [r zrem ztmp z]
- assert_equal 1 [r zrem ztmp y]
- assert_equal 1 [r zrem ztmp x]
- assert_equal 0 [r exists ztmp]
- }
-
- test "ZREM variadic version" {
- r del ztmp
- r zadd ztmp 10 a 20 b 30 c
- assert_equal 2 [r zrem ztmp x y a b k]
- assert_equal 0 [r zrem ztmp foo bar]
- assert_equal 1 [r zrem ztmp c]
- r exists ztmp
- } {0}
-
- test "ZREM variadic version -- remove elements after key deletion" {
- r del ztmp
- r zadd ztmp 10 a 20 b 30 c
- r zrem ztmp a b c d e f g
- } {3}
-
- test "ZRANGE basics - $encoding" {
- r del ztmp
- r zadd ztmp 1 a
- r zadd ztmp 2 b
- r zadd ztmp 3 c
- r zadd ztmp 4 d
-
- assert_equal {a b c d} [r zrange ztmp 0 -1]
- assert_equal {a b c} [r zrange ztmp 0 -2]
- assert_equal {b c d} [r zrange ztmp 1 -1]
- assert_equal {b c} [r zrange ztmp 1 -2]
- assert_equal {c d} [r zrange ztmp -2 -1]
- assert_equal {c} [r zrange ztmp -2 -2]
-
- # out of range start index
- assert_equal {a b c} [r zrange ztmp -5 2]
- assert_equal {a b} [r zrange ztmp -5 1]
- assert_equal {} [r zrange ztmp 5 -1]
- assert_equal {} [r zrange ztmp 5 -2]
-
- # out of range end index
- assert_equal {a b c d} [r zrange ztmp 0 5]
- assert_equal {b c d} [r zrange ztmp 1 5]
- assert_equal {} [r zrange ztmp 0 -5]
- assert_equal {} [r zrange ztmp 1 -5]
-
- # withscores
- assert_equal {a 1 b 2 c 3 d 4} [r zrange ztmp 0 -1 withscores]
- }
-
- test "ZREVRANGE basics - $encoding" {
- r del ztmp
- r zadd ztmp 1 a
- r zadd ztmp 2 b
- r zadd ztmp 3 c
- r zadd ztmp 4 d
-
- assert_equal {d c b a} [r zrevrange ztmp 0 -1]
- assert_equal {d c b} [r zrevrange ztmp 0 -2]
- assert_equal {c b a} [r zrevrange ztmp 1 -1]
- assert_equal {c b} [r zrevrange ztmp 1 -2]
- assert_equal {b a} [r zrevrange ztmp -2 -1]
- assert_equal {b} [r zrevrange ztmp -2 -2]
-
- # out of range start index
- assert_equal {d c b} [r zrevrange ztmp -5 2]
- assert_equal {d c} [r zrevrange ztmp -5 1]
- assert_equal {} [r zrevrange ztmp 5 -1]
- assert_equal {} [r zrevrange ztmp 5 -2]
-
- # out of range end index
- assert_equal {d c b a} [r zrevrange ztmp 0 5]
- assert_equal {c b a} [r zrevrange ztmp 1 5]
- assert_equal {} [r zrevrange ztmp 0 -5]
- assert_equal {} [r zrevrange ztmp 1 -5]
-
- # withscores
- assert_equal {d 4 c 3 b 2 a 1} [r zrevrange ztmp 0 -1 withscores]
- }
-
- test "ZRANK/ZREVRANK basics - $encoding" {
- r del zranktmp
- r zadd zranktmp 10 x
- r zadd zranktmp 20 y
- r zadd zranktmp 30 z
- assert_equal 0 [r zrank zranktmp x]
- assert_equal 1 [r zrank zranktmp y]
- assert_equal 2 [r zrank zranktmp z]
- assert_equal "" [r zrank zranktmp foo]
- assert_equal 2 [r zrevrank zranktmp x]
- assert_equal 1 [r zrevrank zranktmp y]
- assert_equal 0 [r zrevrank zranktmp z]
- assert_equal "" [r zrevrank zranktmp foo]
- }
-
- test "ZRANK - after deletion - $encoding" {
- r zrem zranktmp y
- assert_equal 0 [r zrank zranktmp x]
- assert_equal 1 [r zrank zranktmp z]
- }
-
- test "ZINCRBY - can create a new sorted set - $encoding" {
- r del zset
- r zincrby zset 1 foo
- assert_equal {foo} [r zrange zset 0 -1]
- assert_equal 1 [r zscore zset foo]
- }
-
- test "ZINCRBY - increment and decrement - $encoding" {
- r zincrby zset 2 foo
- r zincrby zset 1 bar
- assert_equal {bar foo} [r zrange zset 0 -1]
-
- r zincrby zset 10 bar
- r zincrby zset -5 foo
- r zincrby zset -5 bar
- assert_equal {foo bar} [r zrange zset 0 -1]
-
- assert_equal -2 [r zscore zset foo]
- assert_equal 6 [r zscore zset bar]
- }
-
- test "ZINCRBY return value" {
- r del ztmp
- set retval [r zincrby ztmp 1.0 x]
- assert {$retval == 1.0}
- }
-
- proc create_default_zset {} {
- create_zset zset {-inf a 1 b 2 c 3 d 4 e 5 f +inf g}
- }
-
- test "ZRANGEBYSCORE/ZREVRANGEBYSCORE/ZCOUNT basics" {
- create_default_zset
-
- # inclusive range
- assert_equal {a b c} [r zrangebyscore zset -inf 2]
- assert_equal {b c d} [r zrangebyscore zset 0 3]
- assert_equal {d e f} [r zrangebyscore zset 3 6]
- assert_equal {e f g} [r zrangebyscore zset 4 +inf]
- assert_equal {c b a} [r zrevrangebyscore zset 2 -inf]
- assert_equal {d c b} [r zrevrangebyscore zset 3 0]
- assert_equal {f e d} [r zrevrangebyscore zset 6 3]
- assert_equal {g f e} [r zrevrangebyscore zset +inf 4]
- assert_equal 3 [r zcount zset 0 3]
-
- # exclusive range
- assert_equal {b} [r zrangebyscore zset (-inf (2]
- assert_equal {b c} [r zrangebyscore zset (0 (3]
- assert_equal {e f} [r zrangebyscore zset (3 (6]
- assert_equal {f} [r zrangebyscore zset (4 (+inf]
- assert_equal {b} [r zrevrangebyscore zset (2 (-inf]
- assert_equal {c b} [r zrevrangebyscore zset (3 (0]
- assert_equal {f e} [r zrevrangebyscore zset (6 (3]
- assert_equal {f} [r zrevrangebyscore zset (+inf (4]
- assert_equal 2 [r zcount zset (0 (3]
-
- # test empty ranges
- r zrem zset a
- r zrem zset g
-
- # inclusive
- assert_equal {} [r zrangebyscore zset 4 2]
- assert_equal {} [r zrangebyscore zset 6 +inf]
- assert_equal {} [r zrangebyscore zset -inf -6]
- assert_equal {} [r zrevrangebyscore zset +inf 6]
- assert_equal {} [r zrevrangebyscore zset -6 -inf]
-
- # exclusive
- assert_equal {} [r zrangebyscore zset (4 (2]
- assert_equal {} [r zrangebyscore zset 2 (2]
- assert_equal {} [r zrangebyscore zset (2 2]
- assert_equal {} [r zrangebyscore zset (6 (+inf]
- assert_equal {} [r zrangebyscore zset (-inf (-6]
- assert_equal {} [r zrevrangebyscore zset (+inf (6]
- assert_equal {} [r zrevrangebyscore zset (-6 (-inf]
-
- # empty inner range
- assert_equal {} [r zrangebyscore zset 2.4 2.6]
- assert_equal {} [r zrangebyscore zset (2.4 2.6]
- assert_equal {} [r zrangebyscore zset 2.4 (2.6]
- assert_equal {} [r zrangebyscore zset (2.4 (2.6]
- }
-
- test "ZRANGEBYSCORE with WITHSCORES" {
- create_default_zset
- assert_equal {b 1 c 2 d 3} [r zrangebyscore zset 0 3 withscores]
- assert_equal {d 3 c 2 b 1} [r zrevrangebyscore zset 3 0 withscores]
- }
-
- test "ZRANGEBYSCORE with LIMIT" {
- create_default_zset
- assert_equal {b c} [r zrangebyscore zset 0 10 LIMIT 0 2]
- assert_equal {d e f} [r zrangebyscore zset 0 10 LIMIT 2 3]
- assert_equal {d e f} [r zrangebyscore zset 0 10 LIMIT 2 10]
- assert_equal {} [r zrangebyscore zset 0 10 LIMIT 20 10]
- assert_equal {f e} [r zrevrangebyscore zset 10 0 LIMIT 0 2]
- assert_equal {d c b} [r zrevrangebyscore zset 10 0 LIMIT 2 3]
- assert_equal {d c b} [r zrevrangebyscore zset 10 0 LIMIT 2 10]
- assert_equal {} [r zrevrangebyscore zset 10 0 LIMIT 20 10]
- }
-
- test "ZRANGEBYSCORE with LIMIT and WITHSCORES" {
- create_default_zset
- assert_equal {e 4 f 5} [r zrangebyscore zset 2 5 LIMIT 2 3 WITHSCORES]
- assert_equal {d 3 c 2} [r zrevrangebyscore zset 5 2 LIMIT 2 3 WITHSCORES]
- }
-
- test "ZRANGEBYSCORE with non-value min or max" {
- assert_error "*double*" {r zrangebyscore fooz str 1}
- assert_error "*double*" {r zrangebyscore fooz 1 str}
- assert_error "*double*" {r zrangebyscore fooz 1 NaN}
- }
-
- test "ZRANGEBYSCORE for min/max score with multi member" {
- # int score
- create_zset mzset {-inf a -inf b -1 c 2 d 3 e +inf f +inf g}
- assert_equal {a -inf b -inf c -1 d 2 e 3 f inf g inf} [r zrangebyscore mzset -inf +inf WITHSCORES]
- assert_equal {g inf f inf e 3 d 2 c -1 b -inf a -inf} [r zrevrangebyscore mzset +inf -inf WITHSCORES]
-
- # double score
- create_zset nzset {-1.004 a -1.004 b -1.002 c 1.002 d 1.004 e 1.004 f}
- assert_equal {a -1.004 b -1.004 c -1.002 d 1.002 e 1.004 f 1.004} [r zrangebyscore nzset -1.004 1.004 WITHSCORES]
- assert_equal {f 1.004 e 1.004 d 1.002 c -1.002 b -1.004 a -1.004} [r zrevrangebyscore nzset 1.004 -1.004 WITHSCORES]
- }
-
- proc create_default_lex_zset {} {
- create_zset zset {0 alpha 0 bar 0 cool 0 down
- 0 elephant 0 foo 0 great 0 hill
- 0 omega}
- }
-
- # TODO: ZLEXCOUNT supports advanced options
- test "ZRANGEBYLEX/ZREVRANGEBYLEX/ZLEXCOUNT basics" {
- create_default_lex_zset
-
- # inclusive range
- assert_equal {alpha bar cool} [r zrangebylex zset - \[cool]
- assert_equal {bar cool down} [r zrangebylex zset \[bar \[down]
- assert_equal {great hill omega} [r zrangebylex zset \[g +]
- assert_equal {cool bar alpha} [r zrevrangebylex zset \[cool -]
- assert_equal {down cool bar} [r zrevrangebylex zset \[down \[bar]
- assert_equal {omega hill great foo elephant down} [r zrevrangebylex zset + \[d]
- assert_equal 3 [r zlexcount zset \[ele \[h]
-
- # exclusive range
- assert_equal {alpha bar} [r zrangebylex zset - (cool]
- assert_equal {cool} [r zrangebylex zset (bar (down]
- assert_equal {hill omega} [r zrangebylex zset (great +]
- assert_equal {bar alpha} [r zrevrangebylex zset (cool -]
- assert_equal {cool} [r zrevrangebylex zset (down (bar]
- assert_equal {omega hill} [r zrevrangebylex zset + (great]
- assert_equal 2 [r zlexcount zset (ele (great]
-
- # inclusive and exclusive
- assert_equal {} [r zrangebylex zset (az (b]
- assert_equal {} [r zrangebylex zset (z +]
- assert_equal {} [r zrangebylex zset - \[aaaa]
- assert_equal {} [r zrevrangebylex zset \[elez \[elex]
- assert_equal {} [r zrevrangebylex zset (hill (omega]
- }
-
- # test "ZLEXCOUNT advanced" {
- # create_default_lex_zset
-
- # assert_equal 9 [r zlexcount zset - +]
- # assert_equal 0 [r zlexcount zset + -]
- # assert_equal 0 [r zlexcount zset + \[c]
- # assert_equal 0 [r zlexcount zset \[c -]
- # assert_equal 8 [r zlexcount zset \[bar +]
- # assert_equal 5 [r zlexcount zset \[bar \[foo]
- # assert_equal 4 [r zlexcount zset \[bar (foo]
- # assert_equal 4 [r zlexcount zset (bar \[foo]
- # assert_equal 3 [r zlexcount zset (bar (foo]
- # assert_equal 5 [r zlexcount zset - (foo]
- # assert_equal 1 [r zlexcount zset (maxstring +]
- # }
-
- test "ZRANGEBYSLEX with LIMIT" {
- create_default_lex_zset
- assert_equal {alpha bar} [r zrangebylex zset - \[cool LIMIT 0 2]
- assert_equal {bar cool} [r zrangebylex zset - \[cool LIMIT 1 2]
- assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 0 0]
- assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 2 0]
- assert_equal {bar} [r zrangebylex zset \[bar \[down LIMIT 0 1]
- assert_equal {cool} [r zrangebylex zset \[bar \[down LIMIT 1 1]
- assert_equal {bar cool down} [r zrangebylex zset \[bar \[down LIMIT 0 100]
- assert_equal {omega hill great foo elephant} [r zrevrangebylex zset + \[d LIMIT 0 5]
- assert_equal {omega hill great foo} [r zrevrangebylex zset + \[d LIMIT 0 4]
- }
-
- test "ZRANGEBYLEX with invalid lex range specifiers" {
- assert_error "*illegal*" {r zrangebylex fooz foo bar}
- assert_error "*illegal*" {r zrangebylex fooz \[foo bar}
- assert_error "*illegal*" {r zrangebylex fooz foo \[bar}
- assert_error "*illegal*" {r zrangebylex fooz +x \[bar}
- assert_error "*illegal*" {r zrangebylex fooz -x \[bar}
- }
-
- test "ZREMRANGEBYSCORE basics" {
- proc remrangebyscore {min max} {
- create_zset zset {1 a 2 b 3 c 4 d 5 e}
- assert_equal 1 [r exists zset]
- r zremrangebyscore zset $min $max
- }
-
- # inner range
- assert_equal 3 [remrangebyscore 2 4]
- assert_equal {a e} [r zrange zset 0 -1]
-
- # start underflow
- assert_equal 1 [remrangebyscore -10 1]
- assert_equal {b c d e} [r zrange zset 0 -1]
-
- # end overflow
- assert_equal 1 [remrangebyscore 5 10]
- assert_equal {a b c d} [r zrange zset 0 -1]
-
- # switch min and max
- assert_equal 0 [remrangebyscore 4 2]
- assert_equal {a b c d e} [r zrange zset 0 -1]
-
- # -inf to mid
- assert_equal 3 [remrangebyscore -inf 3]
- assert_equal {d e} [r zrange zset 0 -1]
-
- # mid to +inf
- assert_equal 3 [remrangebyscore 3 +inf]
- assert_equal {a b} [r zrange zset 0 -1]
-
- # -inf to +inf
- assert_equal 5 [remrangebyscore -inf +inf]
- assert_equal {} [r zrange zset 0 -1]
-
- # exclusive min
- assert_equal 4 [remrangebyscore (1 5]
- assert_equal {a} [r zrange zset 0 -1]
- assert_equal 3 [remrangebyscore (2 5]
- assert_equal {a b} [r zrange zset 0 -1]
-
- # exclusive max
- assert_equal 4 [remrangebyscore 1 (5]
- assert_equal {e} [r zrange zset 0 -1]
- assert_equal 3 [remrangebyscore 1 (4]
- assert_equal {d e} [r zrange zset 0 -1]
-
- # exclusive min and max
- assert_equal 3 [remrangebyscore (1 (5]
- assert_equal {a e} [r zrange zset 0 -1]
-
- # destroy when empty
- assert_equal 5 [remrangebyscore 1 5]
- assert_equal 0 [r exists zset]
- }
-
- test "ZREMRANGEBYSCORE with non-value min or max" {
- assert_error "*double*" {r zremrangebyscore fooz str 1}
- assert_error "*double*" {r zremrangebyscore fooz 1 str}
- assert_error "*double*" {r zremrangebyscore fooz 1 NaN}
- }
-
- test "ZREMRANGEBYRANK basics" {
- proc remrangebyrank {min max} {
- create_zset zset {1 a 2 b 3 c 4 d 5 e}
- assert_equal 1 [r exists zset]
- r zremrangebyrank zset $min $max
- }
-
- # inner range
- assert_equal 3 [remrangebyrank 1 3]
- assert_equal {a e} [r zrange zset 0 -1]
-
- # start underflow
- assert_equal 1 [remrangebyrank -10 0]
- assert_equal {b c d e} [r zrange zset 0 -1]
-
- # start overflow
- assert_equal 0 [remrangebyrank 10 -1]
- assert_equal {a b c d e} [r zrange zset 0 -1]
-
- # end underflow
- assert_equal 0 [remrangebyrank 0 -10]
- assert_equal {a b c d e} [r zrange zset 0 -1]
-
- # end overflow
- assert_equal 5 [remrangebyrank 0 10]
- assert_equal {} [r zrange zset 0 -1]
-
- # destroy when empty
- assert_equal 5 [remrangebyrank 0 4]
- assert_equal 0 [r exists zset]
- }
-
- test "ZUNIONSTORE against non-existing key doesn't set destination - $encoding" {
- r del zseta
- assert_equal 0 [r zunionstore dst_key 1 zseta]
- assert_equal 0 [r exists dst_key]
- }
-
- test "ZUNIONSTORE with empty set - $encoding" {
- r del zseta zsetb
- r zadd zseta 1 a
- r zadd zseta 2 b
- r zunionstore zsetc 2 zseta zsetb
- r zrange zsetc 0 -1 withscores
- } {a 1 b 2}
-
- test "ZUNIONSTORE basics - $encoding" {
- r del zseta zsetb zsetc
- r zadd zseta 1 a
- r zadd zseta 2 b
- r zadd zseta 3 c
- r zadd zsetb 1 b
- r zadd zsetb 2 c
- r zadd zsetb 3 d
-
- assert_equal 4 [r zunionstore zsetc 2 zseta zsetb]
- assert_equal {a 1 b 3 d 3 c 5} [r zrange zsetc 0 -1 withscores]
- }
-
- test "ZUNIONSTORE with weights - $encoding" {
- assert_equal 4 [r zunionstore zsetc 2 zseta zsetb weights 2 3]
- assert_equal {a 2 b 7 d 9 c 12} [r zrange zsetc 0 -1 withscores]
- }
-
- # TODO: support ZUNIONSTORE with a regular SET type
- # test "ZUNIONSTORE with a regular set and weights - $encoding" {
- # r del seta
- # r sadd seta a
- # r sadd seta b
- # r sadd seta c
-
- # assert_equal 4 [r zunionstore zsetc 2 seta zsetb weights 2 3]
- # assert_equal {a 2 b 5 c 8 d 9} [r zrange zsetc 0 -1 withscores]
- # }
-
- test "ZUNIONSTORE with AGGREGATE MIN - $encoding" {
- assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate min]
- assert_equal {a 1 b 1 c 2 d 3} [r zrange zsetc 0 -1 withscores]
- }
-
- test "ZUNIONSTORE with AGGREGATE MAX - $encoding" {
- assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate max]
- assert_equal {a 1 b 2 c 3 d 3} [r zrange zsetc 0 -1 withscores]
- }
-
- test "ZINTERSTORE basics - $encoding" {
- assert_equal 2 [r zinterstore zsetc 2 zseta zsetb]
- assert_equal {b 3 c 5} [r zrange zsetc 0 -1 withscores]
- }
-
- test "ZINTERSTORE with weights - $encoding" {
- assert_equal 2 [r zinterstore zsetc 2 zseta zsetb weights 2 3]
- assert_equal {b 7 c 12} [r zrange zsetc 0 -1 withscores]
- }
-
- test "ZINTERSTORE with AGGREGATE MIN - $encoding" {
- assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate min]
- assert_equal {b 1 c 2} [r zrange zsetc 0 -1 withscores]
- }
-
- test "ZINTERSTORE with AGGREGATE MAX - $encoding" {
- assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate max]
- assert_equal {b 2 c 3} [r zrange zsetc 0 -1 withscores]
- }
-
- foreach cmd {ZUNIONSTORE ZINTERSTORE} {
- test "$cmd with +inf/-inf scores - $encoding" {
- r del zsetinf1 zsetinf2
-
- r zadd zsetinf1 +inf key
- r zadd zsetinf2 +inf key
- r $cmd zsetinf3 2 zsetinf1 zsetinf2
- assert_equal inf [r zscore zsetinf3 key]
-
- r zadd zsetinf1 -inf key
- r zadd zsetinf2 +inf key
- r $cmd zsetinf3 2 zsetinf1 zsetinf2
- assert_equal 0 [r zscore zsetinf3 key]
-
- r zadd zsetinf1 +inf key
- r zadd zsetinf2 -inf key
- r $cmd zsetinf3 2 zsetinf1 zsetinf2
- assert_equal 0 [r zscore zsetinf3 key]
-
- r zadd zsetinf1 -inf key
- r zadd zsetinf2 -inf key
- r $cmd zsetinf3 2 zsetinf1 zsetinf2
- assert_equal -inf [r zscore zsetinf3 key]
- }
-
- test "$cmd with NaN weights $encoding" {
- r del zsetinf1 zsetinf2
-
- r zadd zsetinf1 1.0 key
- r zadd zsetinf2 1.0 key
- assert_error "*weight*not*double*" {
- r $cmd zsetinf3 2 zsetinf1 zsetinf2 weights nan nan
- }
- }
- }
- }
-
- basics skiplist
-
- # TODO: support ZINTERSTORE with a regular SET type
- # test {ZINTERSTORE regression with two sets, intset+hashtable} {
- # r del seta setb setc
- # r sadd set1 a
- # r sadd set2 10
- # r zinterstore set3 2 set1 set2
- # } {0}
-
- test {ZUNIONSTORE regression, should not create NaN in scores} {
- r zadd z -inf neginf
- r zunionstore out 1 z weights 0
- r zrange out 0 -1 withscores
- } {neginf 0}
-
- # test {ZINTERSTORE #516 regression, mixed sets and ziplist zsets} {
- # r sadd one 100 101 102 103
- # r sadd two 100 200 201 202
- # r zadd three 1 500 1 501 1 502 1 503 1 100
- # r zinterstore to_here 3 one two three WEIGHTS 0 0 1
- # r zrange to_here 0 -1
- # } {100}
-
- test {ZUNIONSTORE result is sorted} {
- # Create two sets with common and not common elements, perform
- # the UNION, check that elements are still sorted.
- r del one two dest
- set cmd1 [list r zadd one]
- set cmd2 [list r zadd two]
- for {set j 0} {$j < 1000} {incr j} {
- lappend cmd1 [expr rand()] [randomInt 1000]
- lappend cmd2 [expr rand()] [randomInt 1000]
- }
- {*}$cmd1
- {*}$cmd2
- assert {[r zcard one] > 100}
- assert {[r zcard two] > 100}
- r zunionstore dest 2 one two
- set oldscore 0
- foreach {ele score} [r zrange dest 0 -1 withscores] {
- assert {$score >= $oldscore}
- set oldscore $score
- }
- }
-
- test "ZSET commands don't accept the empty strings as valid score" {
- assert_error "*not*float*" {r zadd myzset "" abc}
- }
-
- proc stressers {encoding} {
- if {$encoding == "ziplist"} {
- set elements 128
- } elseif {$encoding == "skiplist"} {
- if {$::accurate} {set elements 1000} else {set elements 100}
- } else {
- puts "Unknown sorted set encoding"
- exit
- }
-
- test "ZSCORE - $encoding" {
- r del zscoretest
- set aux {}
- for {set i 0} {$i < $elements} {incr i} {
- set score [expr rand()]
- lappend aux $score
- r zadd zscoretest $score $i
- }
-
- #assert_encoding $encoding zscoretest
- for {set i 0} {$i < $elements} {incr i} {
- assert_equal [lindex $aux $i] [r zscore zscoretest $i]
- }
- }
-
- test "ZSET sorting stresser - $encoding" {
- set delta 0
- for {set test 0} {$test < 2} {incr test} {
- unset -nocomplain auxarray
- array set auxarray {}
- set auxlist {}
- r del myzset
- for {set i 0} {$i < $elements} {incr i} {
- if {$test == 0} {
- set score [expr rand()]
- } else {
- set score [expr int(rand()*10)]
- }
- set auxarray($i) $score
- r zadd myzset $score $i
- # Random update
- if {[expr rand()] < .2} {
- set j [expr int(rand()*1000)]
- if {$test == 0} {
- set score [expr rand()]
- } else {
- set score [expr int(rand()*10)]
- }
- set auxarray($j) $score
- r zadd myzset $score $j
- }
- }
- foreach {item score} [array get auxarray] {
- lappend auxlist [list $score $item]
- }
- set sorted [lsort -command zlistAlikeSort $auxlist]
- set auxlist {}
- foreach x $sorted {
- lappend auxlist [lindex $x 1]
- }
-
- #assert_encoding $encoding myzset
- set fromredis [r zrange myzset 0 -1]
- set delta 0
- for {set i 0} {$i < [llength $fromredis]} {incr i} {
- if {[lindex $fromredis $i] != [lindex $auxlist $i]} {
- incr delta
- }
- }
- }
- assert_equal 0 $delta
- }
-
- test "ZRANGEBYSCORE fuzzy test, 100 ranges in $elements element sorted set - $encoding" {
- set err {}
- r del zset
- for {set i 0} {$i < $elements} {incr i} {
- r zadd zset [expr rand()] $i
- }
-
- #assert_encoding $encoding zset
- for {set i 0} {$i < 100} {incr i} {
- set min [expr rand()]
- set max [expr rand()]
- if {$min > $max} {
- set aux $min
- set min $max
- set max $aux
- }
- set low [r zrangebyscore zset -inf $min]
- set ok [r zrangebyscore zset $min $max]
- set high [r zrangebyscore zset $max +inf]
- set lowx [r zrangebyscore zset -inf ($min]
- set okx [r zrangebyscore zset ($min ($max]
- set highx [r zrangebyscore zset ($max +inf]
-
- if {[r zcount zset -inf $min] != [llength $low]} {
- append err "Error, len does not match zcount\n"
- }
- if {[r zcount zset $min $max] != [llength $ok]} {
- append err "Error, len does not match zcount\n"
- }
- if {[r zcount zset $max +inf] != [llength $high]} {
- append err "Error, len does not match zcount\n"
- }
- if {[r zcount zset -inf ($min] != [llength $lowx]} {
- append err "Error, len does not match zcount\n"
- }
- if {[r zcount zset ($min ($max] != [llength $okx]} {
- append err "Error, len does not match zcount\n"
- }
- if {[r zcount zset ($max +inf] != [llength $highx]} {
- append err "Error, len does not match zcount\n"
- }
-
- foreach x $low {
- set score [r zscore zset $x]
- if {$score > $min} {
- append err "Error, score for $x is $score > $min\n"
- }
- }
- foreach x $lowx {
- set score [r zscore zset $x]
- if {$score >= $min} {
- append err "Error, score for $x is $score >= $min\n"
- }
- }
- foreach x $ok {
- set score [r zscore zset $x]
- if {$score < $min || $score > $max} {
- append err "Error, score for $x is $score outside $min-$max range\n"
- }
- }
- foreach x $okx {
- set score [r zscore zset $x]
- if {$score <= $min || $score >= $max} {
- append err "Error, score for $x is $score outside $min-$max open range\n"
- }
- }
- foreach x $high {
- set score [r zscore zset $x]
- if {$score < $max} {
- append err "Error, score for $x is $score < $max\n"
- }
- }
- foreach x $highx {
- set score [r zscore zset $x]
- if {$score <= $max} {
- append err "Error, score for $x is $score <= $max\n"
- }
- }
- }
- assert_equal {} $err
- }
-
- test "ZRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" {
- set lexset {}
- r del zset
- for {set j 0} {$j < $elements} {incr j} {
- set e [randstring 0 30 alpha]
- lappend lexset $e
- r zadd zset 0 $e
- }
- set lexset [lsort -unique $lexset]
- for {set j 0} {$j < 100} {incr j} {
- set min [randstring 0 30 alpha]
- set max [randstring 0 30 alpha]
- set mininc [randomInt 2]
- set maxinc [randomInt 2]
- if {$mininc} {set cmin "\[$min"} else {set cmin "($min"}
- if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"}
- set rev [randomInt 2]
- set cmd zrangebylex
-
- # Make sure data is the same in both sides
- assert {[r zrange zset 0 -1] eq $lexset}
-
- # Get the Redis output
- set output [r $cmd zset $cmin $cmax]
- if {$rev} {
- set outlen [r zlexcount zset $cmax $cmin]
- } else {
- set outlen [r zlexcount zset $cmin $cmax]
- }
-
- # Compute the same output via Tcl
- set o {}
- set copy $lexset
- if {(!$rev && [string compare $min $max] > 0) ||
- ($rev && [string compare $max $min] > 0)} {
- # Empty output when ranges are inverted.
- } else {
- if {$rev} {
- # Invert the Tcl array using Redis itself.
- set copy [r zrevrange zset 0 -1]
- # Invert min / max as well
- lassign [list $min $max $mininc $maxinc] \
- max min maxinc mininc
- }
- foreach e $copy {
- set mincmp [string compare $e $min]
- set maxcmp [string compare $e $max]
- if {
- ($mininc && $mincmp >= 0 || !$mininc && $mincmp > 0)
- &&
- ($maxinc && $maxcmp <= 0 || !$maxinc && $maxcmp < 0)
- } {
- lappend o $e
- }
- }
- }
- # assert {$o eq $output}
- # assert {$outlen eq [llength $output]}
- }
- }
-
- test "ZREMRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" {
- set lexset {}
- r del zset zsetcopy
- for {set j 0} {$j < $elements} {incr j} {
- set e [randstring 0 30 alpha]
- lappend lexset $e
- r zadd zset 0 $e
- }
- set lexset [lsort -unique $lexset]
- for {set j 0} {$j < 100} {incr j} {
- # Copy...
- r zunionstore zsetcopy 1 zset
- set lexsetcopy $lexset
-
- set min [randstring 0 30 alpha]
- set max [randstring 0 30 alpha]
- set mininc [randomInt 2]
- set maxinc [randomInt 2]
- if {$mininc} {set cmin "\[$min"} else {set cmin "($min"}
- if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"}
-
- # Make sure data is the same in both sides
- assert {[r zrange zset 0 -1] eq $lexset}
-
- # Get the range we are going to remove
- set torem [r zrangebylex zset $cmin $cmax]
- set toremlen [r zlexcount zset $cmin $cmax]
- r zremrangebylex zsetcopy $cmin $cmax
- set output [r zrange zsetcopy 0 -1]
-
- # Remove the range with Tcl from the original list
- if {$toremlen} {
- set first [lsearch -exact $lexsetcopy [lindex $torem 0]]
- set last [expr {$first+$toremlen-1}]
- set lexsetcopy [lreplace $lexsetcopy $first $last]
- }
- assert {$lexsetcopy eq $output}
- }
- }
-
- test "ZSETs skiplist implementation backlink consistency test - $encoding" {
- set diff 0
- for {set j 0} {$j < $elements} {incr j} {
- r zadd myzset [expr rand()] "Element-$j"
- r zrem myzset "Element-[expr int(rand()*$elements)]"
- }
-
- #assert_encoding $encoding myzset
- set l1 [r zrange myzset 0 -1]
- set l2 [r zrevrange myzset 0 -1]
- for {set j 0} {$j < [llength $l1]} {incr j} {
- if {[lindex $l1 $j] ne [lindex $l2 end-$j]} {
- incr diff
- }
- }
- assert_equal 0 $diff
- }
-
- test "ZSETs ZRANK augmented skip list stress testing - $encoding" {
- set err {}
- r del myzset
- for {set k 0} {$k < 2000} {incr k} {
- set i [expr {$k % $elements}]
- if {[expr rand()] < .2} {
- r zrem myzset $i
- } else {
- set score [expr rand()]
- r zadd myzset $score $i
- #assert_encoding $encoding myzset
- }
-
- set card [r zcard myzset]
- if {$card > 0} {
- set index [randomInt $card]
- set ele [lindex [r zrange myzset $index $index] 0]
- set rank [r zrank myzset $ele]
- if {$rank != $index} {
- set err "$ele RANK is wrong! ($rank != $index)"
- break
- }
- }
- }
- assert_equal {} $err
- }
- }
-
- tags {"slow"} {
- stressers skiplist
- }
-}