]> git.saurik.com Git - redis.git/blob - tests/unit/type/set.tcl
Configurable synchronous I/O timeout
[redis.git] / 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 {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
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
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
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
108 foreach {type} {hashtable intset} {
109 for {set i 1} {$i <= 5} {incr i} {
110 r del [format "set%d" $i]
111 }
112 for {set i 0} {$i < 200} {incr i} {
113 r sadd set1 $i
114 r sadd set2 [expr $i+195]
115 }
116 foreach i {199 195 1000 2000} {
117 r sadd set3 $i
118 }
119 for {set i 5} {$i < 200} {incr i} {
120 r sadd set4 $i
121 }
122 r sadd set5 0
123
124 # To make sure the sets are encoded as the type we are testing -- also
125 # when the VM is enabled and the values may be swapped in and out
126 # while the tests are running -- an extra element is added to every
127 # set that determines its encoding.
128 set large 200
129 if {$type eq "hashtable"} {
130 set large foo
131 }
132
133 for {set i 1} {$i <= 5} {incr i} {
134 r sadd [format "set%d" $i] $large
135 }
136
137 test "Generated sets must be encoded as $type" {
138 for {set i 1} {$i <= 5} {incr i} {
139 assert_encoding $type [format "set%d" $i]
140 }
141 }
142
143 test "SINTER with two sets - $type" {
144 assert_equal [list 195 196 197 198 199 $large] [lsort [r sinter set1 set2]]
145 }
146
147 test "SINTERSTORE with two sets - $type" {
148 r sinterstore setres set1 set2
149 assert_encoding $type setres
150 assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]]
151 }
152
153 test "SINTERSTORE with two sets, after a DEBUG RELOAD - $type" {
154 r debug reload
155 r sinterstore setres set1 set2
156 assert_encoding $type setres
157 assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]]
158 }
159
160 test "SUNION with two sets - $type" {
161 set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
162 assert_equal $expected [lsort [r sunion set1 set2]]
163 }
164
165 test "SUNIONSTORE with two sets - $type" {
166 r sunionstore setres set1 set2
167 assert_encoding $type setres
168 set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
169 assert_equal $expected [lsort [r smembers setres]]
170 }
171
172 test "SINTER against three sets - $type" {
173 assert_equal [list 195 199 $large] [lsort [r sinter set1 set2 set3]]
174 }
175
176 test "SINTERSTORE with three sets - $type" {
177 r sinterstore setres set1 set2 set3
178 assert_equal [list 195 199 $large] [lsort [r smembers setres]]
179 }
180
181 test "SUNION with non existing keys - $type" {
182 set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
183 assert_equal $expected [lsort [r sunion nokey1 set1 set2 nokey2]]
184 }
185
186 test "SDIFF with two sets - $type" {
187 assert_equal {0 1 2 3 4} [lsort [r sdiff set1 set4]]
188 }
189
190 test "SDIFF with three sets - $type" {
191 assert_equal {1 2 3 4} [lsort [r sdiff set1 set4 set5]]
192 }
193
194 test "SDIFFSTORE with three sets - $type" {
195 r sdiffstore setres set1 set4 set5
196 # The type is determined by type of the first key to diff against.
197 # See the implementation for more information.
198 assert_encoding $type setres
199 assert_equal {1 2 3 4} [lsort [r smembers setres]]
200 }
201 }
202
203 test "SINTER against non-set should throw error" {
204 r set key1 x
205 assert_error "ERR*wrong kind*" {r sinter key1 noset}
206 }
207
208 test "SUNION against non-set should throw error" {
209 r set key1 x
210 assert_error "ERR*wrong kind*" {r sunion key1 noset}
211 }
212
213 test "SINTERSTORE against non existing keys should delete dstkey" {
214 r set setres xxx
215 assert_equal 0 [r sinterstore setres foo111 bar222]
216 assert_equal 0 [r exists setres]
217 }
218
219 test "SUNIONSTORE against non existing keys should delete dstkey" {
220 r set setres xxx
221 assert_equal 0 [r sunionstore setres foo111 bar222]
222 assert_equal 0 [r exists setres]
223 }
224
225 foreach {type contents} {hashtable {a b c} intset {1 2 3}} {
226 test "SPOP basics - $type" {
227 create_set myset $contents
228 assert_encoding $type myset
229 assert_equal $contents [lsort [list [r spop myset] [r spop myset] [r spop myset]]]
230 assert_equal 0 [r scard myset]
231 }
232
233 test "SRANDMEMBER - $type" {
234 create_set myset $contents
235 unset -nocomplain myset
236 array set myset {}
237 for {set i 0} {$i < 100} {incr i} {
238 set myset([r srandmember myset]) 1
239 }
240 assert_equal $contents [lsort [array names myset]]
241 }
242 }
243
244 proc setup_move {} {
245 r del myset3 myset4
246 create_set myset1 {1 a b}
247 create_set myset2 {2 3 4}
248 assert_encoding hashtable myset1
249 assert_encoding intset myset2
250 }
251
252 test "SMOVE basics - from regular set to intset" {
253 # move a non-integer element to an intset should convert encoding
254 setup_move
255 assert_equal 1 [r smove myset1 myset2 a]
256 assert_equal {1 b} [lsort [r smembers myset1]]
257 assert_equal {2 3 4 a} [lsort [r smembers myset2]]
258 assert_encoding hashtable myset2
259
260 # move an integer element should not convert the encoding
261 setup_move
262 assert_equal 1 [r smove myset1 myset2 1]
263 assert_equal {a b} [lsort [r smembers myset1]]
264 assert_equal {1 2 3 4} [lsort [r smembers myset2]]
265 assert_encoding intset myset2
266 }
267
268 test "SMOVE basics - from intset to regular set" {
269 setup_move
270 assert_equal 1 [r smove myset2 myset1 2]
271 assert_equal {1 2 a b} [lsort [r smembers myset1]]
272 assert_equal {3 4} [lsort [r smembers myset2]]
273 }
274
275 test "SMOVE non existing key" {
276 setup_move
277 assert_equal 0 [r smove myset1 myset2 foo]
278 assert_equal {1 a b} [lsort [r smembers myset1]]
279 assert_equal {2 3 4} [lsort [r smembers myset2]]
280 }
281
282 test "SMOVE non existing src set" {
283 setup_move
284 assert_equal 0 [r smove noset myset2 foo]
285 assert_equal {2 3 4} [lsort [r smembers myset2]]
286 }
287
288 test "SMOVE from regular set to non existing destination set" {
289 setup_move
290 assert_equal 1 [r smove myset1 myset3 a]
291 assert_equal {1 b} [lsort [r smembers myset1]]
292 assert_equal {a} [lsort [r smembers myset3]]
293 assert_encoding hashtable myset3
294 }
295
296 test "SMOVE from intset to non existing destination set" {
297 setup_move
298 assert_equal 1 [r smove myset2 myset3 2]
299 assert_equal {3 4} [lsort [r smembers myset2]]
300 assert_equal {2} [lsort [r smembers myset3]]
301 assert_encoding intset myset3
302 }
303
304 test "SMOVE wrong src key type" {
305 r set x 10
306 assert_error "ERR*wrong kind*" {r smove x myset2 foo}
307 }
308
309 test "SMOVE wrong dst key type" {
310 r set x 10
311 assert_error "ERR*wrong kind*" {r smove myset2 x foo}
312 }
313
314 tags {slow} {
315 test {intsets implementation stress testing} {
316 for {set j 0} {$j < 20} {incr j} {
317 unset -nocomplain s
318 array set s {}
319 r del s
320 set len [randomInt 1024]
321 for {set i 0} {$i < $len} {incr i} {
322 randpath {
323 set data [randomInt 65536]
324 } {
325 set data [randomInt 4294967296]
326 } {
327 set data [randomInt 18446744073709551616]
328 }
329 set s($data) {}
330 r sadd s $data
331 }
332 assert_equal [lsort [r smembers s]] [lsort [array names s]]
333 set len [array size s]
334 for {set i 0} {$i < $len} {incr i} {
335 set e [r spop s]
336 if {![info exists s($e)]} {
337 puts "Can't find '$e' on local array"
338 puts "Local array: [lsort [r smembers s]]"
339 puts "Remote array: [lsort [array names s]]"
340 error "exception"
341 }
342 array unset s $e
343 }
344 assert_equal [r scard s] 0
345 assert_equal [array size s] 0
346 }
347 }
348 }
349 }