}
}
- 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}
}
- 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 "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
- 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}
+
+ 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}
+
+ 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]
+ }
+ }
- tags {"slow"} {
- test {ZRANGEBYSCORE fuzzy test, 100 ranges in 1000 elements sorted set} {
+ 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 < 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()]
}
}
}
- set _ $err
- } {}
- }
-
- test {ZREMRANGEBYSCORE basics} {
- r del zset
- r zadd zset 1 a
- r zadd zset 2 b
- r zadd zset 3 c
- r zadd zset 4 d
- r zadd zset 5 e
- list [r zremrangebyscore zset 2 4] [r zrange zset 0 -1]
- } {3 {a e}}
-
- test {ZREMRANGEBYSCORE from -inf to +inf} {
- r del zset
- r zadd zset 1 a
- r zadd zset 2 b
- r zadd zset 3 c
- r zadd zset 4 d
- r zadd zset 5 e
- list [r zremrangebyscore zset -inf +inf] [r zrange zset 0 -1]
- } {5 {}}
-
- 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} {
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]
}
}
}
- 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
}
}
projects / redis.git / blobdiff