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
d4507ec6
Commit
d4507ec6
authored
Jun 04, 2010
by
Pieter Noordhuis
Browse files
refactor list tests to test both encodings; implemented assert functions
parent
d1578a33
Changes
3
Show whitespace changes
Inline
Side-by-side
tests/support/test.tcl
View file @
d4507ec6
...
@@ -2,7 +2,38 @@ set ::passed 0
...
@@ -2,7 +2,38 @@ set ::passed 0
set ::failed 0
set ::failed 0
set ::testnum 0
set ::testnum 0
proc test
{
name code okpattern
}
{
proc assert_match
{
pattern value
}
{
if
{
!
[
string match $pattern $value
]}
{
puts
"!! ERROR
\n
Expected '
$value
' to match '
$pattern
'"
error
"assertion"
}
}
proc assert_equal
{
expected value
}
{
if
{
$expected
ne $value
}
{
puts
"!! ERROR
\n
Expected '
$value
' to be equal to '
$expected
'"
error
"assertion"
}
}
proc assert_error
{
pattern code
}
{
if
{[
catch $code error
]}
{
assert_match $pattern $error
}
else
{
puts
"!! ERROR
\n
Expected an error but nothing was catched"
error
"assertion"
}
}
proc assert_encoding
{
enc key
}
{
assert_match
"* encoding:
$enc
*"
[
r debug object $key
]
}
proc assert_type
{
type key
}
{
assert_equal $type
[
r type $key
]
}
proc test
{
name code
{
okpattern notspecified
}}
{
# abort if tagged with a tag to deny
# abort if tagged with a tag to deny
foreach tag $::denytags
{
foreach tag $::denytags
{
if
{[
lsearch $::tags $tag
]
>= 0
}
{
if
{[
lsearch $::tags $tag
]
>= 0
}
{
...
@@ -28,17 +59,22 @@ proc test {name code okpattern} {
...
@@ -28,17 +59,22 @@ proc test {name code okpattern} {
puts -nonewline
[
format
"#%03d %-68s "
$::testnum $name
]
puts -nonewline
[
format
"#%03d %-68s "
$::testnum $name
]
flush stdout
flush stdout
if
{[
catch
{
set retval
[
uplevel 1 $code
]}
error
]}
{
if
{[
catch
{
set retval
[
uplevel 1 $code
]}
error
]}
{
if
{
$error
eq
"assertion"
}
{
incr ::failed
}
else
{
puts
"EXCEPTION"
puts
"EXCEPTION"
puts
"
\n
Caught error:
$error
"
puts
"
\n
Caught error:
$error
"
error
"exception"
error
"exception"
}
}
if
{
$okpattern
eq $retval ||
[
string match $okpattern $retval
]}
{
}
else
{
if
{
$okpattern
eq
"notspecified"
|| $okpattern eq $retval ||
[
string match $okpattern $retval
]}
{
puts
"PASSED"
puts
"PASSED"
incr ::passed
incr ::passed
}
else
{
}
else
{
puts
"!! ERROR expected
\n
'
$okpattern
'
\n
but got
\n
'
$retval
'"
puts
"!! ERROR expected
\n
'
$okpattern
'
\n
but got
\n
'
$retval
'"
incr ::failed
incr ::failed
}
}
}
if
{
$::traceleaks
}
{
if
{
$::traceleaks
}
{
if
{
!
[
string match
{
*0 leaks*
}
[
exec leaks redis-server
]]}
{
if
{
!
[
string match
{
*0 leaks*
}
[
exec leaks redis-server
]]}
{
puts
"--------- Test
$::testnum
LEAKED! --------"
puts
"--------- Test
$::testnum
LEAKED! --------"
...
...
tests/test_helper.tcl
View file @
d4507ec6
...
@@ -73,7 +73,7 @@ proc main {} {
...
@@ -73,7 +73,7 @@ proc main {} {
execute_tests
"integration/aof"
execute_tests
"integration/aof"
# run tests with VM enabled
# run tests with VM enabled
set ::global_overrides
[
list
[
list
vm-enabled yes
]]
set ::global_overrides
{
vm-enabled yes
}
execute_tests
"unit/protocol"
execute_tests
"unit/protocol"
execute_tests
"unit/basic"
execute_tests
"unit/basic"
execute_tests
"unit/type/list"
execute_tests
"unit/type/list"
...
...
tests/unit/type/list.tcl
View file @
d4507ec6
start_server
{
tags
{
"list"
}}
{
start_server
{
test
{
Basic LPUSH, RPUSH, LLENGTH, LINDEX
}
{
tags
{
"list"
}
set res
[
r lpush mylist a
]
overrides
{
append res
[
r lpush mylist b
]
"list-max-ziplist-value"
16
append res
[
r rpush mylist c
]
"list-max-ziplist-entries"
256
append res
[
r llen mylist
]
}
append res
[
r rpush anotherlist d
]
}
{
append res
[
r lpush anotherlist e
]
test
{
LPUSH, RPUSH, LLENGTH, LINDEX - ziplist
}
{
append res
[
r llen anotherlist
]
# first lpush then rpush
append res
[
r lindex mylist 0
]
assert_equal 1
[
r lpush myziplist1 a
]
append res
[
r lindex mylist 1
]
assert_equal 2
[
r rpush myziplist1 b
]
append res
[
r lindex mylist 2
]
assert_equal 3
[
r rpush myziplist1 c
]
append res
[
r lindex anotherlist 0
]
assert_equal 3
[
r llen myziplist1
]
append res
[
r lindex anotherlist 1
]
assert_equal a
[
r lindex myziplist1 0
]
list $res
[
r lindex mylist 100
]
assert_equal b
[
r lindex myziplist1 1
]
}
{
1233122baced
{}}
assert_equal c
[
r lindex myziplist1 2
]
assert_encoding ziplist myziplist1
test
{
DEL a list
}
{
r del mylist
# first rpush then lpush
r exists mylist
assert_equal 1
[
r rpush myziplist2 a
]
}
{
0
}
assert_equal 2
[
r lpush myziplist2 b
]
assert_equal 3
[
r lpush myziplist2 c
]
assert_equal 3
[
r llen myziplist2
]
assert_equal c
[
r lindex myziplist2 0
]
assert_equal b
[
r lindex myziplist2 1
]
assert_equal a
[
r lindex myziplist2 2
]
assert_encoding ziplist myziplist2
}
test
{
Create a long list and check every single element with LINDEX
}
{
test
{
LPUSH, RPUSH, LLENGTH, LINDEX - regular list
}
{
set ok 0
# use a string of length 17 to ensure a regular list is used
for
{
set i 0
}
{
$i
< 1000
}
{
incr i
}
{
set large_value
"aaaaaaaaaaaaaaaaa"
r rpush mylist $i
# first lpush then rpush
assert_equal 1
[
r lpush mylist1 $large_value
]
assert_encoding list mylist1
assert_equal 2
[
r rpush mylist1 b
]
assert_equal 3
[
r rpush mylist1 c
]
assert_equal 3
[
r llen mylist1
]
assert_equal $large_value
[
r lindex mylist1 0
]
assert_equal b
[
r lindex mylist1 1
]
assert_equal c
[
r lindex mylist1 2
]
# first rpush then lpush
assert_equal 1
[
r rpush mylist2 $large_value
]
assert_encoding list mylist2
assert_equal 2
[
r lpush mylist2 b
]
assert_equal 3
[
r lpush mylist2 c
]
assert_equal 3
[
r llen mylist2
]
assert_equal c
[
r lindex mylist2 0
]
assert_equal b
[
r lindex mylist2 1
]
assert_equal $large_value
[
r lindex mylist2 2
]
}
}
for
{
set i 0
}
{
$i
< 1000
}
{
incr i
}
{
if
{[
r lindex mylist $i
]
eq $i
}
{
incr ok
}
test
{
DEL a list - ziplist
}
{
if
{[
r lindex mylist
[
expr
(
-$i
)
-1
]]
eq
[
expr 999-$i
]}
{
assert_equal 1
[
r del myziplist2
]
incr ok
assert_equal 0
[
r exists myziplist2
]
assert_equal 0
[
r llen myziplist2
]
}
}
test
{
DEL a list - regular list
}
{
assert_equal 1
[
r del mylist2
]
assert_equal 0
[
r exists mylist2
]
assert_equal 0
[
r llen mylist2
]
}
}
format $ok
}
{
2000
}
test
{
Test elements with LINDEX in random access
}
{
proc populate_with_numbers
{
key num
}
{
set ok 0
for
{
set i 0
}
{
$i
< $num
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 1000
}
{
incr i
}
{
r rpush $key $i
set rint
[
expr int
(
rand
()
*1000
)]
if
{[
r lindex mylist $rint
]
eq $rint
}
{
incr ok
}
if
{[
r lindex mylist
[
expr
(
-$rint
)
-1
]]
eq
[
expr 999-$rint
]}
{
incr ok
}
}
}
}
format $ok
}
{
2000
}
test
{
Check if the list is still ok after a DEBUG RELOAD
}
{
proc check_numbered_list_consistency
{
key
}
{
r debug reload
set len
[
r llen $key
]
set ok 0
for
{
set i 0
}
{
$i
< $len
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 1000
}
{
incr i
}
{
assert_equal $i
[
r lindex $key $i
]
set rint
[
expr int
(
rand
()
*1000
)]
assert_equal
[
expr $len-1-$i
]
[
r lindex $key
[
expr
(
-$i
)
-1
]]
if
{[
r lindex mylist $rint
]
eq $rint
}
{
incr ok
}
}
if
{[
r lindex mylist
[
expr
(
-$rint
)
-1
]]
eq
[
expr 999-$rint
]}
{
}
incr ok
proc check_random_access_consistency
{
key
}
{
set len
[
r llen $key
]
for
{
set i 0
}
{
$i
< $len
}
{
incr i
}
{
set rint
[
expr int
(
rand
()
*$len
)]
assert_equal $rint
[
r lindex $key $rint
]
assert_equal
[
expr $len-1-$rint
]
[
r lindex $key
[
expr
(
-$rint
)
-1
]]
}
}
test
{
LINDEX consistency test - ziplist
}
{
populate_with_numbers myziplist 250
assert_encoding ziplist myziplist
}
test
{
LINDEX consistency test - regular list
}
{
populate_with_numbers mylist 500
assert_encoding list mylist
check_numbered_list_consistency mylist
}
test
{
LINDEX random access - ziplist
}
{
assert_encoding ziplist myziplist
check_random_access_consistency myziplist
}
}
test
{
LINDEX random access - regular list
}
{
assert_encoding list mylist
check_random_access_consistency mylist
}
test
{
Check if both list encodings are still ok after a DEBUG RELOAD
}
{
r debug reload
assert_encoding ziplist myziplist
check_numbered_list_consistency myziplist
assert_encoding list mylist
check_numbered_list_consistency mylist
}
}
format $ok
}
{
2000
}
test
{
LLEN against non-list value error
}
{
test
{
LLEN against non-list value error
}
{
r del mylist
r del mylist
r set mylist foobar
r set mylist foobar
catch
{
r llen mylist
}
err
assert_error ERR*
{
r llen mylist
}
format $err
}
}
{
ERR*
}
test
{
LLEN against non existing key
}
{
test
{
LLEN against non existing key
}
{
r llen not-a-key
assert_equal 0
[
r llen not-a-key
]
}
{
0
}
}
test
{
LINDEX against non-list value error
}
{
test
{
LINDEX against non-list value error
}
{
catch
{
r lindex mylist 0
}
err
assert_error ERR*
{
r lindex mylist 0
}
format $err
}
}
{
ERR*
}
test
{
LINDEX against non existing key
}
{
test
{
LINDEX against non existing key
}
{
r lindex not-a-key 10
assert_equal
""
[
r lindex not-a-key 10
]
}
{}
}
test
{
LPUSH against non-list value error
}
{
test
{
LPUSH against non-list value error
}
{
catch
{
r lpush mylist 0
}
err
assert_error ERR*
{
r lpush mylist 0
}
format $err
}
}
{
ERR*
}
test
{
RPUSH against non-list value error
}
{
test
{
RPUSH against non-list value error
}
{
catch
{
r rpush mylist 0
}
err
assert_error ERR*
{
r rpush mylist 0
}
format $err
}
}
{
ERR*
}
test
{
RPOPLPUSH base case
}
{
proc create_ziplist
{
key entries
}
{
r del mylist
r del $key
r rpush mylist a
foreach entry $entries
{
r rpush $key $entry
}
r rpush mylist b
assert_match *encoding:ziplist*
[
r debug object $key
]
r rpush mylist c
}
r rpush mylist d
set v1
[
r rpoplpush mylist newlist
]
proc create_regular_list
{
key entries
}
{
set v2
[
r rpoplpush mylist newlist
]
r del $key
set l1
[
r lrange mylist 0 -1
]
r rpush $key
"aaaaaaaaaaaaaaaaa"
set l2
[
r lrange newlist 0 -1
]
foreach entry $entries
{
r rpush $key $entry
}
list $v1 $v2 $l1 $l2
assert_equal
"aaaaaaaaaaaaaaaaa"
[
r lpop $key
]
}
{
d c
{
a b
}
{
c d
}}
assert_match *encoding:list*
[
r debug object $key
]
}
test
{
RPOPLPUSH with the same list as src and dst
}
{
r del mylist
test
{
RPOPLPUSH base case - ziplist
}
{
r rpush mylist a
r del mylist1 mylist2
r rpush mylist b
create_ziplist mylist1
{
a b c d
}
r rpush mylist c
assert_equal d
[
r rpoplpush mylist1 mylist2
]
set l1
[
r lrange mylist 0 -1
]
assert_equal c
[
r rpoplpush mylist1 mylist2
]
set v
[
r rpoplpush mylist mylist
]
assert_equal
{
a b
}
[
r lrange mylist1 0 -1
]
set l2
[
r lrange mylist 0 -1
]
assert_equal
{
c d
}
[
r lrange mylist2 0 -1
]
list $l1 $v $l2
assert_encoding ziplist mylist2
}
{{
a b c
}
c
{
c a b
}}
}
test
{
RPOPLPUSH target list already exists
}
{
test
{
RPOPLPUSH base case - regular list
}
{
r del mylist
r del mylist1 mylist2
r del newlist
create_regular_list mylist1
{
a b c d
}
r rpush mylist a
assert_equal d
[
r rpoplpush mylist1 mylist2
]
r rpush mylist b
assert_equal c
[
r rpoplpush mylist1 mylist2
]
r rpush mylist c
assert_equal
{
a b
}
[
r lrange mylist1 0 -1
]
r rpush mylist d
assert_equal
{
c d
}
[
r lrange mylist2 0 -1
]
r rpush newlist x
assert_encoding ziplist mylist2
set v1
[
r rpoplpush mylist newlist
]
}
set v2
[
r rpoplpush mylist newlist
]
set l1
[
r lrange mylist 0 -1
]
test
{
RPOPLPUSH with the same list as src and dst - ziplist
}
{
set l2
[
r lrange newlist 0 -1
]
create_ziplist myziplist
{
a b c
}
list $v1 $v2 $l1 $l2
assert_equal
{
a b c
}
[
r lrange myziplist 0 -1
]
}
{
d c
{
a b
}
{
c d x
}}
assert_equal c
[
r rpoplpush myziplist myziplist
]
assert_equal
{
c a b
}
[
r lrange myziplist 0 -1
]
}
test
{
RPOPLPUSH with the same list as src and dst - regular list
}
{
create_regular_list mylist
{
a b c
}
assert_equal
{
a b c
}
[
r lrange mylist 0 -1
]
assert_equal c
[
r rpoplpush mylist mylist
]
assert_equal
{
c a b
}
[
r lrange mylist 0 -1
]
}
test
{
RPOPLPUSH target list already exists, being a ziplist
}
{
create_regular_list srclist
{
a b c d
}
create_ziplist dstlist
{
x
}
assert_equal d
[
r rpoplpush srclist dstlist
]
assert_equal c
[
r rpoplpush srclist dstlist
]
assert_equal
{
a b
}
[
r lrange srclist 0 -1
]
assert_equal
{
c d x
}
[
r lrange dstlist 0 -1
]
}
test
{
RPOPLPUSH target list already exists, being a regular list
}
{
create_regular_list srclist
{
a b c d
}
create_regular_list dstlist
{
x
}
assert_equal d
[
r rpoplpush srclist dstlist
]
assert_equal c
[
r rpoplpush srclist dstlist
]
assert_equal
{
a b
}
[
r lrange srclist 0 -1
]
assert_equal
{
c d x
}
[
r lrange dstlist 0 -1
]
}
test
{
RPOPLPUSH against non existing key
}
{
test
{
RPOPLPUSH against non existing key
}
{
r del
my
list
r del
srclist dst
list
r del newlist
assert_equal
{}
[
r rpoplpush srclist dstlist
]
set v1
[
r rpoplpush mylist new
list
]
assert_equal 0
[
r exists src
list
]
list $v1
[
r exists mylist
]
[
r exists new
list
]
assert_equal 0
[
r exists dst
list
]
}
{{}
0 0
}
}
test
{
RPOPLPUSH against non list src key
}
{
test
{
RPOPLPUSH against non list src key
}
{
r del
my
list
r del
srclist dst
list
r
del new
list
r
set src
list
x
r set my
list
x
assert_error ERR*
{
r rpoplpush srclist dst
list
}
catch
{
r rpoplpush mylist newlist
}
err
assert_type string srclist
list
[
r type mylist
]
[
r exists newlist
]
[
string range $err 0 2
]
assert_equal 0
[
r exists newlist
]
}
{
string 0 ERR
}
}
test
{
RPOPLPUSH against non list dst key
}
{
test
{
RPOPLPUSH against non list dst key
}
{
r del mylist
create_ziplist srclist
{
a b c d
}
r del newlist
r set dstlist x
r rpush mylist a
assert_error ERR*
{
r rpoplpush srclist dstlist
}
r rpush mylist b
assert_type string dstlist
r rpush mylist c
assert_equal
{
a b c d
}
[
r lrange srclist 0 -1
]
r rpush mylist d
}
r set newlist x
catch
{
r rpoplpush mylist newlist
}
err
list
[
r lrange mylist 0 -1
]
[
r type newlist
]
[
string range $err 0 2
]
}
{{
a b c d
}
string ERR
}
test
{
RPOPLPUSH against non existing src key
}
{
test
{
RPOPLPUSH against non existing src key
}
{
r del mylist
r del srclist dstlist
r del newlist
assert_equal
{}
[
r rpoplpush srclist dstlist
]
r rpoplpush mylist newlist
}
{}
}
{}
test
{
Basic LPOP/RPOP
}
{
test
{
Basic LPOP/RPOP
- ziplist
}
{
r del mylist
create_ziplist myziplist
{
0 1 2
}
r rpush my
list
1
assert_equal 0
[
r lpop myzip
list
]
r rpush my
list
2
assert_equal 2
[
r rpop myzip
list
]
r lpush my
list
0
assert_equal 1
[
r lpop myzip
list
]
list
[
r lpop mylist
]
[
r rpop mylist
]
[
r lpop mylist
]
[
r llen mylist
]
assert_equal 0
[
r llen my
zip
list
]
}
[
list 0 2 1 0
]
# pop on empty list
test
{
LPOP/RPOP against empty
list
}
{
assert_equal
{}
[
r lpop myzip
list
]
r l
pop mylist
assert_equal
{}
[
r r
pop my
zip
list
]
}
{}
}
test
{
LPOP against non list value
}
{
test
{
Basic LPOP/RPOP - regular list
}
{
create_regular_list mylist
{
0 1 2
}
assert_equal 0
[
r lpop mylist
]
assert_equal 2
[
r rpop mylist
]
assert_equal 1
[
r lpop mylist
]
assert_equal 0
[
r llen mylist
]
# pop on empty list
assert_equal
{}
[
r lpop mylist
]
assert_equal
{}
[
r rpop mylist
]
}
test
{
LPOP/RPOP against non list value
}
{
r set notalist foo
r set notalist foo
catch
{
r lpop notalist
}
err
assert_error ERR*kind*
{
r lpop notalist
}
format $err
assert_error ERR*kind*
{
r rpop notalist
}
}
{
ERR*kind*
}
}
test
{
Mass LPUSH/LPOP
}
{
test
{
Mass RPOP/LPOP - ziplist
}
{
set sum 0
r del mylist
for
{
set i 0
}
{
$i
< 1000
}
{
incr i
}
{
set sum1 0
for
{
set i 0
}
{
$i
< 250
}
{
incr i
}
{
r lpush mylist $i
r lpush mylist $i
incr sum $i
incr sum
1
$i
}
}
assert_encoding ziplist mylist
set sum2 0
set sum2 0
for
{
set i 0
}
{
$i
< 125
}
{
incr i
}
{
incr sum2
[
r lpop mylist
]
incr sum2
[
r rpop mylist
]
}
assert_equal $sum1 $sum2
}
test
{
Mass RPOP/LPOP - regular list
}
{
r del mylist
set sum1 0
for
{
set i 0
}
{
$i
< 500
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 500
}
{
incr i
}
{
r lpush mylist $i
incr sum1 $i
}
assert_encoding list mylist
set sum2 0
for
{
set i 0
}
{
$i
< 250
}
{
incr i
}
{
incr sum2
[
r lpop mylist
]
incr sum2
[
r lpop mylist
]
incr sum2
[
r rpop mylist
]
incr sum2
[
r rpop mylist
]
}
}
expr
$sum
==
$sum2
assert_equal
$sum
1
$sum2
}
{
1
}
}
test
{
LRANGE basics
}
{
test
{
LRANGE basics - ziplist
}
{
for
{
set i 0
}
{
$i
< 10
}
{
incr i
}
{
create_ziplist mylist
{
0 1 2 3 4 5 6 7 8 9
}
r rpush mylist $i
assert_equal
{
1 2 3 4 5 6 7 8
}
[
r lrange mylist 1 -2
]
assert_equal
{
7 8 9
}
[
r lrange mylist -3 -1
]
assert_equal
{
4
}
[
r lrange mylist 4 4
]
}
}
list
[
r lrange mylist 1 -2
]
\
[
r lrange mylist -3 -1
]
\
[
r lrange mylist 4 4
]
}
{{
1 2 3 4 5 6 7 8
}
{
7 8 9
}
4
}
test
{
LRANGE inverted indexes
}
{
test
{
LRANGE basics - ziplist
}
{
r lrange mylist 6 2
create_regular_list mylist
{
0 1 2 3 4 5 6 7 8 9
}
}
{}
assert_equal
{
1 2 3 4 5 6 7 8
}
[
r lrange mylist 1 -2
]
assert_equal
{
7 8 9
}
[
r lrange mylist -3 -1
]
assert_equal
{
4
}
[
r lrange mylist 4 4
]
}
test
{
LRANGE inverted indexes - ziplist
}
{
create_ziplist mylist
{
0 1 2 3 4 5 6 7 8 9
}
assert_equal
{}
[
r lrange mylist 6 2
]
}
test
{
LRANGE inverted indexes - regular list
}
{
create_regular_list mylist
{
0 1 2 3 4 5 6 7 8 9
}
assert_equal
{}
[
r lrange mylist 6 2
]
}
test
{
LRANGE out of range indexes including the full list - ziplist
}
{
create_ziplist mylist
{
1 2 3
}
assert_equal
{
1 2 3
}
[
r lrange mylist -1000 1000
]
}
test
{
LRANGE out of range indexes including the full list
}
{
test
{
LRANGE out of range indexes including the full list - regular list
}
{
r lrange mylist -1000 1000
create_regular_list mylist
{
1 2 3
}
}
{
0 1 2 3 4 5 6 7 8 9
}
assert_equal
{
1 2 3
}
[
r lrange mylist -1000 1000
]
}
test
{
LRANGE against non existing key
}
{
test
{
LRANGE against non existing key
}
{
r lrange nosuchkey 0 1
assert_equal
{}
[
r lrange nosuchkey 0 1
]
}
{}
}
test
{
LTRIM basics - ziplist
}
{
r del mylist
r lpush mylist
"aaa"
assert_encoding ziplist mylist
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
r lpush mylist $i
r ltrim mylist 0 4
}
r lrange mylist 0 -1
}
{
99 98 97 96 95
}
test
{
LTRIM basics
}
{
test
{
LTRIM basics
- regular list
}
{
r del mylist
r del mylist
r lpush mylist
"aaaaaaaaaaaaaaaaa"
assert_encoding list mylist
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 100
}
{
incr i
}
{
r lpush mylist $i
r lpush mylist $i
r ltrim mylist 0 4
r ltrim mylist 0 4
...
@@ -223,106 +358,103 @@ start_server {tags {"list"}} {
...
@@ -223,106 +358,103 @@ start_server {tags {"list"}} {
r lrange mylist 0 -1
r lrange mylist 0 -1
}
{
99 98 97 96 95
}
}
{
99 98 97 96 95
}
test
{
LTRIM stress testing
}
{
test
{
LTRIM stress testing
- ziplist
}
{
set mylist
{}
set mylist
{}
set err
{}
for
{
set i 0
}
{
$i
< 20
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 20
}
{
incr i
}
{
lappend mylist $i
lappend mylist $i
}
}
for
{
set j 0
}
{
$j
< 100
}
{
incr j
}
{
for
{
set j 0
}
{
$j
< 100
}
{
incr j
}
{
# Fill the list
create_ziplist mylist $mylist
r del mylist
# Trim at random
set a
[
randomInt 20
]
set b
[
randomInt 20
]
r ltrim mylist $a $b
assert_equal
[
lrange $mylist $a $b
]
[
r lrange mylist 0 -1
]
}
}
test
{
LTRIM stress testing - regular list
}
{
set mylist
{}
for
{
set i 0
}
{
$i
< 20
}
{
incr i
}
{
for
{
set i 0
}
{
$i
< 20
}
{
incr i
}
{
r rpush
mylist $i
lappend
mylist $i
}
}
for
{
set j 0
}
{
$j
< 100
}
{
incr j
}
{
create_regular_list mylist $mylist
# Trim at random
# Trim at random
set a
[
randomInt 20
]
set a
[
randomInt 20
]
set b
[
randomInt 20
]
set b
[
randomInt 20
]
r ltrim mylist $a $b
r ltrim mylist $a $b
if
{[
r lrange mylist 0 -1
]
ne
[
lrange $mylist $a $b
]}
{
assert_equal
[
lrange $mylist $a $b
]
[
r lrange mylist 0 -1
]
set err
"
[
r lrange mylist 0 -1
]
!=
[
lrange $mylist $a $b
]
"
break
}
}
}
}
set _ $err
}
{}
test
{
LSET
}
{
test
{
LSET - ziplist
}
{
r del mylist
create_ziplist mylist
{
99 98 97 96 95
}
foreach x
{
99 98 97 96 95
}
{
r lset mylist 1 foo
r rpush mylist $x
r lset mylist -1 bar
assert_equal
{
99 foo 97 96 bar
}
[
r lrange mylist 0 -1
]
}
test
{
LSET out of range index - ziplist
}
{
assert_error ERR*range*
{
r lset mylist 10 foo
}
}
}
test
{
LSET - regular list
}
{
create_regular_list mylist
{
99 98 97 96 95
}
r lset mylist 1 foo
r lset mylist 1 foo
r lset mylist -1 bar
r lset mylist -1 bar
r lrange mylist 0 -1
assert_equal
{
99 foo 97 96 bar
}
[
r lrange mylist 0 -1
]
}
{
99 foo 97 96 bar
}
}
test
{
LSET out of range index
}
{
test
{
LSET out of range index - regular list
}
{
catch
{
r lset mylist 10 foo
}
err
assert_error ERR*range*
{
r lset mylist 10 foo
}
format $err
}
}
{
ERR*range*
}
test
{
LSET against non existing key
}
{
test
{
LSET against non existing key
}
{
catch
{
r lset nosuchkey 10 foo
}
err
assert_error ERR*key*
{
r lset nosuchkey 10 foo
}
format $err
}
}
{
ERR*key*
}
test
{
LSET against non list value
}
{
test
{
LSET against non list value
}
{
r set nolist foobar
r set nolist foobar
catch
{
r lset nolist 0 foo
}
err
assert_error ERR*value*
{
r lset nolist 0 foo
}
format $err
}
}
{
ERR*value*
}
foreach type
{
ziplist regular_list
}
{
test
{
LREM, remove all the occurrences
}
{
set formatted_type
[
string map
{
"_"
" "
}
$type
]
r flushdb
r rpush mylist foo
test
"LREM remove all the occurrences -
$formatted
_type"
{
r rpush mylist bar
create_$type mylist
{
foo bar foobar foobared zap bar test foo
}
r rpush mylist foobar
assert_equal 2
[
r lrem mylist 0 bar
]
r rpush mylist foobared
assert_equal
{
foo foobar foobared zap test foo
}
[
r lrange mylist 0 -1
]
r rpush mylist zap
}
r rpush mylist bar
r rpush mylist test
test
"LREM remove the first occurrence -
$formatted
_type"
{
r rpush mylist foo
assert_equal 1
[
r lrem mylist 1 foo
]
set res
[
r lrem mylist 0 bar
]
assert_equal
{
foobar foobared zap test foo
}
[
r lrange mylist 0 -1
]
list
[
r lrange mylist 0 -1
]
$res
}
}
{{
foo foobar foobared zap test foo
}
2
}
test
"LREM remove non existing element -
$formatted
_type"
{
test
{
LREM, remove the first occurrence
}
{
assert_equal 0
[
r lrem mylist 1 nosuchelement
]
set res
[
r lrem mylist 1 foo
]
assert_equal
{
foobar foobared zap test foo
}
[
r lrange mylist 0 -1
]
list
[
r lrange mylist 0 -1
]
$res
}
}
{{
foobar foobared zap test foo
}
1
}
test
"LREM starting from tail with negative count -
$formatted
_type"
{
test
{
LREM, remove non existing element
}
{
create_$type mylist
{
foo bar foobar foobared zap bar test foo foo
}
set res
[
r lrem mylist 1 nosuchelement
]
assert_equal 1
[
r lrem mylist -1 bar
]
list
[
r lrange mylist 0 -1
]
$res
assert_equal
{
foo bar foobar foobared zap test foo foo
}
[
r lrange mylist 0 -1
]
}
{{
foobar foobared zap test foo
}
0
}
}
test
{
LREM, starting from tail with negative count
}
{
test
"LREM starting from tail with negative count (2) -
$formatted
_type"
{
r flushdb
assert_equal 2
[
r lrem mylist -2 foo
]
r rpush mylist foo
assert_equal
{
foo bar foobar foobared zap test
}
[
r lrange mylist 0 -1
]
r rpush mylist bar
}
r rpush mylist foobar
r rpush mylist foobared
test
"LREM deleting objects that may be int encoded -
$formatted
_type"
{
r rpush mylist zap
create_$type myotherlist
{
1 2 3
}
r rpush mylist bar
assert_equal 1
[
r lrem myotherlist 1 2
]
r rpush mylist test
assert_equal 2
[
r llen myotherlist
]
r rpush mylist foo
}
r rpush mylist foo
}
set res
[
r lrem mylist -1 bar
]
list
[
r lrange mylist 0 -1
]
$res
}
{{
foo bar foobar foobared zap test foo foo
}
1
}
test
{
LREM, starting from tail with negative count
(
2
)}
{
set res
[
r lrem mylist -2 foo
]
list
[
r lrange mylist 0 -1
]
$res
}
{{
foo bar foobar foobared zap test
}
2
}
test
{
LREM, deleting objects that may be encoded as integers
}
{
r lpush myotherlist 1
r lpush myotherlist 2
r lpush myotherlist 3
r lrem myotherlist 1 2
r llen myotherlist
}
{
2
}
}
}
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