[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]]
        }
    }

    test "SRANDMEMBER with <count> against non existing key" {
        r srandmember nonexisting_key 100
    } {}

    foreach {type contents} {
        hashtable {
            1 5 10 50 125 50000 33959417 4775547 65434162
            12098459 427716 483706 2726473884 72615637475
            MARY PATRICIA LINDA BARBARA ELIZABETH JENNIFER MARIA
            SUSAN MARGARET DOROTHY LISA NANCY KAREN BETTY HELEN
            SANDRA DONNA CAROL RUTH SHARON MICHELLE LAURA SARAH
            KIMBERLY DEBORAH JESSICA SHIRLEY CYNTHIA ANGELA MELISSA
            BRENDA AMY ANNA REBECCA VIRGINIA KATHLEEN
        }
        intset {
            0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
            20 21 22 23 24 25 26 27 28 29
            30 31 32 33 34 35 36 37 38 39
            40 41 42 43 44 45 46 47 48 49
        }
    } {
        test "SRANDMEMBER with <count> - $type" {
            create_set myset $contents
            unset -nocomplain myset
            array set myset {}
            foreach ele [r smembers myset] {
                set myset($ele) 1
            }
            assert_equal [lsort $contents] [lsort [array names myset]]

            # Make sure that a count of 0 is handled correctly.
            assert_equal [r srandmember myset 0] {}

            # We'll stress different parts of the code, see the implementation
            # of SRANDMEMBER for more information, but basically there are
            # four different code paths.
            #
            # PATH 1: Use negative count.
            #
            # 1) Check that it returns repeated elements.
            set res [r srandmember myset -100]
            assert_equal [llength $res] 100

            # 2) Check that all the elements actually belong to the
            # original set.
            foreach ele $res {
                assert {[info exists myset($ele)]}
            }

            # 3) Check that eventually all the elements are returned.
            unset -nocomplain auxset
            set iterations 1000
            while {$iterations != 0} {
                incr iterations -1
                set res [r srandmember myset -10]
                foreach ele $res {
                    set auxset($ele) 1
                }
                if {[lsort [array names myset]] eq
                    [lsort [array names auxset]]} {
                    break;
                }
            }
            assert {$iterations != 0}

            # PATH 2: positive count (unique behavior) with requested size
            # equal or greater than set size.
            foreach size {50 100} {
                set res [r srandmember myset $size]
                assert_equal [llength $res] 50
                assert_equal [lsort $res] [lsort [array names myset]]
            }

            # PATH 3: Ask almost as elements as there are in the set.
            # In this case the implementation will duplicate the original
            # set and will remove random elements up to the requested size.
            #
            # PATH 4: Ask a number of elements definitely smaller than
            # the set size.
            #
            # We can test both the code paths just changing the size but
            # using the same code.

            foreach size {45 5} {
                set res [r srandmember myset $size]
                assert_equal [llength $res] $size

                # 1) Check that all the elements actually belong to the
                # original set.
                foreach ele $res {
                    assert {[info exists myset($ele)]}
                }

                # 2) Check that eventually all the elements are returned.
                unset -nocomplain auxset
                set iterations 1000
                while {$iterations != 0} {
                    incr iterations -1
                    set res [r srandmember myset -10]
                    foreach ele $res {
                        set auxset($ele) 1
                    }
                    if {[lsort [array names myset]] eq
                        [lsort [array names auxset]]} {
                        break;
                    }
                }
                assert {$iterations != 0}
            }
        }
    }

    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
