X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/21dbc6499a538af07f52a41742cf1683f3fc9c23..2bcd18a2e95ba1278e8ab4671a6987416800e36f:/tests/unit/type/zset.tcl

diff --git a/tests/unit/type/zset.tcl b/tests/unit/type/zset.tcl
index 6b8fc54a..bab98854 100644
--- a/tests/unit/type/zset.tcl
+++ b/tests/unit/type/zset.tcl
@@ -6,266 +6,626 @@ start_server {tags {"zset"}} {
         }
     }
 
-    test {ZSET basic ZADD and score update} {
-        r zadd ztmp 10 x
-        r zadd ztmp 20 y
-        r zadd ztmp 30 z
-        set aux1 [r zrange ztmp 0 -1]
-        r zadd ztmp 1 y
-        set aux2 [r zrange ztmp 0 -1]
-        list $aux1 $aux2
-    } {{x y z} {y x z}}
-
-    test {ZCARD basics} {
-        r zcard ztmp
-    } {3}
-
-    test {ZCARD non existing key} {
-        r zcard ztmp-blabla
-    } {0}
+    proc basics {encoding} {
+        if {$encoding == "ziplist"} {
+            r config set zset-max-ziplist-entries 128
+            r config set zset-max-ziplist-value 64
+        } elseif {$encoding == "skiplist"} {
+            r config set zset-max-ziplist-entries 0
+            r config set zset-max-ziplist-value 0
+        } else {
+            puts "Unknown sorted set encoding"
+            exit
+        }
 
-    test "ZRANGE basics" {
-        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 "Check encoding - $encoding" {
+            r del ztmp
+            r zadd ztmp 10 x
+            assert_encoding $encoding ztmp
+        }
 
-    test "ZREVRANGE basics" {
-        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 "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]
 
-    test {ZRANK basics} {
-        r zadd zranktmp 10 x
-        r zadd zranktmp 20 y
-        r zadd zranktmp 30 z
-        list [r zrank zranktmp x] [r zrank zranktmp y] [r zrank zranktmp z]
-    } {0 1 2}
-
-    test {ZREVRANK basics} {
-        list [r zrevrank zranktmp x] [r zrevrank zranktmp y] [r zrevrank zranktmp z]
-    } {2 1 0}
-
-    test {ZRANK - after deletion} {
-        r zrem zranktmp y
-        list [r zrank zranktmp x] [r zrank zranktmp z]
-    } {0 1}
-
-    test {ZSCORE} {
-        set aux {}
-        set err {}
-        for {set i 0} {$i < 1000} {incr i} {
-            set score [expr rand()]
-            lappend aux $score
-            r zadd zscoretest $score $i
-        }
-        for {set i 0} {$i < 1000} {incr i} {
-            if {[r zscore zscoretest $i] != [lindex $aux $i]} {
-                set err "Expected score was [lindex $aux $i] but got [r zscore zscoretest $i] for element $i"
-                break
-            }
+            r zadd ztmp 1 y
+            assert_equal {y x z} [r zrange ztmp 0 -1]
         }
-        set _ $err
-    } {}
-
-    test {ZSCORE after a DEBUG RELOAD} {
-        set aux {}
-        set err {}
-        r del zscoretest
-        for {set i 0} {$i < 1000} {incr i} {
-            set score [expr rand()]
-            lappend aux $score
-            r zadd zscoretest $score $i
-        }
-        r debug reload
-        for {set i 0} {$i < 1000} {incr i} {
-            if {[r zscore zscoretest $i] != [lindex $aux $i]} {
-                set err "Expected score was [lindex $aux $i] but got [r zscore zscoretest $i] for element $i"
-                break
-            }
+
+        test "ZSET element can't be set to NaN with ZADD - $encoding" {
+            assert_error "*not*float*" {r zadd myzset nan abc}
+        }
+
+        test "ZSET element can't be set to NaN with ZINCRBY" {
+            assert_error "*not*float*" {r zadd myzset nan abc}
+        }
+
+        test "ZINCRBY calls leading to NaN result in error" {
+            r zincrby myzset +inf abc
+            assert_error "*NaN*" {r zincrby myzset -inf abc}
         }
-        set _ $err
-    } {}
 
-    test {ZSETs stress tester - sorting is working well?} {
-        set delta 0
-        for {set test 0} {$test < 2} {incr test} {
-            unset -nocomplain auxarray
-            array set auxarray {}
-            set auxlist {}
+        test {ZADD - Variadic version base case} {
             r del myzset
-            for {set i 0} {$i < 1000} {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
-                }
+            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}}
+
+        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 {*ERR*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" {
+            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]
+        }
+
+        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 "*not*float*" {r zrangebyscore fooz str 1}
+            assert_error "*not*float*" {r zrangebyscore fooz 1 str}
+            assert_error "*not*float*" {r zrangebyscore fooz 1 NaN}
+        }
+
+        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
             }
-            foreach {item score} [array get auxarray] {
-                lappend auxlist [list $score $item]
+
+            # 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 "*not*float*" {r zremrangebyscore fooz str 1}
+            assert_error "*not*float*" {r zremrangebyscore fooz 1 str}
+            assert_error "*not*float*" {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
             }
-            set sorted [lsort -command zlistAlikeSort $auxlist]
-            set auxlist {}
-            foreach x $sorted {
-                lappend auxlist [lindex $x 1]
+
+            # 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]
+        }
+
+        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 a regular set and weights - $encoding" {
+            r del seta
+            r sadd seta a
+            r sadd seta b
+            r sadd seta c
+            assert_equal 2 [r zinterstore zsetc 2 seta zsetb weights 2 3]
+            assert_equal {b 5 c 8} [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]
             }
-            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
+
+            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*float*" {
+                    r $cmd zsetinf3 2 zsetinf1 zsetinf2 weights nan nan
                 }
             }
         }
