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 set original_max_entries [lindex [r config get zset-max-ziplist-entries] 1] 11 set original_max_value [lindex [r config get zset-max-ziplist-value] 1] 12 if {$encoding == "ziplist"} { 13 r config set zset-max-ziplist-entries 128 14 r config set zset-max-ziplist-value 64 15 } elseif {$encoding == "skiplist"} { 16 r config set zset-max-ziplist-entries 0 17 r config set zset-max-ziplist-value 0 18 } else { 19 puts "Unknown sorted set encoding" 20 exit 21 } 22 23 test "Check encoding - $encoding" { 24 r del ztmp 25 r zadd ztmp 10 x 26 assert_encoding $encoding ztmp 27 } 28 29 test "ZSET basic ZADD and score update - $encoding" { 30 r del ztmp 31 r zadd ztmp 10 x 32 r zadd ztmp 20 y 33 r zadd ztmp 30 z 34 assert_equal {x y z} [r zrange ztmp 0 -1] 35 36 r zadd ztmp 1 y 37 assert_equal {y x z} [r zrange ztmp 0 -1] 38 } 39 40 test "ZSET element can't be set to NaN with ZADD - $encoding" { 41 assert_error "*not*float*" {r zadd myzset nan abc} 42 } 43 44 test "ZSET element can't be set to NaN with ZINCRBY" { 45 assert_error "*not*float*" {r zadd myzset nan abc} 46 } 47 48 test "ZADD with options syntax error with incomplete pair" { 49 r del ztmp 50 catch {r zadd ztmp xx 10 x 20} err 51 set err 52 } {ERR*} 53 54 test "ZADD XX option without key - $encoding" { 55 r del ztmp 56 assert {[r zadd ztmp xx 10 x] == 0} 57 assert {[r type ztmp] eq {none}} 58 } 59 60 test "ZADD XX existing key - $encoding" { 61 r del ztmp 62 r zadd ztmp 10 x 63 assert {[r zadd ztmp xx 20 y] == 0} 64 assert {[r zcard ztmp] == 1} 65 } 66 67 test "ZADD XX returns the number of elements actually added" { 68 r del ztmp 69 r zadd ztmp 10 x 70 set retval [r zadd ztmp 10 x 20 y 30 z] 71 assert {$retval == 2} 72 } 73 74 test "ZADD XX updates existing elements score" { 75 r del ztmp 76 r zadd ztmp 10 x 20 y 30 z 77 r zadd ztmp xx 5 foo 11 x 21 y 40 zap 78 assert {[r zcard ztmp] == 3} 79 assert {[r zscore ztmp x] == 11} 80 assert {[r zscore ztmp y] == 21} 81 } 82 83 test "ZADD XX and NX are not compatible" { 84 r del ztmp 85 catch {r zadd ztmp xx nx 10 x} err 86 set err 87 } {ERR*} 88 89 test "ZADD NX with non existing key" { 90 r del ztmp 91 r zadd ztmp nx 10 x 20 y 30 z 92 assert {[r zcard ztmp] == 3} 93 } 94 95 test "ZADD NX only add new elements without updating old ones" { 96 r del ztmp 97 r zadd ztmp 10 x 20 y 30 z 98 assert {[r zadd ztmp nx 11 x 21 y 100 a 200 b] == 2} 99 assert {[r zscore ztmp x] == 10} 100 assert {[r zscore ztmp y] == 20} 101 assert {[r zscore ztmp a] == 100} 102 assert {[r zscore ztmp b] == 200} 103 } 104 105 test "ZADD INCR works like ZINCRBY" { 106 r del ztmp 107 r zadd ztmp 10 x 20 y 30 z 108 r zadd ztmp INCR 15 x 109 assert {[r zscore ztmp x] == 25} 110 } 111 112 test "ZADD INCR works with a single score-elemenet pair" { 113 r del ztmp 114 r zadd ztmp 10 x 20 y 30 z 115 catch {r zadd ztmp INCR 15 x 10 y} err 116 set err 117 } {ERR*} 118 119 test "ZADD CH option changes return value to all changed elements" { 120 r del ztmp 121 r zadd ztmp 10 x 20 y 30 z 122 assert {[r zadd ztmp 11 x 21 y 30 z] == 0} 123 assert {[r zadd ztmp ch 12 x 22 y 30 z] == 2} 124 } 125 126 test "ZINCRBY calls leading to NaN result in error" { 127 r zincrby myzset +inf abc 128 assert_error "*NaN*" {r zincrby myzset -inf abc} 129 } 130 131 test {ZADD - Variadic version base case} { 132 r del myzset 133 list [r zadd myzset 10 a 20 b 30 c] [r zrange myzset 0 -1 withscores] 134 } {3 {a 10 b 20 c 30}} 135 136 test {ZADD - Return value is the number of actually added items} { 137 list [r zadd myzset 5 x 20 b 30 c] [r zrange myzset 0 -1 withscores] 138 } {1 {x 5 a 10 b 20 c 30}} 139 140 test {ZADD - Variadic version does not add nothing on single parsing err} { 141 r del myzset 142 catch {r zadd myzset 10 a 20 b 30.badscore c} e 143 assert_match {*ERR*not*float*} $e 144 r exists myzset 145 } {0} 146 147 test {ZADD - Variadic version will raise error on missing arg} { 148 r del myzset 149 catch {r zadd myzset 10 a 20 b 30 c 40} e 150 assert_match {*ERR*syntax*} $e 151 } 152 153 test {ZINCRBY does not work variadic even if shares ZADD implementation} { 154 r del myzset 155 catch {r zincrby myzset 10 a 20 b 30 c} e 156 assert_match {*ERR*wrong*number*arg*} $e 157 } 158 159 test "ZCARD basics - $encoding" { 160 r del ztmp 161 r zadd ztmp 10 a 20 b 30 c 162 assert_equal 3 [r zcard ztmp] 163 assert_equal 0 [r zcard zdoesntexist] 164 } 165 166 test "ZREM removes key after last element is removed" { 167 r del ztmp 168 r zadd ztmp 10 x 169 r zadd ztmp 20 y 170 171 assert_equal 1 [r exists ztmp] 172 assert_equal 0 [r zrem ztmp z] 173 assert_equal 1 [r zrem ztmp y] 174 assert_equal 1 [r zrem ztmp x] 175 assert_equal 0 [r exists ztmp] 176 } 177 178 test "ZREM variadic version" { 179 r del ztmp 180 r zadd ztmp 10 a 20 b 30 c 181 assert_equal 2 [r zrem ztmp x y a b k] 182 assert_equal 0 [r zrem ztmp foo bar] 183 assert_equal 1 [r zrem ztmp c] 184 r exists ztmp 185 } {0} 186 187 test "ZREM variadic version -- remove elements after key deletion" { 188 r del ztmp 189 r zadd ztmp 10 a 20 b 30 c 190 r zrem ztmp a b c d e f g 191 } {3} 192 193 test "ZRANGE basics - $encoding" { 194 r del ztmp 195 r zadd ztmp 1 a 196 r zadd ztmp 2 b 197 r zadd ztmp 3 c 198 r zadd ztmp 4 d 199 200 assert_equal {a b c d} [r zrange ztmp 0 -1] 201 assert_equal {a b c} [r zrange ztmp 0 -2] 202 assert_equal {b c d} [r zrange ztmp 1 -1] 203 assert_equal {b c} [r zrange ztmp 1 -2] 204 assert_equal {c d} [r zrange ztmp -2 -1] 205 assert_equal {c} [r zrange ztmp -2 -2] 206 207 # out of range start index 208 assert_equal {a b c} [r zrange ztmp -5 2] 209 assert_equal {a b} [r zrange ztmp -5 1] 210 assert_equal {} [r zrange ztmp 5 -1] 211 assert_equal {} [r zrange ztmp 5 -2] 212 213 # out of range end index 214 assert_equal {a b c d} [r zrange ztmp 0 5] 215 assert_equal {b c d} [r zrange ztmp 1 5] 216 assert_equal {} [r zrange ztmp 0 -5] 217 assert_equal {} [r zrange ztmp 1 -5] 218 219 # withscores 220 assert_equal {a 1 b 2 c 3 d 4} [r zrange ztmp 0 -1 withscores] 221 } 222 223 test "ZREVRANGE basics - $encoding" { 224 r del ztmp 225 r zadd ztmp 1 a 226 r zadd ztmp 2 b 227 r zadd ztmp 3 c 228 r zadd ztmp 4 d 229 230 assert_equal {d c b a} [r zrevrange ztmp 0 -1] 231 assert_equal {d c b} [r zrevrange ztmp 0 -2] 232 assert_equal {c b a} [r zrevrange ztmp 1 -1] 233 assert_equal {c b} [r zrevrange ztmp 1 -2] 234 assert_equal {b a} [r zrevrange ztmp -2 -1] 235 assert_equal {b} [r zrevrange ztmp -2 -2] 236 237 # out of range start index 238 assert_equal {d c b} [r zrevrange ztmp -5 2] 239 assert_equal {d c} [r zrevrange ztmp -5 1] 240 assert_equal {} [r zrevrange ztmp 5 -1] 241 assert_equal {} [r zrevrange ztmp 5 -2] 242 243 # out of range end index 244 assert_equal {d c b a} [r zrevrange ztmp 0 5] 245 assert_equal {c b a} [r zrevrange ztmp 1 5] 246 assert_equal {} [r zrevrange ztmp 0 -5] 247 assert_equal {} [r zrevrange ztmp 1 -5] 248 249 # withscores 250 assert_equal {d 4 c 3 b 2 a 1} [r zrevrange ztmp 0 -1 withscores] 251 } 252 253 test "ZRANK/ZREVRANK basics - $encoding" { 254 r del zranktmp 255 r zadd zranktmp 10 x 256 r zadd zranktmp 20 y 257 r zadd zranktmp 30 z 258 assert_equal 0 [r zrank zranktmp x] 259 assert_equal 1 [r zrank zranktmp y] 260 assert_equal 2 [r zrank zranktmp z] 261 assert_equal "" [r zrank zranktmp foo] 262 assert_equal 2 [r zrevrank zranktmp x] 263 assert_equal 1 [r zrevrank zranktmp y] 264 assert_equal 0 [r zrevrank zranktmp z] 265 assert_equal "" [r zrevrank zranktmp foo] 266 } 267 268 test "ZRANK - after deletion - $encoding" { 269 r zrem zranktmp y 270 assert_equal 0 [r zrank zranktmp x] 271 assert_equal 1 [r zrank zranktmp z] 272 } 273 274 test "ZINCRBY - can create a new sorted set - $encoding" { 275 r del zset 276 r zincrby zset 1 foo 277 assert_equal {foo} [r zrange zset 0 -1] 278 assert_equal 1 [r zscore zset foo] 279 } 280 281 test "ZINCRBY - increment and decrement - $encoding" { 282 r zincrby zset 2 foo 283 r zincrby zset 1 bar 284 assert_equal {bar foo} [r zrange zset 0 -1] 285 286 r zincrby zset 10 bar 287 r zincrby zset -5 foo 288 r zincrby zset -5 bar 289 assert_equal {foo bar} [r zrange zset 0 -1] 290 291 assert_equal -2 [r zscore zset foo] 292 assert_equal 6 [r zscore zset bar] 293 } 294 295 test "ZINCRBY return value" { 296 r del ztmp 297 set retval [r zincrby ztmp 1.0 x] 298 assert {$retval == 1.0} 299 } 300 301 proc create_default_zset {} { 302 create_zset zset {-inf a 1 b 2 c 3 d 4 e 5 f +inf g} 303 } 304 305 test "ZRANGEBYSCORE/ZREVRANGEBYSCORE/ZCOUNT basics" { 306 create_default_zset 307 308 # inclusive range 309 assert_equal {a b c} [r zrangebyscore zset -inf 2] 310 assert_equal {b c d} [r zrangebyscore zset 0 3] 311 assert_equal {d e f} [r zrangebyscore zset 3 6] 312 assert_equal {e f g} [r zrangebyscore zset 4 +inf] 313 assert_equal {c b a} [r zrevrangebyscore zset 2 -inf] 314 assert_equal {d c b} [r zrevrangebyscore zset 3 0] 315 assert_equal {f e d} [r zrevrangebyscore zset 6 3] 316 assert_equal {g f e} [r zrevrangebyscore zset +inf 4] 317 assert_equal 3 [r zcount zset 0 3] 318 319 # exclusive range 320 assert_equal {b} [r zrangebyscore zset (-inf (2] 321 assert_equal {b c} [r zrangebyscore zset (0 (3] 322 assert_equal {e f} [r zrangebyscore zset (3 (6] 323 assert_equal {f} [r zrangebyscore zset (4 (+inf] 324 assert_equal {b} [r zrevrangebyscore zset (2 (-inf] 325 assert_equal {c b} [r zrevrangebyscore zset (3 (0] 326 assert_equal {f e} [r zrevrangebyscore zset (6 (3] 327 assert_equal {f} [r zrevrangebyscore zset (+inf (4] 328 assert_equal 2 [r zcount zset (0 (3] 329 330 # test empty ranges 331 r zrem zset a 332 r zrem zset g 333 334 # inclusive 335 assert_equal {} [r zrangebyscore zset 4 2] 336 assert_equal {} [r zrangebyscore zset 6 +inf] 337 assert_equal {} [r zrangebyscore zset -inf -6] 338 assert_equal {} [r zrevrangebyscore zset +inf 6] 339 assert_equal {} [r zrevrangebyscore zset -6 -inf] 340 341 # exclusive 342 assert_equal {} [r zrangebyscore zset (4 (2] 343 assert_equal {} [r zrangebyscore zset 2 (2] 344 assert_equal {} [r zrangebyscore zset (2 2] 345 assert_equal {} [r zrangebyscore zset (6 (+inf] 346 assert_equal {} [r zrangebyscore zset (-inf (-6] 347 assert_equal {} [r zrevrangebyscore zset (+inf (6] 348 assert_equal {} [r zrevrangebyscore zset (-6 (-inf] 349 350 # empty inner range 351 assert_equal {} [r zrangebyscore zset 2.4 2.6] 352 assert_equal {} [r zrangebyscore zset (2.4 2.6] 353 assert_equal {} [r zrangebyscore zset 2.4 (2.6] 354 assert_equal {} [r zrangebyscore zset (2.4 (2.6] 355 } 356 357 test "ZRANGEBYSCORE with WITHSCORES" { 358 create_default_zset 359 assert_equal {b 1 c 2 d 3} [r zrangebyscore zset 0 3 withscores] 360 assert_equal {d 3 c 2 b 1} [r zrevrangebyscore zset 3 0 withscores] 361 } 362 363 test "ZRANGEBYSCORE with LIMIT" { 364 create_default_zset 365 assert_equal {b c} [r zrangebyscore zset 0 10 LIMIT 0 2] 366 assert_equal {d e f} [r zrangebyscore zset 0 10 LIMIT 2 3] 367 assert_equal {d e f} [r zrangebyscore zset 0 10 LIMIT 2 10] 368 assert_equal {} [r zrangebyscore zset 0 10 LIMIT 20 10] 369 assert_equal {f e} [r zrevrangebyscore zset 10 0 LIMIT 0 2] 370 assert_equal {d c b} [r zrevrangebyscore zset 10 0 LIMIT 2 3] 371 assert_equal {d c b} [r zrevrangebyscore zset 10 0 LIMIT 2 10] 372 assert_equal {} [r zrevrangebyscore zset 10 0 LIMIT 20 10] 373 } 374 375 test "ZRANGEBYSCORE with LIMIT and WITHSCORES" { 376 create_default_zset 377 assert_equal {e 4 f 5} [r zrangebyscore zset 2 5 LIMIT 2 3 WITHSCORES] 378 assert_equal {d 3 c 2} [r zrevrangebyscore zset 5 2 LIMIT 2 3 WITHSCORES] 379 } 380 381 test "ZRANGEBYSCORE with non-value min or max" { 382 assert_error "*not*float*" {r zrangebyscore fooz str 1} 383 assert_error "*not*float*" {r zrangebyscore fooz 1 str} 384 assert_error "*not*float*" {r zrangebyscore fooz 1 NaN} 385 } 386 387 proc create_default_lex_zset {} { 388 create_zset zset {0 alpha 0 bar 0 cool 0 down 389 0 elephant 0 foo 0 great 0 hill 390 0 omega} 391 } 392 393 test "ZRANGEBYLEX/ZREVRANGEBYLEX/ZLEXCOUNT basics" { 394 create_default_lex_zset 395 396 # inclusive range 397 assert_equal {alpha bar cool} [r zrangebylex zset - \[cool] 398 assert_equal {bar cool down} [r zrangebylex zset \[bar \[down] 399 assert_equal {great hill omega} [r zrangebylex zset \[g +] 400 assert_equal {cool bar alpha} [r zrevrangebylex zset \[cool -] 401 assert_equal {down cool bar} [r zrevrangebylex zset \[down \[bar] 402 assert_equal {omega hill great foo elephant down} [r zrevrangebylex zset + \[d] 403 assert_equal 3 [r zlexcount zset \[ele \[h] 404 405 # exclusive range 406 assert_equal {alpha bar} [r zrangebylex zset - (cool] 407 assert_equal {cool} [r zrangebylex zset (bar (down] 408 assert_equal {hill omega} [r zrangebylex zset (great +] 409 assert_equal {bar alpha} [r zrevrangebylex zset (cool -] 410 assert_equal {cool} [r zrevrangebylex zset (down (bar] 411 assert_equal {omega hill} [r zrevrangebylex zset + (great] 412 assert_equal 2 [r zlexcount zset (ele (great] 413 414 # inclusive and exclusive 415 assert_equal {} [r zrangebylex zset (az (b] 416 assert_equal {} [r zrangebylex zset (z +] 417 assert_equal {} [r zrangebylex zset - \[aaaa] 418 assert_equal {} [r zrevrangebylex zset \[elez \[elex] 419 assert_equal {} [r zrevrangebylex zset (hill (omega] 420 } 421 422 test "ZLEXCOUNT advanced" { 423 create_default_lex_zset 424 425 assert_equal 9 [r zlexcount zset - +] 426 assert_equal 0 [r zlexcount zset + -] 427 assert_equal 0 [r zlexcount zset + \[c] 428 assert_equal 0 [r zlexcount zset \[c -] 429 assert_equal 8 [r zlexcount zset \[bar +] 430 assert_equal 5 [r zlexcount zset \[bar \[foo] 431 assert_equal 4 [r zlexcount zset \[bar (foo] 432 assert_equal 4 [r zlexcount zset (bar \[foo] 433 assert_equal 3 [r zlexcount zset (bar (foo] 434 assert_equal 5 [r zlexcount zset - (foo] 435 assert_equal 1 [r zlexcount zset (maxstring +] 436 } 437 438 test "ZRANGEBYSLEX with LIMIT" { 439 create_default_lex_zset 440 assert_equal {alpha bar} [r zrangebylex zset - \[cool LIMIT 0 2] 441 assert_equal {bar cool} [r zrangebylex zset - \[cool LIMIT 1 2] 442 assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 0 0] 443 assert_equal {} [r zrangebylex zset \[bar \[down LIMIT 2 0] 444 assert_equal {bar} [r zrangebylex zset \[bar \[down LIMIT 0 1] 445 assert_equal {cool} [r zrangebylex zset \[bar \[down LIMIT 1 1] 446 assert_equal {bar cool down} [r zrangebylex zset \[bar \[down LIMIT 0 100] 447 assert_equal {omega hill great foo elephant} [r zrevrangebylex zset + \[d LIMIT 0 5] 448 assert_equal {omega hill great foo} [r zrevrangebylex zset + \[d LIMIT 0 4] 449 } 450 451 test "ZRANGEBYLEX with invalid lex range specifiers" { 452 assert_error "*not*string*" {r zrangebylex fooz foo bar} 453 assert_error "*not*string*" {r zrangebylex fooz \[foo bar} 454 assert_error "*not*string*" {r zrangebylex fooz foo \[bar} 455 assert_error "*not*string*" {r zrangebylex fooz +x \[bar} 456 assert_error "*not*string*" {r zrangebylex fooz -x \[bar} 457 } 458 459 test "ZREMRANGEBYSCORE basics" { 460 proc remrangebyscore {min max} { 461 create_zset zset {1 a 2 b 3 c 4 d 5 e} 462 assert_equal 1 [r exists zset] 463 r zremrangebyscore zset $min $max 464 } 465 466 # inner range 467 assert_equal 3 [remrangebyscore 2 4] 468 assert_equal {a e} [r zrange zset 0 -1] 469 470 # start underflow 471 assert_equal 1 [remrangebyscore -10 1] 472 assert_equal {b c d e} [r zrange zset 0 -1] 473 474 # end overflow 475 assert_equal 1 [remrangebyscore 5 10] 476 assert_equal {a b c d} [r zrange zset 0 -1] 477 478 # switch min and max 479 assert_equal 0 [remrangebyscore 4 2] 480 assert_equal {a b c d e} [r zrange zset 0 -1] 481 482 # -inf to mid 483 assert_equal 3 [remrangebyscore -inf 3] 484 assert_equal {d e} [r zrange zset 0 -1] 485 486 # mid to +inf 487 assert_equal 3 [remrangebyscore 3 +inf] 488 assert_equal {a b} [r zrange zset 0 -1] 489 490 # -inf to +inf 491 assert_equal 5 [remrangebyscore -inf +inf] 492 assert_equal {} [r zrange zset 0 -1] 493 494 # exclusive min 495 assert_equal 4 [remrangebyscore (1 5] 496 assert_equal {a} [r zrange zset 0 -1] 497 assert_equal 3 [remrangebyscore (2 5] 498 assert_equal {a b} [r zrange zset 0 -1] 499 500 # exclusive max 501 assert_equal 4 [remrangebyscore 1 (5] 502 assert_equal {e} [r zrange zset 0 -1] 503 assert_equal 3 [remrangebyscore 1 (4] 504 assert_equal {d e} [r zrange zset 0 -1] 505 506 # exclusive min and max 507 assert_equal 3 [remrangebyscore (1 (5] 508 assert_equal {a e} [r zrange zset 0 -1] 509 510 # destroy when empty 511 assert_equal 5 [remrangebyscore 1 5] 512 assert_equal 0 [r exists zset] 513 } 514 515 test "ZREMRANGEBYSCORE with non-value min or max" { 516 assert_error "*not*float*" {r zremrangebyscore fooz str 1} 517 assert_error "*not*float*" {r zremrangebyscore fooz 1 str} 518 assert_error "*not*float*" {r zremrangebyscore fooz 1 NaN} 519 } 520 521 test "ZREMRANGEBYRANK basics" { 522 proc remrangebyrank {min max} { 523 create_zset zset {1 a 2 b 3 c 4 d 5 e} 524 assert_equal 1 [r exists zset] 525 r zremrangebyrank zset $min $max 526 } 527 528 # inner range 529 assert_equal 3 [remrangebyrank 1 3] 530 assert_equal {a e} [r zrange zset 0 -1] 531 532 # start underflow 533 assert_equal 1 [remrangebyrank -10 0] 534 assert_equal {b c d e} [r zrange zset 0 -1] 535 536 # start overflow 537 assert_equal 0 [remrangebyrank 10 -1] 538 assert_equal {a b c d e} [r zrange zset 0 -1] 539 540 # end underflow 541 assert_equal 0 [remrangebyrank 0 -10] 542 assert_equal {a b c d e} [r zrange zset 0 -1] 543 544 # end overflow 545 assert_equal 5 [remrangebyrank 0 10] 546 assert_equal {} [r zrange zset 0 -1] 547 548 # destroy when empty 549 assert_equal 5 [remrangebyrank 0 4] 550 assert_equal 0 [r exists zset] 551 } 552 553 test "ZUNIONSTORE against non-existing key doesn't set destination - $encoding" { 554 r del zseta 555 assert_equal 0 [r zunionstore dst_key 1 zseta] 556 assert_equal 0 [r exists dst_key] 557 } 558 559 test "ZUNIONSTORE with empty set - $encoding" { 560 r del zseta zsetb 561 r zadd zseta 1 a 562 r zadd zseta 2 b 563 r zunionstore zsetc 2 zseta zsetb 564 r zrange zsetc 0 -1 withscores 565 } {a 1 b 2} 566 567 test "ZUNIONSTORE basics - $encoding" { 568 r del zseta zsetb zsetc 569 r zadd zseta 1 a 570 r zadd zseta 2 b 571 r zadd zseta 3 c 572 r zadd zsetb 1 b 573 r zadd zsetb 2 c 574 r zadd zsetb 3 d 575 576 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb] 577 assert_equal {a 1 b 3 d 3 c 5} [r zrange zsetc 0 -1 withscores] 578 } 579 580 test "ZUNIONSTORE with weights - $encoding" { 581 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb weights 2 3] 582 assert_equal {a 2 b 7 d 9 c 12} [r zrange zsetc 0 -1 withscores] 583 } 584 585 test "ZUNIONSTORE with a regular set and weights - $encoding" { 586 r del seta 587 r sadd seta a 588 r sadd seta b 589 r sadd seta c 590 591 assert_equal 4 [r zunionstore zsetc 2 seta zsetb weights 2 3] 592 assert_equal {a 2 b 5 c 8 d 9} [r zrange zsetc 0 -1 withscores] 593 } 594 595 test "ZUNIONSTORE with AGGREGATE MIN - $encoding" { 596 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate min] 597 assert_equal {a 1 b 1 c 2 d 3} [r zrange zsetc 0 -1 withscores] 598 } 599 600 test "ZUNIONSTORE with AGGREGATE MAX - $encoding" { 601 assert_equal 4 [r zunionstore zsetc 2 zseta zsetb aggregate max] 602 assert_equal {a 1 b 2 c 3 d 3} [r zrange zsetc 0 -1 withscores] 603 } 604 605 test "ZINTERSTORE basics - $encoding" { 606 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb] 607 assert_equal {b 3 c 5} [r zrange zsetc 0 -1 withscores] 608 } 609 610 test "ZINTERSTORE with weights - $encoding" { 611 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb weights 2 3] 612 assert_equal {b 7 c 12} [r zrange zsetc 0 -1 withscores] 613 } 614 615 test "ZINTERSTORE with a regular set and weights - $encoding" { 616 r del seta 617 r sadd seta a 618 r sadd seta b 619 r sadd seta c 620 assert_equal 2 [r zinterstore zsetc 2 seta zsetb weights 2 3] 621 assert_equal {b 5 c 8} [r zrange zsetc 0 -1 withscores] 622 } 623 624 test "ZINTERSTORE with AGGREGATE MIN - $encoding" { 625 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate min] 626 assert_equal {b 1 c 2} [r zrange zsetc 0 -1 withscores] 627 } 628 629 test "ZINTERSTORE with AGGREGATE MAX - $encoding" { 630 assert_equal 2 [r zinterstore zsetc 2 zseta zsetb aggregate max] 631 assert_equal {b 2 c 3} [r zrange zsetc 0 -1 withscores] 632 } 633 634 foreach cmd {ZUNIONSTORE ZINTERSTORE} { 635 test "$cmd with +inf/-inf scores - $encoding" { 636 r del zsetinf1 zsetinf2 637 638 r zadd zsetinf1 +inf key 639 r zadd zsetinf2 +inf key 640 r $cmd zsetinf3 2 zsetinf1 zsetinf2 641 assert_equal inf [r zscore zsetinf3 key] 642 643 r zadd zsetinf1 -inf key 644 r zadd zsetinf2 +inf key 645 r $cmd zsetinf3 2 zsetinf1 zsetinf2 646 assert_equal 0 [r zscore zsetinf3 key] 647 648 r zadd zsetinf1 +inf key 649 r zadd zsetinf2 -inf key 650 r $cmd zsetinf3 2 zsetinf1 zsetinf2 651 assert_equal 0 [r zscore zsetinf3 key] 652 653 r zadd zsetinf1 -inf key 654 r zadd zsetinf2 -inf key 655 r $cmd zsetinf3 2 zsetinf1 zsetinf2 656 assert_equal -inf [r zscore zsetinf3 key] 657 } 658 659 test "$cmd with NaN weights $encoding" { 660 r del zsetinf1 zsetinf2 661 662 r zadd zsetinf1 1.0 key 663 r zadd zsetinf2 1.0 key 664 assert_error "*weight*not*float*" { 665 r $cmd zsetinf3 2 zsetinf1 zsetinf2 weights nan nan 666 } 667 } 668 } 669 670 test "Basic ZPOP with a single key - $encoding" { 671 r del zset 672 assert_equal {} [r zpopmin zset] 673 create_zset zset {-1 a 1 b 2 c 3 d 4 e} 674 assert_equal {a -1} [r zpopmin zset] 675 assert_equal {b 1} [r zpopmin zset] 676 assert_equal {e 4} [r zpopmax zset] 677 assert_equal {d 3} [r zpopmax zset] 678 assert_equal {c 2} [r zpopmin zset] 679 assert_equal 0 [r exists zset] 680 r set foo bar 681 assert_error "*WRONGTYPE*" {r zpopmin foo} 682 } 683 684 test "ZPOP with count - $encoding" { 685 r del z1 z2 z3 foo 686 r set foo bar 687 assert_equal {} [r zpopmin z1 2] 688 assert_error "*WRONGTYPE*" {r zpopmin foo 2} 689 create_zset z1 {0 a 1 b 2 c 3 d} 690 assert_equal {a 0 b 1} [r zpopmin z1 2] 691 assert_equal {d 3 c 2} [r zpopmax z1 2] 692 } 693 694 test "BZPOP with a single existing sorted set - $encoding" { 695 set rd [redis_deferring_client] 696 create_zset zset {0 a 1 b 2 c} 697 698 $rd bzpopmin zset 5 699 assert_equal {zset a 0} [$rd read] 700 $rd bzpopmin zset 5 701 assert_equal {zset b 1} [$rd read] 702 $rd bzpopmax zset 5 703 assert_equal {zset c 2} [$rd read] 704 assert_equal 0 [r exists zset] 705 } 706 707 test "BZPOP with multiple existing sorted sets - $encoding" { 708 set rd [redis_deferring_client] 709 create_zset z1 {0 a 1 b 2 c} 710 create_zset z2 {3 d 4 e 5 f} 711 712 $rd bzpopmin z1 z2 5 713 assert_equal {z1 a 0} [$rd read] 714 $rd bzpopmax z1 z2 5 715 assert_equal {z1 c 2} [$rd read] 716 assert_equal 1 [r zcard z1] 717 assert_equal 3 [r zcard z2] 718 719 $rd bzpopmax z2 z1 5 720 assert_equal {z2 f 5} [$rd read] 721 $rd bzpopmin z2 z1 5 722 assert_equal {z2 d 3} [$rd read] 723 assert_equal 1 [r zcard z1] 724 assert_equal 1 [r zcard z2] 725 } 726 727 test "BZPOP second sorted set has members - $encoding" { 728 set rd [redis_deferring_client] 729 r del z1 730 create_zset z2 {3 d 4 e 5 f} 731 $rd bzpopmax z1 z2 5 732 assert_equal {z2 f 5} [$rd read] 733 $rd bzpopmin z2 z1 5 734 assert_equal {z2 d 3} [$rd read] 735 assert_equal 0 [r zcard z1] 736 assert_equal 1 [r zcard z2] 737 } 738 739 r config set zset-max-ziplist-entries $original_max_entries 740 r config set zset-max-ziplist-value $original_max_value 741 742 test "Basic ZPOP - $encoding RESP3" { 743 r hello 3 744 r del z1 745 create_zset z1 {0 a 1 b 2 c 3 d} 746 assert_equal {a 0.0} [r zpopmin z1] 747 assert_equal {d 3.0} [r zpopmax z1] 748 r hello 2 749 } 750 751 test "ZPOP with count - $encoding RESP3" { 752 r hello 3 753 r del z1 754 create_zset z1 {0 a 1 b 2 c 3 d} 755 assert_equal {{a 0.0} {b 1.0}} [r zpopmin z1 2] 756 assert_equal {{d 3.0} {c 2.0}} [r zpopmax z1 2] 757 r hello 2 758 } 759 760 test "BZPOP - $encoding RESP3" { 761 r hello 3 762 set rd [redis_deferring_client] 763 create_zset zset {0 a 1 b 2 c} 764 765 $rd bzpopmin zset 5 766 assert_equal {zset a 0} [$rd read] 767 $rd bzpopmin zset 5 768 assert_equal {zset b 1} [$rd read] 769 $rd bzpopmax zset 5 770 assert_equal {zset c 2} [$rd read] 771 assert_equal 0 [r exists zset] 772 r hello 2 773 } 774 775 r config set zset-max-ziplist-entries $original_max_entries 776 r config set zset-max-ziplist-value $original_max_value 777 } 778 779 basics ziplist 780 basics skiplist 781 782 test {ZINTERSTORE regression with two sets, intset+hashtable} { 783 r del seta setb setc 784 r sadd set1 a 785 r sadd set2 10 786 r zinterstore set3 2 set1 set2 787 } {0} 788 789 test {ZUNIONSTORE regression, should not create NaN in scores} { 790 r zadd z -inf neginf 791 r zunionstore out 1 z weights 0 792 r zrange out 0 -1 withscores 793 } {neginf 0} 794 795 test {ZINTERSTORE #516 regression, mixed sets and ziplist zsets} { 796 r sadd one 100 101 102 103 797 r sadd two 100 200 201 202 798 r zadd three 1 500 1 501 1 502 1 503 1 100 799 r zinterstore to_here 3 one two three WEIGHTS 0 0 1 800 r zrange to_here 0 -1 801 } {100} 802 803 test {ZUNIONSTORE result is sorted} { 804 # Create two sets with common and not common elements, perform 805 # the UNION, check that elements are still sorted. 806 r del one two dest 807 set cmd1 [list r zadd one] 808 set cmd2 [list r zadd two] 809 for {set j 0} {$j < 1000} {incr j} { 810 lappend cmd1 [expr rand()] [randomInt 1000] 811 lappend cmd2 [expr rand()] [randomInt 1000] 812 } 813 {*}$cmd1 814 {*}$cmd2 815 assert {[r zcard one] > 100} 816 assert {[r zcard two] > 100} 817 r zunionstore dest 2 one two 818 set oldscore 0 819 foreach {ele score} [r zrange dest 0 -1 withscores] { 820 assert {$score >= $oldscore} 821 set oldscore $score 822 } 823 } 824 825 test "ZSET commands don't accept the empty strings as valid score" { 826 assert_error "*not*float*" {r zadd myzset "" abc} 827 } 828 829 proc stressers {encoding} { 830 if {$encoding == "ziplist"} { 831 # Little extra to allow proper fuzzing in the sorting stresser 832 r config set zset-max-ziplist-entries 256 833 r config set zset-max-ziplist-value 64 834 set elements 128 835 } elseif {$encoding == "skiplist"} { 836 r config set zset-max-ziplist-entries 0 837 r config set zset-max-ziplist-value 0 838 if {$::accurate} {set elements 1000} else {set elements 100} 839 } else { 840 puts "Unknown sorted set encoding" 841 exit 842 } 843 844 test "ZSCORE - $encoding" { 845 r del zscoretest 846 set aux {} 847 for {set i 0} {$i < $elements} {incr i} { 848 set score [expr rand()] 849 lappend aux $score 850 r zadd zscoretest $score $i 851 } 852 853 assert_encoding $encoding zscoretest 854 for {set i 0} {$i < $elements} {incr i} { 855 assert_equal [lindex $aux $i] [r zscore zscoretest $i] 856 } 857 } 858 859 test "ZSCORE after a DEBUG RELOAD - $encoding" { 860 r del zscoretest 861 set aux {} 862 for {set i 0} {$i < $elements} {incr i} { 863 set score [expr rand()] 864 lappend aux $score 865 r zadd zscoretest $score $i 866 } 867 868 r debug reload 869 assert_encoding $encoding zscoretest 870 for {set i 0} {$i < $elements} {incr i} { 871 assert_equal [lindex $aux $i] [r zscore zscoretest $i] 872 } 873 } 874 875 test "ZSET sorting stresser - $encoding" { 876 set delta 0 877 for {set test 0} {$test < 2} {incr test} { 878 unset -nocomplain auxarray 879 array set auxarray {} 880 set auxlist {} 881 r del myzset 882 for {set i 0} {$i < $elements} {incr i} { 883 if {$test == 0} { 884 set score [expr rand()] 885 } else { 886 set score [expr int(rand()*10)] 887 } 888 set auxarray($i) $score 889 r zadd myzset $score $i 890 # Random update 891 if {[expr rand()] < .2} { 892 set j [expr int(rand()*1000)] 893 if {$test == 0} { 894 set score [expr rand()] 895 } else { 896 set score [expr int(rand()*10)] 897 } 898 set auxarray($j) $score 899 r zadd myzset $score $j 900 } 901 } 902 foreach {item score} [array get auxarray] { 903 lappend auxlist [list $score $item] 904 } 905 set sorted [lsort -command zlistAlikeSort $auxlist] 906 set auxlist {} 907 foreach x $sorted { 908 lappend auxlist [lindex $x 1] 909 } 910 911 assert_encoding $encoding myzset 912 set fromredis [r zrange myzset 0 -1] 913 set delta 0 914 for {set i 0} {$i < [llength $fromredis]} {incr i} { 915 if {[lindex $fromredis $i] != [lindex $auxlist $i]} { 916 incr delta 917 } 918 } 919 } 920 assert_equal 0 $delta 921 } 922 923 test "ZRANGEBYSCORE fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 924 set err {} 925 r del zset 926 for {set i 0} {$i < $elements} {incr i} { 927 r zadd zset [expr rand()] $i 928 } 929 930 assert_encoding $encoding zset 931 for {set i 0} {$i < 100} {incr i} { 932 set min [expr rand()] 933 set max [expr rand()] 934 if {$min > $max} { 935 set aux $min 936 set min $max 937 set max $aux 938 } 939 set low [r zrangebyscore zset -inf $min] 940 set ok [r zrangebyscore zset $min $max] 941 set high [r zrangebyscore zset $max +inf] 942 set lowx [r zrangebyscore zset -inf ($min] 943 set okx [r zrangebyscore zset ($min ($max] 944 set highx [r zrangebyscore zset ($max +inf] 945 946 if {[r zcount zset -inf $min] != [llength $low]} { 947 append err "Error, len does not match zcount\n" 948 } 949 if {[r zcount zset $min $max] != [llength $ok]} { 950 append err "Error, len does not match zcount\n" 951 } 952 if {[r zcount zset $max +inf] != [llength $high]} { 953 append err "Error, len does not match zcount\n" 954 } 955 if {[r zcount zset -inf ($min] != [llength $lowx]} { 956 append err "Error, len does not match zcount\n" 957 } 958 if {[r zcount zset ($min ($max] != [llength $okx]} { 959 append err "Error, len does not match zcount\n" 960 } 961 if {[r zcount zset ($max +inf] != [llength $highx]} { 962 append err "Error, len does not match zcount\n" 963 } 964 965 foreach x $low { 966 set score [r zscore zset $x] 967 if {$score > $min} { 968 append err "Error, score for $x is $score > $min\n" 969 } 970 } 971 foreach x $lowx { 972 set score [r zscore zset $x] 973 if {$score >= $min} { 974 append err "Error, score for $x is $score >= $min\n" 975 } 976 } 977 foreach x $ok { 978 set score [r zscore zset $x] 979 if {$score < $min || $score > $max} { 980 append err "Error, score for $x is $score outside $min-$max range\n" 981 } 982 } 983 foreach x $okx { 984 set score [r zscore zset $x] 985 if {$score <= $min || $score >= $max} { 986 append err "Error, score for $x is $score outside $min-$max open range\n" 987 } 988 } 989 foreach x $high { 990 set score [r zscore zset $x] 991 if {$score < $max} { 992 append err "Error, score for $x is $score < $max\n" 993 } 994 } 995 foreach x $highx { 996 set score [r zscore zset $x] 997 if {$score <= $max} { 998 append err "Error, score for $x is $score <= $max\n" 999 } 1000 } 1001 } 1002 assert_equal {} $err 1003 } 1004 1005 test "ZRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 1006 set lexset {} 1007 r del zset 1008 for {set j 0} {$j < $elements} {incr j} { 1009 set e [randstring 0 30 alpha] 1010 lappend lexset $e 1011 r zadd zset 0 $e 1012 } 1013 set lexset [lsort -unique $lexset] 1014 for {set j 0} {$j < 100} {incr j} { 1015 set min [randstring 0 30 alpha] 1016 set max [randstring 0 30 alpha] 1017 set mininc [randomInt 2] 1018 set maxinc [randomInt 2] 1019 if {$mininc} {set cmin "\[$min"} else {set cmin "($min"} 1020 if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"} 1021 set rev [randomInt 2] 1022 if {$rev} { 1023 set cmd zrevrangebylex 1024 } else { 1025 set cmd zrangebylex 1026 } 1027 1028 # Make sure data is the same in both sides 1029 assert {[r zrange zset 0 -1] eq $lexset} 1030 1031 # Get the Redis output 1032 set output [r $cmd zset $cmin $cmax] 1033 if {$rev} { 1034 set outlen [r zlexcount zset $cmax $cmin] 1035 } else { 1036 set outlen [r zlexcount zset $cmin $cmax] 1037 } 1038 1039 # Compute the same output via Tcl 1040 set o {} 1041 set copy $lexset 1042 if {(!$rev && [string compare $min $max] > 0) || 1043 ($rev && [string compare $max $min] > 0)} { 1044 # Empty output when ranges are inverted. 1045 } else { 1046 if {$rev} { 1047 # Invert the Tcl array using Redis itself. 1048 set copy [r zrevrange zset 0 -1] 1049 # Invert min / max as well 1050 lassign [list $min $max $mininc $maxinc] \ 1051 max min maxinc mininc 1052 } 1053 foreach e $copy { 1054 set mincmp [string compare $e $min] 1055 set maxcmp [string compare $e $max] 1056 if { 1057 ($mininc && $mincmp >= 0 || !$mininc && $mincmp > 0) 1058 && 1059 ($maxinc && $maxcmp <= 0 || !$maxinc && $maxcmp < 0) 1060 } { 1061 lappend o $e 1062 } 1063 } 1064 } 1065 assert {$o eq $output} 1066 assert {$outlen eq [llength $output]} 1067 } 1068 } 1069 1070 test "ZREMRANGEBYLEX fuzzy test, 100 ranges in $elements element sorted set - $encoding" { 1071 set lexset {} 1072 r del zset zsetcopy 1073 for {set j 0} {$j < $elements} {incr j} { 1074 set e [randstring 0 30 alpha] 1075 lappend lexset $e 1076 r zadd zset 0 $e 1077 } 1078 set lexset [lsort -unique $lexset] 1079 for {set j 0} {$j < 100} {incr j} { 1080 # Copy... 1081 r zunionstore zsetcopy 1 zset 1082 set lexsetcopy $lexset 1083 1084 set min [randstring 0 30 alpha] 1085 set max [randstring 0 30 alpha] 1086 set mininc [randomInt 2] 1087 set maxinc [randomInt 2] 1088 if {$mininc} {set cmin "\[$min"} else {set cmin "($min"} 1089 if {$maxinc} {set cmax "\[$max"} else {set cmax "($max"} 1090 1091 # Make sure data is the same in both sides 1092 assert {[r zrange zset 0 -1] eq $lexset} 1093 1094 # Get the range we are going to remove 1095 set torem [r zrangebylex zset $cmin $cmax] 1096 set toremlen [r zlexcount zset $cmin $cmax] 1097 r zremrangebylex zsetcopy $cmin $cmax 1098 set output [r zrange zsetcopy 0 -1] 1099 1100 # Remove the range with Tcl from the original list 1101 if {$toremlen} { 1102 set first [lsearch -exact $lexsetcopy [lindex $torem 0]] 1103 set last [expr {$first+$toremlen-1}] 1104 set lexsetcopy [lreplace $lexsetcopy $first $last] 1105 } 1106 assert {$lexsetcopy eq $output} 1107 } 1108 } 1109 1110 test "ZSETs skiplist implementation backlink consistency test - $encoding" { 1111 set diff 0 1112 for {set j 0} {$j < $elements} {incr j} { 1113 r zadd myzset [expr rand()] "Element-$j" 1114 r zrem myzset "Element-[expr int(rand()*$elements)]" 1115 } 1116 1117 assert_encoding $encoding myzset 1118 set l1 [r zrange myzset 0 -1] 1119 set l2 [r zrevrange myzset 0 -1] 1120 for {set j 0} {$j < [llength $l1]} {incr j} { 1121 if {[lindex $l1 $j] ne [lindex $l2 end-$j]} { 1122 incr diff 1123 } 1124 } 1125 assert_equal 0 $diff 1126 } 1127 1128 test "ZSETs ZRANK augmented skip list stress testing - $encoding" { 1129 set err {} 1130 r del myzset 1131 for {set k 0} {$k < 2000} {incr k} { 1132 set i [expr {$k % $elements}] 1133 if {[expr rand()] < .2} { 1134 r zrem myzset $i 1135 } else { 1136 set score [expr rand()] 1137 r zadd myzset $score $i 1138 assert_encoding $encoding myzset 1139 } 1140 1141 set card [r zcard myzset] 1142 if {$card > 0} { 1143 set index [randomInt $card] 1144 set ele [lindex [r zrange myzset $index $index] 0] 1145 set rank [r zrank myzset $ele] 1146 if {$rank != $index} { 1147 set err "$ele RANK is wrong! ($rank != $index)" 1148 break 1149 } 1150 } 1151 } 1152 assert_equal {} $err 1153 } 1154 1155 test "BZPOPMIN, ZADD + DEL should not awake blocked client" { 1156 set rd [redis_deferring_client] 1157 r del zset 1158 1159 $rd bzpopmin zset 0 1160 r multi 1161 r zadd zset 0 foo 1162 r del zset 1163 r exec 1164 r del zset 1165 r zadd zset 1 bar 1166 $rd read 1167 } {zset bar 1} 1168 1169 test "BZPOPMIN, ZADD + DEL + SET should not awake blocked client" { 1170 set rd [redis_deferring_client] 1171 r del list 1172 1173 r del zset 1174 1175 $rd bzpopmin zset 0 1176 r multi 1177 r zadd zset 0 foo 1178 r del zset 1179 r set zset foo 1180 r exec 1181 r del zset 1182 r zadd zset 1 bar 1183 $rd read 1184 } {zset bar 1} 1185 1186 test "BZPOPMIN with same key multiple times should work" { 1187 set rd [redis_deferring_client] 1188 r del z1 z2 1189 1190 # Data arriving after the BZPOPMIN. 1191 $rd bzpopmin z1 z2 z2 z1 0 1192 r zadd z1 0 a 1193 assert_equal [$rd read] {z1 a 0} 1194 $rd bzpopmin z1 z2 z2 z1 0 1195 r zadd z2 1 b 1196 assert_equal [$rd read] {z2 b 1} 1197 1198 # Data already there. 1199 r zadd z1 0 a 1200 r zadd z2 1 b 1201 $rd bzpopmin z1 z2 z2 z1 0 1202 assert_equal [$rd read] {z1 a 0} 1203 $rd bzpopmin z1 z2 z2 z1 0 1204 assert_equal [$rd read] {z2 b 1} 1205 } 1206 1207 test "MULTI/EXEC is isolated from the point of view of BZPOPMIN" { 1208 set rd [redis_deferring_client] 1209 r del zset 1210 $rd bzpopmin zset 0 1211 r multi 1212 r zadd zset 0 a 1213 r zadd zset 1 b 1214 r zadd zset 2 c 1215 r exec 1216 $rd read 1217 } {zset a 0} 1218 1219 test "BZPOPMIN with variadic ZADD" { 1220 set rd [redis_deferring_client] 1221 r del zset 1222 if {$::valgrind} {after 100} 1223 $rd bzpopmin zset 0 1224 if {$::valgrind} {after 100} 1225 assert_equal 2 [r zadd zset -1 foo 1 bar] 1226 if {$::valgrind} {after 100} 1227 assert_equal {zset foo -1} [$rd read] 1228 assert_equal {bar} [r zrange zset 0 -1] 1229 } 1230 1231 test "BZPOPMIN with zero timeout should block indefinitely" { 1232 set rd [redis_deferring_client] 1233 r del zset 1234 $rd bzpopmin zset 0 1235 after 1000 1236 r zadd zset 0 foo 1237 assert_equal {zset foo 0} [$rd read] 1238 } 1239 } 1240 1241 tags {"slow"} { 1242 stressers ziplist 1243 stressers skiplist 1244 } 1245 1246 test {ZSET skiplist order consistency when elements are moved} { 1247 set original_max [lindex [r config get zset-max-ziplist-entries] 1] 1248 r config set zset-max-ziplist-entries 0 1249 for {set times 0} {$times < 10} {incr times} { 1250 r del zset 1251 for {set j 0} {$j < 1000} {incr j} { 1252 r zadd zset [randomInt 50] ele-[randomInt 10] 1253 } 1254 1255 # Make sure that element ordering is correct 1256 set prev_element {} 1257 set prev_score -1 1258 foreach {element score} [r zrange zset 0 -1 WITHSCORES] { 1259 # Assert that elements are in increasing ordering 1260 assert { 1261 $prev_score < $score || 1262 ($prev_score == $score && 1263 [string compare $prev_element $element] == -1) 1264 } 1265 set prev_element $element 1266 set prev_score $score 1267 } 1268 } 1269 r config set zset-max-ziplist-entries $original_max 1270 } 1271} 1272