2812b945	274	test "SRANDMEMBER with <count> against non existing key" {
	275	r srandmember nonexisting_key 100
	276	} {}
	277
	278	foreach {type contents} {
	279	hashtable {
	280	1 5 10 50 125 50000 33959417 4775547 65434162
	281	12098459 427716 483706 2726473884 72615637475
	282	MARY PATRICIA LINDA BARBARA ELIZABETH JENNIFER MARIA
	283	SUSAN MARGARET DOROTHY LISA NANCY KAREN BETTY HELEN
	284	SANDRA DONNA CAROL RUTH SHARON MICHELLE LAURA SARAH
	285	KIMBERLY DEBORAH JESSICA SHIRLEY CYNTHIA ANGELA MELISSA
	286	BRENDA AMY ANNA REBECCA VIRGINIA KATHLEEN
	287	}
	288	intset {
	289	0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
	290	20 21 22 23 24 25 26 27 28 29
	291	30 31 32 33 34 35 36 37 38 39
	292	40 41 42 43 44 45 46 47 48 49
	293	}
	294	} {
	295	test "SRANDMEMBER with <count> - $type" {
	296	create_set myset $contents
	297	unset -nocomplain myset
	298	array set myset {}
	299	foreach ele [r smembers myset] {
	300	set myset($ele) 1
	301	}
	302	assert_equal [lsort $contents] [lsort [array names myset]]
	303
	304	# Make sure that a count of 0 is handled correctly.
	305	assert_equal [r srandmember myset 0] {}
	306
	307	# We'll stress different parts of the code, see the implementation
	308	# of SRANDMEMBER for more information, but basically there are
	309	# four different code paths.
	310	#
	311	# PATH 1: Use negative count.
	312	#
	313	# 1) Check that it returns repeated elements.
	314	set res [r srandmember myset -100]
	315	assert_equal [llength $res] 100
	316
	317	# 2) Check that all the elements actually belong to the
	318	# original set.
	319	foreach ele $res {
	320	assert {[info exists myset($ele)]}
	321	}
	322
	323	# 3) Check that eventually all the elements are returned.
	324	unset -nocomplain auxset
	325	set iterations 1000
	326	while {$iterations != 0} {
	327	incr iterations -1
	328	set res [r srandmember myset -10]
	329	foreach ele $res {
	330	set auxset($ele) 1
	331	}
	332	if {[lsort [array names myset]] eq
	333	[lsort [array names auxset]]} {
	334	break;
	335	}
	336	}
	337	assert {$iterations != 0}
338
339	# PATH 2: positive count (unique behavior) with requested size
340	# equal or greater than set size.
341	foreach size {50 100} {
342	set res [r srandmember myset $size]
343	assert_equal [llength $res] 50
344	assert_equal [lsort $res] [lsort [array names myset]]
345	}
346
347	# PATH 3: Ask almost as elements as there are in the set.
348	# In this case the implementation will duplicate the original
349	# set and will remove random elements up to the requested size.
350	#
351	# PATH 4: Ask a number of elements definitely smaller than
352	# the set size.
353	#
354	# We can test both the code paths just changing the size but
355	# using the same code.
356
357	foreach size {45 5} {
358	set res [r srandmember myset $size]
359	assert_equal [llength $res] $size
360
361	# 1) Check that all the elements actually belong to the
362	# original set.
363	foreach ele $res {
364	assert {[info exists myset($ele)]}
365	}
366
367	# 2) Check that eventually all the elements are returned.
368	unset -nocomplain auxset
369	set iterations 1000
370	while {$iterations != 0} {
371	incr iterations -1
372	set res [r srandmember myset -10]
373	foreach ele $res {
374	set auxset($ele) 1
375	}
376	if {[lsort [array names myset]] eq
377	[lsort [array names auxset]]} {
378	break;
379	}
380	}
381	assert {$iterations != 0}
382	}
383	}
384	}
385
b978abbf PN	386	proc setup_move {} {
	387	r del myset3 myset4
	388	create_set myset1 {1 a b}
	389	create_set myset2 {2 3 4}
	390	assert_encoding hashtable myset1
	391	assert_encoding intset myset2
	392	}
	393
	394	test "SMOVE basics - from regular set to intset" {
	395	# move a non-integer element to an intset should convert encoding
	396	setup_move
	397	assert_equal 1 [r smove myset1 myset2 a]
	398	assert_equal {1 b} [lsort [r smembers myset1]]
	399	assert_equal {2 3 4 a} [lsort [r smembers myset2]]
	400	assert_encoding hashtable myset2
	401
	402	# move an integer element should not convert the encoding
	403	setup_move
	404	assert_equal 1 [r smove myset1 myset2 1]
	405	assert_equal {a b} [lsort [r smembers myset1]]
	406	assert_equal {1 2 3 4} [lsort [r smembers myset2]]
	407	assert_encoding intset myset2
	408	}
	409
	410	test "SMOVE basics - from intset to regular set" {
	411	setup_move
	412	assert_equal 1 [r smove myset2 myset1 2]
	413	assert_equal {1 2 a b} [lsort [r smembers myset1]]
	414	assert_equal {3 4} [lsort [r smembers myset2]]
	415	}
	416
	417	test "SMOVE non existing key" {
	418	setup_move
	419	assert_equal 0 [r smove myset1 myset2 foo]
	420	assert_equal {1 a b} [lsort [r smembers myset1]]
	421	assert_equal {2 3 4} [lsort [r smembers myset2]]
	422	}
	423
	424	test "SMOVE non existing src set" {
	425	setup_move
	426	assert_equal 0 [r smove noset myset2 foo]
	427	assert_equal {2 3 4} [lsort [r smembers myset2]]
	428	}
	429
	430	test "SMOVE from regular set to non existing destination set" {
	431	setup_move
	432	assert_equal 1 [r smove myset1 myset3 a]
	433	assert_equal {1 b} [lsort [r smembers myset1]]
	434	assert_equal {a} [lsort [r smembers myset3]]
	435	assert_encoding hashtable myset3
	436	}
	437
	438	test "SMOVE from intset to non existing destination set" {
	439	setup_move
	440	assert_equal 1 [r smove myset2 myset3 2]
	441	assert_equal {3 4} [lsort [r smembers myset2]]
	442	assert_equal {2} [lsort [r smembers myset3]]
	443	assert_encoding intset myset3
	444	}
	445
	446	test "SMOVE wrong src key type" {
98578b57	447	r set x 10
b978abbf PN	448	assert_error "ERRwrong kind" {r smove x myset2 foo}
b978abbf PN	449	}
98578b57	450
b978abbf	451	test "SMOVE wrong dst key type" {
98578b57	452	r set x 10
b978abbf PN	453	assert_error "ERRwrong kind" {r smove myset2 x foo}
b978abbf PN	454	}
4610b033	455
ff5e31f7	456	test "SMOVE with identical source and destination" {
	457	r del set
	458	r sadd set a b c
	459	r smove set set b
	460	lsort [r smembers set]
	461	} {a b c}
	462
4610b033	463	tags {slow} {
	464	test {intsets implementation stress testing} {
	465	for {set j 0} {$j < 20} {incr j} {
	466	unset -nocomplain s
	467	array set s {}
	468	r del s
	469	set len [randomInt 1024]
	470	for {set i 0} {$i < $len} {incr i} {
	471	randpath {
	472	set data [randomInt 65536]
	473	} {
	474	set data [randomInt 4294967296]
	475	} {
	476	set data [randomInt 18446744073709551616]
	477	}
	478	set s($data) {}
	479	r sadd s $data
	480	}
	481	assert_equal [lsort [r smembers s]] [lsort [array names s]]
	482	set len [array size s]
	483	for {set i 0} {$i < $len} {incr i} {
	484	set e [r spop s]
	485	if {![info exists s($e)]} {
	486	puts "Can't find '$e' on local array"
	487	puts "Local array: [lsort [r smembers s]]"
	488	puts "Remote array: [lsort [array names s]]"
	489	error "exception"
	490	}
	491	array unset s $e
	492	}
	493	assert_equal [r scard s] 0
	494	assert_equal [array size s] 0
	495	}
	496	}
	497	}
98578b57	498	}