redis-server 0.0.1

data/redis/redis-2.2.11/tests/unit/printver.tcl

@@ -0,0 +1,6 @@
+start_server {} {
+    set i [r info]
+    regexp {redis_version:(.*?)\r\n} $i - version
+    regexp {redis_git_sha1:(.*?)\r\n} $i - sha1
+    puts "Testing Redis version $version ($sha1)"
+}

data/redis/redis-2.2.11/tests/unit/protocol.tcl

@@ -0,0 +1,62 @@
+start_server {tags {"protocol"}} {
+    test "Handle an empty query" {
+        reconnect
+        r write "\r\n"
+        r flush
+        assert_equal "PONG" [r ping]
+    }
+
+    test "Negative multibulk length" {
+        reconnect
+        r write "*-10\r\n"
+        r flush
+        assert_equal PONG [r ping]
+    }
+
+    test "Out of range multibulk length" {
+        reconnect
+        r write "*20000000\r\n"
+        r flush
+        assert_error "*invalid multibulk length*" {r read}
+    }
+
+    test "Wrong multibulk payload header" {
+        reconnect
+        r write "*3\r\n\$3\r\nSET\r\n\$1\r\nx\r\nfooz\r\n"
+        r flush
+        assert_error "*expected '$', got 'f'*" {r read}
+    }
+
+    test "Negative multibulk payload length" {
+        reconnect
+        r write "*3\r\n\$3\r\nSET\r\n\$1\r\nx\r\n\$-10\r\n"
+        r flush
+        assert_error "*invalid bulk length*" {r read}
+    }
+
+    test "Out of range multibulk payload length" {
+        reconnect
+        r write "*3\r\n\$3\r\nSET\r\n\$1\r\nx\r\n\$2000000000\r\n"
+        r flush
+        assert_error "*invalid bulk length*" {r read}
+    }
+
+    test "Non-number multibulk payload length" {
+        reconnect
+        r write "*3\r\n\$3\r\nSET\r\n\$1\r\nx\r\n\$blabla\r\n"
+        r flush
+        assert_error "*invalid bulk length*" {r read}
+    }
+
+    test "Multi bulk request not followed by bulk arguments" {
+        reconnect
+        r write "*1\r\nfoo\r\n"
+        r flush
+        assert_error "*expected '$', got 'f'*" {r read}
+    }
+
+    test "Generic wrong number of args" {
+        reconnect
+        assert_error "*wrong*arguments*ping*" {r ping x y z}
+    }
+}

data/redis/redis-2.2.11/tests/unit/pubsub.tcl

@@ -0,0 +1,195 @@
+start_server {tags {"pubsub"}} {
+    proc __consume_subscribe_messages {client type channels} {
+        set numsub -1
+        set counts {}
+
+        for {set i [llength $channels]} {$i > 0} {incr i -1} {
+            set msg [$client read]
+            assert_equal $type [lindex $msg 0]
+
+            # when receiving subscribe messages the channels names
+            # are ordered. when receiving unsubscribe messages
+            # they are unordered
+            set idx [lsearch -exact $channels [lindex $msg 1]]
+            if {[string match "*unsubscribe" $type]} {
+                assert {$idx >= 0}
+            } else {
+                assert {$idx == 0}
+            }
+            set channels [lreplace $channels $idx $idx]
+
+            # aggregate the subscription count to return to the caller
+            lappend counts [lindex $msg 2]
+        }
+
+        # we should have received messages for channels
+        assert {[llength $channels] == 0}
+        return $counts
+    }
+
+    proc subscribe {client channels} {
+        $client subscribe {*}$channels
+        __consume_subscribe_messages $client subscribe $channels
+    }
+
+    proc unsubscribe {client {channels {}}} {
+        $client unsubscribe {*}$channels
+        __consume_subscribe_messages $client unsubscribe $channels
+    }
+
+    proc psubscribe {client channels} {
+        $client psubscribe {*}$channels
+        __consume_subscribe_messages $client psubscribe $channels
+    }
+
+    proc punsubscribe {client {channels {}}} {
+        $client punsubscribe {*}$channels
+        __consume_subscribe_messages $client punsubscribe $channels
+    }
+
+    test "PUBLISH/SUBSCRIBE basics" {
+        set rd1 [redis_deferring_client]
+
+        # subscribe to two channels
+        assert_equal {1 2} [subscribe $rd1 {chan1 chan2}]
+        assert_equal 1 [r publish chan1 hello]
+        assert_equal 1 [r publish chan2 world]
+        assert_equal {message chan1 hello} [$rd1 read]
+        assert_equal {message chan2 world} [$rd1 read]
+
+        # unsubscribe from one of the channels
+        unsubscribe $rd1 {chan1}
+        assert_equal 0 [r publish chan1 hello]
+        assert_equal 1 [r publish chan2 world]
+        assert_equal {message chan2 world} [$rd1 read]
+
+        # unsubscribe from the remaining channel
+        unsubscribe $rd1 {chan2}
+        assert_equal 0 [r publish chan1 hello]
+        assert_equal 0 [r publish chan2 world]
+
+        # clean up clients
+        $rd1 close
+    }
+
+    test "PUBLISH/SUBSCRIBE with two clients" {
+        set rd1 [redis_deferring_client]
+        set rd2 [redis_deferring_client]
+
+        assert_equal {1} [subscribe $rd1 {chan1}]
+        assert_equal {1} [subscribe $rd2 {chan1}]
+        assert_equal 2 [r publish chan1 hello]
+        assert_equal {message chan1 hello} [$rd1 read]
+        assert_equal {message chan1 hello} [$rd2 read]
+
+        # clean up clients
+        $rd1 close
+        $rd2 close
+    }
+
+    test "PUBLISH/SUBSCRIBE after UNSUBSCRIBE without arguments" {
+        set rd1 [redis_deferring_client]
+        assert_equal {1 2 3} [subscribe $rd1 {chan1 chan2 chan3}]
+        unsubscribe $rd1
+        assert_equal 0 [r publish chan1 hello]
+        assert_equal 0 [r publish chan2 hello]
+        assert_equal 0 [r publish chan3 hello]
+
+        # clean up clients
+        $rd1 close
+    }
+
+    test "SUBSCRIBE to one channel more than once" {
+        set rd1 [redis_deferring_client]
+        assert_equal {1 1 1} [subscribe $rd1 {chan1 chan1 chan1}]
+        assert_equal 1 [r publish chan1 hello]
+        assert_equal {message chan1 hello} [$rd1 read]
+
+        # clean up clients
+        $rd1 close
+    }
+
+    test "UNSUBSCRIBE from non-subscribed channels" {
+        set rd1 [redis_deferring_client]
+        assert_equal {0 0 0} [unsubscribe $rd1 {foo bar quux}]
+
+        # clean up clients
+        $rd1 close
+    }
+
+    test "PUBLISH/PSUBSCRIBE basics" {
+        set rd1 [redis_deferring_client]
+
+        # subscribe to two patterns
+        assert_equal {1 2} [psubscribe $rd1 {foo.* bar.*}]
+        assert_equal 1 [r publish foo.1 hello]
+        assert_equal 1 [r publish bar.1 hello]
+        assert_equal 0 [r publish foo1 hello]
+        assert_equal 0 [r publish barfoo.1 hello]
+        assert_equal 0 [r publish qux.1 hello]
+        assert_equal {pmessage foo.* foo.1 hello} [$rd1 read]
+        assert_equal {pmessage bar.* bar.1 hello} [$rd1 read]
+
+        # unsubscribe from one of the patterns
+        assert_equal {1} [punsubscribe $rd1 {foo.*}]
+        assert_equal 0 [r publish foo.1 hello]
+        assert_equal 1 [r publish bar.1 hello]
+        assert_equal {pmessage bar.* bar.1 hello} [$rd1 read]
+
+        # unsubscribe from the remaining pattern
+        assert_equal {0} [punsubscribe $rd1 {bar.*}]
+        assert_equal 0 [r publish foo.1 hello]
+        assert_equal 0 [r publish bar.1 hello]
+
+        # clean up clients
+        $rd1 close
+    }
+
+    test "PUBLISH/PSUBSCRIBE with two clients" {
+        set rd1 [redis_deferring_client]
+        set rd2 [redis_deferring_client]
+
+        assert_equal {1} [psubscribe $rd1 {chan.*}]
+        assert_equal {1} [psubscribe $rd2 {chan.*}]
+        assert_equal 2 [r publish chan.foo hello]
+        assert_equal {pmessage chan.* chan.foo hello} [$rd1 read]
+        assert_equal {pmessage chan.* chan.foo hello} [$rd2 read]
+
+        # clean up clients
+        $rd1 close
+        $rd2 close
+    }
+
+    test "PUBLISH/PSUBSCRIBE after PUNSUBSCRIBE without arguments" {
+        set rd1 [redis_deferring_client]
+        assert_equal {1 2 3} [psubscribe $rd1 {chan1.* chan2.* chan3.*}]
+        punsubscribe $rd1
+        assert_equal 0 [r publish chan1.hi hello]
+        assert_equal 0 [r publish chan2.hi hello]
+        assert_equal 0 [r publish chan3.hi hello]
+
+        # clean up clients
+        $rd1 close
+    }
+
+    test "PUNSUBSCRIBE from non-subscribed channels" {
+        set rd1 [redis_deferring_client]
+        assert_equal {0 0 0} [punsubscribe $rd1 {foo.* bar.* quux.*}]
+
+        # clean up clients
+        $rd1 close
+    }
+
+    test "Mix SUBSCRIBE and PSUBSCRIBE" {
+        set rd1 [redis_deferring_client]
+        assert_equal {1} [subscribe $rd1 {foo.bar}]
+        assert_equal {2} [psubscribe $rd1 {foo.*}]
+
+        assert_equal 2 [r publish foo.bar hello]
+        assert_equal {message foo.bar hello} [$rd1 read]
+        assert_equal {pmessage foo.* foo.bar hello} [$rd1 read]
+
+        # clean up clients
+        $rd1 close
+    }
+}

