[redis.git] / tests / unit / type / set.tcl

start_server {
    tags {"set"}
    overrides {
        "set-max-intset-entries" 512
    }
} {
    proc create_set {key entries} {
        r del $key
        foreach entry $entries { r sadd $key $entry }
    }

    test {SADD, SCARD, SISMEMBER, SMEMBERS basics - regular set} {
        create_set myset {foo}
        assert_encoding hashtable myset
        assert_equal 1 [r sadd myset bar]
        assert_equal 0 [r sadd myset bar]
        assert_equal 2 [r scard myset]
        assert_equal 1 [r sismember myset foo]
        assert_equal 1 [r sismember myset bar]
        assert_equal 0 [r sismember myset bla]
        assert_equal {bar foo} [lsort [r smembers myset]]
    }

    test {SADD, SCARD, SISMEMBER, SMEMBERS basics - intset} {
        create_set myset {17}
        assert_encoding intset myset
        assert_equal 1 [r sadd myset 16]
        assert_equal 0 [r sadd myset 16]
        assert_equal 2 [r scard myset]
        assert_equal 1 [r sismember myset 16]
        assert_equal 1 [r sismember myset 17]
        assert_equal 0 [r sismember myset 18]
        assert_equal {16 17} [lsort [r smembers myset]]
    }

    test {SADD against non set} {
        r lpush mylist foo
        assert_error ERR*kind* {r sadd mylist bar}
    }

    test "SADD a non-integer against an intset" {
        create_set myset {1 2 3}
        assert_encoding intset myset
        assert_equal 1 [r sadd myset a]
        assert_encoding hashtable myset
    }

    test "SADD an integer larger than 64 bits" {
        create_set myset {213244124402402314402033402}
        assert_encoding hashtable myset
        assert_equal 1 [r sismember myset 213244124402402314402033402]
    }

    test "SADD overflows the maximum allowed integers in an intset" {
        r del myset
        for {set i 0} {$i < 512} {incr i} { r sadd myset $i }
        assert_encoding intset myset
        assert_equal 1 [r sadd myset 512]
        assert_encoding hashtable myset
    }

    test {Variadic SADD} {
        r del myset
        assert_equal 3 [r sadd myset a b c]
        assert_equal 2 [r sadd myset A a b c B]
        assert_equal [lsort {A a b c B}] [lsort [r smembers myset]]
    }

    test "Set encoding after DEBUG RELOAD" {
        r del myintset myhashset mylargeintset
        for {set i 0} {$i <  100} {incr i} { r sadd myintset $i }
        for {set i 0} {$i < 1280} {incr i} { r sadd mylargeintset $i }
        for {set i 0} {$i <  256} {incr i} { r sadd myhashset [format "i%03d" $i] }
        assert_encoding intset myintset
        assert_encoding hashtable mylargeintset
        assert_encoding hashtable myhashset

        r debug reload
        assert_encoding intset myintset
        assert_encoding hashtable mylargeintset
        assert_encoding hashtable myhashset
    }

    test {SREM basics - regular set} {
        create_set myset {foo bar ciao}
        assert_encoding hashtable myset
        assert_equal 0 [r srem myset qux]
        assert_equal 1 [r srem myset foo]
        assert_equal {bar ciao} [lsort [r smembers myset]]
    }

    test {SREM basics - intset} {
        create_set myset {3 4 5}
        assert_encoding intset myset
        assert_equal 0 [r srem myset 6]
        assert_equal 1 [r srem myset 4]
        assert_equal {3 5} [lsort [r smembers myset]]
    }

    test {SREM with multiple arguments} {
        r del myset
        r sadd myset a b c d
        assert_equal 0 [r srem myset k k k]
        assert_equal 2 [r srem myset b d x y]
        lsort [r smembers myset]
    } {a c}

    test {SREM variadic version with more args needed to destroy the key} {
        r del myset
        r sadd myset 1 2 3
        r srem myset 1 2 3 4 5 6 7 8
    } {3}

    foreach {type} {hashtable intset} {
        for {set i 1} {$i <= 5} {incr i} {
            r del [format "set%d" $i]
        }
        for {set i 0} {$i < 200} {incr i} {
            r sadd set1 $i
            r sadd set2 [expr $i+195]
        }
        foreach i {199 195 1000 2000} {
            r sadd set3 $i
        }
        for {set i 5} {$i < 200} {incr i} {
            r sadd set4 $i
        }
        r sadd set5 0

        # To make sure the sets are encoded as the type we are testing -- also
        # when the VM is enabled and the values may be swapped in and out
        # while the tests are running -- an extra element is added to every
        # set that determines its encoding.
        set large 200
        if {$type eq "hashtable"} {
            set large foo
        }

        for {set i 1} {$i <= 5} {incr i} {
            r sadd [format "set%d" $i] $large
        }

        test "Generated sets must be encoded as $type" {
            for {set i 1} {$i <= 5} {incr i} {
                assert_encoding $type [format "set%d" $i]
            }
        }

        test "SINTER with two sets - $type" {
            assert_equal [list 195 196 197 198 199 $large] [lsort [r sinter set1 set2]]
        }

        test "SINTERSTORE with two sets - $type" {
            r sinterstore setres set1 set2
            assert_encoding $type setres
            assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]]
        }

        test "SINTERSTORE with two sets, after a DEBUG RELOAD - $type" {
            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]]
        }

        test "SUNION with two sets - $type" {
            set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
            assert_equal $expected [lsort [r sunion set1 set2]]
        }

        test "SUNIONSTORE with two sets - $type" {
            r sunionstore setres set1 set2
            assert_encoding $type setres
            set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
            assert_equal $expected [lsort [r smembers setres]]
        }

        test "SINTER against three sets - $type" {
            assert_equal [list 195 199 $large] [lsort [r sinter set1 set2 set3]]
        }

        test "SINTERSTORE with three sets - $type" {
            r sinterstore setres set1 set2 set3
            assert_equal [list 195 199 $large] [lsort [r smembers setres]]
        }

        test "SUNION with non existing keys - $type" {
            set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
            assert_equal $expected [lsort [r sunion nokey1 set1 set2 nokey2]]
        }

        test "SDIFF with two sets - $type" {
            assert_equal {0 1 2 3 4} [lsort [r sdiff set1 set4]]
        }

        test "SDIFF with three sets - $type" {
            assert_equal {1 2 3 4} [lsort [r sdiff set1 set4 set5]]
        }

        test "SDIFFSTORE with three sets - $type" {
            r sdiffstore setres set1 set4 set5
            # The type is determined by type of the first key to diff against.
            # See the implementation for more information.
            assert_encoding $type setres
            assert_equal {1 2 3 4} [lsort [r smembers setres]]
        }
    }

    test "SDIFF with first set empty" {
        r del set1 set2 set3
        r sadd set2 1 2 3 4
        r sadd set3 a b c d
        r sdiff set1 set2 set3
    } {}

    test "SINTER against non-set should throw error" {
        r set key1 x
        assert_error "ERR*wrong kind*" {r sinter key1 noset}
    }

    test "SUNION against non-set should throw error" {
        r set key1 x
        assert_error "ERR*wrong kind*" {r sunion key1 noset}
    }

    test "SINTER should handle non existing key as empty" {
        r del set1 set2 set3
        r sadd set1 a b c
        r sadd set2 b c d
        r sinter set1 set2 set3
    } {}

    test "SINTER with same integer elements but different encoding" {
        r del set1 set2
        r sadd set1 1 2 3
        r sadd set2 1 2 3 a
        r srem set2 a
        assert_encoding intset set1
        assert_encoding hashtable set2
        lsort [r sinter set1 set2]
    } {1 2 3}

    test "SINTERSTORE against non existing keys should delete dstkey" {
        r set setres xxx
        assert_equal 0 [r sinterstore setres foo111 bar222]
        assert_equal 0 [r exists setres]
    }

    test "SUNIONSTORE against non existing keys should delete dstkey" {
        r set setres xxx
        assert_equal 0 [r sunionstore setres foo111 bar222]
        assert_equal 0 [r exists setres]
    }

    foreach {type contents} {hashtable {a b c} intset {1 2 3}} {
        test "SPOP basics - $type" {
            create_set myset $contents
            assert_encoding $type myset
            assert_equal $contents [lsort [list [r spop myset] [r spop myset] [r spop myset]]]
            assert_equal 0 [r scard myset]
        }

        test "SRANDMEMBER - $type" {
            create_set myset $contents
            unset -nocomplain myset
            array set myset {}
            for {set i 0} {$i < 100} {incr i} {
                set myset([r srandmember myset]) 1
            }
            assert_equal $contents [lsort [array names myset]]
        }
    }

    proc setup_move {} {
        r del myset3 myset4
        create_set myset1 {1 a b}
        create_set myset2 {2 3 4}
        assert_encoding hashtable myset1
        assert_encoding intset myset2
    }

    test "SMOVE basics - from regular set to intset" {
        # move a non-integer element to an intset should convert encoding
        setup_move
        assert_equal 1 [r smove myset1 myset2 a]
        assert_equal {1 b} [lsort [r smembers myset1]]
        assert_equal {2 3 4 a} [lsort [r smembers myset2]]
        assert_encoding hashtable myset2

        # move an integer element should not convert the encoding
        setup_move
        assert_equal 1 [r smove myset1 myset2 1]
        assert_equal {a b} [lsort [r smembers myset1]]
        assert_equal {1 2 3 4} [lsort [r smembers myset2]]
        assert_encoding intset myset2
    }

    test "SMOVE basics - from intset to regular set" {
        setup_move
        assert_equal 1 [r smove myset2 myset1 2]
        assert_equal {1 2 a b} [lsort [r smembers myset1]]
        assert_equal {3 4} [lsort [r smembers myset2]]
    }

    test "SMOVE non existing key" {
        setup_move
        assert_equal 0 [r smove myset1 myset2 foo]
        assert_equal {1 a b} [lsort [r smembers myset1]]
        assert_equal {2 3 4} [lsort [r smembers myset2]]
    }

    test "SMOVE non existing src set" {
        setup_move
        assert_equal 0 [r smove noset myset2 foo]
        assert_equal {2 3 4} [lsort [r smembers myset2]]
    }

    test "SMOVE from regular set to non existing destination set" {
        setup_move
        assert_equal 1 [r smove myset1 myset3 a]
        assert_equal {1 b} [lsort [r smembers myset1]]
        assert_equal {a} [lsort [r smembers myset3]]
        assert_encoding hashtable myset3
    }

    test "SMOVE from intset to non existing destination set" {
        setup_move
        assert_equal 1 [r smove myset2 myset3 2]
        assert_equal {3 4} [lsort [r smembers myset2]]
        assert_equal {2} [lsort [r smembers myset3]]
        assert_encoding intset myset3
    }

    test "SMOVE wrong src key type" {
        r set x 10
        assert_error "ERR*wrong kind*" {r smove x myset2 foo}
    }

    test "SMOVE wrong dst key type" {
        r set x 10
        assert_error "ERR*wrong kind*" {r smove myset2 x foo}
    }

    test "SMOVE with identical source and destination" {
        r del set
        r sadd set a b c
        r smove set set b
        lsort [r smembers set]
    } {a b c}

    tags {slow} {
        test {intsets implementation stress testing} {
            for {set j 0} {$j < 20} {incr j} {
                unset -nocomplain s
                array set s {}
                r del s
                set len [randomInt 1024]
                for {set i 0} {$i < $len} {incr i} {
                    randpath {
                        set data [randomInt 65536]
                    } {
                        set data [randomInt 4294967296]
                    } {
                        set data [randomInt 18446744073709551616]
                    }
                    set s($data) {}
                    r sadd s $data
                }
                assert_equal [lsort [r smembers s]] [lsort [array names s]]
                set len [array size s]
                for {set i 0} {$i < $len} {incr i} {
                    set e [r spop s]
                    if {![info exists s($e)]} {
                        puts "Can't find '$e' on local array"
                        puts "Local array: [lsort [r smembers s]]"
                        puts "Remote array: [lsort [array names s]]"
                        error "exception"
                    }
                    array unset s $e
                }
                assert_equal [r scard s] 0
                assert_equal [array size s] 0
            }
        }
    }
}
Commit	Line	Data
ab37269c PN	1	start_server {
	2	tags {"set"}
	3	overrides {
	4	"set-max-intset-entries" 512
	5	}
	6	} {
d0b58d53 PN	7	proc create_set {key entries} {
	8	r del $key
	9	foreach entry $entries { r sadd $key $entry }
	10	}
	11
	12	test {SADD, SCARD, SISMEMBER, SMEMBERS basics - regular set} {
	13	create_set myset {foo}
	14	assert_encoding hashtable myset
	15	assert_equal 1 [r sadd myset bar]
	16	assert_equal 0 [r sadd myset bar]
	17	assert_equal 2 [r scard myset]
	18	assert_equal 1 [r sismember myset foo]
	19	assert_equal 1 [r sismember myset bar]
	20	assert_equal 0 [r sismember myset bla]
	21	assert_equal {bar foo} [lsort [r smembers myset]]
	22	}
	23
	24	test {SADD, SCARD, SISMEMBER, SMEMBERS basics - intset} {
	25	create_set myset {17}
	26	assert_encoding intset myset
	27	assert_equal 1 [r sadd myset 16]
	28	assert_equal 0 [r sadd myset 16]
	29	assert_equal 2 [r scard myset]
	30	assert_equal 1 [r sismember myset 16]
	31	assert_equal 1 [r sismember myset 17]
	32	assert_equal 0 [r sismember myset 18]
	33	assert_equal {16 17} [lsort [r smembers myset]]
	34	}
98578b57 PN	35
	36	test {SADD against non set} {
	37	r lpush mylist foo
d0b58d53 PN	38	assert_error ERRkind {r sadd mylist bar}
	39	}
	40
ab37269c PN	41	test "SADD a non-integer against an intset" {
	42	create_set myset {1 2 3}
	43	assert_encoding intset myset
	44	assert_equal 1 [r sadd myset a]
	45	assert_encoding hashtable myset
	46	}
	47
87c74dfa PN	48	test "SADD an integer larger than 64 bits" {
	49	create_set myset {213244124402402314402033402}
	50	assert_encoding hashtable myset
	51	assert_equal 1 [r sismember myset 213244124402402314402033402]
	52	}
	53
ab37269c PN	54	test "SADD overflows the maximum allowed integers in an intset" {
	55	r del myset
	56	for {set i 0} {$i < 512} {incr i} { r sadd myset $i }
	57	assert_encoding intset myset
	58	assert_equal 1 [r sadd myset 512]
	59	assert_encoding hashtable myset
	60	}
	61
271f0878	62	test {Variadic SADD} {
	63	r del myset
	64	assert_equal 3 [r sadd myset a b c]
	65	assert_equal 2 [r sadd myset A a b c B]
	66	assert_equal [lsort {A a b c B}] [lsort [r smembers myset]]
	67	}
	68
273f6169 PN	69	test "Set encoding after DEBUG RELOAD" {
	70	r del myintset myhashset mylargeintset
	71	for {set i 0} {$i < 100} {incr i} { r sadd myintset $i }
	72	for {set i 0} {$i < 1280} {incr i} { r sadd mylargeintset $i }
	73	for {set i 0} {$i < 256} {incr i} { r sadd myhashset [format "i%03d" $i] }
	74	assert_encoding intset myintset
	75	assert_encoding hashtable mylargeintset
	76	assert_encoding hashtable myhashset
	77
	78	r debug reload
	79	assert_encoding intset myintset
	80	assert_encoding hashtable mylargeintset
	81	assert_encoding hashtable myhashset
	82	}
	83
d0b58d53 PN	84	test {SREM basics - regular set} {
	85	create_set myset {foo bar ciao}
	86	assert_encoding hashtable myset
	87	assert_equal 0 [r srem myset qux]
	88	assert_equal 1 [r srem myset foo]
	89	assert_equal {bar ciao} [lsort [r smembers myset]]
	90	}
	91
	92	test {SREM basics - intset} {
	93	create_set myset {3 4 5}
	94	assert_encoding intset myset
	95	assert_equal 0 [r srem myset 6]
	96	assert_equal 1 [r srem myset 4]
	97	assert_equal {3 5} [lsort [r smembers myset]]
	98	}
	99
b3a96d45	100	test {SREM with multiple arguments} {
	101	r del myset
	102	r sadd myset a b c d
	103	assert_equal 0 [r srem myset k k k]
	104	assert_equal 2 [r srem myset b d x y]
	105	lsort [r smembers myset]
	106	} {a c}
	107
3738ff5f	108	test {SREM variadic version with more args needed to destroy the key} {
	109	r del myset
	110	r sadd myset 1 2 3
	111	r srem myset 1 2 3 4 5 6 7 8
	112	} {3}
	113
d0b58d53 PN	114	foreach {type} {hashtable intset} {
	115	for {set i 1} {$i <= 5} {incr i} {
	116	r del [format "set%d" $i]
	117	}
ab37269c	118	for {set i 0} {$i < 200} {incr i} {
98578b57	119	r sadd set1 $i
ab37269c	120	r sadd set2 [expr $i+195]
98578b57	121	}
ab37269c	122	foreach i {199 195 1000 2000} {
d0b58d53 PN	123	r sadd set3 $i
d0b58d53 PN	124	}
ab37269c	125	for {set i 5} {$i < 200} {incr i} {
d0b58d53 PN	126	r sadd set4 $i
	127	}
	128	r sadd set5 0
	129
1eb13e49 PN	130	# To make sure the sets are encoded as the type we are testing -- also
	131	# when the VM is enabled and the values may be swapped in and out
	132	# while the tests are running -- an extra element is added to every
	133	# set that determines its encoding.
	134	set large 200
d0b58d53	135	if {$type eq "hashtable"} {
1eb13e49 PN	136	set large foo
	137	}
	138
	139	for {set i 1} {$i <= 5} {incr i} {
	140	r sadd [format "set%d" $i] $large
d0b58d53 PN	141	}
	142
	143	test "Generated sets must be encoded as $type" {
	144	for {set i 1} {$i <= 5} {incr i} {
	145	assert_encoding $type [format "set%d" $i]
	146	}
	147	}
	148
	149	test "SINTER with two sets - $type" {
1eb13e49	150	assert_equal [list 195 196 197 198 199 $large] [lsort [r sinter set1 set2]]
d0b58d53 PN	151	}
	152
	153	test "SINTERSTORE with two sets - $type" {
	154	r sinterstore setres set1 set2
1eb13e49 PN	155	assert_encoding $type setres
1eb13e49 PN	156	assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]]
d0b58d53 PN	157	}
	158
	159	test "SINTERSTORE with two sets, after a DEBUG RELOAD - $type" {
	160	r debug reload
	161	r sinterstore setres set1 set2
1eb13e49 PN	162	assert_encoding $type setres
1eb13e49 PN	163	assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]]
d0b58d53 PN	164	}
	165
	166	test "SUNION with two sets - $type" {
	167	set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
	168	assert_equal $expected [lsort [r sunion set1 set2]]
	169	}
	170
	171	test "SUNIONSTORE with two sets - $type" {
	172	r sunionstore setres set1 set2
1eb13e49	173	assert_encoding $type setres
d0b58d53 PN	174	set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
	175	assert_equal $expected [lsort [r smembers setres]]
	176	}
	177
	178	test "SINTER against three sets - $type" {
1eb13e49	179	assert_equal [list 195 199 $large] [lsort [r sinter set1 set2 set3]]
d0b58d53 PN	180	}
	181
	182	test "SINTERSTORE with three sets - $type" {
	183	r sinterstore setres set1 set2 set3
1eb13e49	184	assert_equal [list 195 199 $large] [lsort [r smembers setres]]
d0b58d53 PN	185	}
	186
	187	test "SUNION with non existing keys - $type" {
	188	set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
	189	assert_equal $expected [lsort [r sunion nokey1 set1 set2 nokey2]]
	190	}
	191
	192	test "SDIFF with two sets - $type" {
	193	assert_equal {0 1 2 3 4} [lsort [r sdiff set1 set4]]
	194	}
