Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
ruanhaishen
redis
Commits
366e872d
Commit
366e872d
authored
Mar 14, 2011
by
Pieter Noordhuis
Browse files
Test both sorted set encodings for every test
parent
4d8f13dd
Changes
1
Hide whitespace changes
Inline
Side-by-side
tests/unit/type/zset.tcl
View file @
366e872d
...
@@ -6,292 +6,540 @@ start_server {tags {"zset"}} {
...
@@ -6,292 +6,540 @@ start_server {tags {"zset"}} {
}
}
}
}
test
{
ZSET basic ZADD and score update
}
{
proc basics
{
encoding
}
{
r zadd ztmp 10 x
if
{
$encoding
==
"ziplist"
}
{
r zadd ztmp 20 y
r config set zset-max-ziplist-entries 128
r zadd ztmp 30 z
r config set zset-max-ziplist-value 64
set aux1
[
r zrange ztmp 0 -1
]
}
elseif
{
$encoding
==
"raw"
}
{
r zadd ztmp 1 y
r config set zset-max-ziplist-entries 0
set aux2
[
r zrange ztmp 0 -1
]
r config set zset-max-ziplist-value 0
list $aux1 $aux2
}
else
{
}
{{
x y z
}
{
y x z
}}
puts
"Unknown sorted set encoding"
exit
test
{
ZCARD basics
}
{
}
r zcard ztmp
}
{
3
}
test
{
ZCARD non existing key
}
{
r zcard ztmp-blabla
}
{
0
}
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
"ZREVRANGE basics"
{
test
"Check encoding -
$encoding
"
{
r del ztmp
r del ztmp
r zadd ztmp 1 a
r zadd ztmp 10 x
r zadd ztmp 2 b
assert_encoding $encoding ztmp
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 basics
}
{
test
"ZSET basic ZADD and score update -
$encoding
"
{
r zadd zranktmp 10 x
r del ztmp
r zadd zranktmp 20 y
r zadd ztmp 10 x
r zadd zranktmp 30 z
r zadd ztmp 20 y
list
[
r zrank zranktmp x
]
[
r zrank zranktmp y
]
[
r zrank zranktmp z
]
r zadd ztmp 30 z
}
{
0 1 2
}
assert_equal
{
x y z
}
[
r zrange ztmp 0 -1
]
test
{
ZREVRANK basics
}
{
r zadd ztmp 1 y
list
[
r zrevrank zranktmp x
]
[
r zrevrank zranktmp y
]
[
r zrevrank zranktmp z
]
assert_equal
{
y x z
}
[
r zrange ztmp 0 -1
]
}
{
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
}
}
}
set _ $err
}
{}
test
"ZSET element can't be set to NaN with ZADD -
$encoding
"
{
assert_error
"*not a double*"
{
r zadd myzset nan abc
}
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
}
}
}
set _ $err
}
{}
test
{
ZSETs stress tester - sorting is working well?
}
{
test
"ZSET element can't be set to NaN with ZINCRBY"
{
set delta 0
assert_error
"*not a double*"
{
r zadd myzset nan abc
}
for
{
set test 0
}
{
$test
< 2
}
{
incr test
}
{
}
unset -nocomplain auxarray
array set auxarray
{}
test
"ZINCRBY calls leading to NaN result in error"
{
set auxlist
{}
r zincrby myzset +inf abc
r del myzset
assert_error
"*NaN*"
{
r zincrby myzset -inf abc
}
for
{
set i 0
}
{
$i
< 1000
}
{
incr i
}
{
}
if
{
$test
== 0
}
{
set score
[
expr rand
()]
test
"ZCARD basics -
$encoding
"
{
}
else
{
assert_equal 3
[
r zcard ztmp
]
set score
[
expr int
(
rand
()
*10
)]
assert_equal 0
[
r zcard zdoesntexist
]
}
}
set auxarray
(
$i
)
$score
r zadd myzset $score $i
test
"ZRANGE basics -
$encoding
"
{
# Random update
r del ztmp
if
{[
expr rand
()]
< .2
}
{
r zadd ztmp 1 a
set j
[
expr int
(
rand
()
*1000
)]
r zadd ztmp 2 b
if
{
$test
== 0
}
{
r zadd ztmp 3 c
set score
[
expr rand
()]
r zadd ztmp 4 d
}
else
{
set score
[
expr int
(
rand
()
*10
)]
assert_equal
{
a b c d
}
[
r zrange ztmp 0 -1
]
}
assert_equal
{
a b c
}
[
r zrange ztmp 0 -2
]
set auxarray
(
$j
)
$score
assert_equal
{
b c d
}
[
r zrange ztmp 1 -1
]
r zadd myzset $score $j
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 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
"ZREMRANGEBYSCORE basics"
{
proc remrangebyscore
{
min max
}
{
create_zset zset
{
1 a 2 b 3 c 4 d 5 e
}
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
]
}
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
}
}
set sorted
[
lsort -command zlistAlikeSort $auxlist
]
set auxlist
{}
# inner range
foreach x $sorted
{
assert_equal 3
[
remrangebyrank 1 3
]
lappend auxlist
[
lindex $x 1
]
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 -
$encoding
"
{
r del zseta
assert_equal 0
[
r zunionstore dst_key 1 zseta
]
assert_equal 0
[
r exists dst_key
]
}
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
test
"
$cmd
with NaN weights
$encoding
"
{
for
{
set i 0
}
{
$i
<
[
llength $fromredis
]}
{
incr i
}
{
r del zsetinf1 zsetinf2
if
{[
lindex $fromredis $i
]
!=
[
lindex $auxlist $i
]}
{
incr delta
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
}
}
}
}
}
}
format $delta
}
{
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
"ZRANGEBYSCORE/ZREVRANGEBYSCORE/ZCOUNT basics"
{
basics ziplist
create_default_zset
basics raw
# inclusive range
proc stressers
{
encoding
}
{
assert_equal
{
a b c
}
[
r zrangebyscore zset -inf 2
]
if
{
$encoding
==
"ziplist"
}
{
assert_equal
{
b c d
}
[
r zrangebyscore zset 0 3
]
# Little extra to allow proper fuzzing in the sorting stresser
assert_equal
{
d e f
}
[
r zrangebyscore zset 3 6
]
r config set zset-max-ziplist-entries 256
assert_equal
{
e f g
}
[
r zrangebyscore zset 4 +inf
]
r config set zset-max-ziplist-value 64
assert_equal
{
c b a
}
[
r zrevrangebyscore zset 2 -inf
]
set elements 128
assert_equal
{
d c b
}
[
r zrevrangebyscore zset 3 0
]
}
elseif
{
$encoding
==
"raw"
}
{
assert_equal
{
f e d
}
[
r zrevrangebyscore zset 6 3
]
r config set zset-max-ziplist-entries 0
assert_equal
{
g f e
}
[
r zrevrangebyscore zset +inf 4
]
r config set zset-max-ziplist-value 0
assert_equal 3
[
r zcount zset 0 3
]
set elements 1000
}
else
{
# exclusive range
puts
"Unknown sorted set encoding"
assert_equal
{
b
}
[
r zrangebyscore zset
(
-inf
(
2
]
exit
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"
{
test
"ZSCORE -
$encoding
"
{
create_default_zset
r del zscoretest
assert_equal
{
b 1 c 2 d 3
}
[
r zrangebyscore zset 0 3 withscores
]
set aux
{}
assert_equal
{
d 3 c 2 b 1
}
[
r zrevrangebyscore zset 3 0 withscores
]
for
{
set i 0
}
{
$i
< $elements
}
{
incr i
}
{
}
set score
[
expr rand
()]
lappend aux $score
r zadd zscoretest $score $i
}
test
"ZRANGEBYSCORE with LIMIT"
{
assert_encoding $encoding zscoretest
create_default_zset
for
{
set i 0
}
{
$i
< $elements
}
{
incr i
}
{
assert_equal
{
b c
}
[
r zrangebyscore zset 0 10 LIMIT 0 2
]
assert_equal
[
lindex $aux $i
]
[
r zscore zscoretest $i
]
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"
{
test
"ZSCORE after a DEBUG RELOAD -
$encoding
"
{
create_default_zset
r del zscoretest
assert_equal
{
e 4 f 5
}
[
r zrangebyscore zset 2 5 LIMIT 2 3 WITHSCORES
]
set aux
{}
assert_equal
{
d 3 c 2
}
[
r zrevrangebyscore zset 5 2 LIMIT 2 3 WITHSCORES
]
for
{
set i 0
}
{
$i
< $elements
}
{
incr i
}
{
}
set score
[
expr rand
()]
lappend aux $score
r zadd zscoretest $score $i
}
test
"ZRANGEBYSCORE with non-value min or max"
{
r debug reload
assert_error
"*not a double*"
{
r zrangebyscore fooz str 1
}
assert_encoding $encoding zscoretest
assert_error
"*not a double*"
{
r zrangebyscore fooz 1 str
}
for
{
set i 0
}
{
$i
< $elements
}
{
incr i
}
{
assert_error
"*not a double*"
{
r zrangebyscore fooz 1 NaN
}
assert_equal
[
lindex $aux $i
]
[
r zscore zscoretest $i
]
}
}
}
tags
{
"slow"
}
{
test
"ZSET sorting stresser -
$encoding
"
{
test
{
ZRANGEBYSCORE fuzzy test, 100 ranges in 1000 elements sorted set
}
{
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
{}
set err
{}
r del zset
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
r zadd zset
[
expr rand
()]
$i
}
}
assert_encoding $encoding zset
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set min
[
expr rand
()]
set min
[
expr rand
()]
set max
[
expr rand
()]
set max
[
expr rand
()]
...
@@ -363,198 +611,17 @@ start_server {tags {"zset"}} {
...
@@ -363,198 +611,17 @@ start_server {tags {"zset"}} {
}
}
}
}
}
}
set _ $err
assert_equal
{}
$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
test
"ZSETs skiplist implementation backlink consistency test -
$encoding
"
{
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
}
}
}
tags
{
"slow"
}
{
test
{
ZSETs skiplist implementation backlink consistency test
}
{
set diff 0
set diff 0
set elements 10000
for
{
set j 0
}
{
$j
< $elements
}
{
incr j
}
{
for
{
set j 0
}
{
$j
< $elements
}
{
incr j
}
{
r zadd myzset
[
expr rand
()]
"Element-
$j
"
r zadd myzset
[
expr rand
()]
"Element-
$j
"
r zrem myzset
"Element-
[
expr int
(
rand
()
*$elements
)]
"
r zrem myzset
"Element-
[
expr int
(
rand
()
*$elements
)]
"
}
}
assert_encoding $encoding myzset
set l1
[
r zrange myzset 0 -1
]
set l1
[
r zrange myzset 0 -1
]
set l2
[
r zrevrange myzset 0 -1
]
set l2
[
r zrevrange myzset 0 -1
]
for
{
set j 0
}
{
$j
<
[
llength $l1
]}
{
incr j
}
{
for
{
set j 0
}
{
$j
<
[
llength $l1
]}
{
incr j
}
{
...
@@ -562,20 +629,22 @@ start_server {tags {"zset"}} {
...
@@ -562,20 +629,22 @@ start_server {tags {"zset"}} {
incr diff
incr diff
}
}
}
}
format
$diff
assert_equal 0
$diff
}
{
0
}
}
test
{
ZSETs ZRANK augmented skip list stress testing
}
{
test
"
ZSETs ZRANK augmented skip list stress testing
-
$encoding
"
{
set err
{}
set err
{}
r del myzset
r del myzset
for
{
set k 0
}
{
$k
<
10
000
}
{
incr k
}
{
for
{
set k 0
}
{
$k
<
2
000
}
{
incr k
}
{
set i
[
expr
{
$k
%1000
}]
set i
[
expr
{
$k
% $elements
}]
if
{[
expr rand
()]
< .2
}
{
if
{[
expr rand
()]
< .2
}
{
r zrem myzset $i
r zrem myzset $i
}
else
{
}
else
{
set score
[
expr rand
()]
set score
[
expr rand
()]
r zadd myzset $score $i
r zadd myzset $score $i
assert_encoding $encoding myzset
}
}
set card
[
r zcard myzset
]
set card
[
r zcard myzset
]
if
{
$card
> 0
}
{
if
{
$card
> 0
}
{
set index
[
randomInt $card
]
set index
[
randomInt $card
]
...
@@ -587,20 +656,12 @@ start_server {tags {"zset"}} {
...
@@ -587,20 +656,12 @@ start_server {tags {"zset"}} {
}
}
}
}
}
}
set _ $err
assert_equal
{}
$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
}
}
}
t
est
{
ZINCRBY calls leading to NaN result in error
}
{
t
ags
{
"slow"
}
{
r zincrby myzset +inf abc
stressers ziplist
assert_error
"*NaN*"
{
r zincrby myzset -inf abc
}
stressers raw
}
}
}
}
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment