X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/51e01d9b39127eb278957f0c7f122e43a8f830e0..03a37888f6581ec46d5eaee8c77b18b7926d2ca3:/test-redis.tcl?ds=sidebyside

diff --git a/test-redis.tcl b/test-redis.tcl
index 1ca5e21a..039941d3 100644
--- a/test-redis.tcl
+++ b/test-redis.tcl
@@ -1,4 +1,7 @@
-# TODO # test pipelining
+# test-redis.tcl
+# Redis test suite. Copyright (C) 2009 Salvatore Sanfilippo antirez@gmail.com
+# This softare is released under the BSD License. See the COPYING file for
+# more information.
 
 set tcl_precision 17
 source redis.tcl
@@ -235,6 +238,19 @@ proc main {server port} {
         format $ok
     } {2000}
 
+    test {Check if the list is still ok after a DEBUG RELOAD} {
+        $r debug reload
+        set ok 0
+        for {set i 0} {$i < 1000} {incr 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 {LLEN against non-list value error} {
         $r del mylist
         $r set mylist foobar
@@ -257,6 +273,72 @@ proc main {server port} {
         format $err
     } {ERR*}
 
+    test {RPOPLPUSH base case} {
+        $r del mylist
+        $r rpush mylist a
+        $r rpush mylist b
+        $r rpush mylist c
+        $r rpush mylist d
+        set v1 [$r rpoplpush mylist newlist]
+        set v2 [$r rpoplpush mylist newlist]
+        set l1 [$r lrange mylist 0 -1]
+        set l2 [$r lrange newlist 0 -1]
+        list $v1 $v2 $l1 $l2
+    } {d c {a b} {c d}}
+
+    test {RPOPLPUSH with the same list as src and dst} {
+        $r del mylist
+        $r rpush mylist a
+        $r rpush mylist b
+        $r rpush mylist c
+        set l1 [$r lrange mylist 0 -1]
+        set v [$r rpoplpush mylist mylist]
+        set l2 [$r lrange mylist 0 -1]
+        list $l1 $v $l2
+    } {{a b c} c {c a b}}
+
+    test {RPOPLPUSH target list already exists} {
+        $r del mylist
+        $r del newlist
+        $r rpush mylist a
+        $r rpush mylist b
+        $r rpush mylist c
+        $r rpush mylist d
+        $r rpush newlist x
+        set v1 [$r rpoplpush mylist newlist]
+        set v2 [$r rpoplpush mylist newlist]
+        set l1 [$r lrange mylist 0 -1]
+        set l2 [$r lrange newlist 0 -1]
+        list $v1 $v2 $l1 $l2
+    } {d c {a b} {c d x}}
+
+    test {RPOPLPUSH against non existing key} {
+        $r del mylist
+        $r del newlist
+        set v1 [$r rpoplpush mylist newlist]
+        list $v1 [$r exists mylist] [$r exists newlist]
+    } {{} 0 0}
+
+    test {RPOPLPUSH against non list src key} {
+        $r del mylist
+        $r del newlist
+        $r set mylist x
+        catch {$r rpoplpush mylist newlist} err
+        list [$r type mylist] [$r exists newlist] [string range $err 0 2]
+    } {string 0 ERR}
+
+    test {RPOPLPUSH against non list dst key} {
+        $r del mylist
+        $r del newlist
+        $r rpush mylist a
+        $r rpush mylist b
+        $r rpush mylist c
+        $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 {RENAME basic usage} {
         $r set mykey hello
         $r rename mykey mykey1
@@ -485,6 +567,12 @@ proc main {server port} {
         lsort [$r smembers setres]
     } {995 996 997 998 999}
 
+    test {SINTERSTORE with two sets, after a DEBUG RELOAD} {
+        $r debug reload
+        $r sinterstore setres set1 set2
+        lsort [$r smembers setres]
+    } {995 996 997 998 999}
+
     test {SUNIONSTORE with two sets} {
         $r sunionstore setres set1 set2
         lsort [$r smembers setres]
@@ -553,6 +641,19 @@ proc main {server port} {
         $r zadd mytestzset c 30
         $r save
     } {OK}
+
+    test {SRANDMEMBER} {
+        $r del myset
+        $r sadd myset a
+        $r sadd myset b
+        $r sadd myset c
+        unset -nocomplain myset
+        array set myset {}
+        for {set i 0} {$i < 100} {incr i} {
+            set myset([$r srandmember myset]) 1
+        }
+        lsort [array names myset]
+    } {a b c}
     
     test {Create a random list} {
         set tosort {}
@@ -630,6 +731,15 @@ proc main {server port} {
         $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 {LREM, remove all the occurrences} {
         $r flushdb
         $r rpush mylist foo
@@ -818,6 +928,25 @@ proc main {server port} {
         set _ $err
     } {}
 
+    test {ZSCORE after a DEBUG RELOAD} {
+        set aux {}
+        set err {}
+        $r del zscoretest
+        for {set i 0} {$i < 1000} {incr i} {
+            set score [expr rand()]
+            lappend aux $score
+            $r zadd zscoretest $score $i
+        }
+        $r debug reload
+        for {set i 0} {$i < 1000} {incr i} {
+            if {[$r zscore zscoretest $i] != [lindex $aux $i]} {
+                set err "Expected score was [lindex $aux $i] but got [$r zscore zscoretest $i] for element $i"
+                break
+            }
+        }
+        set _ $err
+    } {}
+
     test {ZRANGE and ZREVRANGE} {
         list [$r zrange ztmp 0 -1] [$r zrevrange ztmp 0 -1]
     } {{y x z} {z x y}}
@@ -868,6 +997,116 @@ proc main {server port} {
         format $delta
     } {0}
 
+    test {ZINCRBY - can create a new sorted set} {
+        $r del zset
+        $r zincrby zset 1 foo
+        list [$r zrange zset 0 -1] [$r zscore zset foo]
+    } {foo 1}
+
+    test {ZINCRBY - increment and decrement} {
+        $r zincrby zset 2 foo
+        $r zincrby zset 1 bar
+        set v1 [$r zrange zset 0 -1]
+        $r zincrby zset 10 bar
+        $r zincrby zset -5 foo
+        $r zincrby zset -5 bar
+        set v2 [$r zrange zset 0 -1]
+        list $v1 $v2 [$r zscore zset foo] [$r zscore zset bar]
+    } {{bar foo} {foo bar} -2 6}
+
+    test {ZRANGEBYSCORE basics} {
+        $r del zset
+        $r zadd zset 1 a
+        $r zadd zset 2 b
+        $r zadd zset 3 c
+        $r zadd zset 4 d
+        $r zadd zset 5 e
+        $r zrangebyscore zset 2 4
+    } {b c d}
+
+    test {ZRANGEBYSCORE fuzzy test, 100 ranges in 1000 elements sorted set} {
+        set err {}
+        $r del zset
+        for {set i 0} {$i < 1000} {incr i} {
+            $r zadd zset [expr rand()] $i
+        }
+        for {set i 0} {$i < 100} {incr i} {
+            set min [expr rand()]
+            set max [expr rand()]
+            if {$min > $max} {
+                set aux $min
+                set min $max
+                set max $aux
+            }
+            set low [$r zrangebyscore zset -inf $min]
+            set ok [$r zrangebyscore zset $min $max]
+            set high [$r zrangebyscore zset $max +inf]
+            foreach x $low {
+                set score [$r zscore zset $x]
+                if {$score > $min} {
+                    append err "Error, score for $x is $score > $min\n"
+                }
+            }
+            foreach x $ok {
+                set score [$r zscore zset $x]
+                if {$score < $min || $score > $max} {
+                    append err "Error, score for $x is $score outside $min-$max range\n"
+                }
+            }
+            foreach x $high {
+                set score [$r zscore zset $x]
+                if {$score < $max} {
+                    append err "Error, score for $x is $score < $max\n"
+                }
+            }
+        }
+        set _ $err
+    } {}
+
+    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}
+
+    test {EXPIRE - don't set timeouts multiple times} {
+        $r set x foobar
+        set v1 [$r expire x 5]
+        set v2 [$r ttl x]
+        set v3 [$r expire x 10]
+        set v4 [$r ttl x]
+        list $v1 $v2 $v3 $v4
+    } {1 5 0 5}
+
+    test {EXPIRE - It should be still possible to read 'x'} {
+        $r get x
+    } {foobar}
+
+    test {EXPIRE - After 6 seconds the key should no longer be here} {
+        after 6000
+        list [$r get x] [$r exists x]
+    } {{} 0}
+
+    test {EXPIRE - Delete on write policy} {
+        $r del x
+        $r lpush x foo
+        $r expire x 1000
+        $r lpush x bar
+        $r lrange x 0 -1
+    } {bar}
+
+    test {EXPIREAT - Check for EXPIRE alike behavior} {
+        $r del x
+        $r set x foo
+        $r expireat x [expr [clock seconds]+15]
+        $r ttl x
+    } {1[345]}
+
     test {ZSETs skiplist implementation backlink consistency test} {
         set diff 0
         set elements 10000
@@ -912,6 +1151,18 @@ proc main {server port} {
         lappend aux [$r dbsize]
     } {0 0}
 
+    test {Perform a final SAVE to leave a clean DB on disk} {
+        $r save
+    } {OK}
+
+    catch {
+        if {[string match {*Darwin*} [exec uname -a]]} {
+            test {Check for memory leaks} {
+                exec leaks redis-server
+            } {*0 leaks*}
+        }
+    }
+
     puts "\n[expr $::passed+$::failed] tests, $::passed passed, $::failed failed"
     if {$::failed > 0} {
         puts "\n*** WARNING!!! $::failed FAILED TESTS ***\n"