-        format $delta
+    }
+
+    basics ziplist
+    basics skiplist
+
+    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 {ZINCRBY - can create a new sorted set} {
-        r del zset
-        r zincrby zset 1 foo
-        list [r zrange zset 0 -1] [r zscore zset foo]
-    } {foo 1}
-
-    test {ZINCRBY - increment and decrement} {
-        r zincrby zset 2 foo
-        r zincrby zset 1 bar
-        set v1 [r zrange zset 0 -1]
-        r zincrby zset 10 bar
-        r zincrby zset -5 foo
-        r zincrby zset -5 bar
-        set v2 [r zrange zset 0 -1]
-        list $v1 $v2 [r zscore zset foo] [r zscore zset bar]
-    } {{bar foo} {foo bar} -2 6}
-
-    proc create_default_zset {} {
-        create_zset zset {-inf a 1 b 2 c 3 d 4 e 5 f +inf g}
-    }
+    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}
+
+    proc stressers {encoding} {
+        if {$encoding == "ziplist"} {
+            # Little extra to allow proper fuzzing in the sorting stresser
+            r config set zset-max-ziplist-entries 256
+            r config set zset-max-ziplist-value 64
+            set elements 128
+        } elseif {$encoding == "skiplist"} {
+            r config set zset-max-ziplist-entries 0
+            r config set zset-max-ziplist-value 0
+            if {$::accurate} {set elements 1000} else {set elements 100}
+        } else {
+            puts "Unknown sorted set encoding"
+            exit
+        }
 
-    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 "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
+            }
 
-    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]
-    }
+            assert_encoding $encoding zscoretest
+            for {set i 0} {$i < $elements} {incr i} {
+                assert_equal [lindex $aux $i] [r zscore zscoretest $i]
+            }
+        }
 
-    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 "ZSCORE after a DEBUG RELOAD - $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
+            }
 
-    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]
-    }
+            r debug reload
+            assert_encoding $encoding zscoretest
+            for {set i 0} {$i < $elements} {incr i} {
+                assert_equal [lindex $aux $i] [r zscore zscoretest $i]
+            }
+        }
 
-    test "ZRANGEBYSCORE with non-value min or max" {
-        assert_error "*not a double*" {r zrangebyscore fooz str 1}
-        assert_error "*not a double*" {r zrangebyscore fooz 1 str}
-        assert_error "*not a double*" {r zrangebyscore fooz 1 NaN}
-    }
+        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]
+                }
 
-    tags {"slow"} {
-        test {ZRANGEBYSCORE fuzzy test, 100 ranges in 1000 elements sorted set} {
+                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 < 1000} {incr i} {
+            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()]
@@ -337,198 +697,17 @@ start_server {tags {"zset"}} {
                     }
                 }
             }