data/redis/redis-2.2.11/tests/unit/quit.tcl

@@ -0,0 +1,40 @@
+start_server {tags {"quit"}} {
+    proc format_command {args} {
+        set cmd "*[llength $args]\r\n"
+        foreach a $args {
+            append cmd "$[string length $a]\r\n$a\r\n"
+        }
+        set _ $cmd
+    }
+
+    test "QUIT returns OK" {
+        reconnect
+        assert_equal OK [r quit]
+        assert_error * {r ping}
+    }
+
+    test "Pipelined commands after QUIT must not be executed" {
+        reconnect
+        r write [format_command quit]
+        r write [format_command set foo bar]
+        r flush
+        assert_equal OK [r read]
+        assert_error * {r read}
+
+        reconnect
+        assert_equal {} [r get foo]
+    }
+
+    test "Pipelined commands after QUIT that exceed read buffer size" {
+        reconnect
+        r write [format_command quit]
+        r write [format_command set foo [string repeat "x" 1024]]
+        r flush
+        assert_equal OK [r read]
+        assert_error * {r read}
+
+        reconnect
+        assert_equal {} [r get foo]
+
+    }
+}

data/redis/redis-2.2.11/tests/unit/sort.tcl

@@ -0,0 +1,189 @@
+start_server {
+    tags {"sort"}
+    overrides {
+        "list-max-ziplist-value" 16
+        "list-max-ziplist-entries" 32
+        "set-max-intset-entries" 32
+    }
+} {
+    proc create_random_dataset {num cmd} {
+        set tosort {}
+        set result {}
+        array set seenrand {}
+        r del tosort
+        for {set i 0} {$i < $num} {incr i} {
+            # Make sure all the weights are different because
+            # Redis does not use a stable sort but Tcl does.
+            while 1 {
+                randpath {
+                    set rint [expr int(rand()*1000000)]
+                } {
+                    set rint [expr rand()]
+                }
+                if {![info exists seenrand($rint)]} break
+            }
+            set seenrand($rint) x
+            r $cmd tosort $i
+            r set weight_$i $rint
+            r hset wobj_$i weight $rint
+            lappend tosort [list $i $rint]
+        }
+        set sorted [lsort -index 1 -real $tosort]
+        for {set i 0} {$i < $num} {incr i} {
+            lappend result [lindex $sorted $i 0]
+        }
+        set _ $result
+    }
+
+    foreach {num cmd enc title} {
+        16 lpush ziplist "Ziplist"
+        1000 lpush linkedlist "Linked list"
+        10000 lpush linkedlist "Big Linked list"
+        16 sadd intset "Intset"
+        1000 sadd hashtable "Hash table"
+        10000 sadd hashtable "Big Hash table"
+    } {
+        set result [create_random_dataset $num $cmd]
+        assert_encoding $enc tosort
+
+        test "$title: SORT BY key" {
+            assert_equal $result [r sort tosort BY weight_*]
+        }
+
+        test "$title: SORT BY hash field" {
+            assert_equal $result [r sort tosort BY wobj_*->weight]
+        }
+    }
+
+    set result [create_random_dataset 16 lpush]
+    test "SORT GET #" {
+        assert_equal [lsort -integer $result] [r sort tosort GET #]
+    }
+
+    test "SORT GET <const>" {
+        r del foo
+        set res [r sort tosort GET foo]
+        assert_equal 16 [llength $res]
+        foreach item $res { assert_equal {} $item }
+    }
+
+    test "SORT GET (key and hash) with sanity check" {
+        set l1 [r sort tosort GET # GET weight_*]
+        set l2 [r sort tosort GET # GET wobj_*->weight]
+        foreach {id1 w1} $l1 {id2 w2} $l2 {
+            assert_equal $id1 $id2
+            assert_equal $w1 [r get weight_$id1]
+            assert_equal $w2 [r get weight_$id1]
+        }
+    }
+
+    test "SORT BY key STORE" {
+        r sort tosort BY weight_* store sort-res
+        assert_equal $result [r lrange sort-res 0 -1]
+        assert_equal 16 [r llen sort-res]
+        assert_encoding ziplist sort-res
+    }
+
+    test "SORT BY hash field STORE" {
+        r sort tosort BY wobj_*->weight store sort-res
+        assert_equal $result [r lrange sort-res 0 -1]
+        assert_equal 16 [r llen sort-res]
+        assert_encoding ziplist sort-res
+    }
+
+    test "SORT DESC" {
+        assert_equal [lsort -decreasing -integer $result] [r sort tosort DESC]
+    }
+
+    test "SORT ALPHA against integer encoded strings" {
+        r del mylist
+        r lpush mylist 2
+        r lpush mylist 1
+        r lpush mylist 3
+        r lpush mylist 10
+        r sort mylist alpha
+    } {1 10 2 3}
+
+    test "SORT sorted set" {
+        r del zset
+        r zadd zset 1 a
+        r zadd zset 5 b
+        r zadd zset 2 c
+        r zadd zset 10 d
+        r zadd zset 3 e
+        r sort zset alpha desc
+    } {e d c b a}
+
+    test "SORT sorted set: +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 "SORT regression for issue #19, sorting floats" {
+        r flushdb
+        set floats {1.1 5.10 3.10 7.44 2.1 5.75 6.12 0.25 1.15}
+        foreach x $floats {
+            r lpush mylist $x
+        }
+        assert_equal [lsort -real $floats] [r sort mylist]
+    }
+
+    tags {"slow"} {
+        set num 100
+        set res [create_random_dataset $num lpush]
+
+        test "SORT speed, $num element list BY key, 100 times" {
+            set start [clock clicks -milliseconds]
+            for {set i 0} {$i < 100} {incr i} {
+                set sorted [r sort tosort BY weight_* LIMIT 0 10]
+            }
+            set elapsed [expr [clock clicks -milliseconds]-$start]
+            if {$::verbose} {
+                puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+                flush stdout
+            }
+        }
+
+        test "SORT speed, $num element list BY hash field, 100 times" {
+            set start [clock clicks -milliseconds]
+            for {set i 0} {$i < 100} {incr i} {
+                set sorted [r sort tosort BY wobj_*->weight LIMIT 0 10]
+            }
+            set elapsed [expr [clock clicks -milliseconds]-$start]
+            if {$::verbose} {
+                puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+                flush stdout
+            }
+        }
+
+        test "SORT speed, $num element list directly, 100 times" {
+            set start [clock clicks -milliseconds]
+            for {set i 0} {$i < 100} {incr i} {
+                set sorted [r sort tosort LIMIT 0 10]
+            }
+            set elapsed [expr [clock clicks -milliseconds]-$start]
+            if {$::verbose} {
+                puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+                flush stdout
+            }
+        }
+
+        test "SORT speed, $num element list BY <const>, 100 times" {
+            set start [clock clicks -milliseconds]
+            for {set i 0} {$i < 100} {incr i} {
+                set sorted [r sort tosort BY nokey LIMIT 0 10]
+            }
+            set elapsed [expr [clock clicks -milliseconds]-$start]
+            if {$::verbose} {
+                puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+                flush stdout
+            }
+        }
+    }
+}