tests/unit/type/set.tcl

   1 start_server {
   2     tags {"set"}
   3     overrides {
   4         "set-max-intset-entries" 512
   5     }
   6 } {
   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     }
  35
  36     test {SADD against non set} {
  37         r lpush mylist foo
  38         assert_error ERR*kind* {r sadd mylist bar}
  39     }
  40
  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
  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
  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
  62     test "Set encoding after DEBUG RELOAD" {
  63         r del myintset myhashset mylargeintset
  64         for {set i 0} {$i <  100} {incr i} { r sadd myintset $i }
  65         for {set i 0} {$i < 1280} {incr i} { r sadd mylargeintset $i }
  66         for {set i 0} {$i <  256} {incr i} { r sadd myhashset [format "i%03d" $i] }
  67         assert_encoding intset myintset
  68         assert_encoding hashtable mylargeintset
  69         assert_encoding hashtable myhashset
  70
  71         r debug reload
  72         assert_encoding intset myintset
  73         assert_encoding hashtable mylargeintset
  74         assert_encoding hashtable myhashset
  75     }
  76
  77     test {SREM basics - regular set} {
  78         create_set myset {foo bar ciao}
  79         assert_encoding hashtable myset
  80         assert_equal 0 [r srem myset qux]
  81         assert_equal 1 [r srem myset foo]
  82         assert_equal {bar ciao} [lsort [r smembers myset]]
  83     }
  84
  85     test {SREM basics - intset} {
  86         create_set myset {3 4 5}
  87         assert_encoding intset myset
  88         assert_equal 0 [r srem myset 6]
  89         assert_equal 1 [r srem myset 4]
  90         assert_equal {3 5} [lsort [r smembers myset]]
  91     }
  92
  93     foreach {type} {hashtable intset} {
  94         for {set i 1} {$i <= 5} {incr i} {
  95             r del [format "set%d" $i]
  96         }
  97         for {set i 0} {$i < 200} {incr i} {
  98             r sadd set1 $i
  99             r sadd set2 [expr $i+195]
 100         }
 101         foreach i {199 195 1000 2000} {
 102             r sadd set3 $i
 103         }
 104         for {set i 5} {$i < 200} {incr i} {
 105             r sadd set4 $i
 106         }
 107         r sadd set5 0
 108
 109         # it is possible that a hashtable encoded only contains integers,
 110         # because it is converted from an intset to a hashtable when a
 111         # non-integer element is added and then removed.
 112         if {$type eq "hashtable"} {
 113             for {set i 1} {$i <= 5} {incr i} {
 114                 r sadd [format "set%d" $i] foo
 115                 r srem [format "set%d" $i] foo
 116             }
 117         }
 118
 119         test "Generated sets must be encoded as $type" {
 120             for {set i 1} {$i <= 5} {incr i} {
 121                 assert_encoding $type [format "set%d" $i]
 122             }
 123         }
 124
 125         test "SINTER with two sets - $type" {
 126             assert_equal {195 196 197 198 199} [lsort [r sinter set1 set2]]
 127         }
 128
 129         test "SINTERSTORE with two sets - $type" {
 130             r sinterstore setres set1 set2
 131             assert_encoding intset setres
 132             assert_equal {195 196 197 198 199} [lsort [r smembers setres]]
 133         }
 134
 135         test "SINTERSTORE with two sets, after a DEBUG RELOAD - $type" {
 136             r debug reload
 137             r sinterstore setres set1 set2
 138             assert_encoding intset setres
 139             assert_equal {195 196 197 198 199} [lsort [r smembers setres]]
 140         }
 141
 142         test "SUNION with two sets - $type" {
 143             set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
 144             assert_equal $expected [lsort [r sunion set1 set2]]
 145         }
 146
 147         test "SUNIONSTORE with two sets - $type" {
 148             r sunionstore setres set1 set2
 149             assert_encoding intset setres
 150             set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
 151             assert_equal $expected [lsort [r smembers setres]]
 152         }
 153
 154         test "SINTER against three sets - $type" {
 155             assert_equal {195 199} [lsort [r sinter set1 set2 set3]]
 156         }
 157
 158         test "SINTERSTORE with three sets - $type" {
 159             r sinterstore setres set1 set2 set3
 160             assert_equal {195 199} [r smembers setres]
 161         }
 162
 163         test "SUNION with non existing keys - $type" {
 164             set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
 165             assert_equal $expected [lsort [r sunion nokey1 set1 set2 nokey2]]
 166         }
 167
 168         test "SDIFF with two sets - $type" {
 169             assert_equal {0 1 2 3 4} [lsort [r sdiff set1 set4]]
 170         }
 171
 172         test "SDIFF with three sets - $type" {
 173             assert_equal {1 2 3 4} [lsort [r sdiff set1 set4 set5]]
 174         }
 175
 176         test "SDIFFSTORE with three sets - $type" {
 177             r sdiffstore setres set1 set4 set5
 178             assert_encoding intset setres
 179             assert_equal {1 2 3 4} [lsort [r smembers setres]]
 180         }
 181     }
 182
 183     test "SINTER against non-set should throw error" {
 184         r set key1 x
 185         assert_error "ERR*wrong kind*" {r sinter key1 noset}
 186     }
 187
 188     test "SUNION against non-set should throw error" {
 189         r set key1 x
 190         assert_error "ERR*wrong kind*" {r sunion key1 noset}
 191     }
 192
 193     test "SINTERSTORE against non existing keys should delete dstkey" {
 194         r set setres xxx
 195         assert_equal 0 [r sinterstore setres foo111 bar222]
 196         assert_equal 0 [r exists setres]
 197     }
 198
 199     test "SUNIONSTORE against non existing keys should delete dstkey" {
 200         r set setres xxx
 201         assert_equal 0 [r sunionstore setres foo111 bar222]
 202         assert_equal 0 [r exists setres]
 203     }
 204
 205     foreach {type contents} {hashtable {a b c} intset {1 2 3}} {
 206         test "SPOP basics - $type" {
 207             create_set myset $contents
 208             assert_encoding $type myset
 209             assert_equal $contents [lsort [list [r spop myset] [r spop myset] [r spop myset]]]
 210             assert_equal 0 [r scard myset]
 211         }
 212
 213         test "SRANDMEMBER - $type" {
 214             create_set myset $contents
 215             unset -nocomplain myset
 216             array set myset {}
 217             for {set i 0} {$i < 100} {incr i} {
 218                 set myset([r srandmember myset]) 1
 219             }
 220             assert_equal $contents [lsort [array names myset]]
 221         }
 222     }
 223
 224     proc setup_move {} {
 225         r del myset3 myset4
 226         create_set myset1 {1 a b}
 227         create_set myset2 {2 3 4}
 228         assert_encoding hashtable myset1
 229         assert_encoding intset myset2
 230     }
 231
 232     test "SMOVE basics - from regular set to intset" {
 233         # move a non-integer element to an intset should convert encoding
 234         setup_move
 235         assert_equal 1 [r smove myset1 myset2 a]
 236         assert_equal {1 b} [lsort [r smembers myset1]]
 237         assert_equal {2 3 4 a} [lsort [r smembers myset2]]
 238         assert_encoding hashtable myset2
 239
 240         # move an integer element should not convert the encoding
 241         setup_move
 242         assert_equal 1 [r smove myset1 myset2 1]
 243         assert_equal {a b} [lsort [r smembers myset1]]
 244         assert_equal {1 2 3 4} [lsort [r smembers myset2]]
 245         assert_encoding intset myset2
 246     }
 247
 248     test "SMOVE basics - from intset to regular set" {
 249         setup_move
 250         assert_equal 1 [r smove myset2 myset1 2]
 251         assert_equal {1 2 a b} [lsort [r smembers myset1]]
 252         assert_equal {3 4} [lsort [r smembers myset2]]
 253     }
 254
 255     test "SMOVE non existing key" {
 256         setup_move
 257         assert_equal 0 [r smove myset1 myset2 foo]
 258         assert_equal {1 a b} [lsort [r smembers myset1]]
 259         assert_equal {2 3 4} [lsort [r smembers myset2]]
 260     }
 261
 262     test "SMOVE non existing src set" {
 263         setup_move
 264         assert_equal 0 [r smove noset myset2 foo]
 265         assert_equal {2 3 4} [lsort [r smembers myset2]]
 266     }
 267
 268     test "SMOVE from regular set to non existing destination set" {
 269         setup_move
 270         assert_equal 1 [r smove myset1 myset3 a]
 271         assert_equal {1 b} [lsort [r smembers myset1]]
 272         assert_equal {a} [lsort [r smembers myset3]]
 273         assert_encoding hashtable myset3
 274     }
 275
 276     test "SMOVE from intset to non existing destination set" {
 277         setup_move
 278         assert_equal 1 [r smove myset2 myset3 2]
 279         assert_equal {3 4} [lsort [r smembers myset2]]
 280         assert_equal {2} [lsort [r smembers myset3]]
 281         assert_encoding intset myset3
 282     }
 283
 284     test "SMOVE wrong src key type" {
 285         r set x 10
 286         assert_error "ERR*wrong kind*" {r smove x myset2 foo}
 287     }
 288
 289     test "SMOVE wrong dst key type" {
 290         r set x 10
 291         assert_error "ERR*wrong kind*" {r smove myset2 x foo}
 292     }
 293 }