X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/d68ed1201a8c29d98d63f206946de037b6c5b29d..2c65cbc9e3aa3ff189de3bfe207f4ee8f75edecb:/test-redis.tcl

diff --git a/test-redis.tcl b/test-redis.tcl
index 63df9764..a5182670 100644
--- a/test-redis.tcl
+++ b/test-redis.tcl
@@ -18,6 +18,26 @@ proc test {name code okpattern} {
     }
 }
 
+proc randstring {min max {type binary}} {
+    set len [expr {$min+int(rand()*($max-$min+1))}]
+    set output {}
+    if {$type eq {binary}} {
+        set minval 0
+        set maxval 255
+    } elseif {$type eq {alpha}} {
+        set minval 48
+        set maxval 122
+    } elseif {$type eq {compr}} {
+        set minval 48
+        set maxval 52
+    }
+    while {$len} {
+        append output [format "%c" [expr {$minval+int(rand()*($maxval-$minval+1))}]]
+        incr len -1
+    }
+    return $output
+}
+
 proc main {server port} {
     set r [redis $server $port]
     set err ""
@@ -45,6 +65,13 @@ proc main {server port} {
         $r get x
     } {}
 
+    test {Vararg DEL} {
+        $r set foo1 a
+        $r set foo2 b
+        $r set foo3 c
+        list [$r del foo1 foo2 foo3 foo4] [$r mget foo1 foo2 foo3]
+    } {3 {{} {} {}}}
+
     test {KEYS with pattern} {
         foreach key {key_x key_y key_z foo_a foo_b foo_c} {
             $r set $key hello
@@ -471,6 +498,31 @@ proc main {server port} {
         lsort [$r sunion nokey1 set1 set2 nokey2]
     } [lsort -uniq "[$r smembers set1] [$r smembers set2]"]
 
+    test {SDIFF with two sets} {
+        for {set i 5} {$i < 1000} {incr i} {
+            $r sadd set4 $i
+        }
+        lsort [$r sdiff set1 set4]
+    } {0 1 2 3 4}
+
+    test {SDIFF with three sets} {
+        $r sadd set5 0
+        lsort [$r sdiff set1 set4 set5]
+    } {1 2 3 4}
+
+    test {SDIFFSTORE with three sets} {
+        $r sdiffstore sres set1 set4 set5
+        lsort [$r smembers sres]
+    } {1 2 3 4}
+
+    test {SPOP basics} {
+        $r del myset
+        $r sadd myset 1
+        $r sadd myset 2
+        $r sadd myset 3
+        list [lsort [list [$r spop myset] [$r spop myset] [$r spop myset]]] [$r scard myset]
+    } {{1 2 3} 0}
+
     test {SAVE - make sure there are all the types as values} {
         $r lpush mysavelist hello
         $r lpush mysavelist world
@@ -599,6 +651,14 @@ proc main {server port} {
         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}
+
     test {MGET} {
         $r flushall
         $r set foo BAR
@@ -646,6 +706,84 @@ proc main {server port} {
         $r randomkey
     } {}
 
+    test {GETSET (set new value)} {
+        list [$r getset foo xyz] [$r get foo]
+    } {{} xyz}
+
+    test {GETSET (replace old value)} {
+        $r set foo bar
+        list [$r getset foo xyz] [$r get foo]
+    } {bar xyz}
+
+    test {SMOVE basics} {
+        $r sadd myset1 a
+        $r sadd myset1 b
+        $r sadd myset1 c
+        $r sadd myset2 x
+        $r sadd myset2 y
+        $r sadd myset2 z
+        $r smove myset1 myset2 a
+        list [lsort [$r smembers myset2]] [lsort [$r smembers myset1]]
+    } {{a x y z} {b c}}
+
+    test {SMOVE non existing key} {
+        list [$r smove myset1 myset2 foo] [lsort [$r smembers myset2]] [lsort [$r smembers myset1]]
+    } {0 {a x y z} {b c}}
+
+    test {SMOVE non existing src set} {
+        list [$r smove noset myset2 foo] [lsort [$r smembers myset2]]
+    } {0 {a x y z}}
+
+    test {SMOVE non existing dst set} {
+        list [$r smove myset2 myset3 y] [lsort [$r smembers myset2]] [lsort [$r smembers myset3]]
+    } {1 {a x z} y}
+
+    test {SMOVE wrong src key type} {
+        $r set x 10
+        catch {$r smove x myset2 foo} err
+        format $err
+    } {ERR*}
+
+    test {SMOVE wrong dst key type} {
+        $r set x 10
+        catch {$r smove myset2 x foo} err
+        format $err
+    } {ERR*}
+
+    test {MSET base case} {
+        $r mset x 10 y "foo bar" z "x x x x x x x\n\n\r\n"
+        $r mget x y z
+    } [list 10 {foo bar} "x x x x x x x\n\n\r\n"]
+
+    test {MSET wrong number of args} {
+        catch {$r mset x 10 y "foo bar" z} err
+        format $err
+    } {*wrong number*}
+
+    test {MSETNX with already existent key} {
+        list [$r msetnx x1 xxx y2 yyy x 20] [$r exists x1] [$r exists y2]
+    } {0 0 0}
+
+    test {MSETNX with not existing keys} {
+        list [$r msetnx x1 xxx y2 yyy] [$r get x1] [$r get y2]
+    } {1 xxx yyy}
+
+    foreach fuzztype {binary alpha compr} {
+        test "FUZZ stresser with data model $fuzztype" {
+            set err 0
+            for {set i 0} {$i < 10000} {incr i} {
+                set fuzz [randstring 0 512 $fuzztype]
+                $r set foo $fuzz
+                set got [$r get foo]
+                if {$got ne $fuzz} {
+                    set err [list $fuzz $got]
+                    break
+                }
+            }
+            set _ $err
+        } {0}
+    }
+
     # Leave the user with a clean DB before to exit
     test {FLUSHALL} {
         $r flushall