-            set _ $err
-        } {}
-    }
-
-    test "ZREMRANGEBYSCORE basics" {
-        proc remrangebyscore {min max} {
-            create_zset zset {1 a 2 b 3 c 4 d 5 e}
-            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]
-    }
-
-    test "ZREMRANGEBYSCORE with non-value min or max" {
-        assert_error "*not a double*" {r zremrangebyscore fooz str 1}
-        assert_error "*not a double*" {r zremrangebyscore fooz 1 str}
-        assert_error "*not a 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}
-            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]
-    }
-
-    test {ZUNIONSTORE against non-existing key doesn't set destination} {
-      r del zseta
-      list [r zunionstore dst_key 1 zseta] [r exists dst_key]
-    } {0 0}
-
-    test {ZUNIONSTORE basics} {
-        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
-        list [r zunionstore zsetc 2 zseta zsetb] [r zrange zsetc 0 -1 withscores]
-    } {4 {a 1 b 3 d 3 c 5}}
-
-    test {ZUNIONSTORE with weights} {
-        list [r zunionstore zsetc 2 zseta zsetb weights 2 3] [r zrange zsetc 0 -1 withscores]
-    } {4 {a 2 b 7 d 9 c 12}}
-
-	test {ZUNIONSTORE with a regular set and weights} {
-		r del seta
-		r sadd seta a
-		r sadd seta b
-		r sadd seta c
-        list [r zunionstore zsetc 2 seta zsetb weights 2 3] [r zrange zsetc 0 -1 withscores]
-	} {4 {a 2 b 5 c 8 d 9}}
-
-    test {ZUNIONSTORE with AGGREGATE MIN} {
-        list [r zunionstore zsetc 2 zseta zsetb aggregate min] [r zrange zsetc 0 -1 withscores]
-    } {4 {a 1 b 1 c 2 d 3}}
-
-    test {ZUNIONSTORE with AGGREGATE MAX} {
-        list [r zunionstore zsetc 2 zseta zsetb aggregate max] [r zrange zsetc 0 -1 withscores]
-    } {4 {a 1 b 2 c 3 d 3}}
-
-    test {ZINTERSTORE basics} {
-        list [r zinterstore zsetc 2 zseta zsetb] [r zrange zsetc 0 -1 withscores]
-    } {2 {b 3 c 5}}
-
-    test {ZINTERSTORE with weights} {
-        list [r zinterstore zsetc 2 zseta zsetb weights 2 3] [r zrange zsetc 0 -1 withscores]
-    } {2 {b 7 c 12}}
-
-	test {ZINTERSTORE with a regular set and weights} {
-		r del seta
-		r sadd seta a
-		r sadd seta b
-		r sadd seta c
-        list [r zinterstore zsetc 2 seta zsetb weights 2 3] [r zrange zsetc 0 -1 withscores]
-	} {2 {b 5 c 8}}
-
-    test {ZINTERSTORE with AGGREGATE MIN} {
-        list [r zinterstore zsetc 2 zseta zsetb aggregate min] [r zrange zsetc 0 -1 withscores]
-    } {2 {b 1 c 2}}
-
-    test {ZINTERSTORE with AGGREGATE MAX} {
-        list [r zinterstore zsetc 2 zseta zsetb aggregate max] [r zrange zsetc 0 -1 withscores]
-    } {2 {b 2 c 3}}
-    
-    foreach cmd {ZUNIONSTORE ZINTERSTORE} {
-        test "$cmd with +inf/-inf scores" {
-            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" {
-            r del zsetinf1 zsetinf2
-
-            r zadd zsetinf1 1.0 key
-            r zadd zsetinf2 1.0 key
-            assert_error "*weight value is not a double*" {
-                r $cmd zsetinf3 2 zsetinf1 zsetinf2 weights nan nan
-            }
+            assert_equal {} $err
         }
-    }
 
-    tags {"slow"} {
-        test {ZSETs skiplist implementation backlink consistency test} {
+        test "ZSETs skiplist implementation backlink consistency test - $encoding" {
             set diff 0
-            set elements 10000
             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} {
@@ -536,20 +715,22 @@ start_server {tags {"zset"}} {
                     incr diff
                 }
             }
-            format $diff
-        } {0}
+            assert_equal 0 $diff
+        }
 
-        test {ZSETs ZRANK augmented skip list stress testing} {
+        test "ZSETs ZRANK augmented skip list stress testing - $encoding" {
             set err {}
             r del myzset
-            for {set k 0} {$k < 10000} {incr k} {
-                set i [expr {$k%1000}]
+            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]
@@ -561,20 +742,12 @@ start_server {tags {"zset"}} {
                     }
                 }
             }
-            set _ $err
-        } {}
-    }
-
-    test {ZSET element can't be set to NaN with ZADD} {
-        assert_error "*not a double*" {r zadd myzset nan abc}
-    }
-
-    test {ZSET element can't be set to NaN with ZINCRBY} {
-        assert_error "*not a double*" {r zadd myzset nan abc}
+            assert_equal {} $err
+        }
     }
 
-    test {ZINCRBY calls leading to NaN result in error} {
-        r zincrby myzset +inf abc
-        assert_error "*NaN*" {r zincrby myzset -inf abc}
+    tags {"slow"} {
+        stressers ziplist
+        stressers skiplist
     }
 }