98578b57	195
d0b58d53 PN	196	test "SDIFF with three sets - $type" {
	197	assert_equal {1 2 3 4} [lsort [r sdiff set1 set4 set5]]
	198	}
98578b57	199
d0b58d53 PN	200	test "SDIFFSTORE with three sets - $type" {
d0b58d53 PN	201	r sdiffstore setres set1 set4 set5
1eb13e49 PN	202	# The type is determined by type of the first key to diff against.
	203	# See the implementation for more information.
	204	assert_encoding $type setres
d0b58d53 PN	205	assert_equal {1 2 3 4} [lsort [r smembers setres]]
	206	}
	207	}
98578b57	208
5c45ae1f	209	test "SDIFF with first set empty" {
	210	r del set1 set2 set3
	211	r sadd set2 1 2 3 4
	212	r sadd set3 a b c d
	213	r sdiff set1 set2 set3
	214	} {}
	215
d0b58d53 PN	216	test "SINTER against non-set should throw error" {
	217	r set key1 x
	218	assert_error "ERRwrong kind" {r sinter key1 noset}
	219	}
98578b57	220
d0b58d53 PN	221	test "SUNION against non-set should throw error" {
	222	r set key1 x
	223	assert_error "ERRwrong kind" {r sunion key1 noset}
	224	}
