1 start_server
{tags
{"basic"}} {
2 test
{DEL all keys to start with a clean DB
} {
3 foreach key
[r keys
*] {r del
$key}
7 test
{SET and GET an item
} {
12 test
{SET and GET an empty item
} {
17 test
{DEL against a single item
} {
26 list [r del foo1 foo2 foo3 foo4
] [r mget foo1 foo2 foo3
]
29 test
{KEYS with pattern
} {
30 foreach key
{key_x key_y key_z foo_a foo_b foo_c
} {
36 test
{KEYS to get all keys
} {
38 } {foo_a foo_b foo_c key_x key_y key_z
}
45 foreach key
[r keys
*] {r del
$key}
49 test
{Very big payload in GET
/SET
} {
50 set buf
[string repeat
"abcd" 1000000]
53 } [string repeat
"abcd" 1000000]
56 test
{Very big payload random access
} {
59 for {set j
0} {$j < 100} {incr j
} {
60 set size
[expr 1+[randomInt
100000]]
61 set buf
[string repeat
"pl-$j" $size]
63 r
set bigpayload_
$j $buf
65 for {set j
0} {$j < 1000} {incr j
} {
66 set index
[randomInt
100]
67 set buf
[r get bigpayload_
$index]
68 if {$buf != $payload($index)} {
69 set err
"Values differ: I set '$payload($index)' but I read back '$buf'"
77 test
{SET
10000 numeric keys and access all them in reverse order
} {
79 for {set x
0} {$x < 10000} {incr x
} {
83 for {set x
9999} {$x >= 0} {incr x
-1} {
86 set err
"Eleemnt at position $x is $val instead of $x"
93 test
{DBSIZE should be
10101 now
} {
98 test
{INCR against non existing key
} {
100 append res
[r
incr novar
]
101 append res
[r get novar
]
104 test
{INCR against key created by
incr itself
} {
108 test
{INCR against key originally
set with SET
} {
113 test
{INCR over
32bit value
} {
114 r
set novar
17179869184
118 test
{INCRBY over
32bit value with over
32bit increment
} {
119 r
set novar
17179869184
120 r incrby novar
17179869184
123 test
{INCR fails against key with spaces
(no integer encoded
)} {
125 catch {r
incr novar
} err
129 test
{INCR fails against a key holding a
list} {
131 catch {r
incr mylist
} err
136 test
{DECRBY over
32bit value with over
32bit increment
, negative res
} {
137 r
set novar
17179869184
138 r decrby novar
17179869185
141 test
{SETNX target key missing
} {
142 r setnx novar2 foobared
146 test
{SETNX target key exists
} {
147 r setnx novar2 blabla
151 test
{SETNX against volatile key
} {
154 list [r setnx x
20] [r get x
]
160 append res
[r exists newkey
]
162 append res
[r exists newkey
]
165 test
{Zero length value in key. SET
/GET
/EXISTS
} {
167 set res
[r get emptykey
]
168 append res
[r exists emptykey
]
170 append res
[r exists emptykey
]
173 test
{Commands pipelining
} {
175 puts -nonewline $fd "SET k1 xyzk\r\nGET k1\r\nPING\r\n"
178 append res
[string match OK
* [::redis::redis_read_reply $fd]]
179 append res
[::redis::redis_read_reply $fd]
180 append res
[string match PONG
* [::redis::redis_read_reply $fd]]
184 test
{Non existing command
} {
185 catch {r foobaredcommand
} err
186 string match ERR
* $err
189 test
{RENAME basic usage
} {
191 r
rename mykey mykey1
192 r
rename mykey1 mykey2
196 test
{RENAME
source key should no longer exist
} {
200 test
{RENAME against already existing key
} {
203 r
rename mykey2 mykey
204 set res
[r get mykey
]
205 append res
[r exists mykey2
]
208 test
{RENAMENX basic usage
} {
212 r renamenx mykey mykey2
213 set res
[r get mykey2
]
214 append res
[r exists mykey
]
217 test
{RENAMENX against already existing key
} {
220 r renamenx mykey mykey2
223 test
{RENAMENX against already existing key
(2)} {
224 set res
[r get mykey
]
225 append res
[r get mykey2
]
228 test
{RENAME against non existing
source key
} {
229 catch {r
rename nokey foobar
} err
233 test
{RENAME where
source and dest key is the same
} {
234 catch {r
rename mykey mykey
} err
238 test
{DEL all keys again
(DB
0)} {
239 foreach key
[r keys
*] {
245 test
{DEL all keys again
(DB
1)} {
247 foreach key
[r keys
*] {
255 test
{MOVE basic usage
} {
259 lappend res
[r exists mykey
]
260 lappend res
[r dbsize
]
262 lappend res
[r get mykey
]
263 lappend res
[r dbsize
]
266 } [list 0 0 foobar
1]
268 test
{MOVE against key existing in the target DB
} {
273 test
{SET
/GET keys in different DBs
} {
281 lappend res
[r get a
]
282 lappend res
[r get b
]
284 lappend res
[r get a
]
285 lappend res
[r get b
]
288 } {hello world foo bared
}
297 test
{MGET against non existing key
} {
301 test
{MGET against non-string key
} {
304 r mget foo baazz bar myset
313 for {set i
0} {$i < 100} {incr i
} {
314 set rkey
[r randomkey
]
315 if {$rkey eq
{foo
}} {
318 if {$rkey eq
{bar
}} {
322 list $foo_seen $bar_seen
325 test
{RANDOMKEY against empty DB
} {
330 test
{RANDOMKEY regression
1} {
337 test
{GETSET
(set new value
)} {
338 list [r getset foo xyz
] [r get foo
]
341 test
{GETSET
(replace old value
)} {
343 list [r getset foo xyz
] [r get foo
]
346 test
{MSET base case
} {
347 r mset x
10 y
"foo bar" z
"x x x x x x x\n\n\r\n"
349 } [list 10 {foo bar
} "x x x x x x x\n\n\r\n"]
351 test
{MSET wrong number of args
} {
352 catch {r mset x
10 y
"foo bar" z
} err
356 test
{MSETNX with already existent key
} {
357 list [r msetnx x1 xxx y2 yyy x
20] [r exists x1
] [r exists y2
]
360 test
{MSETNX with not existing keys
} {
361 list [r msetnx x1 xxx y2 yyy
] [r get x1
] [r get y2
]
364 test
{STRLEN against non existing key
} {
368 test
{STRLEN against integer
} {
373 test
{STRLEN against plain
string} {
374 r
set mystring
"foozzz0123456789 baz"
378 test
"SETBIT against non-existing key" {
380 assert_equal
0 [r setbit mykey
1 1]
381 assert_equal
[binary format B
* 01000000] [r get mykey
]
384 test
"SETBIT against string-encoded key" {
385 # Ascii "@" is integer 64 = 01 00 00 00
388 assert_equal
0 [r setbit mykey
2 1]
389 assert_equal
[binary format B
* 01100000] [r get mykey
]
390 assert_equal
1 [r setbit mykey
1 0]
391 assert_equal
[binary format B
* 00100000] [r get mykey
]
394 test
"SETBIT against integer-encoded key" {
395 # Ascii "1" is integer 49 = 00 11 00 01
397 assert_encoding int mykey
399 assert_equal
0 [r setbit mykey
6 1]
400 assert_equal
[binary format B
* 00110011] [r get mykey
]
401 assert_equal
1 [r setbit mykey
2 0]
402 assert_equal
[binary format B
* 00010011] [r get mykey
]
405 test
"SETBIT against key with wrong type" {
408 assert_error
"*wrong kind*" {r setbit mykey
0 1}
411 test
"SETBIT with out of range bit offset" {
413 assert_error
"*out of range*" {r setbit mykey
[expr 4*1024*1024*1024] 1}
414 assert_error
"*out of range*" {r setbit mykey
-1 1}
417 test
"SETBIT with non-bit argument" {
419 assert_error
"*out of range*" {r setbit mykey
0 -1}
420 assert_error
"*out of range*" {r setbit mykey
0 2}
421 assert_error
"*out of range*" {r setbit mykey
0 10}
422 assert_error
"*out of range*" {r setbit mykey
0 20}
425 test
"GETBIT against non-existing key" {
427 assert_equal
0 [r getbit mykey
0]
430 test
"GETBIT against string-encoded key" {
431 # Single byte with 2nd and 3rd bit set
435 assert_equal
0 [r getbit mykey
0]
436 assert_equal
1 [r getbit mykey
1]
437 assert_equal
1 [r getbit mykey
2]
438 assert_equal
0 [r getbit mykey
3]
441 assert_equal
0 [r getbit mykey
8]
442 assert_equal
0 [r getbit mykey
100]
443 assert_equal
0 [r getbit mykey
10000]
446 test
"GETBIT against integer-encoded key" {
448 assert_encoding int mykey
450 # Ascii "1" is integer 49 = 00 11 00 01
451 assert_equal
0 [r getbit mykey
0]
452 assert_equal
0 [r getbit mykey
1]
453 assert_equal
1 [r getbit mykey
2]
454 assert_equal
1 [r getbit mykey
3]
457 assert_equal
0 [r getbit mykey
8]
458 assert_equal
0 [r getbit mykey
100]
459 assert_equal
0 [r getbit mykey
10000]
462 test
"SETRANGE against non-existing key" {
464 assert_equal
3 [r setrange mykey
0 foo
]
465 assert_equal
"foo" [r get mykey
]
468 assert_equal
0 [r setrange mykey
0 ""]
469 assert_equal
0 [r exists mykey
]
472 assert_equal
4 [r setrange mykey
1 foo
]
473 assert_equal
"\000foo" [r get mykey
]
476 assert_equal
3 [r setrange mykey
-1 foo
]
477 assert_equal
"foo" [r get mykey
]
480 assert_equal
3 [r setrange mykey
-100 foo
]
481 assert_equal
"foo" [r get mykey
]
484 test
"SETRANGE against string-encoded key" {
486 assert_equal
3 [r setrange mykey
0 b
]
487 assert_equal
"boo" [r get mykey
]
490 assert_equal
3 [r setrange mykey
0 ""]
491 assert_equal
"foo" [r get mykey
]
494 assert_equal
3 [r setrange mykey
1 b
]
495 assert_equal
"fbo" [r get mykey
]
498 assert_equal
6 [r setrange mykey
-1 bar
]
499 assert_equal
"foobar" [r get mykey
]
502 assert_equal
5 [r setrange mykey
-2 bar
]
503 assert_equal
"fobar" [r get mykey
]
506 assert_equal
3 [r setrange mykey
-20 bar
]
507 assert_equal
"bar" [r get mykey
]
510 assert_equal
7 [r setrange mykey
4 bar
]
511 assert_equal
"foo\000bar" [r get mykey
]
514 test
"SETRANGE against integer-encoded key" {
516 assert_encoding int mykey
517 assert_equal
4 [r setrange mykey
0 2]
518 assert_encoding raw mykey
519 assert_equal
2234 [r get mykey
]
521 # Shouldn't change encoding when nothing is set
523 assert_encoding int mykey
524 assert_equal
4 [r setrange mykey
0 ""]
525 assert_encoding int mykey
526 assert_equal
1234 [r get mykey
]
529 assert_encoding int mykey
530 assert_equal
4 [r setrange mykey
1 3]
531 assert_encoding raw mykey
532 assert_equal
1334 [r get mykey
]
535 assert_encoding int mykey
536 assert_equal
5 [r setrange mykey
-1 5]
537 assert_encoding raw mykey
538 assert_equal
12345 [r get mykey
]
541 assert_encoding int mykey
542 assert_equal
4 [r setrange mykey
-2 5]
543 assert_encoding raw mykey
544 assert_equal
1235 [r get mykey
]
547 assert_encoding int mykey
548 assert_equal
6 [r setrange mykey
5 2]
549 assert_encoding raw mykey
550 assert_equal
"1234\0002" [r get mykey
]
553 test
"SETRANGE against key with wrong type" {
556 assert_error
"*wrong kind*" {r setrange mykey
0 bar
}
559 test
"SETRANGE with out of range offset" {
561 assert_error
"*maximum allowed size*" {r setrange mykey
[expr 512*1024*1024-4] world
}
563 assert_error
"*maximum allowed size*" {r setrange mykey
[expr 512*1024*1024-4] world
}
566 test
"GETRANGE against non-existing key" {
568 assert_equal
"" [r getrange mykey
0 -1]
571 test
"GETRANGE against string value" {
572 r
set mykey
"Hello World"
573 assert_equal
"Hell" [r getrange mykey
0 3]
574 assert_equal
"Hello World" [r getrange mykey
0 -1]
575 assert_equal
"orld" [r getrange mykey
-4 -1]
576 assert_equal
"" [r getrange mykey
5 3]
577 assert_equal
" World" [r getrange mykey
5 5000]
578 assert_equal
"Hello World" [r getrange mykey
-5000 10000]
581 test
"GETRANGE against integer-encoded value" {
583 assert_equal
"123" [r getrange mykey
0 2]
584 assert_equal
"1234" [r getrange mykey
0 -1]
585 assert_equal
"234" [r getrange mykey
-3 -1]
586 assert_equal
"" [r getrange mykey
5 3]
587 assert_equal
"4" [r getrange mykey
3 5000]
588 assert_equal
"1234" [r getrange mykey
-5000 10000]
591 test
"GETRANGE fuzzing" {
592 for {set i
0} {$i < 1000} {incr i
} {
593 r
set bin
[set bin
[randstring
0 1024 binary]]
594 set _start
[set start
[randomInt
1500]]
595 set _end
[set end
[randomInt
1500]]
596 if {$_start < 0} {set _start
"end-[abs($_start)-1]"}
597 if {$_end < 0} {set _end
"end-[abs($_end)-1]"}
598 assert_equal
[string range
$bin $_start $_end] [r getrange bin
$start $end]