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
5d4f3a8c
Commit
5d4f3a8c
authored
Aug 21, 2010
by
Pieter Noordhuis
Browse files
Move SORT tests around
parent
a53ebb4c
Changes
1
Hide whitespace changes
Inline
Side-by-side
tests/unit/sort.tcl
View file @
5d4f3a8c
start_server
{
tags
{
"sort"
}}
{
start_server
{
test
{
SORT ALPHA against integer encoded strings
}
{
tags
{
"sort"
}
overrides
{
"list-max-ziplist-value"
16
"list-max-ziplist-entries"
32
}
}
{
proc create_random_dataset
{
num cmd
}
{
set tosort
{}
set result
{}
array set seenrand
{}
r del tosort
for
{
set i 0
}
{
$i
< $num
}
{
incr i
}
{
# Make sure all the weights are different because
# Redis does not use a stable sort but Tcl does.
while 1
{
randpath
{
set rint
[
expr int
(
rand
()
*1000000
)]
}
{
set rint
[
expr rand
()]
}
if
{
!
[
info exists seenrand
(
$rint
)]}
break
}
set seenrand
(
$rint
)
x
r $cmd tosort $i
r set weight_$i $rint
r hset wobj_$i weight $rint
lappend tosort
[
list $i $rint
]
}
set sorted
[
lsort -index 1 -real $tosort
]
for
{
set i 0
}
{
$i
< $num
}
{
incr i
}
{
lappend result
[
lindex $sorted $i 0
]
}
set _ $result
}
set result
[
create_random_dataset 16 lpush
]
test
"SORT BY key"
{
assert_equal $result
[
r sort tosort
{
BY weight_*
}]
}
test
"SORT BY hash field"
{
assert_equal $result
[
r sort tosort
{
BY wobj_*->weight
}]
}
test
"SORT GET #"
{
assert_equal
[
lsort -integer $result
]
[
r sort tosort GET #
]
}
test
"SORT GET <const>"
{
r del foo
set res
[
r sort tosort GET foo
]
assert_equal 16
[
llength $res
]
foreach item $res
{
assert_equal
{}
$item
}
}
test
"SORT GET (key and hash) with sanity check"
{
set l1
[
r sort tosort GET # GET weight_*
]
set l2
[
r sort tosort GET # GET wobj_*->weight
]
foreach
{
id1 w1
}
$l1
{
id2 w2
}
$l2
{
assert_equal $id1 $id2
assert_equal $w1
[
r get weight_$id1
]
assert_equal $w2
[
r get weight_$id1
]
}
}
test
"SORT BY key STORE"
{
r sort tosort
{
BY weight_*
}
store sort-res
assert_equal $result
[
r lrange sort-res 0 -1
]
assert_equal 16
[
r llen sort-res
]
assert_encoding ziplist sort-res
}
test
"SORT BY hash field STORE"
{
r sort tosort
{
BY wobj_*->weight
}
store sort-res
assert_equal $result
[
r lrange sort-res 0 -1
]
assert_equal 16
[
r llen sort-res
]
assert_encoding ziplist sort-res
}
test
"SORT DESC"
{
assert_equal
[
lsort -decreasing -integer $result
]
[
r sort tosort
{
DESC
}]
}
test
"SORT ALPHA against integer encoded strings"
{
r del mylist
r del mylist
r lpush mylist 2
r lpush mylist 2
r lpush mylist 1
r lpush mylist 1
...
@@ -8,89 +91,41 @@ start_server {tags {"sort"}} {
...
@@ -8,89 +91,41 @@ start_server {tags {"sort"}} {
r sort mylist alpha
r sort mylist alpha
}
{
1 10 2 3
}
}
{
1 10 2 3
}
tags
{
"slow"
}
{
test
"SORT sorted set"
{
set res
{}
r del zset
test
{
Create a random list and a random set
}
{
r zadd zset 1 a
set tosort
{}
r zadd zset 5 b
array set seenrand
{}
r zadd zset 2 c
for
{
set i 0
}
{
$i
< 10000
}
{
incr i
}
{
r zadd zset 10 d
while 1
{
r zadd zset 3 e
# Make sure all the weights are different because
r sort zset alpha desc
# Redis does not use a stable sort but Tcl does.
}
{
e d c b a
}
randpath
{
set rint
[
expr int
(
rand
()
*1000000
)]
}
{
set rint
[
expr rand
()]
}
if
{
!
[
info exists seenrand
(
$rint
)]}
break
}
set seenrand
(
$rint
)
x
r lpush tosort $i
r sadd tosort-set $i
r set weight_$i $rint
r hset wobj_$i weight $rint
lappend tosort
[
list $i $rint
]
}
set sorted
[
lsort -index 1 -real $tosort
]
for
{
set i 0
}
{
$i
< 10000
}
{
incr i
}
{
lappend res
[
lindex $sorted $i 0
]
}
format
{}
}
{}
test
{
SORT with BY against the newly created list
}
{
r sort tosort
{
BY weight_*
}
}
$res
test
{
SORT with BY
(
hash field
)
against the newly created list
}
{
r sort tosort
{
BY wobj_*->weight
}
}
$res
test
{
SORT with GET
(
key+hash
)
with sanity check of each element
(
list
)}
{
set err
{}
set l1
[
r sort tosort GET # GET weight_*
]
set l2
[
r sort tosort GET # GET wobj_*->weight
]
foreach
{
id1 w1
}
$l1
{
id2 w2
}
$l2
{
set realweight
[
r get weight_$id1
]
if
{
$id1
!= $id2
}
{
set err
"ID mismatch
$id1
!=
$id2
"
break
}
if
{
$realweight
!= $w1 || $realweight != $w2
}
{
set err
"Weights mismatch! w1:
$w1
w2:
$w2
real:
$realweight
"
break
}
}
set _ $err
}
{}
test
{
SORT with BY, but against the newly created set
}
{
r sort tosort-set
{
BY weight_*
}
}
$res
test
{
SORT with BY
(
hash field
)
, but against the newly created set
}
{
r sort tosort-set
{
BY wobj_*->weight
}
}
$res
test
{
SORT with BY and STORE against the newly created list
}
{
r sort tosort
{
BY weight_*
}
store sort-res
r lrange sort-res 0 -1
}
$res
test
{
SORT with BY
(
hash field
)
and STORE against the newly created list
}
{
test
"SORT sorted set: +inf and -inf handling"
{
r sort tosort
{
BY wobj_*->weight
}
store sort-res
r del zset
r lrange sort-res 0 -1
r zadd zset -100 a
}
$res
r zadd zset 200 b
r zadd zset -300 c
r zadd zset 1000000 d
r zadd zset +inf max
r zadd zset -inf min
r zrange zset 0 -1
}
{
min c a b d max
}
test
{
SORT direct, numeric, against the newly created list
}
{
test
"SORT regression for issue #19, sorting floats"
{
r sort tosort
r flushdb
}
[
lsort -integer $res
]
set floats
{
1.1 5.10 3.10 7.44 2.1 5.75 6.12 0.25 1.15
}
foreach x $floats
{
r lpush mylist $x
}
assert_equal
[
lsort -real $floats
]
[
r sort mylist
]
}
t
est
{
SORT decreasing sort
}
{
t
ags
{
"slow"
}
{
r sort tosort
{
DESC
}
set num 100
}
[
lsort -decreasing -integer $res
]
set res
[
create_random_dataset $num lpush
]
test
{
SORT speed,
sorting 10000
element
s
list
using BY
, 100 times
}
{
test
"
SORT speed,
$num
element list
BY key
, 100 times
"
{
set start
[
clock clicks -milliseconds
]
set start
[
clock clicks -milliseconds
]
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set sorted
[
r sort tosort
{
BY weight_* LIMIT 0 10
}]
set sorted
[
r sort tosort
{
BY weight_* LIMIT 0 10
}]
...
@@ -98,10 +133,9 @@ start_server {tags {"sort"}} {
...
@@ -98,10 +133,9 @@ start_server {tags {"sort"}} {
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
flush stdout
flush stdout
format
{}
}
}
{}
test
{
SORT speed,
as above but against hash field
}
{
test
"
SORT speed,
$num
element list BY hash field, 100 times"
{
set start
[
clock clicks -milliseconds
]
set start
[
clock clicks -milliseconds
]
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set sorted
[
r sort tosort
{
BY wobj_*->weight LIMIT 0 10
}]
set sorted
[
r sort tosort
{
BY wobj_*->weight LIMIT 0 10
}]
...
@@ -109,10 +143,9 @@ start_server {tags {"sort"}} {
...
@@ -109,10 +143,9 @@ start_server {tags {"sort"}} {
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
flush stdout
flush stdout
format
{}
}
}
{}
test
{
SORT speed,
sorting 10000
element
s
list directly, 100 times
}
{
test
"
SORT speed,
$num
element list directly, 100 times
"
{
set start
[
clock clicks -milliseconds
]
set start
[
clock clicks -milliseconds
]
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set sorted
[
r sort tosort
{
LIMIT 0 10
}]
set sorted
[
r sort tosort
{
LIMIT 0 10
}]
...
@@ -120,10 +153,9 @@ start_server {tags {"sort"}} {
...
@@ -120,10 +153,9 @@ start_server {tags {"sort"}} {
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
flush stdout
flush stdout
format
{}
}
}
{}
test
{
SORT speed,
pseudo-sorting 10000
element
s
list
,
BY <const>, 100 times
}
{
test
"
SORT speed,
$num
element list BY <const>, 100 times
"
{
set start
[
clock clicks -milliseconds
]
set start
[
clock clicks -milliseconds
]
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set sorted
[
r sort tosort
{
BY nokey LIMIT 0 10
}]
set sorted
[
r sort tosort
{
BY nokey LIMIT 0 10
}]
...
@@ -131,49 +163,6 @@ start_server {tags {"sort"}} {
...
@@ -131,49 +163,6 @@ start_server {tags {"sort"}} {
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
flush stdout
flush stdout
format
{}
}
{}
}
test
{
SORT regression for issue #19, sorting floats
}
{
r flushdb
foreach x
{
1.1 5.10 3.10 7.44 2.1 5.75 6.12 0.25 1.15
}
{
r lpush mylist $x
}
}
r sort mylist
}
}
[
lsort -real
{
1.1 5.10 3.10 7.44 2.1 5.75 6.12 0.25 1.15
}]
test
{
SORT with GET #
}
{
r del mylist
r lpush mylist 1
r lpush mylist 2
r lpush mylist 3
r mset weight_1 10 weight_2 5 weight_3 30
r sort mylist BY weight_* GET #
}
{
2 1 3
}
test
{
SORT with constant GET
}
{
r sort mylist GET foo
}
{{}
{}
{}}
test
{
SORT against sorted sets
}
{
r del zset
r zadd zset 1 a
r zadd zset 5 b
r zadd zset 2 c
r zadd zset 10 d
r zadd zset 3 e
r sort zset alpha desc
}
{
e d c b a
}
test
{
Sorted sets +inf and -inf handling
}
{
r del zset
r zadd zset -100 a
r zadd zset 200 b
r zadd zset -300 c
r zadd zset 1000000 d
r zadd zset +inf max
r zadd zset -inf min
r zrange zset 0 -1
}
{
min c a b d max
}
}
}
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