]> git.saurik.com Git - redis.git/blame - test-redis.tcl
SDIFF/SDIFFSTORE implemnted unifying it with the implementation of SUNION/SUNIONSTORE
[redis.git] / test-redis.tcl
CommitLineData
ed9b544e 1# TODO # test pipelining
2
43c9dc7b 3source client-libraries/tcl/redis.tcl
4
ed9b544e 5set ::passed 0
6set ::failed 0
7
8proc test {name code okpattern} {
9 puts -nonewline [format "%-70s " $name]
10 flush stdout
11 set retval [uplevel 1 $code]
12 if {$okpattern eq $retval || [string match $okpattern $retval]} {
13 puts "PASSED"
14 incr ::passed
15 } else {
16 puts "!! ERROR expected\n'$okpattern'\nbut got\n'$retval'"
17 incr ::failed
18 }
19}
20
75398fbc 21proc randstring {min max {type binary}} {
22 set len [expr {$min+int(rand()*($max-$min+1))}]
23 set output {}
24 if {$type eq {binary}} {
25 set minval 0
26 set maxval 255
27 } elseif {$type eq {alpha}} {
28 set minval 48
29 set maxval 122
30 } elseif {$type eq {compr}} {
31 set minval 48
32 set maxval 52
33 }
34 while {$len} {
35 append output [format "%c" [expr {$minval+int(rand()*($maxval-$minval+1))}]]
36 incr len -1
37 }
38 return $output
39}
40
ed9b544e 41proc main {server port} {
43c9dc7b 42 set r [redis $server $port]
43 set err ""
ed9b544e 44
abcb223e
BH
45 # The following AUTH test should be enabled only when requirepass
46 # <PASSWORD> is set in redis.conf and redis-server was started with
47 # redis.conf as the first argument.
48
49 #test {AUTH with requirepass in redis.conf} {
50 # $r auth foobared
51 #} {OK}
52
ed9b544e 53 test {DEL all keys to start with a clean DB} {
43c9dc7b 54 foreach key [$r keys *] {$r del $key}
55 $r dbsize
ed9b544e 56 } {0}
57
58 test {SET and GET an item} {
43c9dc7b 59 $r set x foobar
60 $r get x
ed9b544e 61 } {foobar}
62
63 test {DEL against a single item} {
43c9dc7b 64 $r del x
65 $r get x
ed9b544e 66 } {}
67
cc582a77 68 test {Vararg DEL} {
69 $r set foo1 a
70 $r set foo2 b
71 $r set foo3 c
72 list [$r del foo1 foo2 foo3 foo4] [$r mget foo1 foo2 foo3]
73 } {3 {{} {} {}}}
74
ed9b544e 75 test {KEYS with pattern} {
76 foreach key {key_x key_y key_z foo_a foo_b foo_c} {
43c9dc7b 77 $r set $key hello
ed9b544e 78 }
43c9dc7b 79 lsort [$r keys foo*]
ed9b544e 80 } {foo_a foo_b foo_c}
81
82 test {KEYS to get all keys} {
43c9dc7b 83 lsort [$r keys *]
ed9b544e 84 } {foo_a foo_b foo_c key_x key_y key_z}
85
86 test {DBSIZE} {
43c9dc7b 87 $r dbsize
ed9b544e 88 } {6}
89
90 test {DEL all keys} {
43c9dc7b 91 foreach key [$r keys *] {$r del $key}
92 $r dbsize
ed9b544e 93 } {0}
94
95 test {Very big payload in GET/SET} {
96 set buf [string repeat "abcd" 1000000]
43c9dc7b 97 $r set foo $buf
98 $r get foo
ed9b544e 99 } [string repeat "abcd" 1000000]
100
101 test {SET 10000 numeric keys and access all them in reverse order} {
102 for {set x 0} {$x < 10000} {incr x} {
43c9dc7b 103 $r set $x $x
ed9b544e 104 }
105 set sum 0
106 for {set x 9999} {$x >= 0} {incr x -1} {
43c9dc7b 107 incr sum [$r get $x]
ed9b544e 108 }
109 format $sum
110 } {49995000}
111
112 test {DBSIZE should be 10001 now} {
43c9dc7b 113 $r dbsize
ed9b544e 114 } {10001}
115
116 test {INCR against non existing key} {
117 set res {}
43c9dc7b 118 append res [$r incr novar]
119 append res [$r get novar]
ed9b544e 120 } {11}
121
122 test {INCR against key created by incr itself} {
43c9dc7b 123 $r incr novar
ed9b544e 124 } {2}
125
126 test {INCR against key originally set with SET} {
43c9dc7b 127 $r set novar 100
128 $r incr novar
ed9b544e 129 } {101}
130
d68ed120 131 test {INCR over 32bit value} {
132 $r set novar 17179869184
133 $r incr novar
134 } {17179869185}
135
136 test {INCRBY over 32bit value with over 32bit increment} {
137 $r set novar 17179869184
138 $r incrby novar 17179869184
139 } {34359738368}
140
141 test {DECRBY over 32bit value with over 32bit increment, negative res} {
142 $r set novar 17179869184
143 $r decrby novar 17179869185
144 } {-1}
145
ed9b544e 146 test {SETNX target key missing} {
43c9dc7b 147 $r setnx novar2 foobared
148 $r get novar2
ed9b544e 149 } {foobared}
150
151 test {SETNX target key exists} {
43c9dc7b 152 $r setnx novar2 blabla
153 $r get novar2
ed9b544e 154 } {foobared}
155
156 test {EXISTS} {
157 set res {}
43c9dc7b 158 $r set newkey test
159 append res [$r exists newkey]
160 $r del newkey
161 append res [$r exists newkey]
ed9b544e 162 } {10}
163
164 test {Zero length value in key. SET/GET/EXISTS} {
43c9dc7b 165 $r set emptykey {}
166 set res [$r get emptykey]
167 append res [$r exists emptykey]
168 $r del emptykey
169 append res [$r exists emptykey]
ed9b544e 170 } {10}
171
172 test {Commands pipelining} {
43c9dc7b 173 set fd [$r channel]
ed9b544e 174 puts -nonewline $fd "SET k1 4\r\nxyzk\r\nGET k1\r\nPING\r\n"
175 flush $fd
176 set res {}
43c9dc7b 177 append res [string match OK* [::redis::redis_read_reply $fd]]
178 append res [::redis::redis_read_reply $fd]
179 append res [string match PONG* [::redis::redis_read_reply $fd]]
ed9b544e 180 format $res
181 } {1xyzk1}
182
183 test {Non existing command} {
43c9dc7b 184 catch {$r foobaredcommand} err
185 string match ERR* $err
ed9b544e 186 } {1}
187
188 test {Basic LPUSH, RPUSH, LLENGTH, LINDEX} {
43c9dc7b 189 $r lpush mylist a
190 $r lpush mylist b
191 $r rpush mylist c
192 set res [$r llen mylist]
193 append res [$r lindex mylist 0]
194 append res [$r lindex mylist 1]
195 append res [$r lindex mylist 2]
ed9b544e 196 } {3bac}
197
198 test {DEL a list} {
43c9dc7b 199 $r del mylist
200 $r exists mylist
ed9b544e 201 } {0}
202
203 test {Create a long list and check every single element with LINDEX} {
204 set ok 0
205 for {set i 0} {$i < 1000} {incr i} {
43c9dc7b 206 $r rpush mylist $i
ed9b544e 207 }
208 for {set i 0} {$i < 1000} {incr i} {
43c9dc7b 209 if {[$r lindex mylist $i] eq $i} {incr ok}
210 if {[$r lindex mylist [expr (-$i)-1]] eq [expr 999-$i]} {
ed9b544e 211 incr ok
212 }
213 }
214 format $ok
215 } {2000}
216
217 test {Test elements with LINDEX in random access} {
218 set ok 0
219 for {set i 0} {$i < 1000} {incr i} {
43c9dc7b 220 set rint [expr int(rand()*1000)]
221 if {[$r lindex mylist $rint] eq $rint} {incr ok}
222 if {[$r lindex mylist [expr (-$rint)-1]] eq [expr 999-$rint]} {
ed9b544e 223 incr ok
224 }
225 }
226 format $ok
227 } {2000}
228
229 test {LLEN against non-list value error} {
43c9dc7b 230 $r del mylist
231 $r set mylist foobar
232 catch {$r llen mylist} err
233 format $err
c937aa89 234 } {ERR*}
ed9b544e 235
236 test {LINDEX against non-list value error} {
43c9dc7b 237 catch {$r lindex mylist 0} err
238 format $err
c937aa89 239 } {ERR*}
ed9b544e 240
241 test {LPUSH against non-list value error} {
43c9dc7b 242 catch {$r lpush mylist 0} err
243 format $err
c937aa89 244 } {ERR*}
ed9b544e 245
246 test {RPUSH against non-list value error} {
43c9dc7b 247 catch {$r rpush mylist 0} err
248 format $err
c937aa89 249 } {ERR*}
ed9b544e 250
251 test {RENAME basic usage} {
43c9dc7b 252 $r set mykey hello
253 $r rename mykey mykey1
254 $r rename mykey1 mykey2
255 $r get mykey2
ed9b544e 256 } {hello}
257
258 test {RENAME source key should no longer exist} {
43c9dc7b 259 $r exists mykey
ed9b544e 260 } {0}
261
262 test {RENAME against already existing key} {
43c9dc7b 263 $r set mykey a
264 $r set mykey2 b
265 $r rename mykey2 mykey
266 set res [$r get mykey]
267 append res [$r exists mykey2]
ed9b544e 268 } {b0}
269
270 test {RENAMENX basic usage} {
43c9dc7b 271 $r del mykey
272 $r del mykey2
273 $r set mykey foobar
274 $r renamenx mykey mykey2
275 set res [$r get mykey2]
276 append res [$r exists mykey]
ed9b544e 277 } {foobar0}
278
279 test {RENAMENX against already existing key} {
43c9dc7b 280 $r set mykey foo
281 $r set mykey2 bar
282 $r renamenx mykey mykey2
ed9b544e 283 } {0}
284
285 test {RENAMENX against already existing key (2)} {
43c9dc7b 286 set res [$r get mykey]
287 append res [$r get mykey2]
ed9b544e 288 } {foobar}
289
290 test {RENAME against non existing source key} {
43c9dc7b 291 catch {$r rename nokey foobar} err
292 format $err
c937aa89 293 } {ERR*}
ed9b544e 294
295 test {RENAME where source and dest key is the same} {
43c9dc7b 296 catch {$r rename mykey mykey} err
297 format $err
c937aa89 298 } {ERR*}
ed9b544e 299
300 test {DEL all keys again (DB 0)} {
43c9dc7b 301 foreach key [$r keys *] {
302 $r del $key
ed9b544e 303 }
43c9dc7b 304 $r dbsize
ed9b544e 305 } {0}
306
307 test {DEL all keys again (DB 1)} {
43c9dc7b 308 $r select 1
309 foreach key [$r keys *] {
310 $r del $key
ed9b544e 311 }
43c9dc7b 312 set res [$r dbsize]
313 $r select 0
ed9b544e 314 format $res
315 } {0}
316
317 test {MOVE basic usage} {
43c9dc7b 318 $r set mykey foobar
319 $r move mykey 1
ed9b544e 320 set res {}
43c9dc7b 321 lappend res [$r exists mykey]
322 lappend res [$r dbsize]
323 $r select 1
324 lappend res [$r get mykey]
325 lappend res [$r dbsize]
326 $r select 0
ed9b544e 327 format $res
328 } [list 0 0 foobar 1]
329
330 test {MOVE against key existing in the target DB} {
43c9dc7b 331 $r set mykey hello
332 $r move mykey 1
ed9b544e 333 } {0}
334
335 test {SET/GET keys in different DBs} {
43c9dc7b 336 $r set a hello
337 $r set b world
338 $r select 1
339 $r set a foo
340 $r set b bared
341 $r select 0
ed9b544e 342 set res {}
43c9dc7b 343 lappend res [$r get a]
344 lappend res [$r get b]
345 $r select 1
346 lappend res [$r get a]
347 lappend res [$r get b]
348 $r select 0
ed9b544e 349 format $res
350 } {hello world foo bared}
351
352 test {Basic LPOP/RPOP} {
43c9dc7b 353 $r del mylist
354 $r rpush mylist 1
355 $r rpush mylist 2
356 $r lpush mylist 0
357 list [$r lpop mylist] [$r rpop mylist] [$r lpop mylist] [$r llen mylist]
ed9b544e 358 } [list 0 2 1 0]
359
360 test {LPOP/RPOP against empty list} {
43c9dc7b 361 $r lpop mylist
ed9b544e 362 } {}
363
364 test {LPOP against non list value} {
43c9dc7b 365 $r set notalist foo
366 catch {$r lpop notalist} err
367 format $err
c937aa89 368 } {ERR*kind*}
ed9b544e 369
370 test {Mass LPUSH/LPOP} {
371 set sum 0
372 for {set i 0} {$i < 1000} {incr i} {
43c9dc7b 373 $r lpush mylist $i
ed9b544e 374 incr sum $i
375 }
376 set sum2 0
377 for {set i 0} {$i < 500} {incr i} {
43c9dc7b 378 incr sum2 [$r lpop mylist]
379 incr sum2 [$r rpop mylist]
ed9b544e 380 }
381 expr $sum == $sum2
382 } {1}
383
384 test {LRANGE basics} {
385 for {set i 0} {$i < 10} {incr i} {
43c9dc7b 386 $r rpush mylist $i
ed9b544e 387 }
43c9dc7b 388 list [$r lrange mylist 1 -2] \
389 [$r lrange mylist -3 -1] \
390 [$r lrange mylist 4 4]
ed9b544e 391 } {{1 2 3 4 5 6 7 8} {7 8 9} 4}
392
393 test {LRANGE inverted indexes} {
43c9dc7b 394 $r lrange mylist 6 2
ed9b544e 395 } {}
396
397 test {LRANGE out of range indexes including the full list} {
43c9dc7b 398 $r lrange mylist -1000 1000
ed9b544e 399 } {0 1 2 3 4 5 6 7 8 9}
400
401 test {LRANGE against non existing key} {
43c9dc7b 402 $r lrange nosuchkey 0 1
ed9b544e 403 } {}
404
405 test {LTRIM basics} {
43c9dc7b 406 $r del mylist
ed9b544e 407 for {set i 0} {$i < 100} {incr i} {
43c9dc7b 408 $r lpush mylist $i
409 $r ltrim mylist 0 4
ed9b544e 410 }
43c9dc7b 411 $r lrange mylist 0 -1
ed9b544e 412 } {99 98 97 96 95}
413
414 test {LSET} {
43c9dc7b 415 $r lset mylist 1 foo
416 $r lset mylist -1 bar
417 $r lrange mylist 0 -1
ed9b544e 418 } {99 foo 97 96 bar}
419
420 test {LSET out of range index} {
43c9dc7b 421 catch {$r lset mylist 10 foo} err
422 format $err
c937aa89 423 } {ERR*range*}
ed9b544e 424
425 test {LSET against non existing key} {
43c9dc7b 426 catch {$r lset nosuchkey 10 foo} err
427 format $err
c937aa89 428 } {ERR*key*}
ed9b544e 429
430 test {LSET against non list value} {
43c9dc7b 431 $r set nolist foobar
432 catch {$r lset nolist 0 foo} err
433 format $err
c937aa89 434 } {ERR*value*}
ed9b544e 435
436 test {SADD, SCARD, SISMEMBER, SMEMBERS basics} {
43c9dc7b 437 $r sadd myset foo
438 $r sadd myset bar
439 list [$r scard myset] [$r sismember myset foo] \
440 [$r sismember myset bar] [$r sismember myset bla] \
441 [lsort [$r smembers myset]]
ed9b544e 442 } {2 1 1 0 {bar foo}}
443
444 test {SADD adding the same element multiple times} {
43c9dc7b 445 $r sadd myset foo
446 $r sadd myset foo
447 $r sadd myset foo
448 $r scard myset
ed9b544e 449 } {2}
450
451 test {SADD against non set} {
43c9dc7b 452 catch {$r sadd mylist foo} err
453 format $err
c937aa89 454 } {ERR*kind*}
ed9b544e 455
456 test {SREM basics} {
43c9dc7b 457 $r sadd myset ciao
458 $r srem myset foo
459 lsort [$r smembers myset]
ed9b544e 460 } {bar ciao}
461
462 test {Mass SADD and SINTER with two sets} {
463 for {set i 0} {$i < 1000} {incr i} {
43c9dc7b 464 $r sadd set1 $i
465 $r sadd set2 [expr $i+995]
ed9b544e 466 }
43c9dc7b 467 lsort [$r sinter set1 set2]
ed9b544e 468 } {995 996 997 998 999}
40d224a9 469
470 test {SUNION with two sets} {
471 lsort [$r sunion set1 set2]
472 } [lsort -uniq "[$r smembers set1] [$r smembers set2]"]
ed9b544e 473
474 test {SINTERSTORE with two sets} {
43c9dc7b 475 $r sinterstore setres set1 set2
476 lsort [$r smembers setres]
ed9b544e 477 } {995 996 997 998 999}
478
40d224a9 479 test {SUNIONSTORE with two sets} {
480 $r sunionstore setres set1 set2
481 lsort [$r smembers setres]
482 } [lsort -uniq "[$r smembers set1] [$r smembers set2]"]
483
ed9b544e 484 test {SINTER against three sets} {
43c9dc7b 485 $r sadd set3 999
486 $r sadd set3 995
487 $r sadd set3 1000
488 $r sadd set3 2000
489 lsort [$r sinter set1 set2 set3]
ed9b544e 490 } {995 999}
491
492 test {SINTERSTORE with three sets} {
43c9dc7b 493 $r sinterstore setres set1 set2 set3
494 lsort [$r smembers setres]
ed9b544e 495 } {995 999}
40d224a9 496
497 test {SUNION with non existing keys} {
498 lsort [$r sunion nokey1 set1 set2 nokey2]
499 } [lsort -uniq "[$r smembers set1] [$r smembers set2]"]
500
f4f56e1d 501 test {SDIFF with two sets} {
502 for {set i 5} {$i < 1000} {incr i} {
503 $r sadd set4 $i
504 }
505 lsort [$r sdiff set1 set4]
506 } {0 1 2 3 4}
507
508 test {SDIFF with three sets} {
509 $r sadd set5 0
510 lsort [$r sdiff set1 set4 set5]
511 } {1 2 3 4}
512
513 test {SDIFFSTORE with three sets} {
514 $r sdiffstore sres set1 set4 set5
515 lsort [$r smembers sres]
516 } {1 2 3 4}
517
ed9b544e 518 test {SAVE - make sure there are all the types as values} {
43c9dc7b 519 $r lpush mysavelist hello
520 $r lpush mysavelist world
521 $r set myemptykey {}
522 $r set mynormalkey {blablablba}
523 $r save
c937aa89 524 } {OK}
ed9b544e 525
526 test {Create a random list} {
527 set tosort {}
528 array set seenrand {}
529 for {set i 0} {$i < 10000} {incr i} {
530 while 1 {
531 # Make sure all the weights are different because
532 # Redis does not use a stable sort but Tcl does.
43c9dc7b 533 set rint [expr int(rand()*1000000)]
534 if {![info exists seenrand($rint)]} break
ed9b544e 535 }
43c9dc7b 536 set seenrand($rint) x
537 $r lpush tosort $i
538 $r set weight_$i $rint
539 lappend tosort [list $i $rint]
ed9b544e 540 }
541 set sorted [lsort -index 1 -real $tosort]
542 set res {}
543 for {set i 0} {$i < 10000} {incr i} {
544 lappend res [lindex $sorted $i 0]
545 }
546 format {}
547 } {}
548
549 test {SORT with BY against the newly created list} {
43c9dc7b 550 $r sort tosort {BY weight_*}
ed9b544e 551 } $res
552
553 test {SORT direct, numeric, against the newly created list} {
43c9dc7b 554 $r sort tosort
ed9b544e 555 } [lsort -integer $res]
556
557 test {SORT decreasing sort} {
43c9dc7b 558 $r sort tosort {DESC}
ed9b544e 559 } [lsort -decreasing -integer $res]
560
561 test {SORT speed, sorting 10000 elements list using BY, 100 times} {
562 set start [clock clicks -milliseconds]
563 for {set i 0} {$i < 100} {incr i} {
43c9dc7b 564 set sorted [$r sort tosort {BY weight_* LIMIT 0 10}]
ed9b544e 565 }
566 set elapsed [expr [clock clicks -milliseconds]-$start]
567 puts -nonewline "\n Average time to sort: [expr double($elapsed)/100] milliseconds "
568 flush stdout
569 format {}
570 } {}
571
572 test {SORT speed, sorting 10000 elements list directly, 100 times} {
573 set start [clock clicks -milliseconds]
574 for {set i 0} {$i < 100} {incr i} {
43c9dc7b 575 set sorted [$r sort tosort {LIMIT 0 10}]
ed9b544e 576 }
577 set elapsed [expr [clock clicks -milliseconds]-$start]
578 puts -nonewline "\n Average time to sort: [expr double($elapsed)/100] milliseconds "
579 flush stdout
580 format {}
581 } {}
582
583 test {SORT speed, pseudo-sorting 10000 elements list, BY <const>, 100 times} {
584 set start [clock clicks -milliseconds]
585 for {set i 0} {$i < 100} {incr i} {
43c9dc7b 586 set sorted [$r sort tosort {BY nokey LIMIT 0 10}]
ed9b544e 587 }
588 set elapsed [expr [clock clicks -milliseconds]-$start]
589 puts -nonewline "\n Average time to sort: [expr double($elapsed)/100] milliseconds "
590 flush stdout
591 format {}
592 } {}
593
594 test {SORT regression for issue #19, sorting floats} {
43c9dc7b 595 $r flushdb
ed9b544e 596 foreach x {1.1 5.10 3.10 7.44 2.1 5.75 6.12 0.25 1.15} {
43c9dc7b 597 $r lpush mylist $x
ed9b544e 598 }
43c9dc7b 599 $r sort mylist
ed9b544e 600 } [lsort -real {1.1 5.10 3.10 7.44 2.1 5.75 6.12 0.25 1.15}]
601
602 test {LREM, remove all the occurrences} {
43c9dc7b 603 $r flushall
604 $r rpush mylist foo
605 $r rpush mylist bar
606 $r rpush mylist foobar
607 $r rpush mylist foobared
608 $r rpush mylist zap
609 $r rpush mylist bar
610 $r rpush mylist test
611 $r rpush mylist foo
612 set res [$r lrem mylist 0 bar]
613 list [$r lrange mylist 0 -1] $res
ed9b544e 614 } {{foo foobar foobared zap test foo} 2}
615
616 test {LREM, remove the first occurrence} {
43c9dc7b 617 set res [$r lrem mylist 1 foo]
618 list [$r lrange mylist 0 -1] $res
ed9b544e 619 } {{foobar foobared zap test foo} 1}
620
621 test {LREM, remove non existing element} {
43c9dc7b 622 set res [$r lrem mylist 1 nosuchelement]
623 list [$r lrange mylist 0 -1] $res
ed9b544e 624 } {{foobar foobared zap test foo} 0}
625
626 test {LREM, starting from tail with negative count} {
43c9dc7b 627 $r flushall
628 $r rpush mylist foo
629 $r rpush mylist bar
630 $r rpush mylist foobar
631 $r rpush mylist foobared
632 $r rpush mylist zap
633 $r rpush mylist bar
634 $r rpush mylist test
635 $r rpush mylist foo
636 $r rpush mylist foo
637 set res [$r lrem mylist -1 bar]
638 list [$r lrange mylist 0 -1] $res
ed9b544e 639 } {{foo bar foobar foobared zap test foo foo} 1}
640
641 test {LREM, starting from tail with negative count (2)} {
43c9dc7b 642 set res [$r lrem mylist -2 foo]
643 list [$r lrange mylist 0 -1] $res
ed9b544e 644 } {{foo bar foobar foobared zap test} 2}
645
5b19bd72 646 test {MGET} {
43c9dc7b 647 $r flushall
648 $r set foo BAR
649 $r set bar FOO
650 $r mget foo bar
5b19bd72 651 } {BAR FOO}
652
653 test {MGET against non existing key} {
43c9dc7b 654 $r mget foo baazz bar
5b19bd72 655 } {BAR {} FOO}
656
657 test {MGET against non-string key} {
43c9dc7b 658 $r sadd myset ciao
659 $r sadd myset bau
660 $r mget foo baazz bar myset
5b19bd72 661 } {BAR {} FOO {}}
662
ce7bef07 663 test {RANDOMKEY} {
664 $r flushall
665 $r set foo x
666 $r set bar y
667 set foo_seen 0
668 set bar_seen 0
669 for {set i 0} {$i < 100} {incr i} {
670 set rkey [$r randomkey]
671 if {$rkey eq {foo}} {
672 set foo_seen 1
673 }
674 if {$rkey eq {bar}} {
675 set bar_seen 1
676 }
677 }
678 list $foo_seen $bar_seen
679 } {1 1}
680
681 test {RANDOMKEY against empty DB} {
682 $r flushall
683 $r randomkey
684 } {}
685
f5785ae9 686 test {RANDOMKEY regression 1} {
687 $r flushall
688 $r set x 10
689 $r del x
690 $r randomkey
691 } {}
692
7ac6d461 693 test {GETSET (set new value)} {
694 list [$r getset foo xyz] [$r get foo]
695 } {{} xyz}
696
697 test {GETSET (replace old value)} {
698 $r set foo bar
699 list [$r getset foo xyz] [$r get foo]
700 } {bar xyz}
701
0eeb2a4b 702 test {SMOVE basics} {
703 $r sadd myset1 a
704 $r sadd myset1 b
705 $r sadd myset1 c
706 $r sadd myset2 x
707 $r sadd myset2 y
708 $r sadd myset2 z
709 $r smove myset1 myset2 a
710 list [lsort [$r smembers myset2]] [lsort [$r smembers myset1]]
711 } {{a x y z} {b c}}
712
713 test {SMOVE non existing key} {
714 list [$r smove myset1 myset2 foo] [lsort [$r smembers myset2]] [lsort [$r smembers myset1]]
715 } {0 {a x y z} {b c}}
716
717 test {SMOVE non existing src set} {
718 list [$r smove noset myset2 foo] [lsort [$r smembers myset2]]
719 } {0 {a x y z}}
720
721 test {SMOVE non existing dst set} {
722 list [$r smove myset2 myset3 y] [lsort [$r smembers myset2]] [lsort [$r smembers myset3]]
723 } {1 {a x z} y}
724
725 test {SMOVE wrong src key type} {
726 $r set x 10
727 catch {$r smove x myset2 foo} err
728 format $err
729 } {ERR*}
730
731 test {SMOVE wrong dst key type} {
732 $r set x 10
733 catch {$r smove myset2 x foo} err
734 format $err
735 } {ERR*}
736
75398fbc 737 foreach fuzztype {binary alpha compr} {
738 test "FUZZ stresser with data model $fuzztype" {
739 set err 0
740 for {set i 0} {$i < 1000} {incr i} {
741 set fuzz [randstring 0 512 $fuzztype]
742 $r set foo $fuzz
743 set got [$r get foo]
744 if {$got ne $fuzz} {
745 incr err
746 break
747 }
748 }
749 format $err
750 } {0}
751 }
752
ed9b544e 753 # Leave the user with a clean DB before to exit
754 test {FLUSHALL} {
43c9dc7b 755 $r flushall
756 $r dbsize
ed9b544e 757 } {0}
758
759 puts "\n[expr $::passed+$::failed] tests, $::passed passed, $::failed failed"
760 if {$::failed > 0} {
761 puts "\n*** WARNING!!! $::failed FAILED TESTS ***\n"
762 }
763 close $fd
764}
765
5a6948fb 766proc stress {} {
43c9dc7b 767 set r [redis]
768 $r flushall
5a6948fb 769 while 1 {
770 set randkey [expr int(rand()*10000)]
771 set randval [expr int(rand()*10000)]
772 set randidx0 [expr int(rand()*10)]
773 set randidx1 [expr int(rand()*10)]
774 set cmd [expr int(rand()*10)]
43c9dc7b 775 catch {
776 if {$cmd == 0} {$r set $randkey $randval}
777 if {$cmd == 1} {$r get $randkey}
778 if {$cmd == 2} {$r incr $randkey}
779 if {$cmd == 3} {$r lpush $randkey $randval}
780 if {$cmd == 4} {$r rpop $randkey}
781 if {$cmd == 5} {$r del $randkey}
782 if {$cmd == 6} {$r lrange $randkey $randidx0 $randidx1}
783 if {$cmd == 7} {$r ltrim $randkey $randidx0 $randidx1}
784 if {$cmd == 8} {$r lindex $randkey $randidx0}
785 if {$cmd == 9} {$r lset $randkey $randidx0 $randval}
786 }
5a6948fb 787 flush stdout
788 }
43c9dc7b 789 $r close
5a6948fb 790}
791
ed9b544e 792if {[llength $argv] == 0} {
793 main 127.0.0.1 6379
5a6948fb 794} elseif {[llength $argv] == 1 && [lindex $argv 0] eq {stress}} {
795 stress
ed9b544e 796} else {
797 main [lindex $argv 0] [lindex $argv 1]
798}