You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ri...@apache.org on 2021/10/07 20:23:47 UTC
[geode] 01/01: Restore patch file
This is an automated email from the ASF dual-hosted git repository.
ringles pushed a commit to branch GEODE-9690-restore-redis-tcl-patch-file
in repository https://gitbox.apache.org/repos/asf/geode.git
commit dbd4e70c2174a37aa2bcbc6f546fc00cda2430f7
Author: Ray Ingles <ri...@vmware.com>
AuthorDate: Thu Oct 7 16:22:06 2021 -0400
Restore patch file
---
.../resources/0001-configure-redis-tests.patch | 2855 ++++++++++++++++++++
1 file changed, 2855 insertions(+)
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
+ }
+ }