Commits

Pieter Noordhuis  committed 0319bd1

tags for existing tests

  • Participants
  • Parent commits 19b49c3
  • Branches 2.0.0

Comments (0)

Files changed (11)

File tests/integration/aof.tcl

     kill_server $srv
 }
 
-## Test the server doesn't start when the AOF contains an unfinished MULTI
-create_aof {
-    append_to_aof [formatCommand set foo hello]
-    append_to_aof [formatCommand multi]
-    append_to_aof [formatCommand set bar world]
-}
+tags {"aof"} {
+    ## Test the server doesn't start when the AOF contains an unfinished MULTI
+    create_aof {
+        append_to_aof [formatCommand set foo hello]
+        append_to_aof [formatCommand multi]
+        append_to_aof [formatCommand set bar world]
+    }
 
-start_server_aof [list dir $server_path] {
-    test {Unfinished MULTI: Server should not have been started} {
-        is_alive $srv
-    } {0}
+    start_server_aof [list dir $server_path] {
+        test {Unfinished MULTI: Server should not have been started} {
+            is_alive $srv
+        } {0}
 
-    test {Unfinished MULTI: Server should have logged an error} {
-        exec cat [dict get $srv stdout] | tail -n1
-    } {*Unexpected end of file reading the append only file*}
-}
+        test {Unfinished MULTI: Server should have logged an error} {
+            exec cat [dict get $srv stdout] | tail -n1
+        } {*Unexpected end of file reading the append only file*}
+    }
 
-## Test that the server exits when the AOF contains a short read
-create_aof {
-    append_to_aof [formatCommand set foo hello]
-    append_to_aof [string range [formatCommand set bar world] 0 end-1]
-}
+    ## Test that the server exits when the AOF contains a short read
+    create_aof {
+        append_to_aof [formatCommand set foo hello]
+        append_to_aof [string range [formatCommand set bar world] 0 end-1]
+    }
 
-start_server_aof [list dir $server_path] {
-    test {Short read: Server should not have been started} {
-        is_alive $srv
-    } {0}
+    start_server_aof [list dir $server_path] {
+        test {Short read: Server should not have been started} {
+            is_alive $srv
+        } {0}
 
-    test {Short read: Server should have logged an error} {
-        exec cat [dict get $srv stdout] | tail -n1
-    } {*Bad file format reading the append only file*}
-}
+        test {Short read: Server should have logged an error} {
+            exec cat [dict get $srv stdout] | tail -n1
+        } {*Bad file format reading the append only file*}
+    }
 
-## Test that redis-check-aof indeed sees this AOF is not valid
-test {Short read: Utility should confirm the AOF is not valid} {
-    catch {
-        exec ./redis-check-aof $aof_path
-    } str
-    set _ $str
-} {*not valid*}
+    ## Test that redis-check-aof indeed sees this AOF is not valid
+    test {Short read: Utility should confirm the AOF is not valid} {
+        catch {
+            exec ./redis-check-aof $aof_path
+        } str
+        set _ $str
+    } {*not valid*}
 
-test {Short read: Utility should be able to fix the AOF} {
-    exec echo y | ./redis-check-aof --fix $aof_path
-} {*Successfully truncated AOF*}
+    test {Short read: Utility should be able to fix the AOF} {
+        exec echo y | ./redis-check-aof --fix $aof_path
+    } {*Successfully truncated AOF*}
 
-## Test that the server can be started using the truncated AOF
-start_server_aof [list dir $server_path] {
-    test {Fixed AOF: Server should have been started} {
-        is_alive $srv
-    } {1}
+    ## Test that the server can be started using the truncated AOF
+    start_server_aof [list dir $server_path] {
+        test {Fixed AOF: Server should have been started} {
+            is_alive $srv
+        } {1}
 
-    test {Fixed AOF: Keyspace should contain values that were parsable} {
-        set client [redis [dict get $srv host] [dict get $srv port]]
-        list [$client get foo] [$client get bar]
-    } {hello {}}
+        test {Fixed AOF: Keyspace should contain values that were parsable} {
+            set client [redis [dict get $srv host] [dict get $srv port]]
+            list [$client get foo] [$client get bar]
+        } {hello {}}
+    }
 }

File tests/integration/replication.tcl

-start_server {} {
+start_server {tags {"repl"}} {
     r set mykey foo
     
     start_server {} {

File tests/unit/auth.tcl

-start_server {overrides {requirepass foobar}} {
+start_server {tags {"auth"} overrides {requirepass foobar}} {
     test {AUTH fails when a wrong password is given} {
         catch {r auth wrong!} err
         format $err

File tests/unit/basic.tcl

-start_server {tags {basic}} {
+start_server {tags {"basic"}} {
     test {DEL all keys to start with a clean DB} {
         foreach key [r keys *] {r del $key}
         r dbsize
         r get foo
     } [string repeat "abcd" 1000000]
 
-    tags {slow} {
-    test {Very big payload random access} {
-        set err {}
-        array set payload {}
-        for {set j 0} {$j < 100} {incr j} {
-            set size [expr 1+[randomInt 100000]]
-            set buf [string repeat "pl-$j" $size]
-            set payload($j) $buf
-            r set bigpayload_$j $buf
-        }
-        for {set j 0} {$j < 1000} {incr j} {
-            set index [randomInt 100]
-            set buf [r get bigpayload_$index]
-            if {$buf != $payload($index)} {
-                set err "Values differ: I set '$payload($index)' but I read back '$buf'"
-                break
+    tags {"slow"} {
+        test {Very big payload random access} {
+            set err {}
+            array set payload {}
+            for {set j 0} {$j < 100} {incr j} {
+                set size [expr 1+[randomInt 100000]]
+                set buf [string repeat "pl-$j" $size]
+                set payload($j) $buf
+                r set bigpayload_$j $buf
             }
-        }
-        unset payload
-        set _ $err
-    } {}
-
-    test {SET 10000 numeric keys and access all them in reverse order} {
-        set err {}
-        for {set x 0} {$x < 10000} {incr x} {
-            r set $x $x
-        }
-        set sum 0
-        for {set x 9999} {$x >= 0} {incr x -1} {
-            set val [r get $x]
-            if {$val ne $x} {
-                set err "Eleemnt at position $x is $val instead of $x"
-                break
+            for {set j 0} {$j < 1000} {incr j} {
+                set index [randomInt 100]
+                set buf [r get bigpayload_$index]
+                if {$buf != $payload($index)} {
+                    set err "Values differ: I set '$payload($index)' but I read back '$buf'"
+                    break
+                }
             }
-        }
-        set _ $err
-    } {}
+            unset payload
+            set _ $err
+        } {}
+
+        test {SET 10000 numeric keys and access all them in reverse order} {
+            set err {}
+            for {set x 0} {$x < 10000} {incr x} {
+                r set $x $x
+            }
+            set sum 0
+            for {set x 9999} {$x >= 0} {incr x -1} {
+                set val [r get $x]
+                if {$val ne $x} {
+                    set err "Eleemnt at position $x is $val instead of $x"
+                    break
+                }
+            }
+            set _ $err
+        } {}
 
-    test {DBSIZE should be 10101 now} {
-        r dbsize
-    } {10101}
+        test {DBSIZE should be 10101 now} {
+            r dbsize
+        } {10101}
     }
 
     test {INCR against non existing key} {

File tests/unit/cas.tcl

+start_server {tags {"cas"}} {
+    test {EXEC works on WATCHed key not modified} {
+        r watch x y z
+        r watch k
+        r multi
+        r ping
+        r exec
+    } {PONG}
+
+    test {EXEC fail on WATCHed key modified (1 key of 1 watched)} {
+        r set x 30
+        r watch x
+        r set x 40
+        r multi
+        r ping
+        r exec
+    } {}
+
+    test {EXEC fail on WATCHed key modified (1 key of 5 watched)} {
+        r set x 30
+        r watch a b x k z
+        r set x 40
+        r multi
+        r ping
+        r exec
+    } {}
+
+    test {After successful EXEC key is no longer watched} {
+        r set x 30
+        r watch x
+        r multi
+        r ping
+        r exec
+        r set x 40
+        r multi
+        r ping
+        r exec
+    } {PONG}
+
+    test {After failed EXEC key is no longer watched} {
+        r set x 30
+        r watch x
+        r set x 40
+        r multi
+        r ping
+        r exec
+        r set x 40
+        r multi
+        r ping
+        r exec
+    } {PONG}
+
+    test {It is possible to UNWATCH} {
+        r set x 30
+        r watch x
+        r set x 40
+        r unwatch
+        r multi
+        r ping
+        r exec
+    } {PONG}
+
+    test {UNWATCH when there is nothing watched works as expected} {
+        r unwatch
+    } {OK}
+
+    test {FLUSHALL is able to touch the watched keys} {
+        r set x 30
+        r watch x
+        r flushall
+        r multi
+        r ping
+        r exec
+    } {}
+
+    test {FLUSHALL does not touch non affected keys} {
+        r del x
+        r watch x
+        r flushall
+        r multi
+        r ping
+        r exec
+    } {PONG}
+
+    test {FLUSHDB is able to touch the watched keys} {
+        r set x 30
+        r watch x
+        r flushdb
+        r multi
+        r ping
+        r exec
+    } {}
+
+    test {FLUSHDB does not touch non affected keys} {
+        r del x
+        r watch x
+        r flushdb
+        r multi
+        r ping
+        r exec
+    } {PONG}
+
+    test {WATCH is able to remember the DB a key belongs to} {
+        r select 5
+        r set x 30
+        r watch x
+        r select 1
+        r set x 10
+        r select 5
+        r multi
+        r ping
+        r exec
+    } {PONG}
+}

File tests/unit/expire.tcl

-start_server {} {
+start_server {tags {"expire"}} {
     test {EXPIRE - don't set timeouts multiple times} {
         r set x foobar
         set v1 [r expire x 5]

File tests/unit/sort.tcl

-start_server {} {
+start_server {tags {"sort"}} {
     test {SORT ALPHA against integer encoded strings} {
         r del mylist
         r lpush mylist 2
         r sort mylist alpha
     } {1 10 2 3}
 
-    test {Create a random list and a random set} {
-        set tosort {}
-        array set seenrand {}
-        for {set i 0} {$i < 10000} {incr i} {
-            while 1 {
-                # Make sure all the weights are different because
-                # Redis does not use a stable sort but Tcl does.
-                randpath {
-                    set rint [expr int(rand()*1000000)]
-                } {
-                    set rint [expr rand()]
+    tags {"slow"} {
+        test {Create a random list and a random set} {
+            set tosort {}
+            array set seenrand {}
+            for {set i 0} {$i < 10000} {incr i} {
+                while 1 {
+                    # Make sure all the weights are different because
+                    # Redis does not use a stable sort but Tcl does.
+                    randpath {
+                        set rint [expr int(rand()*1000000)]
+                    } {
+                        set rint [expr rand()]
+                    }
+                    if {![info exists seenrand($rint)]} break
                 }
-                if {![info exists seenrand($rint)]} break
+                set seenrand($rint) x
+                r lpush tosort $i
+                r sadd tosort-set $i
+                r set weight_$i $rint
+                r hset wobj_$i weight $rint
+                lappend tosort [list $i $rint]
             }
-            set seenrand($rint) x
-            r lpush tosort $i
-            r sadd tosort-set $i
-            r set weight_$i $rint
-            r hset wobj_$i weight $rint
-            lappend tosort [list $i $rint]
-        }
-        set sorted [lsort -index 1 -real $tosort]
-        set res {}
-        for {set i 0} {$i < 10000} {incr i} {
-            lappend res [lindex $sorted $i 0]
-        }
-        format {}
-    } {}
-
-    test {SORT with BY against the newly created list} {
-        r sort tosort {BY weight_*}
-    } $res
-
-    test {SORT with BY (hash field) against the newly created list} {
-        r sort tosort {BY wobj_*->weight}
-    } $res
-
-    test {SORT with GET (key+hash) with sanity check of each element (list)} {
-        set err {}
-        set l1 [r sort tosort GET # GET weight_*]
-        set l2 [r sort tosort GET # GET wobj_*->weight]
-        foreach {id1 w1} $l1 {id2 w2} $l2 {
-            set realweight [r get weight_$id1]
-            if {$id1 != $id2} {
-                set err "ID mismatch $id1 != $id2"
-                break
+            set sorted [lsort -index 1 -real $tosort]
+            set res {}
+            for {set i 0} {$i < 10000} {incr i} {
+                lappend res [lindex $sorted $i 0]
             }
-            if {$realweight != $w1 || $realweight != $w2} {
-                set err "Weights mismatch! w1: $w1 w2: $w2 real: $realweight"
-                break
+            format {}
+        } {}
+
+        test {SORT with BY against the newly created list} {
+            r sort tosort {BY weight_*}
+        } $res
+
+        test {SORT with BY (hash field) against the newly created list} {
+            r sort tosort {BY wobj_*->weight}
+        } $res
+
+        test {SORT with GET (key+hash) with sanity check of each element (list)} {
+            set err {}
+            set l1 [r sort tosort GET # GET weight_*]
+            set l2 [r sort tosort GET # GET wobj_*->weight]
+            foreach {id1 w1} $l1 {id2 w2} $l2 {
+                set realweight [r get weight_$id1]
+                if {$id1 != $id2} {
+                    set err "ID mismatch $id1 != $id2"
+                    break
+                }
+                if {$realweight != $w1 || $realweight != $w2} {
+                    set err "Weights mismatch! w1: $w1 w2: $w2 real: $realweight"
+                    break
+                }
             }
-        }
-        set _ $err
-    } {}
-
-    test {SORT with BY, but against the newly created set} {
-        r sort tosort-set {BY weight_*}
-    } $res
-
-    test {SORT with BY (hash field), but against the newly created set} {
-        r sort tosort-set {BY wobj_*->weight}
-    } $res
-
-    test {SORT with BY and STORE against the newly created list} {
-        r sort tosort {BY weight_*} store sort-res
-        r lrange sort-res 0 -1
-    } $res
-
-    test {SORT with BY (hash field) and STORE against the newly created list} {
-        r sort tosort {BY wobj_*->weight} store sort-res
-        r lrange sort-res 0 -1
-    } $res
-
-    test {SORT direct, numeric, against the newly created list} {
-        r sort tosort
-    } [lsort -integer $res]
-
-    test {SORT decreasing sort} {
-        r sort tosort {DESC}
-    } [lsort -decreasing -integer $res]
-
-    test {SORT speed, sorting 10000 elements list using BY, 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]
-        puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
-        flush stdout
-        format {}
-    } {}
-
-    test {SORT speed, as above but against hash field} {
-        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]
-        puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
-        flush stdout
-        format {}
-    } {}
-
-    test {SORT speed, sorting 10000 elements 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]
-        puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
-        flush stdout
-        format {}
-    } {}
-
-    test {SORT speed, pseudo-sorting 10000 elements 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]
-        puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
-        flush stdout
-        format {}
-    } {}
+            set _ $err
+        } {}
+
+        test {SORT with BY, but against the newly created set} {
+            r sort tosort-set {BY weight_*}
+        } $res
+
+        test {SORT with BY (hash field), but against the newly created set} {
+            r sort tosort-set {BY wobj_*->weight}
+        } $res
+
+        test {SORT with BY and STORE against the newly created list} {
+            r sort tosort {BY weight_*} store sort-res
+            r lrange sort-res 0 -1
+        } $res
+
+        test {SORT with BY (hash field) and STORE against the newly created list} {
+            r sort tosort {BY wobj_*->weight} store sort-res
+            r lrange sort-res 0 -1
+        } $res
+
+        test {SORT direct, numeric, against the newly created list} {
+            r sort tosort
+        } [lsort -integer $res]
+
+        test {SORT decreasing sort} {
+            r sort tosort {DESC}
+        } [lsort -decreasing -integer $res]
+
+        test {SORT speed, sorting 10000 elements list using BY, 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]
+            puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+            flush stdout
+            format {}
+        } {}
+
+        test {SORT speed, as above but against hash field} {
+            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]
+            puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+            flush stdout
+            format {}
+        } {}
+
+        test {SORT speed, sorting 10000 elements 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]
+            puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+            flush stdout
+            format {}
+        } {}
+
+        test {SORT speed, pseudo-sorting 10000 elements 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]
+            puts -nonewline "\n  Average time to sort: [expr double($elapsed)/100] milliseconds "
+            flush stdout
+            format {}
+        } {}
+    }
 
     test {SORT regression for issue #19, sorting floats} {
         r flushdb

File tests/unit/type/hash.tcl

-start_server {} {
+start_server {tags {"hash"}} {
     test {HSET/HLEN - Small hash creation} {
         array set smallhash {}
         for {set i 0} {$i < 8} {incr i} {

File tests/unit/type/list.tcl

-start_server {} {
+start_server {tags {"list"}} {
     test {Basic LPUSH, RPUSH, LLENGTH, LINDEX} {
         set res [r lpush mylist a]
         append res [r lpush mylist b]

File tests/unit/type/set.tcl

-start_server {} {
+start_server {tags {"set"}} {
     test {SADD, SCARD, SISMEMBER, SMEMBERS basics} {
         r sadd myset foo
         r sadd myset bar

File tests/unit/type/zset.tcl

-start_server {} {
+start_server {tags {"zset"}} {
     test {ZSET basic ZADD and score update} {
         r zadd ztmp 10 x
         r zadd ztmp 20 y
         r zrangebyscore zset 2 4 withscores
     } {b 2 c 3 d 4}
 
-    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]
-            set lowx [r zrangebyscore zset -inf ($min]
-            set okx [r zrangebyscore zset ($min ($max]
-            set highx [r zrangebyscore zset ($max +inf]
-
-            if {[r zcount zset -inf $min] != [llength $low]} {
-                append err "Error, len does not match zcount\n"
-            }
-            if {[r zcount zset $min $max] != [llength $ok]} {
-                append err "Error, len does not match zcount\n"
-            }
-            if {[r zcount zset $max +inf] != [llength $high]} {
-                append err "Error, len does not match zcount\n"
-            }
-            if {[r zcount zset -inf ($min] != [llength $lowx]} {
-                append err "Error, len does not match zcount\n"
-            }
-            if {[r zcount zset ($min ($max] != [llength $okx]} {
-                append err "Error, len does not match zcount\n"
-            }
-            if {[r zcount zset ($max +inf] != [llength $highx]} {
-                append err "Error, len does not match zcount\n"
+    tags {"slow"} {
+        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]
+                set lowx [r zrangebyscore zset -inf ($min]
+                set okx [r zrangebyscore zset ($min ($max]
+                set highx [r zrangebyscore zset ($max +inf]
+
+                if {[r zcount zset -inf $min] != [llength $low]} {
+                    append err "Error, len does not match zcount\n"
+                }
+                if {[r zcount zset $min $max] != [llength $ok]} {
+                    append err "Error, len does not match zcount\n"
+                }
+                if {[r zcount zset $max +inf] != [llength $high]} {
+                    append err "Error, len does not match zcount\n"
+                }
+                if {[r zcount zset -inf ($min] != [llength $lowx]} {
+                    append err "Error, len does not match zcount\n"
+                }
+                if {[r zcount zset ($min ($max] != [llength $okx]} {
+                    append err "Error, len does not match zcount\n"
+                }
+                if {[r zcount zset ($max +inf] != [llength $highx]} {
+                    append err "Error, len does not match zcount\n"
+                }
 
-            foreach x $low {
-                set score [r zscore zset $x]
-                if {$score > $min} {
-                    append err "Error, score for $x is $score > $min\n"
+                foreach x $low {
+                    set score [r zscore zset $x]
+                    if {$score > $min} {
+                        append err "Error, score for $x is $score > $min\n"
+                    }
                 }
-            }
-            foreach x $lowx {
-                set score [r zscore zset $x]
-                if {$score >= $min} {
-                    append err "Error, score for $x is $score >= $min\n"
+                foreach x $lowx {
+                    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 $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 $okx {
-                set score [r zscore zset $x]
-                if {$score <= $min || $score >= $max} {
-                    append err "Error, score for $x is $score outside $min-$max open range\n"
+                foreach x $okx {
+                    set score [r zscore zset $x]
+                    if {$score <= $min || $score >= $max} {
+                        append err "Error, score for $x is $score outside $min-$max open range\n"
+                    }
                 }
-            }
-            foreach x $high {
-                set score [r zscore zset $x]
-                if {$score < $max} {
-                    append err "Error, score for $x is $score < $max\n"
+                foreach x $high {
+                    set score [r zscore zset $x]
+                    if {$score < $max} {
+                        append err "Error, score for $x is $score < $max\n"
+                    }
                 }
-            }
-            foreach x $highx {
-                set score [r zscore zset $x]
-                if {$score <= $max} {
-                    append err "Error, score for $x is $score <= $max\n"
+                foreach x $highx {
+                    set score [r zscore zset $x]
+                    if {$score <= $max} {
+                        append err "Error, score for $x is $score <= $max\n"
+                    }
                 }
             }
-        }
-        set _ $err
-    } {}
+            set _ $err
+        } {}
+    }
 
     test {ZRANGEBYSCORE with LIMIT} {
         r del zset
         list [r zinterstore zsetc 2 zseta zsetb aggregate max] [r zrange zsetc 0 -1 withscores]
     } {2 {b 2 c 3}}
     
-    test {ZSETs skiplist implementation backlink consistency test} {
-        set diff 0
-        set elements 10000
-        for {set j 0} {$j < $elements} {incr j} {
-            r zadd myzset [expr rand()] "Element-$j"
-            r zrem myzset "Element-[expr int(rand()*$elements)]"
-        }
-        set l1 [r zrange myzset 0 -1]
-        set l2 [r zrevrange myzset 0 -1]
-        for {set j 0} {$j < [llength $l1]} {incr j} {
-            if {[lindex $l1 $j] ne [lindex $l2 end-$j]} {
-                incr diff
+    tags {"slow"} {
+        test {ZSETs skiplist implementation backlink consistency test} {
+            set diff 0
+            set elements 10000
+            for {set j 0} {$j < $elements} {incr j} {
+                r zadd myzset [expr rand()] "Element-$j"
+                r zrem myzset "Element-[expr int(rand()*$elements)]"
             }
-        }
-        format $diff
-    } {0}
-
-    test {ZSETs ZRANK augmented skip list stress testing} {
-        set err {}
-        r del myzset
-        for {set k 0} {$k < 10000} {incr k} {
-            set i [expr {$k%1000}]
-            if {[expr rand()] < .2} {
-                r zrem myzset $i
-            } else {
-                set score [expr rand()]
-                r zadd myzset $score $i
+            set l1 [r zrange myzset 0 -1]
+            set l2 [r zrevrange myzset 0 -1]
+            for {set j 0} {$j < [llength $l1]} {incr j} {
+                if {[lindex $l1 $j] ne [lindex $l2 end-$j]} {
+                    incr diff
+                }
             }
-            set card [r zcard myzset]
-            if {$card > 0} {
-                set index [randomInt $card]
-                set ele [lindex [r zrange myzset $index $index] 0]
-                set rank [r zrank myzset $ele]
-                if {$rank != $index} {
-                    set err "$ele RANK is wrong! ($rank != $index)"
-                    break
+            format $diff
+        } {0}
+
+        test {ZSETs ZRANK augmented skip list stress testing} {
+            set err {}
+            r del myzset
+            for {set k 0} {$k < 10000} {incr k} {
+                set i [expr {$k%1000}]
+                if {[expr rand()] < .2} {
+                    r zrem myzset $i
+                } else {
+                    set score [expr rand()]
+                    r zadd myzset $score $i
+                }
+                set card [r zcard myzset]
+                if {$card > 0} {
+                    set index [randomInt $card]
+                    set ele [lindex [r zrange myzset $index $index] 0]
+                    set rank [r zrank myzset $ele]
+                    if {$rank != $index} {
+                        set err "$ele RANK is wrong! ($rank != $index)"
+                        break
+                    }
                 }
             }
-        }
-        set _ $err
-    } {}
+            set _ $err
+        } {}
+    }
 
     test {ZSET element can't be set to nan with ZADD} {
         set e {}