Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
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
Show whitespace changes
Inline
Side-by-side
tests/unit/sort.tcl
View file @
5d4f3a8c
start_server
{
tags
{
"sort"
}}
{
test
{
SORT ALPHA against integer encoded strings
}
{
r del mylist
r lpush mylist 2
r lpush mylist 1
r lpush mylist 3
r lpush mylist 10
r sort mylist alpha
}
{
1 10 2 3
}
tags
{
"slow"
}
{
set res
{}
test
{
Create a random list and a random set
}
{
start_server
{
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
{}
for
{
set i 0
}
{
$i
< 10000
}
{
incr i
}
{
while 1
{
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
)]
}
{
...
...
@@ -25,72 +22,110 @@ start_server {tags {"sort"}} {
if
{
!
[
info exists seenrand
(
$rint
)]}
break
}
set seenrand
(
$rint
)
x
r lpush tosort $i
r sadd tosort-set $i
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
< 10000
}
{
incr i
}
{
lappend res
[
lindex $sorted $i 0
]
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_*
}]
}
format
{}
}
{}
test
{
SORT
with BY against the newly created list
}
{
r sort tosort
{
BY weight
_*
}
}
$res
test
"
SORT
BY hash field"
{
assert_equal $result
[
r sort tosort
{
BY
wobj_*->
weight
}
]
}
test
{
SORT
with BY
(
hash field
)
against the newly created list
}
{
r sort tosort
{
BY wobj_*->weight
}
}
$res
test
"
SORT
GET #"
{
assert_equal
[
lsort -integer $result
]
[
r sort tosort GET #
]
}
test
{
SORT with GET
(
key+hash
)
with sanity check of each element
(
list
)}
{
set err
{}
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
{
set realweight
[
r get weight_$id1
]
if
{
$id1
!= $id2
}
{
set err
"ID mismatch
$id1
!=
$id2
"
break
assert_equal $id1 $id2
assert_equal $w1
[
r get weight_$id1
]
assert_equal $w2
[
r get weight_$id1
]
}
if
{
$realweight
!= $w1 || $realweight != $w2
}
{
set err
"Weights mismatch! w1:
$w1
w2:
$w2
real:
$realweight
"
break
}
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
}
set _ $err
}
{}
test
{
SORT with BY, but against the newly created set
}
{
r sort tosort-set
{
BY weight_*
}
}
$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
with BY
(
hash field
)
, but against the newly created set
}
{
r sort tosort-set
{
BY wobj_*->weight
}
}
$res
test
"
SORT
DESC"
{
assert_equal
[
lsort -decreasing -integer $result
]
[
r sort tosort
{
DESC
}]
}
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 ALPHA against integer encoded strings"
{
r del mylist
r lpush mylist 2
r lpush mylist 1
r lpush mylist 3
r lpush mylist 10
r sort mylist alpha
}
{
1 10 2 3
}
test
{
SORT with BY
(
hash field
)
and STORE against the newly created list
}
{
r sort tosort
{
BY wobj_*->weight
}
store sort-res
r lrange sort-res 0 -1
}
$res
test
"SORT sorted set"
{
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
{
SORT direct, numeric, against the newly created list
}
{
r sort tosort
}
[
lsort -integer $res
]
test
"SORT sorted set: +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
}
test
"SORT regression for issue #19, sorting floats"
{
r flushdb
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
}
{
r sort tosort
{
DESC
}
}
[
lsort -decreasing -integer $res
]
t
ags
{
"slow"
}
{
set num 100
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
]
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set sorted
[
r sort tosort
{
BY weight_* LIMIT 0 10
}]
...
...
@@ -98,10 +133,9 @@ start_server {tags {"sort"}} {
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
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
]
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set sorted
[
r sort tosort
{
BY wobj_*->weight LIMIT 0 10
}]
...
...
@@ -109,10 +143,9 @@ start_server {tags {"sort"}} {
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
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
]
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set sorted
[
r sort tosort
{
LIMIT 0 10
}]
...
...
@@ -120,10 +153,9 @@ start_server {tags {"sort"}} {
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
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
]
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
set sorted
[
r sort tosort
{
BY nokey LIMIT 0 10
}]
...
...
@@ -131,49 +163,6 @@ start_server {tags {"sort"}} {
set elapsed
[
expr
[
clock clicks -milliseconds
]
-$start
]
puts -nonewline
"
\n
Average time to sort:
[
expr double
(
$elapsed
)
/100
]
milliseconds "
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