98578b57	225
eb624e34	226	test "SINTER should handle non existing key as empty" {
	227	r del set1 set2 set3
	228	r sadd set1 a b c
	229	r sadd set2 b c d
	230	r sinter set1 set2 set3
	231	} {}
	232
7a2065ef	233	test "SINTER with same integer elements but different encoding" {
	234	r del set1 set2
	235	r sadd set1 1 2 3
	236	r sadd set2 1 2 3 a
	237	r srem set2 a
	238	assert_encoding intset set1
	239	assert_encoding hashtable set2
	240	lsort [r sinter set1 set2]
	241	} {1 2 3}
	242
d0b58d53	243	test "SINTERSTORE against non existing keys should delete dstkey" {
98578b57	244	r set setres xxx
d0b58d53 PN	245	assert_equal 0 [r sinterstore setres foo111 bar222]
	246	assert_equal 0 [r exists setres]
	247	}
	248
	249	test "SUNIONSTORE against non existing keys should delete dstkey" {
	250	r set setres xxx
	251	assert_equal 0 [r sunionstore setres foo111 bar222]
	252	assert_equal 0 [r exists setres]
	253	}
	254
	255	foreach {type contents} {hashtable {a b c} intset {1 2 3}} {
	256	test "SPOP basics - $type" {
	257	create_set myset $contents
	258	assert_encoding $type myset
	259	assert_equal $contents [lsort [list [r spop myset] [r spop myset] [r spop myset]]]
	260	assert_equal 0 [r scard myset]
98578b57	261	}
98578b57	262
d0b58d53 PN	263	test "SRANDMEMBER - $type" {
	264	create_set myset $contents
	265	unset -nocomplain myset
	266	array set myset {}
	267	for {set i 0} {$i < 100} {incr i} {
	268	set myset([r srandmember myset]) 1
	269	}
	270	assert_equal $contents [lsort [array names myset]]
	271	}
	272	}
	273
