Remove testing data

1 files changed, 0 insertions, 706 deletions

diff --git a/examples/redis-unstable/tests/unit/bitops.tcl b/examples/redis-unstable/tests/unit/bitops.tcl
deleted file mode 100644
index 23b2736..0000000
--- a/examples/redis-unstable/tests/unit/bitops.tcl
+++ /dev/null
@@ -1,706 +0,0 @@
-# Compare Redis commands against Tcl implementations of the same commands.
-proc count_bits s {
-    binary scan $s b* bits
-    string length [regsub -all {0} $bits {}]
-}
-
-# start end are bit index
-proc count_bits_start_end {s start end} {
-    binary scan $s B* bits
-    string length [regsub -all {0} [string range $bits $start $end] {}]
-}
-
-proc simulate_bit_op {op args} {
-    set maxlen 0
-    set j 0
-    set count [llength $args]
-    foreach a $args {
-        binary scan $a b* bits
-        set b($j) $bits
-        if {[string length $bits] > $maxlen} {
-            set maxlen [string length $bits]
-        }
-        incr j
-    }
-    for {set j 0} {$j < $count} {incr j} {
-        if {[string length $b($j)] < $maxlen} {
-            append b($j) [string repeat 0 [expr $maxlen-[string length $b($j)]]]
-        }
-    }
-    set out {}
-    for {set x 0} {$x < $maxlen} {incr x} {
-        set fst_bit [string range $b(0) $x $x]
-        set bit $fst_bit
-        if {[expr {$op == {diff} || $op == {diff1} || $op == {andor}}]} {
-            set bit "0"
-        }
-        if {$op eq {not}} {set bit [expr {!$bit}]}
-        set multi_cnt "0"
-        for {set j 1} {$j < $count} {incr j} {
-            set bit2 [string range $b($j) $x $x]
-            switch $op {
-                and   {set bit [expr {$bit & $bit2}]}
-                or    {set bit [expr {$bit | $bit2}]}
-                xor   {set bit [expr {$bit ^ $bit2}]}
-                diff  {set bit [expr {$bit | $bit2}]}
-                diff1 {set bit [expr {$bit | $bit2}]}
-                andor {set bit [expr {$bit | $bit2}]}
-                one {
-                    set multi_cnt [expr $multi_cnt | {$bit & $bit2}]
-                    set bit [expr {$bit ^ $bit2}]
-                    set bit [expr {$bit & !$multi_cnt}]
-                }
-            }
-        }
-        switch $op {
-            diff  { set bit [expr {$fst_bit & !$bit}] }
-            diff1 { set bit [expr {!$fst_bit & $bit}] }
-            andor { set bit [expr {$fst_bit & $bit}] }
-        }
-
-        append out $bit
-    }
-    binary format b* $out
-}
-
-start_server {tags {"bitops"}} {
-    test {BITCOUNT against wrong type} {
-        r del mylist
-        r lpush mylist a b c
-        assert_error "*WRONGTYPE*" {r bitcount mylist}
-        assert_error "*WRONGTYPE*" {r bitcount mylist 0 100}
-
-        # with negative indexes where start > end
-        assert_error "*WRONGTYPE*" {r bitcount mylist -6 -7}
-        assert_error "*WRONGTYPE*" {r bitcount mylist -6 -15 bit}
-    }
-
-    test {BITCOUNT returns 0 against non existing key} {
-        r del no-key
-        assert {[r bitcount no-key] == 0}
-        assert {[r bitcount no-key 0 1000 bit] == 0}
-    }
-
-    test {BITCOUNT returns 0 with out of range indexes} {
-        r set str "xxxx"
-        assert {[r bitcount str 4 10] == 0}
-        assert {[r bitcount str 32 87 bit] == 0}
-    }
-
-    test {BITCOUNT returns 0 with negative indexes where start > end} {
-        r set str "xxxx"
-        assert {[r bitcount str -6 -7] == 0}
-        assert {[r bitcount str -6 -15 bit] == 0}
-
-        # against non existing key
-        r del str
-        assert {[r bitcount str -6 -7] == 0}
-        assert {[r bitcount str -6 -15 bit] == 0}
-    }
-
-    catch {unset num}
-    foreach vec [list "" "\xaa" "\x00\x00\xff" "foobar" "123"] {
-        incr num
-        test "BITCOUNT against test vector #$num" {
-            r set str $vec
-            set count [count_bits $vec]
-            assert {[r bitcount str] == $count}
-            assert {[r bitcount str 0 -1 bit] == $count}
-        }
-    }
-
-    test {BITCOUNT fuzzing without start/end} {
-        for {set j 0} {$j < 100} {incr j} {
-            set str [randstring 0 3000]
-            r set str $str
-            set count [count_bits $str]
-            assert {[r bitcount str] == $count}
-            assert {[r bitcount str 0 -1 bit] == $count}
-        }
-    }
-
-    test {BITCOUNT fuzzing with start/end} {
-        for {set j 0} {$j < 100} {incr j} {
-            set str [randstring 0 3000]
-            r set str $str
-            set l [string length $str]
-            set start [randomInt $l]
-            set end [randomInt $l]
-            if {$start > $end} {
-                # Swap start and end
-                lassign [list $end $start] start end
-            }
-            assert {[r bitcount str $start $end] == [count_bits [string range $str $start $end]]}
-        }
-
-        for {set j 0} {$j < 100} {incr j} {
-            set str [randstring 0 3000]
-            r set str $str
-            set l [expr [string length $str] * 8]
-            set start [randomInt $l]
-            set end [randomInt $l]
-            if {$start > $end} {
-                # Swap start and end
-                lassign [list $end $start] start end
-            }
-            assert {[r bitcount str $start $end bit] == [count_bits_start_end $str $start $end]}
-        }
-    }
-
-    test {BITCOUNT with start, end} {
-        set s "foobar"
-        r set s $s
-        assert_equal [r bitcount s 0 -1] [count_bits "foobar"]
-        assert_equal [r bitcount s 1 -2] [count_bits "ooba"]
-        assert_equal [r bitcount s -2 1] [count_bits ""]
-        assert_equal [r bitcount s 0 1000] [count_bits "foobar"]
-
-        assert_equal [r bitcount s 0 -1 bit] [count_bits $s]
-        assert_equal [r bitcount s 10 14 bit] [count_bits_start_end $s 10 14]
-        assert_equal [r bitcount s 3 14 bit] [count_bits_start_end $s 3 14]
-        assert_equal [r bitcount s 3 29 bit] [count_bits_start_end $s 3 29]
-        assert_equal [r bitcount s 10 -34 bit] [count_bits_start_end $s 10 14]
-        assert_equal [r bitcount s 3 -34 bit] [count_bits_start_end $s 3 14]
-        assert_equal [r bitcount s 3 -19 bit] [count_bits_start_end $s 3 29]
-        assert_equal [r bitcount s -2 1 bit] 0
-        assert_equal [r bitcount s 0 1000 bit] [count_bits $s]
-    }
-
-    test {BITCOUNT with illegal arguments} {
-        # Used to return 0 for non-existing key instead of errors
-        r del s
-        assert_error {ERR *syntax*} {r bitcount s 0}
-        assert_error {ERR *syntax*} {r bitcount s 0 1 hello}
-        assert_error {ERR *syntax*} {r bitcount s 0 1 hello hello2}
-
-        r set s 1
-        assert_error {ERR *syntax*} {r bitcount s 0}
-        assert_error {ERR *syntax*} {r bitcount s 0 1 hello}
-        assert_error {ERR *syntax*} {r bitcount s 0 1 hello hello2}
-    }
-
-    test {BITCOUNT against non-integer value} {
-        # against existing key
-        r set s 1
-        assert_error {ERR *not an integer*} {r bitcount s a b}
-
-        # against non existing key
-        r del s
-        assert_error {ERR *not an integer*} {r bitcount s a b}
-
-        # against wrong type
-        r lpush s a b c
-        assert_error {ERR *not an integer*} {r bitcount s a b}
-    }
-
-    test {BITCOUNT regression test for github issue #582} {
-        r del foo
-        r setbit foo 0 1
-        if {[catch {r bitcount foo 0 4294967296} e]} {
-            assert_match {*ERR*out of range*} $e
-            set _ 1
-        } else {
-            set e
-        }
-    } {1}
-
-    test {BITCOUNT misaligned prefix} {
-        r del str
-        r set str ab
-        r bitcount str 1 -1
-    } {3}
-
-    test {BITCOUNT misaligned prefix + full words + remainder} {
-        r del str
-        r set str __PPxxxxxxxxxxxxxxxxRR__
-        r bitcount str 2 -3
-    } {74}
-
-    test {BITOP NOT (empty string)} {
-        r set s{t} ""
-        r bitop not dest{t} s{t}
-        r get dest{t}
-    } {}
-
-    test {BITOP NOT (known string)} {
-        r set s{t} "\xaa\x00\xff\x55"
-        r bitop not dest{t} s{t}
-        r get dest{t}
-    } "\x55\xff\x00\xaa"
-
-    test {BITOP NOT with multiple source keys} {
-        r set s{t} "\xaa\x00\xff\x55"
-        assert_error "ERR BITOP NOT*" { r bitop not dest{t} s{t} s{t} }
-    }
-
-    test {BITOP where dest and target are the same key} {
-        r set s "\xaa\x00\xff\x55"
-        r bitop not s s
-        r get s
-    } "\x55\xff\x00\xaa"
-
-    test {BITOP AND|OR|XOR|ONE don't change the string with single input key} {
-        r set a{t} "\x01\x02\xff"
-        r bitop and res1{t} a{t}
-        r bitop or  res2{t} a{t}
-        r bitop xor res3{t} a{t}
-        r bitop one res4{t} a{t}
-        list [r get res1{t}] [r get res2{t}] [r get res3{t}] [r get res4{t}]
-    } [list "\x01\x02\xff" "\x01\x02\xff" "\x01\x02\xff" "\x01\x02\xff"]
-
-    test {BITOP DIFF|DIFF1|ANDOR with one source key} {
-        r set s{t} ""
-        assert_error "ERR BITOP DIFF*" { r bitop diff dest{t} s{t} }
-        assert_error "ERR BITOP DIFF1*" { r bitop diff1 dest{t} s{t} }
-        assert_error "ERR BITOP ANDOR*" { r bitop andor dest{t} s{t} }
-    }
-
-    test {BITOP missing key is considered a stream of zero} {
-        r set a{t} "\x01\x02\xff"
-        r bitop and   res1{t} no-such-key{t} a{t}
-        r bitop or    res2{t} no-such-key{t} a{t} no-such-key{t}
-        r bitop xor   res3{t} no-such-key{t} a{t}
-        r bitop diff  res4{t} a{t} no-such-key{t}
-        r bitop diff1 res5{t} a{t} no-such-key{t}
-        r bitop andor res6{t} a{t} no-such-key{t}
-        r bitop one   res7{t} no-such_key{t} a{t}
-        list [r get res1{t}] [r get res2{t}] [r get res3{t}] [r get res4{t}] [r get res5{t}] [r get res6{t}] [r get res7{t}]
-    } [list "\x00\x00\x00" "\x01\x02\xff" "\x01\x02\xff" "\x01\x02\xff" "\x00\x00\x00" "\x00\x00\x00" "\x01\x02\xff"]
-
-    test {BITOP shorter keys are zero-padded to the key with max length} {
-        r set a{t} "\x01\x02\xff\xff"
-        r set b{t} "\x01\x02\xff"
-        r bitop and   res1{t} a{t} b{t}
-        r bitop or    res2{t} a{t} b{t}
-        r bitop xor   res3{t} a{t} b{t}
-        r bitop diff  res4{t} a{t} b{t}
-        r bitop diff1 res5{t} a{t} b{t}
-        r bitop andor res6{t} a{t} b{t}
-        r bitop one   res7{t} a{t} b{t}
-        list [r get res1{t}] [r get res2{t}] [r get res3{t}] [r get res4{t}] [r get res5{t}] [r get res6{t}] [r get res7{t}]
-    } [list "\x01\x02\xff\x00" "\x01\x02\xff\xff" "\x00\x00\x00\xff" "\x00\x00\x00\xff" "\x00\x00\x00\x00" "\x01\x02\xff\x00" "\x00\x00\x00\xff"]
-
-    foreach op {and or xor diff diff1 andor one} {
-        test "BITOP $op fuzzing" {
-            set min_args 1
-            if {[expr {$op == {diff} || $op == {diff1} || $op == {andor}}]} {
-                set min_args 2
-            }
-            for {set i 0} {$i < 10} {incr i} {
-                r flushall
-                set vec {}
-                set veckeys {}
-                set numvec [expr {[randomInt 10]+$min_args}]
-                for {set j 0} {$j < $numvec} {incr j} {
-                    set str [randstring 0 1000]
-                    lappend vec $str
-                    lappend veckeys vector_$j{t}
-                    r set vector_$j{t} $str
-                }
-                r bitop $op target{t} {*}$veckeys
-                assert_equal [r get target{t}] [simulate_bit_op $op {*}$vec]
-            }
-        }
-    }
-
-    test {BITOP NOT fuzzing} {
-        for {set i 0} {$i < 10} {incr i} {
-            r flushall
-            set str [randstring 0 1000]
-            r set str{t} $str
-            r bitop not target{t} str{t}
-            assert_equal [r get target{t}] [simulate_bit_op not $str]
-        }
-    }
-
-    test {BITOP with integer encoded source objects} {
-        r set a{t} 1
-        r set b{t} 2
-        r bitop xor dest{t} a{t} b{t} a{t}
-        r get dest{t}
-    } {2}
-
-    test {BITOP with non string source key} {
-        r del c{t}
-        r set a{t} 1
-        r set b{t} 2
-        r lpush c{t} foo
-        catch {r bitop xor dest{t} a{t} b{t} c{t} d{t}} e
-        set e
-    } {WRONGTYPE*}
-
-    test {BITOP with empty string after non empty string (issue #529)} {
-        r flushdb
-        r set a{t} "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-        r bitop or x{t} a{t} b{t}
-    } {32}
-
-    test {BITPOS against wrong type} {
-        r del mylist
-        r lpush mylist a b c
-        assert_error "*WRONGTYPE*" {r bitpos mylist 0}
-        assert_error "*WRONGTYPE*" {r bitpos mylist 1 10 100}
-    }
-
-    test {BITPOS will illegal arguments} {
-        # Used to return 0 for non-existing key instead of errors
-        r del s
-        assert_error {ERR *syntax*} {r bitpos s 0 1 hello hello2}
-        assert_error {ERR *syntax*} {r bitpos s 0 0 1 hello}
-
-        r set s 1
-        assert_error {ERR *syntax*} {r bitpos s 0 1 hello hello2}
-        assert_error {ERR *syntax*} {r bitpos s 0 0 1 hello}
-    }
-
-    test {BITPOS against non-integer value} {
-        # against existing key
-        r set s 1
-        assert_error {ERR *not an integer*} {r bitpos s a}
-        assert_error {ERR *not an integer*} {r bitpos s 0 a b}
-
-        # against non existing key
-        r del s
-        assert_error {ERR *not an integer*} {r bitpos s b}
-        assert_error {ERR *not an integer*} {r bitpos s 0 a b}
-
-        # against wrong type
-        r lpush s a b c
-        assert_error {ERR *not an integer*} {r bitpos s a}
-        assert_error {ERR *not an integer*} {r bitpos s 1 a b}
-    }
-
-    test {BITPOS bit=0 with empty key returns 0} {
-        r del str
-        assert {[r bitpos str 0] == 0}
-        assert {[r bitpos str 0 0 -1 bit] == 0}
-    }
-
-    test {BITPOS bit=1 with empty key returns -1} {
-        r del str
-        assert {[r bitpos str 1] == -1}
-        assert {[r bitpos str 1 0 -1] == -1}
-    }
-
-    test {BITPOS bit=0 with string less than 1 word works} {
-        r set str "\xff\xf0\x00"
-        assert {[r bitpos str 0] == 12}
-        assert {[r bitpos str 0 0 -1 bit] == 12}
-    }
-
-    test {BITPOS bit=1 with string less than 1 word works} {
-        r set str "\x00\x0f\x00"
-        assert {[r bitpos str 1] == 12}
-        assert {[r bitpos str 1 0 -1 bit] == 12}
-    }
-
-    test {BITPOS bit=0 starting at unaligned address} {
-        r set str "\xff\xf0\x00"
-        assert {[r bitpos str 0 1] == 12}
-        assert {[r bitpos str 0 1 -1 bit] == 12}
-    }
-
-    test {BITPOS bit=1 starting at unaligned address} {
-        r set str "\x00\x0f\xff"
-        assert {[r bitpos str 1 1] == 12}
-        assert {[r bitpos str 1 1 -1 bit] == 12}
-    }
-
-    test {BITPOS bit=0 unaligned+full word+reminder} {
-        r del str
-        r set str "\xff\xff\xff" ; # Prefix
-        # Followed by two (or four in 32 bit systems) full words
-        r append str "\xff\xff\xff\xff\xff\xff\xff\xff"
-        r append str "\xff\xff\xff\xff\xff\xff\xff\xff"
-        r append str "\xff\xff\xff\xff\xff\xff\xff\xff"
-        # First zero bit.
-        r append str "\x0f"
-        assert {[r bitpos str 0] == 216}
-        assert {[r bitpos str 0 1] == 216}
-        assert {[r bitpos str 0 2] == 216}
-        assert {[r bitpos str 0 3] == 216}
-        assert {[r bitpos str 0 4] == 216}
-        assert {[r bitpos str 0 5] == 216}
-        assert {[r bitpos str 0 6] == 216}
-        assert {[r bitpos str 0 7] == 216}
-        assert {[r bitpos str 0 8] == 216}
-
-        assert {[r bitpos str 0 1 -1 bit] == 216}
-        assert {[r bitpos str 0 9 -1 bit] == 216}
-        assert {[r bitpos str 0 17 -1 bit] == 216}
-        assert {[r bitpos str 0 25 -1 bit] == 216}
-        assert {[r bitpos str 0 33 -1 bit] == 216}
-        assert {[r bitpos str 0 41 -1 bit] == 216}
-        assert {[r bitpos str 0 49 -1 bit] == 216}
-        assert {[r bitpos str 0 57 -1 bit] == 216}
-        assert {[r bitpos str 0 65 -1 bit] == 216}
-    }
-
-    test {BITPOS bit=1 unaligned+full word+reminder} {
-        r del str
-        r set str "\x00\x00\x00" ; # Prefix
-        # Followed by two (or four in 32 bit systems) full words
-        r append str "\x00\x00\x00\x00\x00\x00\x00\x00"
-        r append str "\x00\x00\x00\x00\x00\x00\x00\x00"
-        r append str "\x00\x00\x00\x00\x00\x00\x00\x00"
-        # First zero bit.
-        r append str "\xf0"
-        assert {[r bitpos str 1] == 216}
-        assert {[r bitpos str 1 1] == 216}
-        assert {[r bitpos str 1 2] == 216}
-        assert {[r bitpos str 1 3] == 216}
-        assert {[r bitpos str 1 4] == 216}
-        assert {[r bitpos str 1 5] == 216}
-        assert {[r bitpos str 1 6] == 216}
-        assert {[r bitpos str 1 7] == 216}
-        assert {[r bitpos str 1 8] == 216}
-
-        assert {[r bitpos str 1 1 -1 bit] == 216}
-        assert {[r bitpos str 1 9 -1 bit] == 216}
-        assert {[r bitpos str 1 17 -1 bit] == 216}
-        assert {[r bitpos str 1 25 -1 bit] == 216}
-        assert {[r bitpos str 1 33 -1 bit] == 216}
-        assert {[r bitpos str 1 41 -1 bit] == 216}
-        assert {[r bitpos str 1 49 -1 bit] == 216}
-        assert {[r bitpos str 1 57 -1 bit] == 216}
-        assert {[r bitpos str 1 65 -1 bit] == 216}
-    }
-
-    test {BITPOS bit=1 returns -1 if string is all 0 bits} {
-        r set str ""
-        for {set j 0} {$j < 20} {incr j} {
-            assert {[r bitpos str 1] == -1}
-            assert {[r bitpos str 1 0 -1 bit] == -1}
-            r append str "\x00"
-        }
-    }
-
-    test {BITPOS bit=0 works with intervals} {
-        r set str "\x00\xff\x00"
-        assert {[r bitpos str 0 0 -1] == 0}
-        assert {[r bitpos str 0 1 -1] == 16}
-        assert {[r bitpos str 0 2 -1] == 16}
-        assert {[r bitpos str 0 2 200] == 16}
-        assert {[r bitpos str 0 1 1] == -1}
-
-        assert {[r bitpos str 0 0 -1 bit] == 0}
-        assert {[r bitpos str 0 8 -1 bit] == 16}
-        assert {[r bitpos str 0 16 -1 bit] == 16}
-        assert {[r bitpos str 0 16 200 bit] == 16}
-        assert {[r bitpos str 0 8 8 bit] == -1}
-    }
-
-    test {BITPOS bit=1 works with intervals} {
-        r set str "\x00\xff\x00"
-        assert {[r bitpos str 1 0 -1] == 8}
-        assert {[r bitpos str 1 1 -1] == 8}
-        assert {[r bitpos str 1 2 -1] == -1}
-        assert {[r bitpos str 1 2 200] == -1}
-        assert {[r bitpos str 1 1 1] == 8}
-
-        assert {[r bitpos str 1 0 -1 bit] == 8}
-        assert {[r bitpos str 1 8 -1 bit] == 8}
-        assert {[r bitpos str 1 16 -1 bit] == -1}
-        assert {[r bitpos str 1 16 200 bit] == -1}
-        assert {[r bitpos str 1 8 8 bit] == 8}
-    }
-
-    test {BITPOS bit=0 changes behavior if end is given} {
-        r set str "\xff\xff\xff"
-        assert {[r bitpos str 0] == 24}
-        assert {[r bitpos str 0 0] == 24}
-        assert {[r bitpos str 0 0 -1] == -1}
-        assert {[r bitpos str 0 0 -1 bit] == -1}
-    }
-
-    test {SETBIT/BITFIELD only increase dirty when the value changed} {
-        r del foo{t} foo2{t} foo3{t}
-        set dirty [s rdb_changes_since_last_save]
-
-        # Create a new key, always increase the dirty.
-        r setbit foo{t} 0 0
-        r bitfield foo2{t} set i5 0 0
-        set dirty2 [s rdb_changes_since_last_save]
-        assert {$dirty2 == $dirty + 2}
-
-        # No change.
-        r setbit foo{t} 0 0
-        r bitfield foo2{t} set i5 0 0
-        set dirty3 [s rdb_changes_since_last_save]
-        assert {$dirty3 == $dirty2}
-
-        # Do a change and a no change.
-        r setbit foo{t} 0 1
-        r setbit foo{t} 0 1
-        r setbit foo{t} 0 0
-        r setbit foo{t} 0 0
-        r bitfield foo2{t} set i5 0 1
-        r bitfield foo2{t} set i5 0 1
-        r bitfield foo2{t} set i5 0 0
-        r bitfield foo2{t} set i5 0 0
-        set dirty4 [s rdb_changes_since_last_save]
-        assert {$dirty4 == $dirty3 + 4}
-
-        # BITFIELD INCRBY always increase dirty.
-        r bitfield foo3{t} incrby i5 0 1
-        r bitfield foo3{t} incrby i5 0 1
-        set dirty5 [s rdb_changes_since_last_save]
-        assert {$dirty5 == $dirty4 + 2}
-
-        # Change length only
-        r setbit foo{t} 90 0
-        r bitfield foo2{t} set i5 90 0
-        set dirty6 [s rdb_changes_since_last_save]
-        assert {$dirty6 == $dirty5 + 2}
-    }
-
-    test {BITPOS bit=1 fuzzy testing using SETBIT} {
-        r del str
-        set max 524288; # 64k
-        set first_one_pos -1
-        for {set j 0} {$j < 1000} {incr j} {
-            assert {[r bitpos str 1] == $first_one_pos}
-            assert {[r bitpos str 1 0 -1 bit] == $first_one_pos}
-            set pos [randomInt $max]
-            r setbit str $pos 1
-            if {$first_one_pos == -1 || $first_one_pos > $pos} {
-                # Update the position of the first 1 bit in the array
-                # if the bit we set is on the left of the previous one.
-                set first_one_pos $pos
-            }
-        }
-    }
-
-    test {BITPOS bit=0 fuzzy testing using SETBIT} {
-        set max 524288; # 64k
-        set first_zero_pos $max
-        r set str [string repeat "\xff" [expr $max/8]]
-        for {set j 0} {$j < 1000} {incr j} {
-            assert {[r bitpos str 0] == $first_zero_pos}
-            if {$first_zero_pos == $max} {
-                assert {[r bitpos str 0 0 -1 bit] == -1}
-            } else {
-                assert {[r bitpos str 0 0 -1 bit] == $first_zero_pos}
-            }
-            set pos [randomInt $max]
-            r setbit str $pos 0
-            if {$first_zero_pos > $pos} {
-                # Update the position of the first 0 bit in the array
-                # if the bit we clear is on the left of the previous one.
-                set first_zero_pos $pos
-            }
-        }
-    }
-
-    # This test creates a string of 10 bytes. It has two iterations. One clears
-    # all the bits and sets just one bit and another set all the bits and clears
-    # just one bit. Each iteration loops from bit offset 0 to 79 and uses SETBIT
-    # to set the bit to 0 or 1, and then use BITPOS and BITCOUNT on a few mutations.
-    test {BITPOS/BITCOUNT fuzzy testing using SETBIT} {
-        # We have two start and end ranges, each range used to select a random
-        # position, one for start position and one for end position.
-        proc test_one {start1 end1 start2 end2 pos bit pos_type} {
-            set start [randomRange $start1 $end1]
-            set end [randomRange $start2 $end2]
-            if {$start > $end} {
-                # Swap start and end
-                lassign [list $end $start] start end
-            }
-            set startbit $start
-            set endbit $end
-            # For byte index, we need to generate the real bit index
-            if {[string equal $pos_type byte]} {
-                set startbit [expr $start << 3]
-                set endbit [expr ($end << 3) + 7]
-            }
-            # This means whether the test bit index is in the range.
-            set inrange [expr ($pos >= $startbit && $pos <= $endbit) ? 1: 0]
-            # For bitcount, there are four different results.
-            # $inrange == 0 && $bit == 0, all bits in the range are set, so $endbit - $startbit + 1
-            # $inrange == 0 && $bit == 1, all bits in the range are clear, so 0
-            # $inrange == 1 && $bit == 0, all bits in the range are set but one, so $endbit - $startbit
-            # $inrange == 1 && $bit == 1, all bits in the range are clear but one, so 1
-            set res_count [expr ($endbit - $startbit + 1) * (1 - $bit) + $inrange * [expr $bit ? 1 : -1]]
-            assert {[r bitpos str $bit $start $end $pos_type] == [expr $inrange ? $pos : -1]}
-            assert {[r bitcount str $start $end $pos_type] == $res_count}
-        }
-
-        r del str
-        set max 80;
-        r setbit str [expr $max - 1] 0
-        set bytes [expr $max >> 3]
-        # First iteration sets all bits to 1, then set bit to 0 from 0 to max - 1
-        # Second iteration sets all bits to 0, then set bit to 1 from 0 to max - 1
-        for {set bit 0} {$bit < 2} {incr bit} {
-            r bitop not str str
-            for {set j 0} {$j < $max} {incr j} {
-                r setbit str $j $bit
-
-                # First iteration tests byte index and second iteration tests bit index.
-                foreach {curr end pos_type} [list [expr $j >> 3] $bytes byte $j $max bit] {
-                    # start==end set to bit position
-                    test_one $curr $curr $curr $curr $j $bit $pos_type
-                    # Both start and end are before bit position
-                    if {$curr > 0} {
-                        test_one 0 $curr 0 $curr $j $bit $pos_type
-                    }
-                    # Both start and end are after bit position
-                    if {$curr < [expr $end - 1]} {
-                        test_one [expr $curr + 1] $end [expr $curr + 1] $end $j $bit $pos_type
-                    }
-                    # start is before and end is after bit position
-                    if {$curr > 0 && $curr < [expr $end - 1]} {
-                        test_one 0 $curr [expr $curr +1] $end $j $bit $pos_type
-                    }
-                }
-
-                # restore bit
-                r setbit str $j [expr 1 - $bit]
-            }
-        }
-    }
-}
-
-run_solo {bitops-large-memory} {
-start_server {tags {"bitops"}} {
-    test "BIT pos larger than UINT_MAX" {
-        set bytes [expr (1 << 29) + 1]
-        set bitpos [expr (1 << 32)]
-        set oldval [lindex [r config get proto-max-bulk-len] 1]
-        r config set proto-max-bulk-len $bytes
-        r setbit mykey $bitpos 1
-        assert_equal $bytes [r strlen mykey]
-        assert_equal 1 [r getbit mykey $bitpos]
-        assert_equal [list 128 128 -1] [r bitfield mykey get u8 $bitpos set u8 $bitpos 255 get i8 $bitpos]
-        assert_equal $bitpos [r bitpos mykey 1]
-        assert_equal $bitpos [r bitpos mykey 1 [expr $bytes - 1]]
-        if {$::accurate} {
-            # set all bits to 1
-            set mega [expr (1 << 23)]
-            set part [string repeat "\xFF" $mega]
-            for {set i 0} {$i < 64} {incr i} {
-                r setrange mykey [expr $i * $mega] $part
-            }
-            r setrange mykey [expr $bytes - 1] "\xFF"
-            assert_equal [expr $bitpos + 8] [r bitcount mykey]
-            assert_equal -1 [r bitpos mykey 0 0 [expr $bytes - 1]]
-        }
-        r config set proto-max-bulk-len $oldval
-        r del mykey
-    } {1} {large-memory}
-
-    test "SETBIT values larger than UINT32_MAX and lzf_compress/lzf_decompress correctly" {
-        set bytes [expr (1 << 32) + 1]
-        set bitpos [expr (1 << 35)]
-        set oldval [lindex [r config get proto-max-bulk-len] 1]
-        r config set proto-max-bulk-len $bytes
-        r setbit mykey $bitpos 1
-        assert_equal $bytes [r strlen mykey]
-        assert_equal 1 [r getbit mykey $bitpos]
-        r debug reload ;# lzf_compress/lzf_decompress when RDB saving/loading.
-        assert_equal 1 [r getbit mykey $bitpos]
-        r config set proto-max-bulk-len $oldval
-        r del mykey
-    } {1} {large-memory needs:debug}
-}
-} ;#run_solo