1start_server {tags {"zset"}} { 2 proc create_zset {key items} { 3 r del $key 4 foreach {score entry} $items { 5 r zadd $key $score $entry 6 } 7 } 8 9 proc basics {encoding} { 10 if {$encoding == "ziplist"} { 11 r config set zset-max-ziplist-entries 128 12 r config set zset-max-ziplist-value 64 13 } elseif {$encoding == "skiplist"} { 14 r config set zset-max-ziplist-entries 0 15 r config set zset-max-ziplist-value 0 16 } else { 17 puts "Unknown sorted set encoding" 18 exit 19 } 20 21 test "Check encoding - $encoding" { 22 r del ztmp 23 r zadd ztmp 10 x 24 assert_encoding $encoding ztmp 25 } 26 27 test "ZSET basic ZADD and score update - $encoding" { 28 r del ztmp 29 r zadd ztmp 10 x 30 r zadd ztmp 20 y 31 r zadd ztmp 30 z 32 assert_equal {x y z} [r zrange ztmp 0 -1] 33 34 r zadd ztmp 1 y 35 assert_equal {y x z} [r zrange ztmp 0 -1] 36 } 37 38 test "ZSET element can't be set to NaN with ZADD - $encoding" { 39 assert_error "*not*float*" {r zadd myzset nan abc} 40 } 41 42 test "ZSET element can't be set to NaN with ZINCRBY" { 43 assert_error "*not*float*" {r zadd myzset nan abc} 44 } 45 46 test "ZINCRBY calls leading to NaN result in error" { 47 r zincrby myzset +inf abc 48 assert_error "*NaN*" {r zincrby myzset -inf abc} 49 } 50 51 test {ZADD - Variadic version base case} { 52 r del myzset 53 list [r zadd myzset 10 a 20 b 30 c] [r zrange myzset 0 -1 withscores] 54 } {3 {a 10 b 20 c 30}} 55 56 test {ZADD - Return value is the number of actually added items} { 57 list [r zadd myzset 5 x 20 b 30 c] [r zrange myzset 0 -1 withscores] 58 } {1 {x 5 a 10 b 20 c 30}} 59 60 test {ZADD - Variadic version does not add nothing on single parsing err} { 61 r del myzset 62 catch {r zadd myzset 10 a 20 b 30.badscore c} e 63 assert_match {*ERR*not*float*} $e 64 r exists myzset 65 } {0} 66 67 test {ZADD - Variadic version will raise error on missing arg} { 68 r del myzset 69 catch {r zadd myzset 10 a 20 b 30 c 40} e 70 assert_match {*ERR*syntax*} $e 71 } 72 73 test {ZINCRBY does not work variadic even if shares ZADD implementation} { 74 r del myzset 75 catch {r zincrby myzset 10 a 20 b 30 c} e 76 assert_match {*ERR*wrong*number*arg*} $e 77 } 78 79 test "ZCARD basics - $encoding" { 80 assert_equal 3 [r zcard ztmp] 81 assert_equal 0 [r zcard zdoesntexist] 82 } 83 84 test "ZREM removes key after last element is removed" { 85 r del ztmp 86 r zadd ztmp 10 x 87 r zadd ztmp 20 y 88 89 assert_equal 1 [r exists ztmp] 90 assert_equal 0 [r zrem ztmp z] 91 assert_equal 1 [r zrem ztmp y] 92 assert_equal 1 [r zrem ztmp x] 93 assert_equal 0 [r exists ztmp] 94 } 95 96 test "ZREM variadic version" { 97 r del ztmp 98 r zadd ztmp 10 a 20 b 30 c 99 assert_equal 2 [r zrem ztmp x y a b k] 100 assert_equal 0 [r zrem ztmp foo bar] 101 assert_equal 1 [r zrem ztmp c] 102 r exists ztmp 103 } {0} 104 105 test "ZREM variadic version -- remove elements after key deletion" { 106 r del ztmp 107 r zadd ztmp 10 a 20 b 30 c 108 r zrem ztmp a b c d e f g 109 } {3} 110 111 test "ZRANGE basics - $encoding" { 112 r del ztmp 113 r zadd ztmp 1 a 114 r zadd ztmp 2 b 115 r zadd ztmp 3 c 116 r zadd ztmp 4 d 117 118 assert_equal {a b c d} [r zrange ztmp 0 -1] 119 assert_equal {a b c} [r zrange ztmp 0 -2] 120 assert_equal {b c d} [r zrange ztmp 1 -1] 121 assert_equal {b c} [r zrange ztmp 1 -2] 122 assert_equal {c d} [r zrange ztmp -2 -1] 123 assert_equal {c} [r zrange ztmp -2 -2] 124 125 # out of range start index 126 assert_equal {a b c} [r zrange ztmp -5 2] 127 assert_equal {a b} [r zrange ztmp -5 1] 128 assert_equal {} [r zrange ztmp 5 -1] 129 assert_equal {} [r zrange ztmp 5 -2] 130 131 # out of range end index 132 assert_equal {a b c d} [r zrange ztmp 0 5] 133 assert_equal {b c d} [r zrange ztmp 1 5] 134 assert_equal {} [r zrange ztmp 0 -5] 135 assert_equal {} [r zrange ztmp 1 -5] 136 137 # withscores 138 assert_equal {a 1 b 2 c 3 d 4} [r zrange ztmp 0 -1 withscores] 139 } 140 141 test "ZREVRANGE basics - $encoding" { 142 r del ztmp 143 r zadd ztmp 1 a 144 r zadd ztmp 2 b 145 r zadd ztmp 3 c 146 r zadd ztmp 4 d 147 148 assert_equal {d c b a} [r zrevrange ztmp 0 -1] 149 assert_equal {d c b} [r zrevrange ztmp 0 -2] 150 assert_equal {c b a} [r zrevrange ztmp 1 -1] 151 assert_equal {c b} [r zrevrange ztmp 1 -2] 152 assert_equal {b a} [r zrevrange ztmp -2 -1] 153 assert_equal {b} [r zrevrange ztmp -2 -2] 154 155 # out of range start index 156 assert_equal {d c b} [r zrevrange ztmp -5 2] 157 assert_equal {d c} [r zrevrange ztmp -5 1] 158 assert_equal {} [r zrevrange ztmp 5 -1] 159 assert_equal {} [r zrevrange ztmp 5 -2] 160 161 # out of range end index 162 assert_equal {d c b a} [r zrevrange ztmp 0 5] 163 assert_equal {c b a} [r zrevrange ztmp 1 5] 164 assert_equal {} [r zrevrange ztmp 0 -5] 165 assert_equal {} [r zrevrange ztmp 1 -5] 166 167 # withscores 168 assert_equal {d 4 c 3 b 2 a 1} [r zrevrange ztmp 0 -1 withscores] 169 } 170 171 test "ZRANK/ZREVRANK basics - $encoding" { 172 r del zranktmp 173 r zadd zranktmp 10 x 174 r zadd zranktmp 20 y 175 r zadd zranktmp 30 z 176 assert_equal 0 [r zrank zranktmp x] 177 assert_equal 1 [r zrank zranktmp y] 178 assert_equal 2 [r zrank zranktmp z] 179 assert_equal "" [r zrank zranktmp foo] 180 assert_equal 2 [r zrevrank zranktmp x] 181 assert_equal 1 [r zrevrank zranktmp y] 182 assert_equal 0 [r zrevrank zranktmp z] 183 assert_equal "" [r zrevrank zranktmp foo] 184 } 185 186 test "ZRANK - after deletion - $encoding" { 187 r zrem zranktmp y 188 assert_equal 0 [r zrank zranktmp x] 189 assert_equal 1 [r zrank zranktmp z] 190 } 191 192 test "ZINCRBY - can create a new sorted set - $encoding" { 193 r del zset 194 r zincrby zset 1 foo 195 assert_equal {foo} [r zrange zset 0 -1] 196 assert_equal 1 [r zscore zset foo] 197 } 198 199 test "ZINCRBY - increment and decrement - $encoding" { 200 r zincrby zset 2 foo 201 r zincrby zset 1 bar 202 assert_equal {bar foo} [r zrange zset 0 -1] 203 204 r zincrby zset 10 bar 205 r zincrby zset -5 foo 206 r zincrby zset -5 bar 207 assert_equal {foo bar} [r zrange zset 0 -1] 208 209 assert_equal -2 [r zscore zset foo] 210 assert_equal 6 [r zscore zset bar] 211 } 212 213 proc create_default_zset {} { 214 create_zset zset {-inf a 1 b 2 c 3 d 4 e 5 f +inf g} 215 } 216 217 test "ZRANGEBYSCORE/ZREVRANGEBYSCORE/ZCOUNT basics" { 218 create_default_zset 219 220 # inclusive range 221 assert_equal {a b c} [r zrangebyscore zset -inf 2] 222 assert_equal {b c d} [r zrangebyscore zset 0 3] 223 assert_equal {d e f} [r zrangebyscore zset 3 6] 224 assert_equal {e f g} [r zrangebyscore zset 4 +inf] 225 assert_equal {c b a} [r zrevrangebyscore zset 2 -inf] 226 assert_equal {d c b} [r zrevrangebyscore zset 3 0] 227 assert_equal {f e d} [r zrevrangebyscore zset 6 3] 228 assert_equal {g f e} [r zrevrangebyscore zset +inf 4] 229 assert_equal 3 [r zcount zset 0 3] 230 231 # exclusive range 232 assert_equal {b} [r zrangebyscore zset (-inf (2] 233 assert_equal {b c} [r zrangebyscore zset (0 (3] 234 assert_equal {e f} [r zrangebyscore zset (3 (6] 235 assert_equal {f} [r zrangebyscore zset (4 (+inf] 236 assert_equal {b} [r zrevrangebyscore zset (2 (-inf] 237 assert_equal {c b} [r zrevrangebyscore zset (3 (0] 238 assert_equal {f e} [r zrevrangebyscore zset (6 (3] 239 assert_equal {f} [r zrevrangebyscore zset (+inf (4] 240 assert_equal 2 [r zcount zset (0 (3] 241 242 # test empty ranges 243 r zrem zset a 244 r zrem zset g 245 246 # inclusive 247 assert_equal {} [r zrangebyscore zset 4 2] 248 assert_equal {} [r zrangebyscore zset 6 +inf] 249 assert_equal {} [r zrangebyscore zset -inf -6] 250 assert_equal {} [r zrevrangebyscore zset +inf 6] 251 assert_equal {} [r zrevrangebyscore zset -6 -inf] 252 253 # exclusive 254 assert_equal {} [r zrangebyscore zset (4 (2] 255 assert_equal {} [r zrangebyscore zset 2 (2] 256 assert_equal {} [r zrangebyscore zset (2 2] 257 assert_equal {} [r zrangebyscore zset (6 (+inf] 258 assert_equal {} [r zrangebyscore zset (-inf (-6] 259 assert_equal {} [r zrevrangebyscore zset (+inf (6] 260 assert_equal {} [r zrevrangebyscore zset (-6 (-inf] 261 262 # empty inner range 263 assert_equal {} [r zrangebyscore zset 2.4 2.6] 264 assert_equal {} [r zrangebyscore zset (2.4 2.6] 265 assert_equal {} [r zrangebyscore zset 2.4 (2.6] 266 assert_equal {} [r zrangebyscore zset (2.4 (2.6] 267 } 268 269 test "ZRANGEBYSCORE with WITHSCORES" { 270 create_default_zset 271 assert_equal {b 1 c 2 d 3} [r zrangebyscore zset 0 3 withscores] 272 assert_equal {d 3 c 2 b 1} [r zrevrangebyscore zset 3 0 withscores] 273 } 274 275 test "ZRANGEBYSCORE with LIMIT" { 276 create_default_zset 277 assert_equal {b c} [r zrangebyscore zset 0 10 LIMIT 0 2] 278 assert_equal {d e f} [r zrangebyscore zset 0 10 LIMIT 2 3] 279 assert_equal {d e f} [r zrangebyscore zset 0 10 LIMIT 2 10] 280 assert_equal {} [r zrangebyscore zset 0 10 LIMIT 20 10] 281 assert_equal {f e} [r zrevrangebyscore zset 10 0 LIMIT 0 2] 282 assert_equal {d c b} [r zrevrangebyscore zset 10 0 LIMIT 2 3] 283 assert_equal {d c b} [r zrevrangebyscore zset 10 0 LIMIT 2 10] 284 assert_equal {} [r zrevrangebyscore zset 10 0 LIMIT 20 10] 285 } 286 287 test "ZRANGEBYSCORE with LIMIT and WITHSCORES" { 288 create_default_zset 289 assert_equal {e 4 f 5} [r zrangebyscore zset 2 5 LIMIT 2 3 WITHSCORES] 290 assert_equal {d 3 c 2} [r zrevrangebyscore zset 5 2 LIMIT 2 3 WITHSCORES] 291 } 292 293 test "ZRANGEBYSCORE with non-value min or max" { 294 assert_error "*not*float*" {r zrangebyscore fooz str 1} 295 assert_error "*not*float*" {r zrangebyscore fooz 1 str} 296 assert_error "*not*float*" {r zrangebyscore fooz 1 NaN} 297 } 298 299 proc create_default_lex_zset {} { 300 create_zset zset {0 alpha 0 bar 0 cool 0 down 301 0 elephant 0 foo 0 great 0 hill 302 0 omega} 303 } 304 305 test "ZRANGEBYLEX/ZREVRANGEBYLEX/ZCOUNT basics" { 306 create_default_lex_zset 307 308 # inclusive range 309 assert_equal {alpha bar cool} [r zrangebylex zset - \[cool] 310 assert_equal {bar cool down} [r zrangebylex zset \[bar \[down] 311 assert_equal {great hill omega} [r zrangebylex zset \[g +] 312 assert_equal {cool bar alpha} [r zrevrangebylex zset \[cool -] 313 assert_equal {down cool bar} [r zrevrangebylex zset \[down \[bar] 314 assert_equal {omega hill great foo elephant down} [r zrevrangebylex zset + \[d] 315 assert_equal 3 [r zlexcount zset \[ele \[h] 316 317 # exclusive range 318 assert_equal {alpha bar} [r zrangebylex zset - (cool] 319 assert_equal {cool} [r zrangebylex zset (bar (down] 320 assert_equal {hill omega} [r zrangebylex zset (great +] 321 assert_equal {bar alpha} [r zrevrangebylex zset (cool -] 322 assert_equal {cool} [r zrevrangebylex zset (down (bar] 323 assert_equal {omega hill} [r zrevrangebylex zset + (great] 324 assert_equal 2 [r zlexcount zset (ele (great] 325 326 # inclusive and exclusive 327 assert_equal {} [r zrangebylex zset (az (b] 328 assert_equal {} [r zrangebylex zset (z +] 329 assert_equal {} [r zrangebylex zset - \[aaaa] 330 assert_equal {} [r zrevrangebylex zset \[elez \[elex] 331 assert_equal {} [r zrevrangebylex zset (hill (omega] 332 } 333 334 test "ZRANGEBYSLEX with LIMIT" { 335 create_default_lex_zset 336 assert_equal {alpha bar} [r zrangebylex zset - \[cool LIMIT 0 2] 337 assert_equal {bar cool} [r zrangebylex zset - \[cool LIMIT 1 2] 338 assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 0 0] 339 assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 2 0] 340 assert_equal {bar} [r zrangebylex zset \[bar \[down LIMIT 0 1] 341 assert_equal {cool} [r zrangebylex zset \[bar \[down LIMIT 1 1] 342 assert_equal {bar cool down} [r zrangebylex zset \[bar \[down LIMIT 0 100] 343 assert_equal {omega hill great foo elephant} [r zrevrangebylex zset + \[d LIMIT 0 5] 344 assert_equal {omega hill great foo} [r zrevrangebylex zset + \[d LIMIT 0 4] 345 } 346 347 test "ZRANGEBYLEX with invalid lex range specifiers" { 348 assert_error "*not*string*" {r zrangebylex fooz foo bar} 349 assert_error "*not*string*" {r zrangebylex fooz \[foo bar} 350 assert_error "*not*string*" {r zrangebylex fooz foo \[bar} 351 assert_error "*not*string*" {r zrangebylex fooz +x \[bar} 352 assert_error "*not*string*" {r zrangebylex fooz -x \[bar} 353 } 354 355 test "ZREMRANGEBYSCORE basics" { 356 proc remrangebyscore {min max} { 357 create_zset zset {1 a 2 b 3 c 4 d 5 e} 358 assert_equal 1 [r exists zset] 359 r zremrangebyscore zset $min $max 360 } 361 362 # inner range 363 assert_equal 3 [remrangebyscore 2 4] 364 assert_equal {a e} [r zrange zset 0 -1] 365 366 # start underflow 367 assert_equal 1 [remrangebyscore -10 1] 368 assert_equal {b c d e} [r zrange zset 0 -1] 369 370 # end overflow 371 assert_equal 1 [remrangebyscore 5 10] 372 assert_equal {a b c d} [r zrange zset 0 -1] 373 374 # switch min and max 375 assert_equal 0 [remrangebyscore 4 2] 376 assert_equal {a b c d e} [r zrange zset 0 -1] 377 378 # -inf to mid 379 assert_equal 3 [remrangebyscore -inf 3] 380 assert_equal {d e} [r zrange zset 0 -1] 381 382 # mid to +inf 383 assert_equal 3 [remrangebyscore 3 +inf] 384 assert_equal {a b} [r zrange zset 0 -1] 385 386 # -inf to +inf 387 assert_equal 5 [remrangebyscore -inf +inf] 388 assert_equal {} [r zrange zset 0 -1] 389 390 # exclusive min 391 assert_equal 4 [remrangebyscore (1 5] 392 assert_equal {a} [r zrange zset 0 -1] 393 assert_equal 3 [remrangebyscore (2 5] 394 assert_equal {a b} [r zrange zset 0 -1] 395 396 # exclusive max 397 assert_equal 4 [remrangebyscore 1 (5] 398 assert_equal {e} [r zrange zset 0 -1] 399 assert_equal 3 [remrangebyscore 1 (4] 400 assert_equal {d e} [r zrange zset 0 -1] 401 402 # exclusive min and max 403 assert_equal 3 [remrangebyscore (1 (5] 404 assert_equal {a e} [r zrange zset 0 -1] 405 406 # destroy when empty 407 assert_equal 5 [remrangebyscore 1 5] 408 assert_equal 0 [r exists zset] 409 } 410 411 test "ZREMRANGEBYSCORE with non-value min or max" { 412 assert_error "*not*float*" {r zremrangebyscore fooz str 1} 413 assert_error "*not*float*" {r zremrangebyscore fooz 1 str} 414 assert_error "*not*float*" {r zremrangebyscore fooz 1 NaN} 415 } 416 417 test "ZREMRANGEBYRANK basics" { 418 proc remrangebyrank {min max} { 419 create_zset zset {1 a 2 b 3 c 4 d 5 e} 420 assert_equal 1 [r exists zset] 421 r zremrangebyrank zset $min $max 422 } 423 424 # inner range 425 assert_equal 3 [remrangebyrank 1 3] 426 assert_equal {a e} [r zrange zset 0 -1] 427 428 # start underflow 429 assert_equal 1 [remrangebyrank -10 0] 430 assert_equal {b c d e} [r zrange zset 0 -1] 431 432 # start overflow 433 assert_equal 0 [remrangebyrank 10 -1] 434 assert_equal {a b c d e} [r zrange zset 0 -1] 435 436 # end underflow 437 assert_equal 0 [remrangebyrank 0 -10] 438 assert_equal {a b c d e} [r zrange zset 0 -1] 439 440 # end overflow 441 assert_equal 5 [remrangebyrank 0 10] 442 assert_equal {} [r zrange zset 0 -1] 443 444 # destroy when empty 445 assert_equal 5 [remrangebyrank 0 4] 446 assert_equal 0 [r exists zset] 447 } 448 449 test "ZUNIONSTORE against non-existing key doesn't set destination - $encoding" { 450 r del zseta 451 assert_equal 0 [r zunionstore dst_key 1 zseta] 452 assert_equal 0 [r exists dst_key] 453 } 454 455 test "ZUNIONSTORE with empty set - $encoding" { 456 r del zseta zsetb 457 r zadd zseta 1 a 458 r zadd zseta 2 b 459 r zunionstore zsetc 2 zseta zsetb 460 r zrange zsetc 0 -1 withscores 461 } {a 1 b 2} 462 463 test "ZUNIONSTORE basics - $encoding" { 464 r del zseta zsetb zsetc 465 r zadd zseta 1 a 466 r zadd zseta 2 b 467 r zadd zseta 3 c 468 r zadd zsetb 1 b 469 r zadd zsetb 2 c 470 r zadd zsetb 3 d 471 472 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb] 473 assert_equal {a 1 b 3 d 3 c 5} [r zrange zsetc 0 -1 withscores] 474 } 475 476 test "ZUNIONSTORE with weights - $encoding" { 477 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb weights 2 3] 478 assert_equal {a 2 b 7 d 9 c 12} [r zrange zsetc 0 -1 withscores] 479 } 480 481 test "ZUNIONSTORE with a regular set and weights - $encoding" { 482 r del seta 483 r sadd seta a 484 r sadd seta b 485 r sadd seta c 486 487 assert_equal 4 [r zunionstore zsetc 2 seta zsetb weights 2 3] 488 assert_equal {a 2 b 5 c 8 d 9} [r zrange zsetc 0 -1 withscores] 489 } 490 491 test "ZUNIONSTORE with AGGREGATE MIN - $encoding" { 492 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate min] 493 assert_equal {a 1 b 1 c 2 d 3} [r zrange zsetc 0 -1 withscores] 494 } 495 496 test "ZUNIONSTORE with AGGREGATE MAX - $encoding" { 497 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate max] 498 assert_equal {a 1 b 2 c 3 d 3} [r zrange zsetc 0 -1 withscores] 499 } 500 501 test "ZINTERSTORE basics - $encoding" { 502 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb] 503 assert_equal {b 3 c 5} [r zrange zsetc 0 -1 withscores] 504 } 505 506 test "ZINTERSTORE with weights - $encoding" { 507 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb weights 2 3] 508 assert_equal {b 7 c 12} [r zrange zsetc 0 -1 withscores] 509 } 510 511 test "ZINTERSTORE with a regular set and weights - $encoding" { 512 r del seta 513 r sadd seta a 514 r sadd seta b 515 r sadd seta c 516 assert_equal 2 [r zinterstore zsetc 2 seta zsetb weights 2 3] 517 assert_equal {b 5 c 8} [r zrange zsetc 0 -1 withscores] 518 } 519 520 test "ZINTERSTORE with AGGREGATE MIN - $encoding" { 521 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate min] 522 assert_equal {b 1 c 2} [r zrange zsetc 0 -1 withscores] 523 } 524 525 test "ZINTERSTORE with AGGREGATE MAX - $encoding" { 526 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate max] 527 assert_equal {b 2 c 3} [r zrange zsetc 0 -1 withscores] 528 } 529 530 foreach cmd {ZUNIONSTORE ZINTERSTORE} { 531 test "$cmd with +inf/-inf scores - $encoding" { 532 r del zsetinf1 zsetinf2 533 534 r zadd zsetinf1 +inf key 535 r zadd zsetinf2 +inf key 536 r $cmd zsetinf3 2 zsetinf1 zsetinf2 537 assert_equal inf [r zscore zsetinf3 key] 538 539 r zadd zsetinf1 -inf key 540 r zadd zsetinf2 +inf key 541 r $cmd zsetinf3 2 zsetinf1 zsetinf2 542 assert_equal 0 [r zscore zsetinf3 key] 543 544 r zadd zsetinf1 +inf key 545 r zadd zsetinf2 -inf key 546 r $cmd zsetinf3 2 zsetinf1 zsetinf2 547 assert_equal 0 [r zscore zsetinf3 key] 548 549 r zadd zsetinf1 -inf key 550 r zadd zsetinf2 -inf key 551 r $cmd zsetinf3 2 zsetinf1 zsetinf2 552 assert_equal -inf [r zscore zsetinf3 key] 553 } 554 555 test "$cmd with NaN weights $encoding" { 556 r del zsetinf1 zsetinf2 557 558 r zadd zsetinf1 1.0 key 559 r zadd zsetinf2 1.0 key 560 assert_error "*weight*not*float*" { 561 r $cmd zsetinf3 2 zsetinf1 zsetinf2 weights nan nan 562 } 563 } 564 } 565 } 566 567 basics ziplist 568 basics skiplist 569 570 test {ZINTERSTORE regression with two sets, intset+hashtable} { 571 r del seta setb setc 572 r sadd set1 a 573 r sadd set2 10 574 r zinterstore set3 2 set1 set2 575 } {0} 576 577 test {ZUNIONSTORE regression, should not create NaN in scores} { 578 r zadd z -inf neginf 579 r zunionstore out 1 z weights 0 580 r zrange out 0 -1 withscores 581 } {neginf 0} 582 583 test {ZINTERSTORE #516 regression, mixed sets and ziplist zsets} { 584 r sadd one 100 101 102 103 585 r sadd two 100 200 201 202 586 r zadd three 1 500 1 501 1 502 1 503 1 100 587 r zinterstore to_here 3 one two three WEIGHTS 0 0 1 588 r zrange to_here 0 -1 589 } {100} 590 591 proc stressers {encoding} { 592 if {$encoding == "ziplist"} { 593 # Little extra to allow proper fuzzing in the sorting stresser 594 r config set zset-max-ziplist-entries 256 595 r config set zset-max-ziplist-value 64 596 set elements 128 597 } elseif {$encoding == "skiplist"} { 598 r config set zset-max-ziplist-entries 0 599 r config set zset-max-ziplist-value 0 600 if {$::accurate} {set elements 1000} else {set elements 100} 601 } else { 602 puts "Unknown sorted set encoding" 603 exit 604 } 605 606 test "ZSCORE - $encoding" { 607 r del zscoretest 608 set aux {} 609 for {set i 0} {$i < $elements} {incr i} { 610 set score [expr rand()] 611 lappend aux $score 612 r zadd zscoretest $score $i 613 } 614 615 assert_encoding $encoding zscoretest 616 for {set i 0} {$i < $elements} {incr i} { 617 assert_equal [lindex $aux $i] [r zscore zscoretest $i] 618 } 619 } 620 621 test "ZSCORE after a DEBUG RELOAD - $encoding" { 622 r del zscoretest 623 set aux {} 624 for {set i 0} {$i < $elements} {incr i} { 625 set score [expr rand()] 626 lappend aux $score 627 r zadd zscoretest $score $i 628 } 629 630 r debug reload 631 assert_encoding $encoding zscoretest 632 for {set i 0} {$i < $elements} {incr i} { 633 assert_equal [lindex $aux $i] [r zscore zscoretest $i] 634 } 635 } 636 637 test "ZSET sorting stresser - $encoding" { 638 set delta 0 639 for {set test 0} {$test < 2} {incr test} { 640 unset -nocomplain auxarray 641 array set auxarray {} 642 set auxlist {} 643 r del myzset 644 for {set i 0} {$i < $elements} {incr i} { 645 if {$test == 0} { 646 set score [expr rand()] 647 } else { 648 set score [expr int(rand()*10)] 649 } 650 set auxarray($i) $score 651 r zadd myzset $score $i 652 # Random update 653 if {[expr rand()] < .2} { 654 set j [expr int(rand()*1000)] 655 if {$test == 0} { 656 set score [expr rand()] 657 } else { 658 set score [expr int(rand()*10)] 659 } 660 set auxarray($j) $score 661 r zadd myzset $score $j 662 } 663 } 664 foreach {item score} [array get auxarray] { 665 lappend auxlist [list $score $item] 666 } 667 set sorted [lsort -command zlistAlikeSort $auxlist] 668 set auxlist {} 669 foreach x $sorted { 670 lappend auxlist [lindex $x 1] 671 } 672 673 assert_encoding $encoding myzset 674 set fromredis [r zrange myzset 0 -1] 675 set delta 0 676 for {set i 0} {$i < [llength $fromredis]} {incr i} { 677 if {[lindex $fromredis $i] != [lindex $auxlist $i]} { 678 incr delta 679 } 680 } 681 } 682 assert_equal 0 $delta 683 } 684 685 test "ZRANGEBYSCORE fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 686 set err {} 687 r del zset 688 for {set i 0} {$i < $elements} {incr i} { 689 r zadd zset [expr rand()] $i 690 } 691 692 assert_encoding $encoding zset 693 for {set i 0} {$i < 100} {incr i} { 694 set min [expr rand()] 695 set max [expr rand()] 696 if {$min > $max} { 697 set aux $min 698 set min $max 699 set max $aux 700 } 701 set low [r zrangebyscore zset -inf $min] 702 set ok [r zrangebyscore zset $min $max] 703 set high [r zrangebyscore zset $max +inf] 704 set lowx [r zrangebyscore zset -inf ($min] 705 set okx [r zrangebyscore zset ($min ($max] 706 set highx [r zrangebyscore zset ($max +inf] 707 708 if {[r zcount zset -inf $min] != [llength $low]} { 709 append err "Error, len does not match zcount\n" 710 } 711 if {[r zcount zset $min $max] != [llength $ok]} { 712 append err "Error, len does not match zcount\n" 713 } 714 if {[r zcount zset $max +inf] != [llength $high]} { 715 append err "Error, len does not match zcount\n" 716 } 717 if {[r zcount zset -inf ($min] != [llength $lowx]} { 718 append err "Error, len does not match zcount\n" 719 } 720 if {[r zcount zset ($min ($max] != [llength $okx]} { 721 append err "Error, len does not match zcount\n" 722 } 723 if {[r zcount zset ($max +inf] != [llength $highx]} { 724 append err "Error, len does not match zcount\n" 725 } 726 727 foreach x $low { 728 set score [r zscore zset $x] 729 if {$score > $min} { 730 append err "Error, score for $x is $score > $min\n" 731 } 732 } 733 foreach x $lowx { 734 set score [r zscore zset $x] 735 if {$score >= $min} { 736 append err "Error, score for $x is $score >= $min\n" 737 } 738 } 739 foreach x $ok { 740 set score [r zscore zset $x] 741 if {$score < $min || $score > $max} { 742 append err "Error, score for $x is $score outside $min-$max range\n" 743 } 744 } 745 foreach x $okx { 746 set score [r zscore zset $x] 747 if {$score <= $min || $score >= $max} { 748 append err "Error, score for $x is $score outside $min-$max open range\n" 749 } 750 } 751 foreach x $high { 752 set score [r zscore zset $x] 753 if {$score < $max} { 754 append err "Error, score for $x is $score < $max\n" 755 } 756 } 757 foreach x $highx { 758 set score [r zscore zset $x] 759 if {$score <= $max} { 760 append err "Error, score for $x is $score <= $max\n" 761 } 762 } 763 } 764 assert_equal {} $err 765 } 766 767 test "ZRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 768 set lexset {} 769 r del zset 770 for {set j 0} {$j < $elements} {incr j} { 771 set e [randstring 0 30 alpha] 772 lappend lexset $e 773 r zadd zset 0 $e 774 } 775 set lexset [lsort -unique $lexset] 776 for {set j 0} {$j < 100} {incr j} { 777 set min [randstring 0 30 alpha] 778 set max [randstring 0 30 alpha] 779 set mininc [randomInt 2] 780 set maxinc [randomInt 2] 781 if {$mininc} {set cmin "\[$min"} else {set cmin "($min"} 782 if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"} 783 set rev [randomInt 2] 784 if {$rev} { 785 set cmd zrevrangebylex 786 } else { 787 set cmd zrangebylex 788 } 789 790 # Make sure data is the same in both sides 791 assert {[r zrange zset 0 -1] eq $lexset} 792 793 # Get the Redis output 794 set output [r $cmd zset $cmin $cmax] 795 if {$rev} { 796 set outlen [r zlexcount zset $cmax $cmin] 797 } else { 798 set outlen [r zlexcount zset $cmin $cmax] 799 } 800 801 # Compute the same output via Tcl 802 set o {} 803 set copy $lexset 804 if {(!$rev && [string compare $min $max] > 0) || 805 ($rev && [string compare $max $min] > 0)} { 806 # Empty output when ranges are inverted. 807 } else { 808 if {$rev} { 809 # Invert the Tcl array using Redis itself. 810 set copy [r zrevrange zset 0 -1] 811 # Invert min / max as well 812 lassign [list $min $max $mininc $maxinc] \ 813 max min maxinc mininc 814 } 815 foreach e $copy { 816 set mincmp [string compare $e $min] 817 set maxcmp [string compare $e $max] 818 if { 819 ($mininc && $mincmp >= 0 || !$mininc && $mincmp > 0) 820 && 821 ($maxinc && $maxcmp <= 0 || !$maxinc && $maxcmp < 0) 822 } { 823 lappend o $e 824 } 825 } 826 } 827 assert {$o eq $output} 828 assert {$outlen eq [llength $output]} 829 } 830 } 831 832 test "ZREMRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 833 set lexset {} 834 r del zset zsetcopy 835 for {set j 0} {$j < $elements} {incr j} { 836 set e [randstring 0 30 alpha] 837 lappend lexset $e 838 r zadd zset 0 $e 839 } 840 set lexset [lsort -unique $lexset] 841 for {set j 0} {$j < 100} {incr j} { 842 # Copy... 843 r zunionstore zsetcopy 1 zset 844 set lexsetcopy $lexset 845 846 set min [randstring 0 30 alpha] 847 set max [randstring 0 30 alpha] 848 set mininc [randomInt 2] 849 set maxinc [randomInt 2] 850 if {$mininc} {set cmin "\[$min"} else {set cmin "($min"} 851 if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"} 852 853 # Make sure data is the same in both sides 854 assert {[r zrange zset 0 -1] eq $lexset} 855 856 # Get the range we are going to remove 857 set torem [r zrangebylex zset $cmin $cmax] 858 set toremlen [r zlexcount zset $cmin $cmax] 859 r zremrangebylex zsetcopy $cmin $cmax 860 set output [r zrange zsetcopy 0 -1] 861 862 # Remove the range with Tcl from the original list 863 if {$toremlen} { 864 set first [lsearch -exact $lexsetcopy [lindex $torem 0]] 865 set last [expr {$first+$toremlen-1}] 866 set lexsetcopy [lreplace $lexsetcopy $first $last] 867 } 868 assert {$lexsetcopy eq $output} 869 } 870 } 871 872 test "ZSETs skiplist implementation backlink consistency test - $encoding" { 873 set diff 0 874 for {set j 0} {$j < $elements} {incr j} { 875 r zadd myzset [expr rand()] "Element-$j" 876 r zrem myzset "Element-[expr int(rand()*$elements)]" 877 } 878 879 assert_encoding $encoding myzset 880 set l1 [r zrange myzset 0 -1] 881 set l2 [r zrevrange myzset 0 -1] 882 for {set j 0} {$j < [llength $l1]} {incr j} { 883 if {[lindex $l1 $j] ne [lindex $l2 end-$j]} { 884 incr diff 885 } 886 } 887 assert_equal 0 $diff 888 } 889 890 test "ZSETs ZRANK augmented skip list stress testing - $encoding" { 891 set err {} 892 r del myzset 893 for {set k 0} {$k < 2000} {incr k} { 894 set i [expr {$k % $elements}] 895 if {[expr rand()] < .2} { 896 r zrem myzset $i 897 } else { 898 set score [expr rand()] 899 r zadd myzset $score $i 900 assert_encoding $encoding myzset 901 } 902 903 set card [r zcard myzset] 904 if {$card > 0} { 905 set index [randomInt $card] 906 set ele [lindex [r zrange myzset $index $index] 0] 907 set rank [r zrank myzset $ele] 908 if {$rank != $index} { 909 set err "$ele RANK is wrong! ($rank != $index)" 910 break 911 } 912 } 913 } 914 assert_equal {} $err 915 } 916 } 917 918 tags {"slow"} { 919 stressers ziplist 920 stressers skiplist 921 } 922} 923