Remove testing data

1 files changed, 0 insertions, 733 deletions

diff --git a/examples/redis-unstable/tests/unit/other.tcl b/examples/redis-unstable/tests/unit/other.tcl
deleted file mode 100644
index 2faa7e9..0000000
--- a/examples/redis-unstable/tests/unit/other.tcl
+++ /dev/null
@@ -1,733 +0,0 @@
-start_server {tags {"other"}} {
-    if {$::force_failure} {
-        # This is used just for test suite development purposes.
-        test {Failing test} {
-            format err
-        } {ok}
-    }
-
-    test {Coverage: HELP commands} {
-        assert_match "*OBJECT <subcommand> *" [r OBJECT HELP]
-        assert_match "*MEMORY <subcommand> *" [r MEMORY HELP]
-        assert_match "*PUBSUB <subcommand> *" [r PUBSUB HELP]
-        assert_match "*SLOWLOG <subcommand> *" [r SLOWLOG HELP]
-        assert_match "*CLIENT <subcommand> *" [r CLIENT HELP]
-        assert_match "*COMMAND <subcommand> *" [r COMMAND HELP]
-        assert_match "*CONFIG <subcommand> *" [r CONFIG HELP]
-        assert_match "*FUNCTION <subcommand> *" [r FUNCTION HELP]
-        assert_match "*MODULE <subcommand> *" [r MODULE HELP]
-    }
-
-    test {Coverage: MEMORY MALLOC-STATS} {
-        if {[string match {*jemalloc*} [s mem_allocator]]} {
-            assert_match "*jemalloc*" [r memory malloc-stats]
-        }
-    }
-
-    test {Coverage: MEMORY PURGE} {
-        if {[string match {*jemalloc*} [s mem_allocator]]} {
-            assert_equal {OK} [r memory purge]
-        }
-    }
-
-    test {SAVE - make sure there are all the types as values} {
-        # Wait for a background saving in progress to terminate
-        waitForBgsave r
-        r lpush mysavelist hello
-        r lpush mysavelist world
-        r set myemptykey {}
-        r set mynormalkey {blablablba}
-        r zadd mytestzset 10 a
-        r zadd mytestzset 20 b
-        r zadd mytestzset 30 c
-        r save
-    } {OK} {needs:save}
-
-    tags {slow} {
-        if {$::accurate} {set iterations 10000} else {set iterations 1000}
-        foreach fuzztype {binary alpha compr} {
-            test "FUZZ stresser with data model $fuzztype" {
-                set err 0
-                for {set i 0} {$i < $iterations} {incr i} {
-                    set fuzz [randstring 0 512 $fuzztype]
-                    r set foo $fuzz
-                    set got [r get foo]
-                    if {$got ne $fuzz} {
-                        set err [list $fuzz $got]
-                        break
-                    }
-                }
-                set _ $err
-            } {0}
-        }
-    }
-
-    start_server {overrides {save ""} tags {external:skip}} {
-        test {FLUSHALL should not reset the dirty counter if we disable save} {
-            r set key value
-            r flushall
-            assert_morethan [s rdb_changes_since_last_save] 0
-        }
-
-        test {FLUSHALL should reset the dirty counter to 0 if we enable save} {
-            r config set save "3600 1 300 100 60 10000"
-            r set key value
-            r flushall
-            assert_equal [s rdb_changes_since_last_save] 0
-        }
-
-        test {FLUSHALL and bgsave} {
-            r config set save "3600 1 300 100 60 10000"
-            r set x y
-            r bgsave
-            r set x y
-            r multi
-            r debug sleep 1
-            # by the time we'll get to run flushall, the child will finish,
-            # but the parent will be unaware of it, and it could wrongly set the dirty counter.
-            r flushall
-            r exec
-            assert_equal [s rdb_changes_since_last_save] 0
-        }
-    }
-
-    test {BGSAVE} {
-        # Use FLUSHALL instead of FLUSHDB, FLUSHALL do a foreground save
-        # and reset the dirty counter to 0, so we won't trigger an unexpected bgsave.
-        r flushall
-        r save
-        r set x 10
-        r bgsave
-        waitForBgsave r
-        r debug reload
-        r get x
-    } {10} {needs:debug needs:save}
-
-    test {SELECT an out of range DB} {
-        catch {r select 1000000} err
-        set _ $err
-    } {*index is out of range*} {cluster:skip}
-
-    tags {consistency} {
-        proc check_consistency {dumpname code} {
-            set dump [csvdump r]
-            set sha1 [debug_digest]
-
-            uplevel 1 $code
-
-            set sha1_after [debug_digest]
-            if {$sha1 eq $sha1_after} {
-                return 1
-            }
-
-            # Failed
-            set newdump [csvdump r]
-            puts "Consistency test failed!"
-            puts "You can inspect the two dumps in /tmp/${dumpname}*.txt"
-
-            set fd [open /tmp/${dumpname}1.txt w]
-            puts $fd $dump
-            close $fd
-            set fd [open /tmp/${dumpname}2.txt w]
-            puts $fd $newdump
-            close $fd
-
-            return 0
-        }
-
-        if {$::accurate} {set numops 10000} else {set numops 1000}
-        test {Check consistency of different data types after a reload} {
-            r flushdb
-            # TODO: integrate usehexpire following next commit that will support replication
-            createComplexDataset r $numops {usetag usehexpire}
-            if {$::ignoredigest} {
-                set _ 1
-            } else {
-                check_consistency {repldump} {
-                    r debug reload
-                }
-            }
-        } {1} {needs:debug}
-
-        test {Same dataset digest if saving/reloading as AOF?} {
-            if {$::ignoredigest} {
-                set _ 1
-            } else {
-                check_consistency {aofdump} {
-                    r config set aof-use-rdb-preamble no
-                    r bgrewriteaof
-                    waitForBgrewriteaof r
-                    r debug loadaof
-                }
-            }
-        } {1} {needs:debug}
-    }
-
-    test {EXPIRES after a reload (snapshot + append only file rewrite)} {
-        r flushdb
-        r set x 10
-        r expire x 1000
-        r save
-        r debug reload
-        set ttl [r ttl x]
-        set e1 [expr {$ttl > 900 && $ttl <= 1000}]
-        r bgrewriteaof
-        waitForBgrewriteaof r
-        r debug loadaof
-        set ttl [r ttl x]
-        set e2 [expr {$ttl > 900 && $ttl <= 1000}]
-        list $e1 $e2
-    } {1 1} {needs:debug needs:save}
-
-    test {EXPIRES after AOF reload (without rewrite)} {
-        r flushdb
-        r config set appendonly yes
-        r config set aof-use-rdb-preamble no
-        r set x somevalue
-        r expire x 1000
-        r setex y 2000 somevalue
-        r set z somevalue
-        r expireat z [expr {[clock seconds]+3000}]
-
-        # Milliseconds variants
-        r set px somevalue
-        r pexpire px 1000000
-        r psetex py 2000000 somevalue
-        r set pz somevalue
-        r pexpireat pz [expr {([clock seconds]+3000)*1000}]
-
-        # Reload and check
-        waitForBgrewriteaof r
-        # We need to wait two seconds to avoid false positives here, otherwise
-        # the DEBUG LOADAOF command may read a partial file.
-        # Another solution would be to set the fsync policy to no, since this
-        # prevents write() to be delayed by the completion of fsync().
-        after 2000
-        r debug loadaof
-        set ttl [r ttl x]
-        assert {$ttl > 900 && $ttl <= 1000}
-        set ttl [r ttl y]
-        assert {$ttl > 1900 && $ttl <= 2000}
-        set ttl [r ttl z]
-        assert {$ttl > 2900 && $ttl <= 3000}
-        set ttl [r ttl px]
-        assert {$ttl > 900 && $ttl <= 1000}
-        set ttl [r ttl py]
-        assert {$ttl > 1900 && $ttl <= 2000}
-        set ttl [r ttl pz]
-        assert {$ttl > 2900 && $ttl <= 3000}
-        r config set appendonly no
-    } {OK} {needs:debug}
-
-    tags {protocol} {
-        test {PIPELINING stresser (also a regression for the old epoll bug)} {
-            if {$::tls} {
-                set fd2 [::tls::socket [srv host] [srv port]]
-            } else {
-                set fd2 [socket [srv host] [srv port]]
-            }
-            fconfigure $fd2 -encoding binary -translation binary
-            if {!$::singledb} {
-                puts -nonewline $fd2 "SELECT 9\r\n"
-                flush $fd2
-                gets $fd2
-            }
-
-            for {set i 0} {$i < 100000} {incr i} {
-                set q {}
-                set val "0000${i}0000"
-                append q "SET key:$i $val\r\n"
-                puts -nonewline $fd2 $q
-                set q {}
-                append q "GET key:$i\r\n"
-                puts -nonewline $fd2 $q
-            }
-            flush $fd2
-
-            for {set i 0} {$i < 100000} {incr i} {
-                gets $fd2 line
-                gets $fd2 count
-                set count [string range $count 1 end]
-                set val [read $fd2 $count]
-                read $fd2 2
-            }
-            close $fd2
-            set _ 1
-        } {1}
-    }
-
-    test {APPEND basics} {
-        r del foo
-        list [r append foo bar] [r get foo] \
-             [r append foo 100] [r get foo]
-    } {3 bar 6 bar100}
-
-    test {APPEND basics, integer encoded values} {
-        set res {}
-        r del foo
-        r append foo 1
-        r append foo 2
-        lappend res [r get foo]
-        r set foo 1
-        r append foo 2
-        lappend res [r get foo]
-    } {12 12}
-
-    test {APPEND fuzzing} {
-        set err {}
-        foreach type {binary alpha compr} {
-            set buf {}
-            r del x
-            for {set i 0} {$i < 1000} {incr i} {
-                set bin [randstring 0 10 $type]
-                append buf $bin
-                r append x $bin
-            }
-            if {$buf != [r get x]} {
-                set err "Expected '$buf' found '[r get x]'"
-                break
-            }
-        }
-        set _ $err
-    } {}
-
-    # Leave the user with a clean DB before to exit
-    test {FLUSHDB} {
-        set aux {}
-        if {$::singledb} {
-            r flushdb
-            lappend aux 0 [r dbsize]
-        } else {
-            r select 9
-            r flushdb
-            lappend aux [r dbsize]
-            r select 10
-            r flushdb
-            lappend aux [r dbsize]
-        }
-    } {0 0}
-
-    test {Perform a final SAVE to leave a clean DB on disk} {
-        waitForBgsave r
-        r save
-    } {OK} {needs:save}
-
-    test {RESET clears client state} {
-        r client setname test-client
-        r client tracking on
-
-        assert_equal [r reset] "RESET"
-        set client [r client list]
-        assert_match {*name= *} $client
-        assert_match {*flags=N *} $client
-    } {} {needs:reset}
-
-    test {RESET clears MONITOR state} {
-        set rd [redis_deferring_client]
-        $rd monitor
-        assert_equal [$rd read] "OK"
-
-        $rd reset
-        assert_equal [$rd read] "RESET"
-        $rd close
-
-        assert_no_match {*flags=O*} [r client list]
-    } {} {needs:reset}
-
-    test {RESET clears and discards MULTI state} {
-        r multi
-        r set key-a a
-
-        r reset
-        catch {r exec} err
-        assert_match {*EXEC without MULTI*} $err
-    } {} {needs:reset}
-
-    test {RESET clears Pub/Sub state} {
-        r subscribe channel-1
-        r reset
-
-        # confirm we're not subscribed by executing another command
-        r set key val
-    } {OK} {needs:reset}
-
-    test {RESET clears authenticated state} {
-        r acl setuser user1 on >secret +@all
-        r auth user1 secret
-        assert_equal [r acl whoami] user1
-
-        r reset
-
-        assert_equal [r acl whoami] default
-    } {} {needs:reset}
-
-    test "Subcommand syntax error crash (issue #10070)" {
-        assert_error {*unknown command*} {r GET|}
-        assert_error {*unknown command*} {r GET|SET}
-        assert_error {*unknown command*} {r GET|SET|OTHER}
-        assert_error {*unknown command*} {r CONFIG|GET GET_XX}
-        assert_error {*unknown subcommand*} {r CONFIG GET_XX}
-    }
-}
-
-start_server {tags {"other external:skip"}} {
-    test {Don't rehash if redis has child process} {
-        r config set save ""
-        r config set rdb-key-save-delay 1000000
-
-        populate 4095 "" 1
-        r bgsave
-        wait_for_condition 10 100 {
-            [s rdb_bgsave_in_progress] eq 1
-        } else {
-            fail "bgsave did not start in time"
-        }
-
-        r mset k1 v1 k2 v2
-        # Hash table should not rehash
-        assert_no_match "*table size: 8192*" [r debug HTSTATS 9]
-        exec kill -9 [get_child_pid 0]
-        waitForBgsave r
-
-        # Hash table should rehash since there is no child process,
-        # size is power of two and over 4096, so it is 8192
-        wait_for_condition 50 100 {
-            [string match "*table size: 8192*" [r debug HTSTATS 9]]
-        } else {
-            fail "hash table did not rehash after child process killed"
-        }
-    } {} {needs:debug needs:local-process}
-}
-
-proc read_proc_title {pid} {
-    set fd [open "/proc/$pid/cmdline" "r"]
-    set cmdline [read $fd 1024]
-    close $fd
-
-    return $cmdline
-}
-
-start_server {tags {"other external:skip"}} {
-    test {Process title set as expected} {
-        # Test only on Linux where it's easy to get cmdline without relying on tools.
-        # Skip valgrind as it messes up the arguments.
-        set os [exec uname]
-        if {$os == "Linux" && !$::valgrind} {
-            # Set a custom template
-            r config set "proc-title-template" "TEST {title} {listen-addr} {port} {tls-port} {unixsocket} {config-file}"
-            set cmdline [read_proc_title [srv 0 pid]]
-
-            assert_equal "TEST" [lindex $cmdline 0]
-            assert_match "*/redis-server" [lindex $cmdline 1]
-            
-            if {$::tls} {
-                set expect_port [srv 0 pport]
-                set expect_tls_port [srv 0 port]
-                set port [srv 0 pport]
-            } else {
-                set expect_port [srv 0 port]
-                set expect_tls_port 0
-                set port [srv 0 port]
-            }
-
-            assert_equal "$::host:$port" [lindex $cmdline 2]
-            assert_equal $expect_port [lindex $cmdline 3]
-            assert_equal $expect_tls_port [lindex $cmdline 4]
-            assert_match "*/tests/tmp/server.*/socket" [lindex $cmdline 5]
-            assert_match "*/tests/tmp/redis.conf.*" [lindex $cmdline 6]
-
-            # Try setting a bad template
-            catch {r config set "proc-title-template" "{invalid-var}"} err
-            assert_match {*template format is invalid*} $err
-        }
-    }
-}
-
-start_cluster 1 0 {tags {"other external:skip cluster slow"}} {
-    r config set dynamic-hz no hz 500
-    test "Redis can trigger resizing" {
-        r flushall
-        # hashslot(foo) is 12182
-        for {set j 1} {$j <= 128} {incr j} {
-            r set "{foo}$j" a
-        }
-        assert_match "*table size: 128*" [r debug HTSTATS 0]
-
-        # disable resizing, the reason for not using slow bgsave is because
-        # it will hit the dict_force_resize_ratio.
-        r debug dict-resizing 0
-
-        # delete data to have lot's (96%) of empty buckets
-        for {set j 1} {$j <= 123} {incr j} {
-            r del "{foo}$j"
-        }
-        assert_match "*table size: 128*" [r debug HTSTATS 0]
-
-        # enable resizing
-        r debug dict-resizing 1
-
-        # waiting for serverCron to resize the tables
-        wait_for_condition 1000 10 {
-            [string match {*table size: 8*} [r debug HTSTATS 0]]
-        } else {
-            puts [r debug HTSTATS 0]
-            fail "hash tables weren't resize."
-        }
-    } {} {needs:debug}
-
-    test "Redis can rewind and trigger smaller slot resizing" {
-        # hashslot(foo) is 12182
-        # hashslot(alice) is 749, smaller than hashslot(foo),
-        # attempt to trigger a resize on it, see details in #12802.
-        for {set j 1} {$j <= 128} {incr j} {
-            r set "{alice}$j" a
-        }
-
-        # disable resizing, the reason for not using slow bgsave is because
-        # it will hit the dict_force_resize_ratio.
-        r debug dict-resizing 0
-
-        for {set j 1} {$j <= 123} {incr j} {
-            r del "{alice}$j"
-        }
-
-        # enable resizing
-        r debug dict-resizing 1
-
-        # waiting for serverCron to resize the tables
-        wait_for_condition 1000 10 {
-            [string match {*table size: 16*} [r debug HTSTATS 0]]
-        } else {
-            puts [r debug HTSTATS 0]
-            fail "hash tables weren't resize."
-        }
-    } {} {needs:debug}
-}
-
-start_server {tags {"other external:skip"}} {
-    test "Redis can resize empty dict" {
-        # Write and then delete 128 keys, creating an empty dict
-        r flushall
-        
-        # Add one key to the db just to create the dict and get its initial size
-        r set x 1
-        set initial_size [dict get [r memory stats] db.9 overhead.hashtable.main] 
-        
-        # Now add 128 keys and then delete them
-        for {set j 1} {$j <= 128} {incr j} {
-            r set $j{b} a
-        }
-        
-        for {set j 1} {$j <= 128} {incr j} {
-            r del $j{b}
-        }
-        
-        # dict must have expanded. Verify it eventually shrinks back to its initial size.
-        wait_for_condition 100 50 {
-            [dict get [r memory stats] db.9 overhead.hashtable.main] == $initial_size
-        } else {
-            fail "dict did not resize in time to its initial size"
-        }
-    }
-}
-
-start_server {tags {"other external:skip"} overrides {cluster-compatibility-sample-ratio 100}} {
-    test {Cross DB command is incompatible with cluster mode} {
-        set incompatible_ops [s cluster_incompatible_ops]
-
-        # SELECT with 0 is compatible command in cluster mode
-        assert_equal {OK} [r select 0]
-        assert_equal $incompatible_ops [s cluster_incompatible_ops]
-
-        # SELECT with nonzero is incompatible command in cluster mode
-        assert_equal {OK} [r select 1]
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-
-        # SWAPDB is incompatible command in cluster mode
-        assert_equal {OK} [r swapdb 0 1]
-        assert_equal [expr $incompatible_ops + 2] [s cluster_incompatible_ops]
-
-
-        # If destination db in COPY command is equal to source db, it is compatible
-        # with cluster mode, otherwise it is incompatible.
-        r select 0
-        r set key1 value1
-        set incompatible_ops [s cluster_incompatible_ops]
-        assert_equal {1} [r copy key1 key2{key1}] ;# destination db is equal to source db
-        assert_equal $incompatible_ops [s cluster_incompatible_ops]
-        assert_equal {1} [r copy key2{key1} key1 db 1] ;# destination db is not equal to source db
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-
-        # If destination db in MOVE command is not equal to source db, it is incompatible
-        # with cluster mode.
-        r set key3 value3
-        assert_equal {1} [r move key3 1]
-        assert_equal [expr $incompatible_ops + 2] [s cluster_incompatible_ops]
-    } {} {cluster:skip}
-
-    test {Function no-cluster flag is incompatible with cluster mode} {
-        set incompatible_ops [s cluster_incompatible_ops]
-
-        # no-cluster flag is incompatible with cluster mode
-        r function load {#!lua name=test
-            redis.register_function{function_name='f1', callback=function() return 'hello' end, flags={'no-cluster'}}
-        }
-        r fcall f1 0
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-
-        # It is compatible without no-cluster flag, should not increase the cluster_incompatible_ops
-        r function load {#!lua name=test2
-            redis.register_function{function_name='f2', callback=function() return 'hello' end}
-        }
-        r fcall f2 0
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-    } {} {cluster:skip}
-
-    test {Script no-cluster flag is incompatible with cluster mode} {
-        set incompatible_ops [s cluster_incompatible_ops]
-
-        # no-cluster flag is incompatible with cluster mode
-        r eval {#!lua flags=no-cluster
-                return 1
-            } 0
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-
-        # It is compatible without no-cluster flag, should not increase the cluster_incompatible_ops
-        r eval {#!lua
-                return 1
-            } 0
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-    } {} {cluster:skip}
-
-    test {SORT command incompatible operations with cluster mode} {
-        set incompatible_ops [s cluster_incompatible_ops]
-
-        # If the BY pattern slot is not equal with the slot of keys, we consider
-        # an incompatible behavior, otherwise it is compatible, should not increase
-        # the cluster_incompatible_ops
-        r lpush mylist 1 2 3
-        for {set i 1} {$i < 4} {incr i} {
-            r set weight_$i [expr 4 - $i]
-        }
-        assert_equal {3 2 1} [r sort mylist BY weight_*]
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-        # weight{mylist}_* and mylist have the same slot
-        for {set i 1} {$i < 4} {incr i} {
-            r set weight{mylist}_$i [expr 4 - $i]
-        }
-        assert_equal {3 2 1} [r sort mylist BY weight{mylist}_*]
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-
-        # If the GET pattern slot is not equal with the slot of keys, we consider
-        # an incompatible behavior, otherwise it is compatible, should not increase
-        # the cluster_incompatible_ops
-        for {set i 1} {$i < 4} {incr i} {
-            r set object_$i o_$i
-        }
-        assert_equal {o_3 o_2 o_1} [r sort mylist BY weight{mylist}_* GET object_*]
-        assert_equal [expr $incompatible_ops + 2] [s cluster_incompatible_ops]
-        # object{mylist}_*, weight{mylist}_* and mylist have the same slot
-        for {set i 1} {$i < 4} {incr i} {
-            r set object{mylist}_$i o_$i
-        }
-        assert_equal {o_3 o_2 o_1} [r sort mylist BY weight{mylist}_* GET object{mylist}_*]
-        assert_equal [expr $incompatible_ops + 2] [s cluster_incompatible_ops]
-    } {} {cluster:skip}
-
-    test {Normal cross slot commands are incompatible with cluster mode} {
-        # Normal cross slot command
-        set incompatible_ops [s cluster_incompatible_ops]
-        r mset foo bar bar foo
-        r del foo bar
-        assert_equal [expr $incompatible_ops + 2] [s cluster_incompatible_ops]
-    } {} {cluster:skip}
-
-    test {Transaction is incompatible with cluster mode} {
-        set incompatible_ops [s cluster_incompatible_ops]
-
-        # Incomplete transaction
-        catch {r EXEC}
-        r multi
-        r exec
-        assert_equal $incompatible_ops [s cluster_incompatible_ops]
-
-        # Transaction, SET and DEL have keys with different slots
-        r multi
-        r set foo bar
-        r del bar
-        r exec
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-    } {} {cluster:skip}
-
-    test {Lua scripts are incompatible with cluster mode} {
-        # Lua script, declared keys have different slots, it is not a compatible operation
-        set incompatible_ops [s cluster_incompatible_ops]
-        r eval {#!lua
-            redis.call('mset', KEYS[1], 0, KEYS[2], 0)
-        } 2 foo bar
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-
-        # Lua script, no declared keys, but accessing keys have different slots,
-        # it is not a compatible operation
-        set incompatible_ops [s cluster_incompatible_ops]
-        r eval {#!lua
-            redis.call('mset', 'foo', 0, 'bar', 0)
-        } 0
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-
-        # Lua script, declared keys have the same slot, but accessing keys
-        # have different slots in one command, even with flag 'allow-cross-slot-keys',
-        # it still is not a compatible operation
-        set incompatible_ops [s cluster_incompatible_ops]
-        r eval {#!lua flags=allow-cross-slot-keys
-            redis.call('mset', 'foo', 0, 'bar', 0)
-            redis.call('mset', KEYS[1], 0, KEYS[2], 0)
-        } 2 foo bar{foo}
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-
-        # Lua script, declared keys have the same slot, but accessing keys have different slots
-        # in multiple commands, and with flag 'allow-cross-slot-keys', it is a compatible operation
-        set incompatible_ops [s cluster_incompatible_ops]
-        r eval {#!lua flags=allow-cross-slot-keys
-            redis.call('set', 'foo', 0)
-            redis.call('set', 'bar', 0)
-            redis.call('mset', KEYS[1], 0, KEYS[2], 0)
-        } 2 foo bar{foo}
-        assert_equal $incompatible_ops [s cluster_incompatible_ops]
-    } {} {cluster:skip}
-
-    test {Shard subscribe commands are incompatible with cluster mode} {
-        set rd1 [redis_deferring_client]
-        set incompatible_ops [s cluster_incompatible_ops]
-        assert_equal {1 2} [ssubscribe $rd1 {foo bar}]
-        assert_equal [expr $incompatible_ops + 1] [s cluster_incompatible_ops]
-    } {} {cluster:skip}
-
-    test {cluster-compatibility-sample-ratio configuration can work} {
-        # Disable cluster compatibility sampling, no increase in cluster_incompatible_ops
-        set incompatible_ops [s cluster_incompatible_ops]
-        r config set cluster-compatibility-sample-ratio 0
-        for {set i 0} {$i < 100} {incr i} {
-            r mset foo bar$i bar foo$i
-        }
-        # Enable cluster compatibility sampling again to show the metric
-        r config set cluster-compatibility-sample-ratio 1
-        assert_equal $incompatible_ops [s cluster_incompatible_ops]
-
-        # 100% sample ratio, all operations should increase cluster_incompatible_ops
-        set incompatible_ops [s cluster_incompatible_ops]
-        r config set cluster-compatibility-sample-ratio 100
-        for {set i 0} {$i < 100} {incr i} {
-            r mset foo bar$i bar foo$i
-        }
-        assert_equal [expr $incompatible_ops + 100] [s cluster_incompatible_ops]
-
-        # 30% sample ratio, cluster_incompatible_ops should increase between 20% and 40%
-        set incompatible_ops [s cluster_incompatible_ops]
-        r config set cluster-compatibility-sample-ratio 30
-        for {set i 0} {$i < 1000} {incr i} {
-            r mset foo bar$i bar foo$i
-        }
-        assert_range [s cluster_incompatible_ops] [expr $incompatible_ops + 200] [expr $incompatible_ops + 400]
-    } {} {cluster:skip}
-}