diff --git a/geode-for-redis/src/acceptanceTest/resources/0001-configure-redis-tests.patch b/geode-for-redis/src/acceptanceTest/resources/0001-configure-redis-tests.patch
new file mode 100644
index 0000000..5a5ff36
--- /dev/null
+++ b/geode-for-redis/src/acceptanceTest/resources/0001-configure-redis-tests.patch
@@ -0,0 +1,2855 @@
+diff --git a/tests/support/server.tcl b/tests/support/server.tcl
+index 5578f1fd6..55c0a5253 100644
+--- a/tests/support/server.tcl
++++ b/tests/support/server.tcl
+@@ -143,11 +143,12 @@ proc start_server {options {code undefined}} {
+     if {$::external} {
+         if {[llength $::servers] == 0} {
+             set srv {}
++            set baseport [expr {$::port-100}]
+             dict set srv "host" $::host
+-            dict set srv "port" $::port
+-            set client [redis $::host $::port]
++            dict set srv "port" $baseport
++            set client [redis $::host $baseport]
+             dict set srv "client" $client
+-            $client select 9
++           # $client select 9
+ 
+             # append the server to the stack
+             lappend ::servers $srv
+diff --git a/tests/support/test.tcl b/tests/support/test.tcl
+index 6f02f2f12..5a31cb4ca 100644
+--- a/tests/support/test.tcl
++++ b/tests/support/test.tcl
+@@ -39,8 +39,8 @@ proc assert_error {pattern code} {
+ }
+ 
+ proc assert_encoding {enc key} {
+-    set dbg [r debug object $key]
+-    assert_match "* encoding:$enc *" $dbg
++#    set dbg [r debug object $key]
++#    assert_match "* encoding:$enc *" $dbg
+ }
+ 
+ proc assert_type {type key} {
+diff --git a/tests/test_helper.tcl b/tests/test_helper.tcl
+index 8978631e0..33c10eb15 100644
+--- a/tests/test_helper.tcl
++++ b/tests/test_helper.tcl
+@@ -144,14 +144,14 @@ proc reconnect {args} {
+     set srv [lindex $::servers end+$level]
+     set host [dict get $srv "host"]
+     set port [dict get $srv "port"]
+-    set config [dict get $srv "config"]
++# set config [dict get $srv "config"]
+     set client [redis $host $port]
+     dict set srv "client" $client
+ 
+     # select the right db when we don't have to authenticate
+-    if {![dict exists $config "requirepass"]} {
+-        $client select 9
+-    }
++#    if {![dict exists $config "requirepass"]} {
++#        $client select 9
++#    }
+ 
+     # re-set $srv in the servers list
+     lset ::servers end+$level $srv
+@@ -168,7 +168,7 @@ proc redis_deferring_client {args} {
+     set client [redis [srv $level "host"] [srv $level "port"] 1]
+ 
+     # select the right db and read the response (OK)
+-    $client select 9
++    $client select 0
+     $client read
+     return $client
+ }
+@@ -488,6 +488,7 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
+     } elseif {$opt eq {--host}} {
+         set ::external 1
+         set ::host $arg
++        set ::numclients 1
+         incr j
+     } elseif {$opt eq {--port}} {
+         set ::port $arg
+diff --git a/tests/unit/auth.tcl b/tests/unit/auth.tcl
+index f5da728e8..6ae96f295 100644
+--- a/tests/unit/auth.tcl
++++ b/tests/unit/auth.tcl
+@@ -1,15 +1,16 @@
+-start_server {tags {"auth"}} {
+-    test {AUTH fails if there is no password configured server side} {
+-        catch {r auth foo} err
+-        set _ $err
+-    } {ERR*no password*}
+-}
++#we don't currently integrate with Redis's tag system to remove our server's password
++#start_server {tags {"auth"}} {
++#    test {AUTH fails if there is no password configured server side} {
++#        catch {r auth foo} err
++#        set _ $err
++#    } {ERR*no password*}
++#}
+ 
+ start_server {tags {"auth"} overrides {requirepass foobar}} {
+     test {AUTH fails when a wrong password is given} {
+         catch {r auth wrong!} err
+         set _ $err
+-    } {ERR*invalid password}
++    } {WRONGPASS invalid username-password pair or user is disabled.}
+ 
+     test {Arbitrary command gives an error when AUTH is required} {
+         catch {r set foo bar} err
+@@ -17,7 +18,7 @@ start_server {tags {"auth"} overrides {requirepass foobar}} {
+     } {NOAUTH*}
+ 
+     test {AUTH succeeds when the right password is given} {
+-        r auth foobar
++        r auth dataWrite dataWrite
+     } {OK}
+ 
+     test {Once AUTH succeeded we can actually send commands to the server} {
+@@ -25,19 +26,19 @@ start_server {tags {"auth"} overrides {requirepass foobar}} {
+         r incr foo
+     } {101}
+ 
+-    test {For unauthenticated clients multibulk and bulk length are limited} {
+-        set rr [redis [srv "host"] [srv "port"] 0]
+-        $rr write "*100\r\n"
+-        $rr flush
+-        catch {[$rr read]} e
+-        assert_match {*unauthenticated multibulk length*} $e
+-        $rr close
+-
+-        set rr [redis [srv "host"] [srv "port"] 0]
+-        $rr write "*1\r\n\$100000000\r\n"
+-        $rr flush
+-        catch {[$rr read]} e
+-        assert_match {*unauthenticated bulk length*} $e
+-        $rr close
+-    }
++#    test {For unauthenticated clients multibulk and bulk length are limited} {
++#        set rr [redis [srv "host"] [srv "port"] 0]
++#        $rr write "*100\r\n"
++#        $rr flush
++#        catch {[$rr read]} e
++#        assert_match {*unauthenticated multibulk length*} $e
++#        $rr close
++#
++#        set rr [redis [srv "host"] [srv "port"] 0]
++#        $rr write "*1\r\n\$100000000\r\n"
++#        $rr flush
++#        catch {[$rr read]} e
++#        assert_match {*unauthenticated bulk length*} $e
++#        $rr close
++#    }
+ }
+diff --git a/tests/unit/dump.tcl b/tests/unit/dump.tcl
+index 4c4e5d075..18bb694f2 100644
+--- a/tests/unit/dump.tcl
++++ b/tests/unit/dump.tcl
+@@ -41,34 +41,35 @@ start_server {tags {"dump"}} {
+         r set foo bar
+         set encoded [r dump foo]
+         set now [clock milliseconds]
+-        r debug set-active-expire 0
++#        r debug set-active-expire 0
+         r restore foo [expr $now-3000] $encoded absttl REPLACE
+-        catch {r debug object foo} e
+-        r debug set-active-expire 1
+-        set e
+-    } {ERR no such key}
+-
+-    test {RESTORE can set LRU} {
+-        r set foo bar
+-        set encoded [r dump foo]
+-        r del foo
+-        r config set maxmemory-policy allkeys-lru
+-        r restore foo 0 $encoded idletime 1000
+-        set idle [r object idletime foo]
+-        assert {$idle >= 1000 && $idle <= 1010}
+-        r get foo
+-    } {bar}
+-    
+-    test {RESTORE can set LFU} {
+-        r set foo bar
+-        set encoded [r dump foo]
+-        r del foo
+-        r config set maxmemory-policy allkeys-lfu
+-        r restore foo 0 $encoded freq 100
+-        set freq [r object freq foo]
+-        assert {$freq == 100}
++#        catch {r debug object foo} e
++#        r debug set-active-expire 1
++#        set e
+         r get foo
+-    } {bar}
++    } {}
++
++#    test {RESTORE can set LRU} {
++#        r set foo bar
++#        set encoded [r dump foo]
++#        r del foo
++#        r config set maxmemory-policy allkeys-lru
++#        r restore foo 0 $encoded idletime 1000
++#        set idle [r object idletime foo]
++#        assert {$idle >= 1000 && $idle <= 1010}
++#        r get foo
++#    } {bar}
++#    
++#    test {RESTORE can set LFU} {
++#        r set foo bar
++#        set encoded [r dump foo]
++#        r del foo
++#        r config set maxmemory-policy allkeys-lfu
++#        r restore foo 0 $encoded freq 100
++#        set freq [r object freq foo]
++#        assert {$freq == 100}
++#        r get foo
++#    } {bar}
+ 
+     test {RESTORE returns an error of the key already exists} {
+         r set foo bar
+@@ -97,283 +98,283 @@ start_server {tags {"dump"}} {
+         r dump nonexisting_key
+     } {}
+ 
+-    test {MIGRATE is caching connections} {
+-        # Note, we run this as first test so that the connection cache
+-        # is empty.
+-        set first [srv 0 client]
+-        r set key "Some Value"
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert_match {*migrate_cached_sockets:0*} [r -1 info]
+-            r -1 migrate $second_host $second_port key 9 1000
+-            assert_match {*migrate_cached_sockets:1*} [r -1 info]
+-        }
+-    }
+-
+-    test {MIGRATE cached connections are released after some time} {
+-        after 15000
+-        assert_match {*migrate_cached_sockets:0*} [r info]
+-    }
+-
+-    test {MIGRATE is able to migrate a key between two instances} {
+-        set first [srv 0 client]
+-        r set key "Some Value"
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert {[$first exists key] == 1}
+-            assert {[$second exists key] == 0}
+-            set ret [r -1 migrate $second_host $second_port key 9 5000]
+-            assert {$ret eq {OK}}
+-            assert {[$first exists key] == 0}
+-            assert {[$second exists key] == 1}
+-            assert {[$second get key] eq {Some Value}}
+-            assert {[$second ttl key] == -1}
+-        }
+-    }
+-
+-    test {MIGRATE is able to copy a key between two instances} {
+-        set first [srv 0 client]
+-        r del list
+-        r lpush list a b c d
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert {[$first exists list] == 1}
+-            assert {[$second exists list] == 0}
+-            set ret [r -1 migrate $second_host $second_port list 9 5000 copy]
+-            assert {$ret eq {OK}}
+-            assert {[$first exists list] == 1}
+-            assert {[$second exists list] == 1}
+-            assert {[$first lrange list 0 -1] eq [$second lrange list 0 -1]}
+-        }
+-    }
+-
+-    test {MIGRATE will not overwrite existing keys, unless REPLACE is used} {
+-        set first [srv 0 client]
+-        r del list
+-        r lpush list a b c d
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert {[$first exists list] == 1}
+-            assert {[$second exists list] == 0}
+-            $second set list somevalue
+-            catch {r -1 migrate $second_host $second_port list 9 5000 copy} e
+-            assert_match {ERR*} $e
+-            set res [r -1 migrate $second_host $second_port list 9 5000 copy replace]
+-            assert {$ret eq {OK}}
+-            assert {[$first exists list] == 1}
+-            assert {[$second exists list] == 1}
+-            assert {[$first lrange list 0 -1] eq [$second lrange list 0 -1]}
+-        }
+-    }
+-
+-    test {MIGRATE propagates TTL correctly} {
+-        set first [srv 0 client]
+-        r set key "Some Value"
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert {[$first exists key] == 1}
+-            assert {[$second exists key] == 0}
+-            $first expire key 10
+-            set ret [r -1 migrate $second_host $second_port key 9 5000]
+-            assert {$ret eq {OK}}
+-            assert {[$first exists key] == 0}
+-            assert {[$second exists key] == 1}
+-            assert {[$second get key] eq {Some Value}}
+-            assert {[$second ttl key] >= 7 && [$second ttl key] <= 10}
+-        }
+-    }
+-
+-    test {MIGRATE can correctly transfer large values} {
+-        set first [srv 0 client]
+-        r del key
+-        for {set j 0} {$j < 40000} {incr j} {
+-            r rpush key 1 2 3 4 5 6 7 8 9 10
+-            r rpush key "item 1" "item 2" "item 3" "item 4" "item 5" \
+-                        "item 6" "item 7" "item 8" "item 9" "item 10"
+-        }
+-        assert {[string length [r dump key]] > (1024*64)}
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert {[$first exists key] == 1}
+-            assert {[$second exists key] == 0}
+-            set ret [r -1 migrate $second_host $second_port key 9 10000]
+-            assert {$ret eq {OK}}
+-            assert {[$first exists key] == 0}
+-            assert {[$second exists key] == 1}
+-            assert {[$second ttl key] == -1}
+-            assert {[$second llen key] == 40000*20}
+-        }
+-    }
+-
+-    test {MIGRATE can correctly transfer hashes} {
+-        set first [srv 0 client]
+-        r del key
+-        r hmset key field1 "item 1" field2 "item 2" field3 "item 3" \
+-                    field4 "item 4" field5 "item 5" field6 "item 6"
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert {[$first exists key] == 1}
+-            assert {[$second exists key] == 0}
+-            set ret [r -1 migrate $second_host $second_port key 9 10000]
+-            assert {$ret eq {OK}}
+-            assert {[$first exists key] == 0}
+-            assert {[$second exists key] == 1}
+-            assert {[$second ttl key] == -1}
+-        }
+-    }
+-
+-    test {MIGRATE timeout actually works} {
+-        set first [srv 0 client]
+-        r set key "Some Value"
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert {[$first exists key] == 1}
+-            assert {[$second exists key] == 0}
+-
+-            set rd [redis_deferring_client]
+-            $rd debug sleep 1.0 ; # Make second server unable to reply.
+-            set e {}
+-            catch {r -1 migrate $second_host $second_port key 9 500} e
+-            assert_match {IOERR*} $e
+-        }
+-    }
+-
+-    test {MIGRATE can migrate multiple keys at once} {
+-        set first [srv 0 client]
+-        r set key1 "v1"
+-        r set key2 "v2"
+-        r set key3 "v3"
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            assert {[$first exists key1] == 1}
+-            assert {[$second exists key1] == 0}
+-            set ret [r -1 migrate $second_host $second_port "" 9 5000 keys key1 key2 key3]
+-            assert {$ret eq {OK}}
+-            assert {[$first exists key1] == 0}
+-            assert {[$first exists key2] == 0}
+-            assert {[$first exists key3] == 0}
+-            assert {[$second get key1] eq {v1}}
+-            assert {[$second get key2] eq {v2}}
+-            assert {[$second get key3] eq {v3}}
+-        }
+-    }
+-
+-    test {MIGRATE with multiple keys must have empty key arg} {
+-        catch {r MIGRATE 127.0.0.1 6379 NotEmpty 9 5000 keys a b c} e
+-        set e
+-    } {*empty string*}
+-
+-    test {MIGRATE with multiple keys migrate just existing ones} {
+-        set first [srv 0 client]
+-        r set key1 "v1"
+-        r set key2 "v2"
+-        r set key3 "v3"
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            set ret [r -1 migrate $second_host $second_port "" 9 5000 keys nokey-1 nokey-2 nokey-2]
+-            assert {$ret eq {NOKEY}}
+-
+-            assert {[$first exists key1] == 1}
+-            assert {[$second exists key1] == 0}
+-            set ret [r -1 migrate $second_host $second_port "" 9 5000 keys nokey-1 key1 nokey-2 key2 nokey-3 key3]
+-            assert {$ret eq {OK}}
+-            assert {[$first exists key1] == 0}
+-            assert {[$first exists key2] == 0}
+-            assert {[$first exists key3] == 0}
+-            assert {[$second get key1] eq {v1}}
+-            assert {[$second get key2] eq {v2}}
+-            assert {[$second get key3] eq {v3}}
+-        }
+-    }
+-
+-    test {MIGRATE with multiple keys: stress command rewriting} {
+-        set first [srv 0 client]
+-        r flushdb
+-        r mset a 1 b 2 c 3 d 4 c 5 e 6 f 7 g 8 h 9 i 10 l 11 m 12 n 13 o 14 p 15 q 16
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            set ret [r -1 migrate $second_host $second_port "" 9 5000 keys a b c d e f g h i l m n o p q]
+-
+-            assert {[$first dbsize] == 0}
+-            assert {[$second dbsize] == 15}
+-        }
+-    }
+-
+-    test {MIGRATE with multiple keys: delete just ack keys} {
+-        set first [srv 0 client]
+-        r flushdb
+-        r mset a 1 b 2 c 3 d 4 c 5 e 6 f 7 g 8 h 9 i 10 l 11 m 12 n 13 o 14 p 15 q 16
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-
+-            $second mset c _ d _; # Two busy keys and no REPLACE used
+-
+-            catch {r -1 migrate $second_host $second_port "" 9 5000 keys a b c d e f g h i l m n o p q} e
+-
+-            assert {[$first dbsize] == 2}
+-            assert {[$second dbsize] == 15}
+-            assert {[$first exists c] == 1}
+-            assert {[$first exists d] == 1}
+-        }
+-    }
+-
+-    test {MIGRATE AUTH: correct and wrong password cases} {
+-        set first [srv 0 client]
+-        r del list
+-        r lpush list a b c d
+-        start_server {tags {"repl"}} {
+-            set second [srv 0 client]
+-            set second_host [srv 0 host]
+-            set second_port [srv 0 port]
+-            $second config set requirepass foobar
+-            $second auth foobar
+-
+-            assert {[$first exists list] == 1}
+-            assert {[$second exists list] == 0}
+-            set ret [r -1 migrate $second_host $second_port list 9 5000 AUTH foobar]
+-            assert {$ret eq {OK}}
+-            assert {[$second exists list] == 1}
+-            assert {[$second lrange list 0 -1] eq {d c b a}}
+-
+-            r -1 lpush list a b c d
+-            $second config set requirepass foobar2
+-            catch {r -1 migrate $second_host $second_port list 9 5000 AUTH foobar} err
+-            assert_match {*invalid password*} $err
+-        }
+-    }
++#    test {MIGRATE is caching connections} {
++#        # Note, we run this as first test so that the connection cache
++#        # is empty.
++#        set first [srv 0 client]
++#        r set key "Some Value"
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert_match {*migrate_cached_sockets:0*} [r -1 info]
++#            r -1 migrate $second_host $second_port key 9 1000
++#            assert_match {*migrate_cached_sockets:1*} [r -1 info]
++#        }
++#    }
++#
++#    test {MIGRATE cached connections are released after some time} {
++#        after 15000
++#        assert_match {*migrate_cached_sockets:0*} [r info]
++#    }
++#
++#    test {MIGRATE is able to migrate a key between two instances} {
++#        set first [srv 0 client]
++#        r set key "Some Value"
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert {[$first exists key] == 1}
++#            assert {[$second exists key] == 0}
++#            set ret [r -1 migrate $second_host $second_port key 9 5000]
++#            assert {$ret eq {OK}}
++#            assert {[$first exists key] == 0}
++#            assert {[$second exists key] == 1}
++#            assert {[$second get key] eq {Some Value}}
++#            assert {[$second ttl key] == -1}
++#        }
++#    }
++#
++#    test {MIGRATE is able to copy a key between two instances} {
++#        set first [srv 0 client]
++#        r del list
++#        r lpush list a b c d
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert {[$first exists list] == 1}
++#            assert {[$second exists list] == 0}
++#            set ret [r -1 migrate $second_host $second_port list 9 5000 copy]
++#            assert {$ret eq {OK}}
++#            assert {[$first exists list] == 1}
++#            assert {[$second exists list] == 1}
++#            assert {[$first lrange list 0 -1] eq [$second lrange list 0 -1]}
++#        }
++#    }
++#
++#    test {MIGRATE will not overwrite existing keys, unless REPLACE is used} {
++#        set first [srv 0 client]
++#        r del list
++#        r lpush list a b c d
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert {[$first exists list] == 1}
++#            assert {[$second exists list] == 0}
++#            $second set list somevalue
++#            catch {r -1 migrate $second_host $second_port list 9 5000 copy} e
++#            assert_match {ERR*} $e
++#            set res [r -1 migrate $second_host $second_port list 9 5000 copy replace]
++#            assert {$ret eq {OK}}
++#            assert {[$first exists list] == 1}
++#            assert {[$second exists list] == 1}
++#            assert {[$first lrange list 0 -1] eq [$second lrange list 0 -1]}
++#        }
++#    }
++#
++#    test {MIGRATE propagates TTL correctly} {
++#        set first [srv 0 client]
++#        r set key "Some Value"
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert {[$first exists key] == 1}
++#            assert {[$second exists key] == 0}
++#            $first expire key 10
++#            set ret [r -1 migrate $second_host $second_port key 9 5000]
++#            assert {$ret eq {OK}}
++#            assert {[$first exists key] == 0}
++#            assert {[$second exists key] == 1}
++#            assert {[$second get key] eq {Some Value}}
++#            assert {[$second ttl key] >= 7 && [$second ttl key] <= 10}
++#        }
++#    }
++#
++#    test {MIGRATE can correctly transfer large values} {
++#        set first [srv 0 client]
++#        r del key
++#        for {set j 0} {$j < 40000} {incr j} {
++#            r rpush key 1 2 3 4 5 6 7 8 9 10
++#            r rpush key "item 1" "item 2" "item 3" "item 4" "item 5" \
++#                        "item 6" "item 7" "item 8" "item 9" "item 10"
++#        }
++#        assert {[string length [r dump key]] > (1024*64)}
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert {[$first exists key] == 1}
++#            assert {[$second exists key] == 0}
++#            set ret [r -1 migrate $second_host $second_port key 9 10000]
++#            assert {$ret eq {OK}}
++#            assert {[$first exists key] == 0}
++#            assert {[$second exists key] == 1}
++#            assert {[$second ttl key] == -1}
++#            assert {[$second llen key] == 40000*20}
++#        }
++#    }
++#
++#    test {MIGRATE can correctly transfer hashes} {
++#        set first [srv 0 client]
++#        r del key
++#        r hmset key field1 "item 1" field2 "item 2" field3 "item 3" \
++#                    field4 "item 4" field5 "item 5" field6 "item 6"
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert {[$first exists key] == 1}
++#            assert {[$second exists key] == 0}
++#            set ret [r -1 migrate $second_host $second_port key 9 10000]
++#            assert {$ret eq {OK}}
++#            assert {[$first exists key] == 0}
++#            assert {[$second exists key] == 1}
++#            assert {[$second ttl key] == -1}
++#        }
++#    }
++#
++#    test {MIGRATE timeout actually works} {
++#        set first [srv 0 client]
++#        r set key "Some Value"
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert {[$first exists key] == 1}
++#            assert {[$second exists key] == 0}
++#
++#            set rd [redis_deferring_client]
++#            $rd debug sleep 1.0 ; # Make second server unable to reply.
++#            set e {}
++#            catch {r -1 migrate $second_host $second_port key 9 500} e
++#            assert_match {IOERR*} $e
++#        }
++#    }
++#
++#    test {MIGRATE can migrate multiple keys at once} {
++#        set first [srv 0 client]
++#        r set key1 "v1"
++#        r set key2 "v2"
++#        r set key3 "v3"
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            assert {[$first exists key1] == 1}
++#            assert {[$second exists key1] == 0}
++#            set ret [r -1 migrate $second_host $second_port "" 9 5000 keys key1 key2 key3]
++#            assert {$ret eq {OK}}
++#            assert {[$first exists key1] == 0}
++#            assert {[$first exists key2] == 0}
++#            assert {[$first exists key3] == 0}
++#            assert {[$second get key1] eq {v1}}
++#            assert {[$second get key2] eq {v2}}
++#            assert {[$second get key3] eq {v3}}
++#        }
++#    }
++#
++#    test {MIGRATE with multiple keys must have empty key arg} {
++#        catch {r MIGRATE 127.0.0.1 6379 NotEmpty 9 5000 keys a b c} e
++#        set e
++#    } {*empty string*}
++#
++#    test {MIGRATE with multiple keys migrate just existing ones} {
++#        set first [srv 0 client]
++#        r set key1 "v1"
++#        r set key2 "v2"
++#        r set key3 "v3"
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            set ret [r -1 migrate $second_host $second_port "" 9 5000 keys nokey-1 nokey-2 nokey-2]
++#            assert {$ret eq {NOKEY}}
++#
++#            assert {[$first exists key1] == 1}
++#            assert {[$second exists key1] == 0}
++#            set ret [r -1 migrate $second_host $second_port "" 9 5000 keys nokey-1 key1 nokey-2 key2 nokey-3 key3]
++#            assert {$ret eq {OK}}
++#            assert {[$first exists key1] == 0}
++#            assert {[$first exists key2] == 0}
++#            assert {[$first exists key3] == 0}
++#            assert {[$second get key1] eq {v1}}
++#            assert {[$second get key2] eq {v2}}
++#            assert {[$second get key3] eq {v3}}
++#        }
++#    }
++#
++#    test {MIGRATE with multiple keys: stress command rewriting} {
++#        set first [srv 0 client]
++#        r flushdb
++#        r mset a 1 b 2 c 3 d 4 c 5 e 6 f 7 g 8 h 9 i 10 l 11 m 12 n 13 o 14 p 15 q 16
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            set ret [r -1 migrate $second_host $second_port "" 9 5000 keys a b c d e f g h i l m n o p q]
++#
++#            assert {[$first dbsize] == 0}
++#            assert {[$second dbsize] == 15}
++#        }
++#    }
++#
++#    test {MIGRATE with multiple keys: delete just ack keys} {
++#        set first [srv 0 client]
++#        r flushdb
++#        r mset a 1 b 2 c 3 d 4 c 5 e 6 f 7 g 8 h 9 i 10 l 11 m 12 n 13 o 14 p 15 q 16
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#
++#            $second mset c _ d _; # Two busy keys and no REPLACE used
++#
++#            catch {r -1 migrate $second_host $second_port "" 9 5000 keys a b c d e f g h i l m n o p q} e
++#
++#            assert {[$first dbsize] == 2}
++#            assert {[$second dbsize] == 15}
++#            assert {[$first exists c] == 1}
++#            assert {[$first exists d] == 1}
++#        }
++#    }
++#
++#    test {MIGRATE AUTH: correct and wrong password cases} {
++#        set first [srv 0 client]
++#        r del list
++#        r lpush list a b c d
++#        start_server {tags {"repl"}} {
++#            set second [srv 0 client]
++#            set second_host [srv 0 host]
++#            set second_port [srv 0 port]
++#            $second config set requirepass foobar
++#            $second auth foobar
++#
++#            assert {[$first exists list] == 1}
++#            assert {[$second exists list] == 0}
++#            set ret [r -1 migrate $second_host $second_port list 9 5000 AUTH foobar]
++#            assert {$ret eq {OK}}
++#            assert {[$second exists list] == 1}
++#            assert {[$second lrange list 0 -1] eq {d c b a}}
++#
++#            r -1 lpush list a b c d
++#            $second config set requirepass foobar2
++#            catch {r -1 migrate $second_host $second_port list 9 5000 AUTH foobar} err
++#            assert_match {*invalid password*} $err
++#        }
++#    }
+ }
+diff --git a/tests/unit/expire.tcl b/tests/unit/expire.tcl
+index de24eabed..533eca9ac 100644
+--- a/tests/unit/expire.tcl
++++ b/tests/unit/expire.tcl
+@@ -7,7 +7,7 @@ start_server {tags {"expire"}} {
+         set v4 [r ttl x]
+         r expire x 2
+         list $v1 $v2 $v3 $v4
+-    } {1 [45] 1 10}
++    } {1 [45] 1 [19-]0}
+ 
+     test {EXPIRE - It should be still possible to read 'x'} {
+         r get x
+@@ -22,11 +22,11 @@ start_server {tags {"expire"}} {
+ 
+     test {EXPIRE - write on expire should work} {
+         r del x
+-        r lpush x foo
++        r set x foo
+         r expire x 1000
+-        r lpush x bar
+-        r lrange x 0 -1
+-    } {bar foo}
++        r set x bar
++        r get x
++    } {bar}
+ 
+     test {EXPIREAT - Check for EXPIRE alike behavior} {
+         r del x
+@@ -56,16 +56,16 @@ start_server {tags {"expire"}} {
+         } {}
+     }
+ 
+-    test {SETEX - Wrong time parameter} {
+-        catch {r setex z -10 foo} e
+-        set _ $e
+-    } {*invalid expire*}
++    #test {SETEX - Wrong time parameter} {
++    #    catch {r setex z -10 foo} e
++    #    set _ $e
++    #} {*invalid expire*}
+ 
+     test {PERSIST can undo an EXPIRE} {
+         r set x foo
+         r expire x 50
+         list [r ttl x] [r persist x] [r ttl x] [r get x]
+-    } {50 1 -1 foo}
++    } {[45][90] 1 -1 foo}
+ 
+     test {PERSIST returns 0 against non existing or non volatile keys} {
+         r set x foo
+@@ -146,47 +146,47 @@ start_server {tags {"expire"}} {
+         list [r ttl x] [r pttl x]
+     } {-2 -2}
+ 
+-    test {Redis should actively expire keys incrementally} {
+-        r flushdb
+-        r psetex key1 500 a
+-        r psetex key2 500 a
+-        r psetex key3 500 a
+-        set size1 [r dbsize]
+-        # Redis expires random keys ten times every second so we are
+-        # fairly sure that all the three keys should be evicted after
+-        # one second.
+-        after 1000
+-        set size2 [r dbsize]
+-        list $size1 $size2
+-    } {3 0}
+-
+-    test {Redis should lazy expire keys} {
+-        r flushdb
+-        r debug set-active-expire 0
+-        r psetex key1 500 a
+-        r psetex key2 500 a
+-        r psetex key3 500 a
+-        set size1 [r dbsize]
+-        # Redis expires random keys ten times every second so we are
+-        # fairly sure that all the three keys should be evicted after
+-        # one second.
+-        after 1000
+-        set size2 [r dbsize]
+-        r mget key1 key2 key3
+-        set size3 [r dbsize]
+-        r debug set-active-expire 1
+-        list $size1 $size2 $size3
+-    } {3 3 0}
+-
+-    test {EXPIRE should not resurrect keys (issue #1026)} {
+-        r debug set-active-expire 0
+-        r set foo bar
+-        r pexpire foo 500
+-        after 1000
+-        r expire foo 10
+-        r debug set-active-expire 1
+-        r exists foo
+-    } {0}
++#    test {Redis should actively expire keys incrementally} {
++#        r flushdb
++#        r psetex key1 500 a
++#        r psetex key2 500 a
++#        r psetex key3 500 a
++#        set size1 [r dbsize]
++#        # Redis expires random keys ten times every second so we are
++#        # fairly sure that all the three keys should be evicted after
++#        # one second.
++#        after 1000
++#        set size2 [r dbsize]
++#        list $size1 $size2
++#    } {3 0}
++
++ #   test {Redis should lazy expire keys} {
++ #       r flushdb
++ #       r debug set-active-expire 0
++ #       r psetex key1 500 a
++ #       r psetex key2 500 a
++ #       r psetex key3 500 a
++ #       set size1 [r dbsize]
++ #       # Redis expires random keys ten times every second so we are
++ #       # fairly sure that all the three keys should be evicted after
++ #       # one second.
++ #       after 1000
++ #       set size2 [r dbsize]
++ #       r mget key1 key2 key3
++ #       set size3 [r dbsize]
++ #       r debug set-active-expire 1
++ #       list $size1 $size2 $size3
++ #   } {3 3 0}
++
++#    test {EXPIRE should not resurrect keys (issue #1026)} {
++#        r debug set-active-expire 0
++#        r set foo bar
++#        r pexpire foo 500
++#        after 1000
++#        r expire foo 10
++#        r debug set-active-expire 1
++#        r exists foo
++#    } {0}
+ 
+     test {5 keys in, 5 keys out} {
+         r flushdb
+@@ -205,18 +205,18 @@ start_server {tags {"expire"}} {
+         set e
+     } {*not an integer*}
+ 
+-    test {SET - use EX/PX option, TTL should not be reseted after loadaof} {
+-        r config set appendonly yes
+-        r set foo bar EX 100
+-        after 2000
+-        r debug loadaof
+-        set ttl [r ttl foo]
+-        assert {$ttl <= 98 && $ttl > 90}
+-
+-        r set foo bar PX 100000
+-        after 2000
+-        r debug loadaof
+-        set ttl [r ttl foo]
+-        assert {$ttl <= 98 && $ttl > 90}
+-    }
++#    test {SET - use EX/PX option, TTL should not be reseted after loadaof} {
++#        r config set appendonly yes
++#        r set foo bar EX 100
++#        after 2000
++#        r debug loadaof
++#        set ttl [r ttl foo]
++#        assert {$ttl <= 98 && $ttl > 90}
++#
++#        r set foo bar PX 100000
++#        after 2000
++#        r debug loadaof
++#        set ttl [r ttl foo]
++#        assert {$ttl <= 98 && $ttl > 90}
++#    }
+ }
+diff --git a/tests/unit/pubsub.tcl b/tests/unit/pubsub.tcl
+index 9c7a43bf0..16173b654 100644
+--- a/tests/unit/pubsub.tcl
++++ b/tests/unit/pubsub.tcl
+@@ -107,6 +107,7 @@ start_server {tags {"pubsub"}} {
+         set rd1 [redis_deferring_client]
+         assert_equal {1 2 3} [subscribe $rd1 {chan1 chan2 chan3}]
+         unsubscribe $rd1
++        after 500
+         assert_equal 0 [r publish chan1 hello]
+         assert_equal 0 [r publish chan2 hello]
+         assert_equal 0 [r publish chan3 hello]
+@@ -180,6 +181,7 @@ start_server {tags {"pubsub"}} {
+         set rd1 [redis_deferring_client]
+         assert_equal {1 2 3} [psubscribe $rd1 {chan1.* chan2.* chan3.*}]
+         punsubscribe $rd1
++        after 500
+         assert_equal 0 [r publish chan1.hi hello]
+         assert_equal 0 [r publish chan2.hi hello]
+         assert_equal 0 [r publish chan3.hi hello]
+@@ -223,168 +225,168 @@ start_server {tags {"pubsub"}} {
+         concat $reply1 $reply2
+     } {punsubscribe {} 0 unsubscribe {} 0}
+ 
+-    ### Keyspace events notification tests
+-
+-    test "Keyspace notifications: we receive keyspace notifications" {
+-        r config set notify-keyspace-events KA
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r set foo bar
+-        assert_equal {pmessage * __keyspace@9__:foo set} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: we receive keyevent notifications" {
+-        r config set notify-keyspace-events EA
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r set foo bar
+-        assert_equal {pmessage * __keyevent@9__:set foo} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: we can receive both kind of events" {
+-        r config set notify-keyspace-events KEA
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r set foo bar
+-        assert_equal {pmessage * __keyspace@9__:foo set} [$rd1 read]
+-        assert_equal {pmessage * __keyevent@9__:set foo} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: we are able to mask events" {
+-        r config set notify-keyspace-events KEl
+-        r del mylist
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r set foo bar
+-        r lpush mylist a
+-        # No notification for set, because only list commands are enabled.
+-        assert_equal {pmessage * __keyspace@9__:mylist lpush} [$rd1 read]
+-        assert_equal {pmessage * __keyevent@9__:lpush mylist} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: general events test" {
+-        r config set notify-keyspace-events KEg
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r set foo bar
+-        r expire foo 1
+-        r del foo
+-        assert_equal {pmessage * __keyspace@9__:foo expire} [$rd1 read]
+-        assert_equal {pmessage * __keyevent@9__:expire foo} [$rd1 read]
+-        assert_equal {pmessage * __keyspace@9__:foo del} [$rd1 read]
+-        assert_equal {pmessage * __keyevent@9__:del foo} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: list events test" {
+-        r config set notify-keyspace-events KEl
+-        r del mylist
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r lpush mylist a
+-        r rpush mylist a
+-        r rpop mylist
+-        assert_equal {pmessage * __keyspace@9__:mylist lpush} [$rd1 read]
+-        assert_equal {pmessage * __keyevent@9__:lpush mylist} [$rd1 read]
+-        assert_equal {pmessage * __keyspace@9__:mylist rpush} [$rd1 read]
+-        assert_equal {pmessage * __keyevent@9__:rpush mylist} [$rd1 read]
+-        assert_equal {pmessage * __keyspace@9__:mylist rpop} [$rd1 read]
+-        assert_equal {pmessage * __keyevent@9__:rpop mylist} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: set events test" {
+-        r config set notify-keyspace-events Ks
+-        r del myset
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r sadd myset a b c d
+-        r srem myset x
+-        r sadd myset x y z
+-        r srem myset x
+-        assert_equal {pmessage * __keyspace@9__:myset sadd} [$rd1 read]
+-        assert_equal {pmessage * __keyspace@9__:myset sadd} [$rd1 read]
+-        assert_equal {pmessage * __keyspace@9__:myset srem} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: zset events test" {
+-        r config set notify-keyspace-events Kz
+-        r del myzset
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r zadd myzset 1 a 2 b
+-        r zrem myzset x
+-        r zadd myzset 3 x 4 y 5 z
+-        r zrem myzset x
+-        assert_equal {pmessage * __keyspace@9__:myzset zadd} [$rd1 read]
+-        assert_equal {pmessage * __keyspace@9__:myzset zadd} [$rd1 read]
+-        assert_equal {pmessage * __keyspace@9__:myzset zrem} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: hash events test" {
+-        r config set notify-keyspace-events Kh
+-        r del myhash
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r hmset myhash yes 1 no 0
+-        r hincrby myhash yes 10
+-        assert_equal {pmessage * __keyspace@9__:myhash hset} [$rd1 read]
+-        assert_equal {pmessage * __keyspace@9__:myhash hincrby} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: expired events (triggered expire)" {
+-        r config set notify-keyspace-events Ex
+-        r del foo
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r psetex foo 100 1
+-        wait_for_condition 50 100 {
+-            [r exists foo] == 0
+-        } else {
+-            fail "Key does not expire?!"
+-        }
+-        assert_equal {pmessage * __keyevent@9__:expired foo} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: expired events (background expire)" {
+-        r config set notify-keyspace-events Ex
+-        r del foo
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r psetex foo 100 1
+-        assert_equal {pmessage * __keyevent@9__:expired foo} [$rd1 read]
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: evicted events" {
+-        r config set notify-keyspace-events Ee
+-        r config set maxmemory-policy allkeys-lru
+-        r flushdb
+-        set rd1 [redis_deferring_client]
+-        assert_equal {1} [psubscribe $rd1 *]
+-        r set foo bar
+-        r config set maxmemory 1
+-        assert_equal {pmessage * __keyevent@9__:evicted foo} [$rd1 read]
+-        r config set maxmemory 0
+-        $rd1 close
+-    }
+-
+-    test "Keyspace notifications: test CONFIG GET/SET of event flags" {
+-        r config set notify-keyspace-events gKE
+-        assert_equal {gKE} [lindex [r config get notify-keyspace-events] 1]
+-        r config set notify-keyspace-events {$lshzxeKE}
+-        assert_equal {$lshzxeKE} [lindex [r config get notify-keyspace-events] 1]
+-        r config set notify-keyspace-events KA
+-        assert_equal {AK} [lindex [r config get notify-keyspace-events] 1]
+-        r config set notify-keyspace-events EA
+-        assert_equal {AE} [lindex [r config get notify-keyspace-events] 1]
+-    }
++#    ### Keyspace events notification tests
++#
++#    test "Keyspace notifications: we receive keyspace notifications" {
++#        r config set notify-keyspace-events KA
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r set foo bar
++#        assert_equal {pmessage * __keyspace@9__:foo set} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: we receive keyevent notifications" {
++#        r config set notify-keyspace-events EA
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r set foo bar
++#        assert_equal {pmessage * __keyevent@9__:set foo} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: we can receive both kind of events" {
++#        r config set notify-keyspace-events KEA
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r set foo bar
++#        assert_equal {pmessage * __keyspace@9__:foo set} [$rd1 read]
++#        assert_equal {pmessage * __keyevent@9__:set foo} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: we are able to mask events" {
++#        r config set notify-keyspace-events KEl
++#        r del mylist
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r set foo bar
++#        r lpush mylist a
++#        # No notification for set, because only list commands are enabled.
++#        assert_equal {pmessage * __keyspace@9__:mylist lpush} [$rd1 read]
++#        assert_equal {pmessage * __keyevent@9__:lpush mylist} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: general events test" {
++#        r config set notify-keyspace-events KEg
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r set foo bar
++#        r expire foo 1
++#        r del foo
++#        assert_equal {pmessage * __keyspace@9__:foo expire} [$rd1 read]
++#        assert_equal {pmessage * __keyevent@9__:expire foo} [$rd1 read]
++#        assert_equal {pmessage * __keyspace@9__:foo del} [$rd1 read]
++#        assert_equal {pmessage * __keyevent@9__:del foo} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: list events test" {
++#        r config set notify-keyspace-events KEl
++#        r del mylist
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r lpush mylist a
++#        r rpush mylist a
++#        r rpop mylist
++#        assert_equal {pmessage * __keyspace@9__:mylist lpush} [$rd1 read]
++#        assert_equal {pmessage * __keyevent@9__:lpush mylist} [$rd1 read]
++#        assert_equal {pmessage * __keyspace@9__:mylist rpush} [$rd1 read]
++#        assert_equal {pmessage * __keyevent@9__:rpush mylist} [$rd1 read]
++#        assert_equal {pmessage * __keyspace@9__:mylist rpop} [$rd1 read]
++#        assert_equal {pmessage * __keyevent@9__:rpop mylist} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: set events test" {
++#        r config set notify-keyspace-events Ks
++#        r del myset
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r sadd myset a b c d
++#        r srem myset x
++#        r sadd myset x y z
++#        r srem myset x
++#        assert_equal {pmessage * __keyspace@9__:myset sadd} [$rd1 read]
++#        assert_equal {pmessage * __keyspace@9__:myset sadd} [$rd1 read]
++#        assert_equal {pmessage * __keyspace@9__:myset srem} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: zset events test" {
++#        r config set notify-keyspace-events Kz
++#        r del myzset
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r zadd myzset 1 a 2 b
++#        r zrem myzset x
++#        r zadd myzset 3 x 4 y 5 z
++#        r zrem myzset x
++#        assert_equal {pmessage * __keyspace@9__:myzset zadd} [$rd1 read]
++#        assert_equal {pmessage * __keyspace@9__:myzset zadd} [$rd1 read]
++#        assert_equal {pmessage * __keyspace@9__:myzset zrem} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: hash events test" {
++#        r config set notify-keyspace-events Kh
++#        r del myhash
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r hmset myhash yes 1 no 0
++#        r hincrby myhash yes 10
++#        assert_equal {pmessage * __keyspace@9__:myhash hset} [$rd1 read]
++#        assert_equal {pmessage * __keyspace@9__:myhash hincrby} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: expired events (triggered expire)" {
++#        r config set notify-keyspace-events Ex
++#        r del foo
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r psetex foo 100 1
++#        wait_for_condition 50 100 {
++#            [r exists foo] == 0
++#        } else {
++#            fail "Key does not expire?!"
++#        }
++#        assert_equal {pmessage * __keyevent@9__:expired foo} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: expired events (background expire)" {
++#        r config set notify-keyspace-events Ex
++#        r del foo
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r psetex foo 100 1
++#        assert_equal {pmessage * __keyevent@9__:expired foo} [$rd1 read]
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: evicted events" {
++#        r config set notify-keyspace-events Ee
++#        r config set maxmemory-policy allkeys-lru
++#        r flushdb
++#        set rd1 [redis_deferring_client]
++#        assert_equal {1} [psubscribe $rd1 *]
++#        r set foo bar
++#        r config set maxmemory 1
++#        assert_equal {pmessage * __keyevent@9__:evicted foo} [$rd1 read]
++#        r config set maxmemory 0
++#        $rd1 close
++#    }
++#
++#    test "Keyspace notifications: test CONFIG GET/SET of event flags" {
++#        r config set notify-keyspace-events gKE
++#        assert_equal {gKE} [lindex [r config get notify-keyspace-events] 1]
++#        r config set notify-keyspace-events {$lshzxeKE}
++#        assert_equal {$lshzxeKE} [lindex [r config get notify-keyspace-events] 1]
++#        r config set notify-keyspace-events KA
++#        assert_equal {AK} [lindex [r config get notify-keyspace-events] 1]
++#        r config set notify-keyspace-events EA
++#        assert_equal {AE} [lindex [r config get notify-keyspace-events] 1]
++#    }
+ }
+diff --git a/tests/unit/quit.tcl b/tests/unit/quit.tcl
+index 4cf440abf..990513d50 100644
+--- a/tests/unit/quit.tcl
++++ b/tests/unit/quit.tcl
+@@ -16,17 +16,18 @@ start_server {tags {"quit"}} {
+     test "Pipelined commands after QUIT must not be executed" {
+         reconnect
+         r write [format_command quit]
+-        r write [format_command set foo bar]
++        r write [format_command set foox bar]
+         r flush
+         assert_equal OK [r read]
+         assert_error * {r read}
+ 
+         reconnect
+-        assert_equal {} [r get foo]
++        assert_equal {} [r get foox]
+     }
+ 
+     test "Pipelined commands after QUIT that exceed read buffer size" {
+         reconnect
++        r del foo
+         r write [format_command quit]
+         r write [format_command set foo [string repeat "x" 1024]]
+         r flush
+diff --git a/tests/unit/type/hash.tcl b/tests/unit/type/hash.tcl
+index d2c679d32..6d17de48b 100644
+--- a/tests/unit/type/hash.tcl
++++ b/tests/unit/type/hash.tcl
+@@ -252,10 +252,10 @@ start_server {tags {"hash"}} {
+         lappend rv [r hexists bighash nokey]
+     } {1 0 1 0}
+ 
+-    test {Is a ziplist encoded Hash promoted on big payload?} {
+-        r hset smallhash foo [string repeat a 1024]
+-        r debug object smallhash
+-    } {*hashtable*}
++    #test {Is a ziplist encoded Hash promoted on big payload?} {
++        #r hset smallhash foo [string repeat a 1024]
++        #r debug object smallhash
++    #} {*hashtable*}
+ 
+     test {HINCRBY against non existing database key} {
+         r del htest
+@@ -505,16 +505,16 @@ start_server {tags {"hash"}} {
+         }
+     }
+ 
+-    test {Stress test the hash ziplist -> hashtable encoding conversion} {
+-        r config set hash-max-ziplist-entries 32
+-        for {set j 0} {$j < 100} {incr j} {
+-            r del myhash
+-            for {set i 0} {$i < 64} {incr i} {
+-                r hset myhash [randomValue] [randomValue]
+-            }
+-            assert {[r object encoding myhash] eq {hashtable}}
+-        }
+-    }
++#    test {Stress test the hash ziplist -> hashtable encoding conversion} {
++#        r config set hash-max-ziplist-entries 32
++#        for {set j 0} {$j < 100} {incr j} {
++#            r del myhash
++#            for {set i 0} {$i < 64} {incr i} {
++#                r hset myhash [randomValue] [randomValue]
++#            }
++#            assert {[r object encoding myhash] eq {hashtable}}
++#        }
++#    }
+ 
+     # The following test can only be executed if we don't use Valgrind, and if
+     # we are using x86_64 architecture, because:
+diff --git a/tests/unit/type/set.tcl b/tests/unit/type/set.tcl
+index 7b467f1c4..21f0721c4 100644
+--- a/tests/unit/type/set.tcl
++++ b/tests/unit/type/set.tcl
+@@ -34,8 +34,8 @@ start_server {
+     }
+ 
+     test {SADD against non set} {
+-        r lpush mylist foo
+-        assert_error WRONGTYPE* {r sadd mylist bar}
++        r set mystring foo
++        assert_error WRONGTYPE* {r sadd mystring bar}
+     }
+ 
+     test "SADD a non-integer against an intset" {
+@@ -75,7 +75,7 @@ start_server {
+         assert_encoding hashtable mylargeintset
+         assert_encoding hashtable myhashset
+ 
+-        r debug reload
++        #r debug reload
+         assert_encoding intset myintset
+         assert_encoding hashtable mylargeintset
+         assert_encoding hashtable myhashset
+@@ -157,7 +157,7 @@ start_server {
+         }
+ 
+         test "SINTERSTORE with two sets, after a DEBUG RELOAD - $type" {
+-            r debug reload
++            #r debug reload
+             r sinterstore setres set1 set2
+             assert_encoding $type setres
+             assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]]
+diff --git a/tests/unit/type/string.tcl b/tests/unit/type/string.tcl
+index 7122fd987..2274c82cc 100644
+--- a/tests/unit/type/string.tcl
++++ b/tests/unit/type/string.tcl
+@@ -130,8 +130,8 @@ start_server {tags {"string"}} {
+     } {bar xyz}
+ 
+     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
++        r mset "{A}x" 10 "{A}y" "foo bar" "{A}z" "x x x x x x x\n\n\r\n"
++        r mget "{A}x" "{A}y" "{A}z"
+     } [list 10 {foo bar} "x x x x x x x\n\n\r\n"]
+ 
+     test {MSET wrong number of args} {
+@@ -140,11 +140,11 @@ start_server {tags {"string"}} {
+     } {*wrong number*}
+ 
+     test {MSETNX with already existent key} {
+-        list [r msetnx x1 xxx y2 yyy x 20] [r exists x1] [r exists y2]
++        list [r msetnx "{A}x1" xxx "{A}y2" yyy "{A}x" 20] [r exists "{A}x1"] [r exists "{A}y2"]
+     } {0 0 0}
+ 
+     test {MSETNX with not existing keys} {
+-        list [r msetnx x1 xxx y2 yyy] [r get x1] [r get y2]
++        list [r msetnx "{A}x1" xxx "{A}y2" yyy] [r get "{A}x1"] [r get "{A}y2"]
+     } {1 xxx yyy}
+ 
+     test "STRLEN against non-existing key" {
+@@ -188,11 +188,11 @@ start_server {tags {"string"}} {
+         assert_equal [binary format B* 00010011] [r get mykey]
+     }
+ 
+-    test "SETBIT against key with wrong type" {
+-        r del mykey
+-        r lpush mykey "foo"
+-        assert_error "WRONGTYPE*" {r setbit mykey 0 1}
+-    }
++#    test "SETBIT against key with wrong type" {
++#        r del mykey
++#        r lpush mykey "foo"
++#        assert_error "WRONGTYPE*" {r setbit mykey 0 1}
++#    }
+ 
+     test "SETBIT with out of range bit offset" {
+         r del mykey
+@@ -208,23 +208,23 @@ start_server {tags {"string"}} {
+         assert_error "*out of range*" {r setbit mykey 0 20}
+     }
+ 
+-    test "SETBIT fuzzing" {
+-        set str ""
+-        set len [expr 256*8]
+-        r del mykey
++#    test "SETBIT fuzzing" {
++#        set str ""
++#        set len [expr 256*8]
++#        r del mykey
+ 
+-        for {set i 0} {$i < 2000} {incr i} {
+-            set bitnum [randomInt $len]
+-            set bitval [randomInt 2]
+-            set fmt [format "%%-%ds%%d%%-s" $bitnum]
+-            set head [string range $str 0 $bitnum-1]
+-            set tail [string range $str $bitnum+1 end]
+-            set str [string map {" " 0} [format $fmt $head $bitval $tail]]
++#        for {set i 0} {$i < 2000} {incr i} {
++#            set bitnum [randomInt $len]
++#            set bitval [randomInt 2]
++#            set fmt [format "%%-%ds%%d%%-s" $bitnum]
++#            set head [string range $str 0 $bitnum-1]
++#            set tail [string range $str $bitnum+1 end]
++#            set str [string map {" " 0} [format $fmt $head $bitval $tail]]
+ 
+-            r setbit mykey $bitnum $bitval
+-            assert_equal [binary format B* $str] [r get mykey]
+-        }
+-    }
++#            r setbit mykey $bitnum $bitval
++#            assert_equal [binary format B* $str] [r get mykey]
++#        }
++#    }
+ 
+     test "GETBIT against non-existing key" {
+         r del mykey
+@@ -324,7 +324,7 @@ start_server {tags {"string"}} {
+ 
+     test "SETRANGE against key with wrong type" {
+         r del mykey
+-        r lpush mykey "foo"
++        r sadd mykey "foo"
+         assert_error "WRONGTYPE*" {r setrange mykey 0 bar}
+     }
+ 
+diff --git a/tests/unit/type/zset.tcl b/tests/unit/type/zset.tcl
+index a8c817f6e..d0809b581 100644
+--- a/tests/unit/type/zset.tcl
++++ b/tests/unit/type/zset.tcl
+@@ -7,22 +7,22 @@ start_server {tags {"zset"}} {
+     }
+ 
+     proc basics {encoding} {
+-        if {$encoding == "ziplist"} {
+-            r config set zset-max-ziplist-entries 128
+-            r config set zset-max-ziplist-value 64
+-        } elseif {$encoding == "skiplist"} {
+-            r config set zset-max-ziplist-entries 0
+-            r config set zset-max-ziplist-value 0
+-        } else {
+-            puts "Unknown sorted set encoding"
+-            exit
+-        }
+-
+-        test "Check encoding - $encoding" {
+-            r del ztmp
+-            r zadd ztmp 10 x
+-            assert_encoding $encoding ztmp
+-        }
++        # if {$encoding == "ziplist"} {
++        #     r config set zset-max-ziplist-entries 128
++        #     r config set zset-max-ziplist-value 64
++        # } elseif {$encoding == "skiplist"} {
++        #     r config set zset-max-ziplist-entries 0
++        #     r config set zset-max-ziplist-value 0
++        # } else {
++        #     puts "Unknown sorted set encoding"
++        #     exit
++        # }
++
++        # test "Check encoding - $encoding" {
++        #     r del ztmp
++        #     r zadd ztmp 10 x
++        #     assert_encoding $encoding ztmp
++        # }
+ 
+         test "ZSET basic ZADD and score update - $encoding" {
+             r del ztmp
+@@ -40,7 +40,7 @@ start_server {tags {"zset"}} {
+         }
+ 
+         test "ZSET element can't be set to NaN with ZINCRBY" {
+-            assert_error "*not*float*" {r zadd myzset nan abc}
++            assert_error "*not*float*" {r zincrby myzset nan abc}
+         }
+ 
+         test "ZADD with options syntax error with incomplete pair" {
+@@ -257,10 +257,10 @@ start_server {tags {"zset"}} {
+             assert_equal 1 [r zrank zranktmp y]
+             assert_equal 2 [r zrank zranktmp z]
+             assert_equal "" [r zrank zranktmp foo]
+-            assert_equal 2 [r zrevrank zranktmp x]
+-            assert_equal 1 [r zrevrank zranktmp y]
+-            assert_equal 0 [r zrevrank zranktmp z]
+-            assert_equal "" [r zrevrank zranktmp foo]
++            # assert_equal 2 [r zrevrank zranktmp x]
++            # assert_equal 1 [r zrevrank zranktmp y]
++            # assert_equal 0 [r zrevrank zranktmp z]
++            # assert_equal "" [r zrevrank zranktmp foo]
+         }
+ 
+         test "ZRANK - after deletion - $encoding" {
+@@ -376,145 +376,145 @@ start_server {tags {"zset"}} {
+             assert_equal {d 3 c 2} [r zrevrangebyscore zset 5 2 LIMIT 2 3 WITHSCORES]
+         }
+ 
+-        test "ZRANGEBYSCORE with non-value min or max" {
+-            assert_error "*not*float*" {r zrangebyscore fooz str 1}
+-            assert_error "*not*float*" {r zrangebyscore fooz 1 str}
+-            assert_error "*not*float*" {r zrangebyscore fooz 1 NaN}
+-        }
+-
+-        proc create_default_lex_zset {} {
+-            create_zset zset {0 alpha 0 bar 0 cool 0 down
+-                              0 elephant 0 foo 0 great 0 hill
+-                              0 omega}
+-        }
+-
+-        test "ZRANGEBYLEX/ZREVRANGEBYLEX/ZLEXCOUNT basics" {
+-            create_default_lex_zset
+-
+-            # inclusive range
+-            assert_equal {alpha bar cool} [r zrangebylex zset - \[cool]
+-            assert_equal {bar cool down} [r zrangebylex zset \[bar \[down]
+-            assert_equal {great hill omega} [r zrangebylex zset \[g +]
+-            assert_equal {cool bar alpha} [r zrevrangebylex zset \[cool -]
+-            assert_equal {down cool bar} [r zrevrangebylex zset \[down \[bar]
+-            assert_equal {omega hill great foo elephant down} [r zrevrangebylex zset + \[d]
+-            assert_equal 3 [r zlexcount zset \[ele \[h]
+-
+-            # exclusive range
+-            assert_equal {alpha bar} [r zrangebylex zset - (cool]
+-            assert_equal {cool} [r zrangebylex zset (bar (down]
+-            assert_equal {hill omega} [r zrangebylex zset (great +]
+-            assert_equal {bar alpha} [r zrevrangebylex zset (cool -]
+-            assert_equal {cool} [r zrevrangebylex zset (down (bar]
+-            assert_equal {omega hill} [r zrevrangebylex zset + (great]
+-            assert_equal 2 [r zlexcount zset (ele (great]
+-
+-            # inclusive and exclusive
+-            assert_equal {} [r zrangebylex zset (az (b]
+-            assert_equal {} [r zrangebylex zset (z +]
+-            assert_equal {} [r zrangebylex zset - \[aaaa]
+-            assert_equal {} [r zrevrangebylex zset \[elez \[elex]
+-            assert_equal {} [r zrevrangebylex zset (hill (omega]
+-        }
++        #test "ZRANGEBYSCORE with non-value min or max" {
++            #assert_error "*not*float*" {r zrangebyscore fooz str 1}
++            #assert_error "*not*float*" {r zrangebyscore fooz 1 str}
++        #    assert_error "*not*float*" {r zrangebyscore fooz 1 NaN}
++        #}
++
++        # proc create_default_lex_zset {} {
++        #     create_zset zset {0 alpha 0 bar 0 cool 0 down
++        #                       0 elephant 0 foo 0 great 0 hill
++        #                       0 omega}
++        # }
++
++        # test "ZRANGEBYLEX/ZREVRANGEBYLEX/ZLEXCOUNT basics" {
++        #     create_default_lex_zset
++
++        #     # inclusive range
++        #     assert_equal {alpha bar cool} [r zrangebylex zset - \[cool]
++        #     assert_equal {bar cool down} [r zrangebylex zset \[bar \[down]
++        #     assert_equal {great hill omega} [r zrangebylex zset \[g +]
++        #     assert_equal {cool bar alpha} [r zrevrangebylex zset \[cool -]
++        #     assert_equal {down cool bar} [r zrevrangebylex zset \[down \[bar]
++        #     assert_equal {omega hill great foo elephant down} [r zrevrangebylex zset + \[d]
++        #     assert_equal 3 [r zlexcount zset \[ele \[h]
++
++        #     # exclusive range
++        #     assert_equal {alpha bar} [r zrangebylex zset - (cool]
++        #     assert_equal {cool} [r zrangebylex zset (bar (down]
++        #     assert_equal {hill omega} [r zrangebylex zset (great +]
++        #     assert_equal {bar alpha} [r zrevrangebylex zset (cool -]
++        #     assert_equal {cool} [r zrevrangebylex zset (down (bar]
++        #     assert_equal {omega hill} [r zrevrangebylex zset + (great]
++        #     assert_equal 2 [r zlexcount zset (ele (great]
++
++        #     # inclusive and exclusive
++        #     assert_equal {} [r zrangebylex zset (az (b]
++        #     assert_equal {} [r zrangebylex zset (z +]
++        #     assert_equal {} [r zrangebylex zset - \[aaaa]
++        #     assert_equal {} [r zrevrangebylex zset \[elez \[elex]
++        #     assert_equal {} [r zrevrangebylex zset (hill (omega]
++        # }
+         
+-        test "ZLEXCOUNT advanced" {
+-            create_default_lex_zset
++        # test "ZLEXCOUNT advanced" {
++        #     create_default_lex_zset
+     
+-            assert_equal 9 [r zlexcount zset - +]
+-            assert_equal 0 [r zlexcount zset + -]
+-            assert_equal 0 [r zlexcount zset + \[c]
+-            assert_equal 0 [r zlexcount zset \[c -]
+-            assert_equal 8 [r zlexcount zset \[bar +]
+-            assert_equal 5 [r zlexcount zset \[bar \[foo]
+-            assert_equal 4 [r zlexcount zset \[bar (foo]
+-            assert_equal 4 [r zlexcount zset (bar \[foo]
+-            assert_equal 3 [r zlexcount zset (bar (foo]
+-            assert_equal 5 [r zlexcount zset - (foo]
+-            assert_equal 1 [r zlexcount zset (maxstring +]
+-        }
+-
+-        test "ZRANGEBYSLEX with LIMIT" {
+-            create_default_lex_zset
+-            assert_equal {alpha bar} [r zrangebylex zset - \[cool LIMIT 0 2]
+-            assert_equal {bar cool} [r zrangebylex zset - \[cool LIMIT 1 2]
+-            assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 0 0]
+-            assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 2 0]
+-            assert_equal {bar} [r zrangebylex zset \[bar \[down LIMIT 0 1]
+-            assert_equal {cool} [r zrangebylex zset \[bar \[down LIMIT 1 1]
+-            assert_equal {bar cool down} [r zrangebylex zset \[bar \[down LIMIT 0 100]
+-            assert_equal {omega hill great foo elephant} [r zrevrangebylex zset + \[d LIMIT 0 5]
+-            assert_equal {omega hill great foo} [r zrevrangebylex zset + \[d LIMIT 0 4]
+-        }
+-
+-        test "ZRANGEBYLEX with invalid lex range specifiers" {
+-            assert_error "*not*string*" {r zrangebylex fooz foo bar}
+-            assert_error "*not*string*" {r zrangebylex fooz \[foo bar}
+-            assert_error "*not*string*" {r zrangebylex fooz foo \[bar}
+-            assert_error "*not*string*" {r zrangebylex fooz +x \[bar}
+-            assert_error "*not*string*" {r zrangebylex fooz -x \[bar}
+-        }
+-
+-        test "ZREMRANGEBYSCORE basics" {
+-            proc remrangebyscore {min max} {
+-                create_zset zset {1 a 2 b 3 c 4 d 5 e}
+-                assert_equal 1 [r exists zset]
+-                r zremrangebyscore zset $min $max
+-            }
+-
+-            # inner range
+-            assert_equal 3 [remrangebyscore 2 4]
+-            assert_equal {a e} [r zrange zset 0 -1]
+-
+-            # start underflow
+-            assert_equal 1 [remrangebyscore -10 1]
+-            assert_equal {b c d e} [r zrange zset 0 -1]
+-
+-            # end overflow
+-            assert_equal 1 [remrangebyscore 5 10]
+-            assert_equal {a b c d} [r zrange zset 0 -1]
+-
+-            # switch min and max
+-            assert_equal 0 [remrangebyscore 4 2]
+-            assert_equal {a b c d e} [r zrange zset 0 -1]
+-
+-            # -inf to mid
+-            assert_equal 3 [remrangebyscore -inf 3]
+-            assert_equal {d e} [r zrange zset 0 -1]
+-
+-            # mid to +inf
+-            assert_equal 3 [remrangebyscore 3 +inf]
+-            assert_equal {a b} [r zrange zset 0 -1]
+-
+-            # -inf to +inf
+-            assert_equal 5 [remrangebyscore -inf +inf]
+-            assert_equal {} [r zrange zset 0 -1]
+-
+-            # exclusive min
+-            assert_equal 4 [remrangebyscore (1 5]
+-            assert_equal {a} [r zrange zset 0 -1]
+-            assert_equal 3 [remrangebyscore (2 5]
+-            assert_equal {a b} [r zrange zset 0 -1]
+-
+-            # exclusive max
+-            assert_equal 4 [remrangebyscore 1 (5]
+-            assert_equal {e} [r zrange zset 0 -1]
+-            assert_equal 3 [remrangebyscore 1 (4]
+-            assert_equal {d e} [r zrange zset 0 -1]
+-
+-            # exclusive min and max
+-            assert_equal 3 [remrangebyscore (1 (5]
+-            assert_equal {a e} [r zrange zset 0 -1]
+-
+-            # destroy when empty
+-            assert_equal 5 [remrangebyscore 1 5]
+-            assert_equal 0 [r exists zset]
+-        }
+-
+-        test "ZREMRANGEBYSCORE with non-value min or max" {
+-            assert_error "*not*float*" {r zremrangebyscore fooz str 1}
+-            assert_error "*not*float*" {r zremrangebyscore fooz 1 str}
+-            assert_error "*not*float*" {r zremrangebyscore fooz 1 NaN}
+-        }
++        #     assert_equal 9 [r zlexcount zset - +]
++        #     assert_equal 0 [r zlexcount zset + -]
++        #     assert_equal 0 [r zlexcount zset + \[c]
++        #     assert_equal 0 [r zlexcount zset \[c -]
++        #     assert_equal 8 [r zlexcount zset \[bar +]
++        #     assert_equal 5 [r zlexcount zset \[bar \[foo]
++        #     assert_equal 4 [r zlexcount zset \[bar (foo]
++        #     assert_equal 4 [r zlexcount zset (bar \[foo]
++        #     assert_equal 3 [r zlexcount zset (bar (foo]
++        #     assert_equal 5 [r zlexcount zset - (foo]
++        #     assert_equal 1 [r zlexcount zset (maxstring +]
++        # }
++
++        # test "ZRANGEBYSLEX with LIMIT" {
++        #     create_default_lex_zset
++        #     assert_equal {alpha bar} [r zrangebylex zset - \[cool LIMIT 0 2]
++        #     assert_equal {bar cool} [r zrangebylex zset - \[cool LIMIT 1 2]
++        #     assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 0 0]
++        #     assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 2 0]
++        #     assert_equal {bar} [r zrangebylex zset \[bar \[down LIMIT 0 1]
++        #     assert_equal {cool} [r zrangebylex zset \[bar \[down LIMIT 1 1]
++        #     assert_equal {bar cool down} [r zrangebylex zset \[bar \[down LIMIT 0 100]
++        #     assert_equal {omega hill great foo elephant} [r zrevrangebylex zset + \[d LIMIT 0 5]
++        #     assert_equal {omega hill great foo} [r zrevrangebylex zset + \[d LIMIT 0 4]
++        # }
++
++        # test "ZRANGEBYLEX with invalid lex range specifiers" {
++        #     assert_error "*not*string*" {r zrangebylex fooz foo bar}
++        #     assert_error "*not*string*" {r zrangebylex fooz \[foo bar}
++        #     assert_error "*not*string*" {r zrangebylex fooz foo \[bar}
++        #     assert_error "*not*string*" {r zrangebylex fooz +x \[bar}
++        #     assert_error "*not*string*" {r zrangebylex fooz -x \[bar}
++        # }
++
++        # test "ZREMRANGEBYSCORE basics" {
++        #     proc remrangebyscore {min max} {
++        #         create_zset zset {1 a 2 b 3 c 4 d 5 e}
++        #         assert_equal 1 [r exists zset]
++        #         r zremrangebyscore zset $min $max
++        #     }
++
++        #     # inner range
++        #     assert_equal 3 [remrangebyscore 2 4]
++        #     assert_equal {a e} [r zrange zset 0 -1]
++
++        #     # start underflow
++        #     assert_equal 1 [remrangebyscore -10 1]
++        #     assert_equal {b c d e} [r zrange zset 0 -1]
++
++        #     # end overflow
++        #     assert_equal 1 [remrangebyscore 5 10]
++        #     assert_equal {a b c d} [r zrange zset 0 -1]
++
++        #     # switch min and max
++        #     assert_equal 0 [remrangebyscore 4 2]
++        #     assert_equal {a b c d e} [r zrange zset 0 -1]
++
++        #     # -inf to mid
++        #     assert_equal 3 [remrangebyscore -inf 3]
++        #     assert_equal {d e} [r zrange zset 0 -1]
++
++        #     # mid to +inf
++        #     assert_equal 3 [remrangebyscore 3 +inf]
++        #     assert_equal {a b} [r zrange zset 0 -1]
++
++        #     # -inf to +inf
++        #     assert_equal 5 [remrangebyscore -inf +inf]
++        #     assert_equal {} [r zrange zset 0 -1]
++
++        #     # exclusive min
++        #     assert_equal 4 [remrangebyscore (1 5]
++        #     assert_equal {a} [r zrange zset 0 -1]
++        #     assert_equal 3 [remrangebyscore (2 5]
++        #     assert_equal {a b} [r zrange zset 0 -1]
++
++        #     # exclusive max
++        #     assert_equal 4 [remrangebyscore 1 (5]
++        #     assert_equal {e} [r zrange zset 0 -1]
++        #     assert_equal 3 [remrangebyscore 1 (4]
++        #     assert_equal {d e} [r zrange zset 0 -1]
++
++        #     # exclusive min and max
++        #     assert_equal 3 [remrangebyscore (1 (5]
++        #     assert_equal {a e} [r zrange zset 0 -1]
++
++        #     # destroy when empty
++        #     assert_equal 5 [remrangebyscore 1 5]
++        #     assert_equal 0 [r exists zset]
++        # }
++
++        # test "ZREMRANGEBYSCORE with non-value min or max" {
++        #     assert_error "*not*float*" {r zremrangebyscore fooz str 1}
++        #     assert_error "*not*float*" {r zremrangebyscore fooz 1 str}
++        #     assert_error "*not*float*" {r zremrangebyscore fooz 1 NaN}
++        # }
+ 
+         test "ZREMRANGEBYRANK basics" {
+             proc remrangebyrank {min max} {
+@@ -548,257 +548,257 @@ start_server {tags {"zset"}} {
+             assert_equal 0 [r exists zset]
+         }
+ 
+-        test "ZUNIONSTORE against non-existing key doesn't set destination - $encoding" {
+-            r del zseta
+-            assert_equal 0 [r zunionstore dst_key 1 zseta]
+-            assert_equal 0 [r exists dst_key]
+-        }
+-
+-        test "ZUNIONSTORE with empty set - $encoding" {
+-            r del zseta zsetb
+-            r zadd zseta 1 a
+-            r zadd zseta 2 b
+-            r zunionstore zsetc 2 zseta zsetb
+-            r zrange zsetc 0 -1 withscores
+-        } {a 1 b 2}
+-
+-        test "ZUNIONSTORE basics - $encoding" {
+-            r del zseta zsetb zsetc
+-            r zadd zseta 1 a
+-            r zadd zseta 2 b
+-            r zadd zseta 3 c
+-            r zadd zsetb 1 b
+-            r zadd zsetb 2 c
+-            r zadd zsetb 3 d
+-
+-            assert_equal 4 [r zunionstore zsetc 2 zseta zsetb]
+-            assert_equal {a 1 b 3 d 3 c 5} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZUNIONSTORE with weights - $encoding" {
+-            assert_equal 4 [r zunionstore zsetc 2 zseta zsetb weights 2 3]
+-            assert_equal {a 2 b 7 d 9 c 12} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZUNIONSTORE with a regular set and weights - $encoding" {
+-            r del seta
+-            r sadd seta a
+-            r sadd seta b
+-            r sadd seta c
+-
+-            assert_equal 4 [r zunionstore zsetc 2 seta zsetb weights 2 3]
+-            assert_equal {a 2 b 5 c 8 d 9} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZUNIONSTORE with AGGREGATE MIN - $encoding" {
+-            assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate min]
+-            assert_equal {a 1 b 1 c 2 d 3} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZUNIONSTORE with AGGREGATE MAX - $encoding" {
+-            assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate max]
+-            assert_equal {a 1 b 2 c 3 d 3} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZINTERSTORE basics - $encoding" {
+-            assert_equal 2 [r zinterstore zsetc 2 zseta zsetb]
+-            assert_equal {b 3 c 5} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZINTERSTORE with weights - $encoding" {
+-            assert_equal 2 [r zinterstore zsetc 2 zseta zsetb weights 2 3]
+-            assert_equal {b 7 c 12} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZINTERSTORE with a regular set and weights - $encoding" {
+-            r del seta
+-            r sadd seta a
+-            r sadd seta b
+-            r sadd seta c
+-            assert_equal 2 [r zinterstore zsetc 2 seta zsetb weights 2 3]
+-            assert_equal {b 5 c 8} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZINTERSTORE with AGGREGATE MIN - $encoding" {
+-            assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate min]
+-            assert_equal {b 1 c 2} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        test "ZINTERSTORE with AGGREGATE MAX - $encoding" {
+-            assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate max]
+-            assert_equal {b 2 c 3} [r zrange zsetc 0 -1 withscores]
+-        }
+-
+-        foreach cmd {ZUNIONSTORE ZINTERSTORE} {
+-            test "$cmd with +inf/-inf scores - $encoding" {
+-                r del zsetinf1 zsetinf2
+-
+-                r zadd zsetinf1 +inf key
+-                r zadd zsetinf2 +inf key
+-                r $cmd zsetinf3 2 zsetinf1 zsetinf2
+-                assert_equal inf [r zscore zsetinf3 key]
+-
+-                r zadd zsetinf1 -inf key
+-                r zadd zsetinf2 +inf key
+-                r $cmd zsetinf3 2 zsetinf1 zsetinf2
+-                assert_equal 0 [r zscore zsetinf3 key]
+-
+-                r zadd zsetinf1 +inf key
+-                r zadd zsetinf2 -inf key
+-                r $cmd zsetinf3 2 zsetinf1 zsetinf2
+-                assert_equal 0 [r zscore zsetinf3 key]
+-
+-                r zadd zsetinf1 -inf key
+-                r zadd zsetinf2 -inf key
+-                r $cmd zsetinf3 2 zsetinf1 zsetinf2
+-                assert_equal -inf [r zscore zsetinf3 key]
+-            }
+-
+-            test "$cmd with NaN weights $encoding" {
+-                r del zsetinf1 zsetinf2
+-
+-                r zadd zsetinf1 1.0 key
+-                r zadd zsetinf2 1.0 key
+-                assert_error "*weight*not*float*" {
+-                    r $cmd zsetinf3 2 zsetinf1 zsetinf2 weights nan nan
+-                }
+-            }
+-        }
+-
+-        test "Basic ZPOP with a single key - $encoding" {
+-            r del zset
+-            assert_equal {} [r zpopmin zset]
+-            create_zset zset {-1 a 1 b 2 c 3 d 4 e}
+-            assert_equal {a -1} [r zpopmin zset]
+-            assert_equal {b 1} [r zpopmin zset]
+-            assert_equal {e 4} [r zpopmax zset]
+-            assert_equal {d 3} [r zpopmax zset]
+-            assert_equal {c 2} [r zpopmin zset]
+-            assert_equal 0 [r exists zset]
+-            r set foo bar
+-            assert_error "*WRONGTYPE*" {r zpopmin foo}
+-        }
+-
+-        test "ZPOP with count - $encoding" {
+-            r del z1 z2 z3 foo
+-            r set foo bar
+-            assert_equal {} [r zpopmin z1 2]
+-            assert_error "*WRONGTYPE*" {r zpopmin foo 2}
+-            create_zset z1 {0 a 1 b 2 c 3 d}
+-            assert_equal {a 0 b 1} [r zpopmin z1 2]
+-            assert_equal {d 3 c 2} [r zpopmax z1 2]
+-        }
+-
+-        test "BZPOP with a single existing sorted set - $encoding" {
+-            set rd [redis_deferring_client]
+-            create_zset zset {0 a 1 b 2 c}
+-
+-            $rd bzpopmin zset 5
+-            assert_equal {zset a 0} [$rd read]
+-            $rd bzpopmin zset 5
+-            assert_equal {zset b 1} [$rd read]
+-            $rd bzpopmax zset 5
+-            assert_equal {zset c 2} [$rd read]
+-            assert_equal 0 [r exists zset]
+-        }
+-
+-        test "BZPOP with multiple existing sorted sets - $encoding" {
+-            set rd [redis_deferring_client]
+-            create_zset z1 {0 a 1 b 2 c}
+-            create_zset z2 {3 d 4 e 5 f}
+-
+-            $rd bzpopmin z1 z2 5
+-            assert_equal {z1 a 0} [$rd read]
+-            $rd bzpopmax z1 z2 5
+-            assert_equal {z1 c 2} [$rd read]
+-            assert_equal 1 [r zcard z1]
+-            assert_equal 3 [r zcard z2]
+-
+-            $rd bzpopmax z2 z1 5
+-            assert_equal {z2 f 5} [$rd read]
+-            $rd bzpopmin z2 z1 5
+-            assert_equal {z2 d 3} [$rd read]
+-            assert_equal 1 [r zcard z1]
+-            assert_equal 1 [r zcard z2]
+-        }
+-
+-        test "BZPOP second sorted set has members - $encoding" {
+-            set rd [redis_deferring_client]
+-            r del z1
+-            create_zset z2 {3 d 4 e 5 f}
+-            $rd bzpopmax z1 z2 5
+-            assert_equal {z2 f 5} [$rd read]
+-            $rd bzpopmin z2 z1 5
+-            assert_equal {z2 d 3} [$rd read]
+-            assert_equal 0 [r zcard z1]
+-            assert_equal 1 [r zcard z2]
+-        }
+-    }
+-
+-    basics ziplist
++        # test "ZUNIONSTORE against non-existing key doesn't set destination - $encoding" {
++        #     r del zseta
++        #     assert_equal 0 [r zunionstore dst_key 1 zseta]
++        #     assert_equal 0 [r exists dst_key]
++        # }
++
++        # test "ZUNIONSTORE with empty set - $encoding" {
++        #     r del zseta zsetb
++        #     r zadd zseta 1 a
++        #     r zadd zseta 2 b
++        #     r zunionstore zsetc 2 zseta zsetb
++        #     r zrange zsetc 0 -1 withscores
++        # } {a 1 b 2}
++
++        # test "ZUNIONSTORE basics - $encoding" {
++        #     r del zseta zsetb zsetc
++        #     r zadd zseta 1 a
++        #     r zadd zseta 2 b
++        #     r zadd zseta 3 c
++        #     r zadd zsetb 1 b
++        #     r zadd zsetb 2 c
++        #     r zadd zsetb 3 d
++
++        #     assert_equal 4 [r zunionstore zsetc 2 zseta zsetb]
++        #     assert_equal {a 1 b 3 d 3 c 5} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZUNIONSTORE with weights - $encoding" {
++        #     assert_equal 4 [r zunionstore zsetc 2 zseta zsetb weights 2 3]
++        #     assert_equal {a 2 b 7 d 9 c 12} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZUNIONSTORE with a regular set and weights - $encoding" {
++        #     r del seta
++        #     r sadd seta a
++        #     r sadd seta b
++        #     r sadd seta c
++
++        #     assert_equal 4 [r zunionstore zsetc 2 seta zsetb weights 2 3]
++        #     assert_equal {a 2 b 5 c 8 d 9} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZUNIONSTORE with AGGREGATE MIN - $encoding" {
++        #     assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate min]
++        #     assert_equal {a 1 b 1 c 2 d 3} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZUNIONSTORE with AGGREGATE MAX - $encoding" {
++        #     assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate max]
++        #     assert_equal {a 1 b 2 c 3 d 3} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZINTERSTORE basics - $encoding" {
++        #     assert_equal 2 [r zinterstore zsetc 2 zseta zsetb]
++        #     assert_equal {b 3 c 5} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZINTERSTORE with weights - $encoding" {
++        #     assert_equal 2 [r zinterstore zsetc 2 zseta zsetb weights 2 3]
++        #     assert_equal {b 7 c 12} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZINTERSTORE with a regular set and weights - $encoding" {
++        #     r del seta
++        #     r sadd seta a
++        #     r sadd seta b
++        #     r sadd seta c
++        #     assert_equal 2 [r zinterstore zsetc 2 seta zsetb weights 2 3]
++        #     assert_equal {b 5 c 8} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZINTERSTORE with AGGREGATE MIN - $encoding" {
++        #     assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate min]
++        #     assert_equal {b 1 c 2} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # test "ZINTERSTORE with AGGREGATE MAX - $encoding" {
++        #     assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate max]
++        #     assert_equal {b 2 c 3} [r zrange zsetc 0 -1 withscores]
++        # }
++
++        # foreach cmd {ZUNIONSTORE ZINTERSTORE} {
++        #     test "$cmd with +inf/-inf scores - $encoding" {
++        #         r del zsetinf1 zsetinf2
++
++        #         r zadd zsetinf1 +inf key
++        #         r zadd zsetinf2 +inf key
++        #         r $cmd zsetinf3 2 zsetinf1 zsetinf2
++        #         assert_equal inf [r zscore zsetinf3 key]
++
++        #         r zadd zsetinf1 -inf key
++        #         r zadd zsetinf2 +inf key
++        #         r $cmd zsetinf3 2 zsetinf1 zsetinf2
++        #         assert_equal 0 [r zscore zsetinf3 key]
++
++        #         r zadd zsetinf1 +inf key
++        #         r zadd zsetinf2 -inf key
++        #         r $cmd zsetinf3 2 zsetinf1 zsetinf2
++        #         assert_equal 0 [r zscore zsetinf3 key]
++
++        #         r zadd zsetinf1 -inf key
++        #         r zadd zsetinf2 -inf key
++        #         r $cmd zsetinf3 2 zsetinf1 zsetinf2
++        #         assert_equal -inf [r zscore zsetinf3 key]
++        #     }
++
++        #     test "$cmd with NaN weights $encoding" {
++        #         r del zsetinf1 zsetinf2
++
++        #         r zadd zsetinf1 1.0 key
++        #         r zadd zsetinf2 1.0 key
++        #         assert_error "*weight*not*float*" {
++        #             r $cmd zsetinf3 2 zsetinf1 zsetinf2 weights nan nan
++        #         }
++        #     }
++        # }
++
++    #     test "Basic ZPOP with a single key - $encoding" {
++    #         r del zset
++    #         assert_equal {} [r zpopmin zset]
++    #         create_zset zset {-1 a 1 b 2 c 3 d 4 e}
++    #         assert_equal {a -1} [r zpopmin zset]
++    #         assert_equal {b 1} [r zpopmin zset]
++    #         assert_equal {e 4} [r zpopmax zset]
++    #         assert_equal {d 3} [r zpopmax zset]
++    #         assert_equal {c 2} [r zpopmin zset]
++    #         assert_equal 0 [r exists zset]
++    #         r set foo bar
++    #         assert_error "*WRONGTYPE*" {r zpopmin foo}
++    #     }
++
++    #     test "ZPOP with count - $encoding" {
++    #         r del z1 z2 z3 foo
++    #         r set foo bar
++    #         assert_equal {} [r zpopmin z1 2]
++    #         assert_error "*WRONGTYPE*" {r zpopmin foo 2}
++    #         create_zset z1 {0 a 1 b 2 c 3 d}
++    #         assert_equal {a 0 b 1} [r zpopmin z1 2]
++    #         assert_equal {d 3 c 2} [r zpopmax z1 2]
++    #     }
++
++    #     test "BZPOP with a single existing sorted set - $encoding" {
++    #         set rd [redis_deferring_client]
++    #         create_zset zset {0 a 1 b 2 c}
++
++    #         $rd bzpopmin zset 5
++    #         assert_equal {zset a 0} [$rd read]
++    #         $rd bzpopmin zset 5
++    #         assert_equal {zset b 1} [$rd read]
++    #         $rd bzpopmax zset 5
++    #         assert_equal {zset c 2} [$rd read]
++    #         assert_equal 0 [r exists zset]
++    #     }
++
++    #     test "BZPOP with multiple existing sorted sets - $encoding" {
++    #         set rd [redis_deferring_client]
++    #         create_zset z1 {0 a 1 b 2 c}
++    #         create_zset z2 {3 d 4 e 5 f}
++
++    #         $rd bzpopmin z1 z2 5
++    #         assert_equal {z1 a 0} [$rd read]
++    #         $rd bzpopmax z1 z2 5
++    #         assert_equal {z1 c 2} [$rd read]
++    #         assert_equal 1 [r zcard z1]
++    #         assert_equal 3 [r zcard z2]
++
++    #         $rd bzpopmax z2 z1 5
++    #         assert_equal {z2 f 5} [$rd read]
++    #         $rd bzpopmin z2 z1 5
++    #         assert_equal {z2 d 3} [$rd read]
++    #         assert_equal 1 [r zcard z1]
++    #         assert_equal 1 [r zcard z2]
++    #     }
++
++    #     test "BZPOP second sorted set has members - $encoding" {
++    #         set rd [redis_deferring_client]
++    #         r del z1
++    #         create_zset z2 {3 d 4 e 5 f}
++    #         $rd bzpopmax z1 z2 5
++    #         assert_equal {z2 f 5} [$rd read]
++    #         $rd bzpopmin z2 z1 5
++    #         assert_equal {z2 d 3} [$rd read]
++    #         assert_equal 0 [r zcard z1]
++    #         assert_equal 1 [r zcard z2]
++    #     }
++    # }
++
++    # basics ziplist
+     basics skiplist
+ 
+-    test {ZINTERSTORE regression with two sets, intset+hashtable} {
+-        r del seta setb setc
+-        r sadd set1 a
+-        r sadd set2 10
+-        r zinterstore set3 2 set1 set2
+-    } {0}
+-
+-    test {ZUNIONSTORE regression, should not create NaN in scores} {
+-        r zadd z -inf neginf
+-        r zunionstore out 1 z weights 0
+-        r zrange out 0 -1 withscores
+-    } {neginf 0}
+-
+-    test {ZINTERSTORE #516 regression, mixed sets and ziplist zsets} {
+-        r sadd one 100 101 102 103
+-        r sadd two 100 200 201 202
+-        r zadd three 1 500 1 501 1 502 1 503 1 100
+-        r zinterstore to_here 3 one two three WEIGHTS 0 0 1
+-        r zrange to_here 0 -1
+-    } {100}
+-
+-    test {ZUNIONSTORE result is sorted} {
+-        # Create two sets with common and not common elements, perform
+-        # the UNION, check that elements are still sorted.
+-        r del one two dest
+-        set cmd1 [list r zadd one]
+-        set cmd2 [list r zadd two]
+-        for {set j 0} {$j < 1000} {incr j} {
+-            lappend cmd1 [expr rand()] [randomInt 1000]
+-            lappend cmd2 [expr rand()] [randomInt 1000]
+-        }
+-        {*}$cmd1
+-        {*}$cmd2
+-        assert {[r zcard one] > 100}
+-        assert {[r zcard two] > 100}
+-        r zunionstore dest 2 one two
+-        set oldscore 0
+-        foreach {ele score} [r zrange dest 0 -1 withscores] {
+-            assert {$score >= $oldscore}
+-            set oldscore $score
+-        }
+-    }
++    # test {ZINTERSTORE regression with two sets, intset+hashtable} {
++    #     r del seta setb setc
++    #     r sadd set1 a
++    #     r sadd set2 10
++    #     r zinterstore set3 2 set1 set2
++    # } {0}
++
++    # test {ZUNIONSTORE regression, should not create NaN in scores} {
++    #     r zadd z -inf neginf
++    #     r zunionstore out 1 z weights 0
++    #     r zrange out 0 -1 withscores
++    # } {neginf 0}
++
++    # test {ZINTERSTORE #516 regression, mixed sets and ziplist zsets} {
++    #     r sadd one 100 101 102 103
++    #     r sadd two 100 200 201 202
++    #     r zadd three 1 500 1 501 1 502 1 503 1 100
++    #     r zinterstore to_here 3 one two three WEIGHTS 0 0 1
++    #     r zrange to_here 0 -1
++    # } {100}
++
++    # test {ZUNIONSTORE result is sorted} {
++    #     # Create two sets with common and not common elements, perform
++    #     # the UNION, check that elements are still sorted.
++    #     r del one two dest
++    #     set cmd1 [list r zadd one]
++    #     set cmd2 [list r zadd two]
++    #     for {set j 0} {$j < 1000} {incr j} {
++    #         lappend cmd1 [expr rand()] [randomInt 1000]
++    #         lappend cmd2 [expr rand()] [randomInt 1000]
++    #     }
++    #     {*}$cmd1
++    #     {*}$cmd2
++    #     assert {[r zcard one] > 100}
++    #     assert {[r zcard two] > 100}
++    #     r zunionstore dest 2 one two
++    #     set oldscore 0
++    #     foreach {ele score} [r zrange dest 0 -1 withscores] {
++    #         assert {$score >= $oldscore}
++    #         set oldscore $score
++    #     }
++    # }
+ 
+     test "ZSET commands don't accept the empty strings as valid score" {
+         assert_error "*not*float*" {r zadd myzset "" abc}
+     }
+ 
+     proc stressers {encoding} {
+-        if {$encoding == "ziplist"} {
+-            # Little extra to allow proper fuzzing in the sorting stresser
+-            r config set zset-max-ziplist-entries 256
+-            r config set zset-max-ziplist-value 64
+-            set elements 128
+-        } elseif {$encoding == "skiplist"} {
+-            r config set zset-max-ziplist-entries 0
+-            r config set zset-max-ziplist-value 0
+-            if {$::accurate} {set elements 1000} else {set elements 100}
+-        } else {
+-            puts "Unknown sorted set encoding"
+-            exit
+-        }
++        # if {$encoding == "ziplist"} {
++        #     # Little extra to allow proper fuzzing in the sorting stresser
++        #     r config set zset-max-ziplist-entries 256
++        #     r config set zset-max-ziplist-value 64
++        set elements 128
++        # } elseif {$encoding == "skiplist"} {
++        #     r config set zset-max-ziplist-entries 0
++        #     r config set zset-max-ziplist-value 0
++        #     if {$::accurate} {set elements 1000} else {set elements 100}
++        # } else {
++        #     puts "Unknown sorted set encoding"
++        #     exit
++        # }
+ 
+         test "ZSCORE - $encoding" {
+             r del zscoretest
+@@ -809,9 +809,11 @@ start_server {tags {"zset"}} {
+                 r zadd zscoretest $score $i
+             }
+ 
+-            assert_encoding $encoding zscoretest
++            # assert_encoding $encoding zscoretest
+             for {set i 0} {$i < $elements} {incr i} {
+-                assert_equal [lindex $aux $i] [r zscore zscoretest $i]
++                set expected [lindex $aux $i]
++                set actual [r zscore zscoretest $i]
++                assert {abs($expected - $actual) < 0.0000000000000001}
+             }
+         }
+ 
+@@ -824,10 +826,12 @@ start_server {tags {"zset"}} {
+                 r zadd zscoretest $score $i
+             }
+ 
+-            r debug reload
+-            assert_encoding $encoding zscoretest
++            # r debug reload
++            # assert_encoding $encoding zscoretest
+             for {set i 0} {$i < $elements} {incr i} {
+-                assert_equal [lindex $aux $i] [r zscore zscoretest $i]
++                 set expected [lindex $aux $i]
++                 set actual [r zscore zscoretest $i]
++                 assert {abs($expected - $actual) < 0.0000000000000001}
+             }
+         }
+ 
+@@ -867,7 +871,7 @@ start_server {tags {"zset"}} {
+                     lappend auxlist [lindex $x 1]
+                 }
+ 
+-                assert_encoding $encoding myzset
++                # assert_encoding $encoding myzset
+                 set fromredis [r zrange myzset 0 -1]
+                 set delta 0
+                 for {set i 0} {$i < [llength $fromredis]} {incr i} {
+@@ -886,7 +890,7 @@ start_server {tags {"zset"}} {
+                 r zadd zset [expr rand()] $i
+             }
+ 
+-            assert_encoding $encoding zset
++        #     assert_encoding $encoding zset
+             for {set i 0} {$i < 100} {incr i} {
+                 set min [expr rand()]
+                 set max [expr rand()]
+@@ -961,128 +965,128 @@ start_server {tags {"zset"}} {
+             assert_equal {} $err
+         }
+ 
+-        test "ZRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" {
+-            set lexset {}
+-            r del zset
+-            for {set j 0} {$j < $elements} {incr j} {
+-                set e [randstring 0 30 alpha]
+-                lappend lexset $e
+-                r zadd zset 0 $e
+-            }
+-            set lexset [lsort -unique $lexset]
+-            for {set j 0} {$j < 100} {incr j} {
+-                set min [randstring 0 30 alpha]
+-                set max [randstring 0 30 alpha]
+-                set mininc [randomInt 2]
+-                set maxinc [randomInt 2]
+-                if {$mininc} {set cmin "\[$min"} else {set cmin "($min"}
+-                if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"}
+-                set rev [randomInt 2]
+-                if {$rev} {
+-                    set cmd zrevrangebylex
+-                } else {
+-                    set cmd zrangebylex
+-                }
+-
+-                # Make sure data is the same in both sides
+-                assert {[r zrange zset 0 -1] eq $lexset}
+-
+-                # Get the Redis output
+-                set output [r $cmd zset $cmin $cmax]
+-                if {$rev} {
+-                    set outlen [r zlexcount zset $cmax $cmin]
+-                } else {
+-                    set outlen [r zlexcount zset $cmin $cmax]
+-                }
+-
+-                # Compute the same output via Tcl
+-                set o {}
+-                set copy $lexset
+-                if {(!$rev && [string compare $min $max] > 0) ||
+-                    ($rev && [string compare $max $min] > 0)} {
+-                    # Empty output when ranges are inverted.
+-                } else {
+-                    if {$rev} {
+-                        # Invert the Tcl array using Redis itself.
+-                        set copy [r zrevrange zset 0 -1]
+-                        # Invert min / max as well
+-                        lassign [list $min $max $mininc $maxinc] \
+-                            max min maxinc mininc
+-                    }
+-                    foreach e $copy {
+-                        set mincmp [string compare $e $min]
+-                        set maxcmp [string compare $e $max]
+-                        if {
+-                             ($mininc && $mincmp >= 0 || !$mininc && $mincmp > 0)
+-                             &&
+-                             ($maxinc && $maxcmp <= 0 || !$maxinc && $maxcmp < 0)
+-                        } {
+-                            lappend o $e
+-                        }
+-                    }
+-                }
+-                assert {$o eq $output}
+-                assert {$outlen eq [llength $output]}
+-            }
+-        }
+-
+-        test "ZREMRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" {
+-            set lexset {}
+-            r del zset zsetcopy
+-            for {set j 0} {$j < $elements} {incr j} {
+-                set e [randstring 0 30 alpha]
+-                lappend lexset $e
+-                r zadd zset 0 $e
+-            }
+-            set lexset [lsort -unique $lexset]
+-            for {set j 0} {$j < 100} {incr j} {
+-                # Copy...
+-                r zunionstore zsetcopy 1 zset
+-                set lexsetcopy $lexset
+-
+-                set min [randstring 0 30 alpha]
+-                set max [randstring 0 30 alpha]
+-                set mininc [randomInt 2]
+-                set maxinc [randomInt 2]
+-                if {$mininc} {set cmin "\[$min"} else {set cmin "($min"}
+-                if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"}
+-
+-                # Make sure data is the same in both sides
+-                assert {[r zrange zset 0 -1] eq $lexset}
+-
+-                # Get the range we are going to remove
+-                set torem [r zrangebylex zset $cmin $cmax]
+-                set toremlen [r zlexcount zset $cmin $cmax]
+-                r zremrangebylex zsetcopy $cmin $cmax
+-                set output [r zrange zsetcopy 0 -1]
+-
+-                # Remove the range with Tcl from the original list
+-                if {$toremlen} {
+-                    set first [lsearch -exact $lexsetcopy [lindex $torem 0]]
+-                    set last [expr {$first+$toremlen-1}]
+-                    set lexsetcopy [lreplace $lexsetcopy $first $last]
+-                }
+-                assert {$lexsetcopy eq $output}
+-            }
+-        }
+-
+-        test "ZSETs skiplist implementation backlink consistency test - $encoding" {
+-            set diff 0
+-            for {set j 0} {$j < $elements} {incr j} {
+-                r zadd myzset [expr rand()] "Element-$j"
+-                r zrem myzset "Element-[expr int(rand()*$elements)]"
+-            }
+-
+-            assert_encoding $encoding myzset
+-            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
+-                }
+-            }
+-            assert_equal 0 $diff
+-        }
++        # test "ZRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" {
++        #     set lexset {}
++        #     r del zset
++        #     for {set j 0} {$j < $elements} {incr j} {
++        #         set e [randstring 0 30 alpha]
++        #         lappend lexset $e
++        #         r zadd zset 0 $e
++        #     }
++        #     set lexset [lsort -unique $lexset]
++        #     for {set j 0} {$j < 100} {incr j} {
++        #         set min [randstring 0 30 alpha]
++        #         set max [randstring 0 30 alpha]
++        #         set mininc [randomInt 2]
++        #         set maxinc [randomInt 2]
++        #         if {$mininc} {set cmin "\[$min"} else {set cmin "($min"}
++        #         if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"}
++        #         set rev [randomInt 2]
++        #         if {$rev} {
++        #             set cmd zrevrangebylex
++        #         } else {
++        #             set cmd zrangebylex
++        #         }
++
++        #         # Make sure data is the same in both sides
++        #         assert {[r zrange zset 0 -1] eq $lexset}
++
++        #         # Get the Redis output
++        #         set output [r $cmd zset $cmin $cmax]
++        #         if {$rev} {
++        #             set outlen [r zlexcount zset $cmax $cmin]
++        #         } else {
++        #             set outlen [r zlexcount zset $cmin $cmax]
++        #         }
++
++        #         # Compute the same output via Tcl
++        #         set o {}
++        #         set copy $lexset
++        #         if {(!$rev && [string compare $min $max] > 0) ||
++        #             ($rev && [string compare $max $min] > 0)} {
++        #             # Empty output when ranges are inverted.
++        #         } else {
++        #             if {$rev} {
++        #                 # Invert the Tcl array using Redis itself.
++        #                 set copy [r zrevrange zset 0 -1]
++        #                 # Invert min / max as well
++        #                 lassign [list $min $max $mininc $maxinc] \
++        #                     max min maxinc mininc
++        #             }
++        #             foreach e $copy {
++        #                 set mincmp [string compare $e $min]
++        #                 set maxcmp [string compare $e $max]
++        #                 if {
++        #                      ($mininc && $mincmp >= 0 || !$mininc && $mincmp > 0)
++        #                      &&
++        #                      ($maxinc && $maxcmp <= 0 || !$maxinc && $maxcmp < 0)
++        #                 } {
++        #                     lappend o $e
++        #                 }
++        #             }
++        #         }
++        #         assert {$o eq $output}
++        #         assert {$outlen eq [llength $output]}
++        #     }
++        # }
++
++        # test "ZREMRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" {
++        #     set lexset {}
++        #     r del zset zsetcopy
++        #     for {set j 0} {$j < $elements} {incr j} {
++        #         set e [randstring 0 30 alpha]
++        #         lappend lexset $e
++        #         r zadd zset 0 $e
++        #     }
++        #     set lexset [lsort -unique $lexset]
++        #     for {set j 0} {$j < 100} {incr j} {
++        #         # Copy...
++        #         r zunionstore zsetcopy 1 zset
++        #         set lexsetcopy $lexset
++
++        #         set min [randstring 0 30 alpha]
++        #         set max [randstring 0 30 alpha]
++        #         set mininc [randomInt 2]
++        #         set maxinc [randomInt 2]
++        #         if {$mininc} {set cmin "\[$min"} else {set cmin "($min"}
++        #         if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"}
++
++        #         # Make sure data is the same in both sides
++        #         assert {[r zrange zset 0 -1] eq $lexset}
++
++        #         # Get the range we are going to remove
++        #         set torem [r zrangebylex zset $cmin $cmax]
++        #         set toremlen [r zlexcount zset $cmin $cmax]
++        #         r zremrangebylex zsetcopy $cmin $cmax
++        #         set output [r zrange zsetcopy 0 -1]
++
++        #         # Remove the range with Tcl from the original list
++        #         if {$toremlen} {
++        #             set first [lsearch -exact $lexsetcopy [lindex $torem 0]]
++        #             set last [expr {$first+$toremlen-1}]
++        #             set lexsetcopy [lreplace $lexsetcopy $first $last]
++        #         }
++        #         assert {$lexsetcopy eq $output}
++        #     }
++        # }
++
++        # test "ZSETs skiplist implementation backlink consistency test - $encoding" {
++        #     set diff 0
++        #     for {set j 0} {$j < $elements} {incr j} {
++        #         r zadd myzset [expr rand()] "Element-$j"
++        #         r zrem myzset "Element-[expr int(rand()*$elements)]"
++        #     }
++
++        #     # assert_encoding $encoding myzset
++        #     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
++        #         }
++        #     }
++        #     assert_equal 0 $diff
++        # }
+ 
+         test "ZSETs ZRANK augmented skip list stress testing - $encoding" {
+             set err {}
+@@ -1094,7 +1098,7 @@ start_server {tags {"zset"}} {
+                 } else {
+                     set score [expr rand()]
+                     r zadd myzset $score $i
+-                    assert_encoding $encoding myzset
++                    # assert_encoding $encoding myzset
+                 }
+ 
+                 set card [r zcard myzset]
+@@ -1111,100 +1115,100 @@ start_server {tags {"zset"}} {
+             assert_equal {} $err
+         }
+ 
+-        test "BZPOPMIN, ZADD + DEL should not awake blocked client" {
+-            set rd [redis_deferring_client]
+-            r del zset
+-
+-            $rd bzpopmin zset 0
+-            r multi
+-            r zadd zset 0 foo
+-            r del zset
+-            r exec
+-            r del zset
+-            r zadd zset 1 bar
+-            $rd read
+-        } {zset bar 1}
+-
+-        test "BZPOPMIN, ZADD + DEL + SET should not awake blocked client" {
+-            set rd [redis_deferring_client]
+-            r del list
+-
+-            r del zset
+-
+-            $rd bzpopmin zset 0
+-            r multi
+-            r zadd zset 0 foo
+-            r del zset
+-            r set zset foo
+-            r exec
+-            r del zset
+-            r zadd zset 1 bar
+-            $rd read
+-        } {zset bar 1}
+-
+-        test "BZPOPMIN with same key multiple times should work" {
+-            set rd [redis_deferring_client]
+-            r del z1 z2
+-
+-            # Data arriving after the BZPOPMIN.
+-            $rd bzpopmin z1 z2 z2 z1 0
+-            r zadd z1 0 a
+-            assert_equal [$rd read] {z1 a 0}
+-            $rd bzpopmin z1 z2 z2 z1 0
+-            r zadd z2 1 b
+-            assert_equal [$rd read] {z2 b 1}
+-
+-            # Data already there.
+-            r zadd z1 0 a
+-            r zadd z2 1 b
+-            $rd bzpopmin z1 z2 z2 z1 0
+-            assert_equal [$rd read] {z1 a 0}
+-            $rd bzpopmin z1 z2 z2 z1 0
+-            assert_equal [$rd read] {z2 b 1}
+-        }
+-
+-        test "MULTI/EXEC is isolated from the point of view of BZPOPMIN" {
+-            set rd [redis_deferring_client]
+-            r del zset
+-            $rd bzpopmin zset 0
+-            r multi
+-            r zadd zset 0 a
+-            r zadd zset 1 b
+-            r zadd zset 2 c
+-            r exec
+-            $rd read
+-        } {zset a 0}
+-
+-        test "BZPOPMIN with variadic ZADD" {
+-            set rd [redis_deferring_client]
+-            r del zset
+-            if {$::valgrind} {after 100}
+-            $rd bzpopmin zset 0
+-            if {$::valgrind} {after 100}
+-            assert_equal 2 [r zadd zset -1 foo 1 bar]
+-            if {$::valgrind} {after 100}
+-            assert_equal {zset foo -1} [$rd read]
+-            assert_equal {bar} [r zrange zset 0 -1]
+-        }
+-
+-        test "BZPOPMIN with zero timeout should block indefinitely" {
+-            set rd [redis_deferring_client]
+-            r del zset
+-            $rd bzpopmin zset 0
+-            after 1000
+-            r zadd zset 0 foo
+-            assert_equal {zset foo 0} [$rd read]
+-        }
++        # test "BZPOPMIN, ZADD + DEL should not awake blocked client" {
++        #     set rd [redis_deferring_client]
++        #     r del zset
++
++        #     $rd bzpopmin zset 0
++        #     r multi
++        #     r zadd zset 0 foo
++        #     r del zset
++        #     r exec
++        #     r del zset
++        #     r zadd zset 1 bar
++        #     $rd read
++        # } {zset bar 1}
++
++        # test "BZPOPMIN, ZADD + DEL + SET should not awake blocked client" {
++        #     set rd [redis_deferring_client]
++        #     r del list
++
++        #     r del zset
++
++        #     $rd bzpopmin zset 0
++        #     r multi
++        #     r zadd zset 0 foo
++        #     r del zset
++        #     r set zset foo
++        #     r exec
++        #     r del zset
++        #     r zadd zset 1 bar
++        #     $rd read
++        # } {zset bar 1}
++
++        # test "BZPOPMIN with same key multiple times should work" {
++        #     set rd [redis_deferring_client]
++        #     r del z1 z2
++
++        #     # Data arriving after the BZPOPMIN.
++        #     $rd bzpopmin z1 z2 z2 z1 0
++        #     r zadd z1 0 a
++        #     assert_equal [$rd read] {z1 a 0}
++        #     $rd bzpopmin z1 z2 z2 z1 0
++        #     r zadd z2 1 b
++        #     assert_equal [$rd read] {z2 b 1}
++
++        #     # Data already there.
++        #     r zadd z1 0 a
++        #     r zadd z2 1 b
++        #     $rd bzpopmin z1 z2 z2 z1 0
++        #     assert_equal [$rd read] {z1 a 0}
++        #     $rd bzpopmin z1 z2 z2 z1 0
++        #     assert_equal [$rd read] {z2 b 1}
++        # }
++
++        # test "MULTI/EXEC is isolated from the point of view of BZPOPMIN" {
++        #     set rd [redis_deferring_client]
++        #     r del zset
++        #     $rd bzpopmin zset 0
++        #     r multi
++        #     r zadd zset 0 a
++        #     r zadd zset 1 b
++        #     r zadd zset 2 c
++        #     r exec
++        #     $rd read
++        # } {zset a 0}
++
++        # test "BZPOPMIN with variadic ZADD" {
++        #     set rd [redis_deferring_client]
++        #     r del zset
++        #     if {$::valgrind} {after 100}
++        #     $rd bzpopmin zset 0
++        #     if {$::valgrind} {after 100}
++        #     assert_equal 2 [r zadd zset -1 foo 1 bar]
++        #     if {$::valgrind} {after 100}
++        #     assert_equal {zset foo -1} [$rd read]
++        #     assert_equal {bar} [r zrange zset 0 -1]
++        # }
++
++        # test "BZPOPMIN with zero timeout should block indefinitely" {
++        #     set rd [redis_deferring_client]
++        #     r del zset
++        #     $rd bzpopmin zset 0
++        #     after 1000
++        #     r zadd zset 0 foo
++        #     assert_equal {zset foo 0} [$rd read]
++        # }
+     }
+ 
+     tags {"slow"} {
+-        stressers ziplist
++        # stressers ziplist
+         stressers skiplist
+     }
+ 
+     test {ZSET skiplist order consistency when elements are moved} {
+-        set original_max [lindex [r config get zset-max-ziplist-entries] 1]
+-        r config set zset-max-ziplist-entries 0
++        # set original_max [lindex [r config get zset-max-ziplist-entries] 1]
++        # r config set zset-max-ziplist-entries 0
+         for {set times 0} {$times < 10} {incr times} {
+             r del zset
+             for {set j 0} {$j < 1000} {incr j} {
+@@ -1225,6 +1229,6 @@ start_server {tags {"zset"}} {
+                 set prev_score $score
+             }
+         }
+-        r config set zset-max-ziplist-entries $original_max
++        # r config set zset-max-ziplist-entries $original_max
+     }
+ }