b978abbf PN	274	proc setup_move {} {
	275	r del myset3 myset4
	276	create_set myset1 {1 a b}
	277	create_set myset2 {2 3 4}
	278	assert_encoding hashtable myset1
	279	assert_encoding intset myset2
	280	}
	281
	282	test "SMOVE basics - from regular set to intset" {
	283	# move a non-integer element to an intset should convert encoding
	284	setup_move
	285	assert_equal 1 [r smove myset1 myset2 a]
	286	assert_equal {1 b} [lsort [r smembers myset1]]
	287	assert_equal {2 3 4 a} [lsort [r smembers myset2]]
	288	assert_encoding hashtable myset2
	289
	290	# move an integer element should not convert the encoding
	291	setup_move
	292	assert_equal 1 [r smove myset1 myset2 1]
	293	assert_equal {a b} [lsort [r smembers myset1]]
	294	assert_equal {1 2 3 4} [lsort [r smembers myset2]]
	295	assert_encoding intset myset2
	296	}
	297
	298	test "SMOVE basics - from intset to regular set" {
	299	setup_move
	300	assert_equal 1 [r smove myset2 myset1 2]
	301	assert_equal {1 2 a b} [lsort [r smembers myset1]]
	302	assert_equal {3 4} [lsort [r smembers myset2]]
	303	}
	304
	305	test "SMOVE non existing key" {
	306	setup_move
	307	assert_equal 0 [r smove myset1 myset2 foo]
	308	assert_equal {1 a b} [lsort [r smembers myset1]]
	309	assert_equal {2 3 4} [lsort [r smembers myset2]]
	310	}
	311
	312	test "SMOVE non existing src set" {
	313	setup_move
	314	assert_equal 0 [r smove noset myset2 foo]
	315	assert_equal {2 3 4} [lsort [r smembers myset2]]
	316	}
	317
	318	test "SMOVE from regular set to non existing destination set" {
	319	setup_move
	320	assert_equal 1 [r smove myset1 myset3 a]
	321	assert_equal {1 b} [lsort [r smembers myset1]]
	322	assert_equal {a} [lsort [r smembers myset3]]
	323	assert_encoding hashtable myset3
	324	}
	325
	326	test "SMOVE from intset to non existing destination set" {
	327	setup_move
	328	assert_equal 1 [r smove myset2 myset3 2]
	329	assert_equal {3 4} [lsort [r smembers myset2]]
	330	assert_equal {2} [lsort [r smembers myset3]]
	331	assert_encoding intset myset3
	332	}
	333
	334	test "SMOVE wrong src key type" {
98578b57	335	r set x 10
b978abbf PN	336	assert_error "ERRwrong kind" {r smove x myset2 foo}
b978abbf PN	337	}
98578b57	338
b978abbf	339	test "SMOVE wrong dst key type" {
98578b57	340	r set x 10
b978abbf PN	341	assert_error "ERRwrong kind" {r smove myset2 x foo}
b978abbf PN	342	}
4610b033	343
ff5e31f7	344	test "SMOVE with identical source and destination" {
	345	r del set
	346	r sadd set a b c
	347	r smove set set b
	348	lsort [r smembers set]
	349	} {a b c}
	350
4610b033	351	tags {slow} {
	352	test {intsets implementation stress testing} {
	353	for {set j 0} {$j < 20} {incr j} {
	354	unset -nocomplain s
	355	array set s {}
	356	r del s
	357	set len [randomInt 1024]
	358	for {set i 0} {$i < $len} {incr i} {
	359	randpath {
	360	set data [randomInt 65536]
	361	} {
	362	set data [randomInt 4294967296]
	363	} {
	364	set data [randomInt 18446744073709551616]
	365	}
	366	set s($data) {}
	367	r sadd s $data
	368	}
	369	assert_equal [lsort [r smembers s]] [lsort [array names s]]
	370	set len [array size s]
	371	for {set i 0} {$i < $len} {incr i} {
	372	set e [r spop s]
	373	if {![info exists s($e)]} {
	374	puts "Can't find '$e' on local array"
	375	puts "Local array: [lsort [r smembers s]]"
	376	puts "Remote array: [lsort [array names s]]"
	377	error "exception"
	378	}
	379	array unset s $e
	380	}
	381	assert_equal [r scard s] 0
	382	assert_equal [array size s] 0
	383	}
	384	}
	385	}
98578b57	386	}