test/unit/type/list.tcl

   1 start_server default.conf {} {
   2     test {Basic LPUSH, RPUSH, LLENGTH, LINDEX} {
   3         set res [r lpush mylist a]
   4         append res [r lpush mylist b]
   5         append res [r rpush mylist c]
   6         append res [r llen mylist]
   7         append res [r rpush anotherlist d]
   8         append res [r lpush anotherlist e]
   9         append res [r llen anotherlist]
  10         append res [r lindex mylist 0]
  11         append res [r lindex mylist 1]
  12         append res [r lindex mylist 2]
  13         append res [r lindex anotherlist 0]
  14         append res [r lindex anotherlist 1]
  15         list $res [r lindex mylist 100]
  16     } {1233122baced {}}
  17
  18     test {DEL a list} {
  19         r del mylist
  20         r exists mylist
  21     } {0}
  22
  23     test {Create a long list and check every single element with LINDEX} {
  24         set ok 0
  25         for {set i 0} {$i < 1000} {incr i} {
  26             r rpush mylist $i
  27         }
  28         for {set i 0} {$i < 1000} {incr i} {
  29             if {[r lindex mylist $i] eq $i} {incr ok}
  30             if {[r lindex mylist [expr (-$i)-1]] eq [expr 999-$i]} {
  31                 incr ok
  32             }
  33         }
  34         format $ok
  35     } {2000}
  36
  37     test {Test elements with LINDEX in random access} {
  38         set ok 0
  39         for {set i 0} {$i < 1000} {incr i} {
  40             set rint [expr int(rand()*1000)]
  41             if {[r lindex mylist $rint] eq $rint} {incr ok}
  42             if {[r lindex mylist [expr (-$rint)-1]] eq [expr 999-$rint]} {
  43                 incr ok
  44             }
  45         }
  46         format $ok
  47     } {2000}
  48
  49     test {Check if the list is still ok after a DEBUG RELOAD} {
  50         r debug reload
  51         set ok 0
  52         for {set i 0} {$i < 1000} {incr i} {
  53             set rint [expr int(rand()*1000)]
  54             if {[r lindex mylist $rint] eq $rint} {incr ok}
  55             if {[r lindex mylist [expr (-$rint)-1]] eq [expr 999-$rint]} {
  56                 incr ok
  57             }
  58         }
  59         format $ok
  60     } {2000}
  61
  62     test {LLEN against non-list value error} {
  63         r del mylist
  64         r set mylist foobar
  65         catch {r llen mylist} err
  66         format $err
  67     } {ERR*}
  68
  69     test {LLEN against non existing key} {
  70         r llen not-a-key
  71     } {0}
  72
  73     test {LINDEX against non-list value error} {
  74         catch {r lindex mylist 0} err
  75         format $err
  76     } {ERR*}
  77
  78     test {LINDEX against non existing key} {
  79         r lindex not-a-key 10
  80     } {}
  81
  82     test {LPUSH against non-list value error} {
  83         catch {r lpush mylist 0} err
  84         format $err
  85     } {ERR*}
  86
  87     test {RPUSH against non-list value error} {
  88         catch {r rpush mylist 0} err
  89         format $err
  90     } {ERR*}
  91
  92     test {RPOPLPUSH base case} {
  93         r del mylist
  94         r rpush mylist a
  95         r rpush mylist b
  96         r rpush mylist c
  97         r rpush mylist d
  98         set v1 [r rpoplpush mylist newlist]
  99         set v2 [r rpoplpush mylist newlist]
 100         set l1 [r lrange mylist 0 -1]
 101         set l2 [r lrange newlist 0 -1]
 102         list $v1 $v2 $l1 $l2
 103     } {d c {a b} {c d}}
 104
 105     test {RPOPLPUSH with the same list as src and dst} {
 106         r del mylist
 107         r rpush mylist a
 108         r rpush mylist b
 109         r rpush mylist c
 110         set l1 [r lrange mylist 0 -1]
 111         set v [r rpoplpush mylist mylist]
 112         set l2 [r lrange mylist 0 -1]
 113         list $l1 $v $l2
 114     } {{a b c} c {c a b}}
 115
 116     test {RPOPLPUSH target list already exists} {
 117         r del mylist
 118         r del newlist
 119         r rpush mylist a
 120         r rpush mylist b
 121         r rpush mylist c
 122         r rpush mylist d
 123         r rpush newlist x
 124         set v1 [r rpoplpush mylist newlist]
 125         set v2 [r rpoplpush mylist newlist]
 126         set l1 [r lrange mylist 0 -1]
 127         set l2 [r lrange newlist 0 -1]
 128         list $v1 $v2 $l1 $l2
 129     } {d c {a b} {c d x}}
 130
 131     test {RPOPLPUSH against non existing key} {
 132         r del mylist
 133         r del newlist
 134         set v1 [r rpoplpush mylist newlist]
 135         list $v1 [r exists mylist] [r exists newlist]
 136     } {{} 0 0}
 137
 138     test {RPOPLPUSH against non list src key} {
 139         r del mylist
 140         r del newlist
 141         r set mylist x
 142         catch {r rpoplpush mylist newlist} err
 143         list [r type mylist] [r exists newlist] [string range $err 0 2]
 144     } {string 0 ERR}
 145
 146     test {RPOPLPUSH against non list dst key} {
 147         r del mylist
 148         r del newlist
 149         r rpush mylist a
 150         r rpush mylist b
 151         r rpush mylist c
 152         r rpush mylist d
 153         r set newlist x
 154         catch {r rpoplpush mylist newlist} err
 155         list [r lrange mylist 0 -1] [r type newlist] [string range $err 0 2]
 156     } {{a b c d} string ERR}
 157
 158     test {RPOPLPUSH against non existing src key} {
 159         r del mylist
 160         r del newlist
 161         r rpoplpush mylist newlist
 162     } {}
 163
 164     test {Basic LPOP/RPOP} {
 165         r del mylist
 166         r rpush mylist 1
 167         r rpush mylist 2
 168         r lpush mylist 0
 169         list [r lpop mylist] [r rpop mylist] [r lpop mylist] [r llen mylist]
 170     } [list 0 2 1 0]
 171
 172     test {LPOP/RPOP against empty list} {
 173         r lpop mylist
 174     } {}
 175
 176     test {LPOP against non list value} {
 177         r set notalist foo
 178         catch {r lpop notalist} err
 179         format $err
 180     } {ERR*kind*}
 181
 182     test {Mass LPUSH/LPOP} {
 183         set sum 0
 184         for {set i 0} {$i < 1000} {incr i} {
 185             r lpush mylist $i
 186             incr sum $i
 187         }
 188         set sum2 0
 189         for {set i 0} {$i < 500} {incr i} {
 190             incr sum2 [r lpop mylist]
 191             incr sum2 [r rpop mylist]
 192         }
 193         expr $sum == $sum2
 194     } {1}
 195
 196     test {LRANGE basics} {
 197         for {set i 0} {$i < 10} {incr i} {
 198             r rpush mylist $i
 199         }
 200         list [r lrange mylist 1 -2] \
 201                 [r lrange mylist -3 -1] \
 202                 [r lrange mylist 4 4]
 203     } {{1 2 3 4 5 6 7 8} {7 8 9} 4}
 204
 205     test {LRANGE inverted indexes} {
 206         r lrange mylist 6 2
 207     } {}
 208
 209     test {LRANGE out of range indexes including the full list} {
 210         r lrange mylist -1000 1000
 211     } {0 1 2 3 4 5 6 7 8 9}
 212
 213     test {LRANGE against non existing key} {
 214         r lrange nosuchkey 0 1
 215     } {}
 216
 217     test {LTRIM basics} {
 218         r del mylist
 219         for {set i 0} {$i < 100} {incr i} {
 220             r lpush mylist $i
 221             r ltrim mylist 0 4
 222         }
 223         r lrange mylist 0 -1
 224     } {99 98 97 96 95}
 225
 226     test {LTRIM stress testing} {
 227         set mylist {}
 228         set err {}
 229         for {set i 0} {$i < 20} {incr i} {
 230             lappend mylist $i
 231         }
 232
 233         for {set j 0} {$j < 100} {incr j} {
 234             # Fill the list
 235             r del mylist
 236             for {set i 0} {$i < 20} {incr i} {
 237                 r rpush mylist $i
 238             }
 239             # Trim at random
 240             set a [randomInt 20]
 241             set b [randomInt 20]
 242             r ltrim mylist $a $b
 243             if {[r lrange mylist 0 -1] ne [lrange $mylist $a $b]} {
 244                 set err "[r lrange mylist 0 -1] != [lrange $mylist $a $b]"
 245                 break
 246             }
 247         }
 248         set _ $err
 249     } {}
 250
 251     test {LSET} {
 252         r del mylist
 253         foreach x {99 98 97 96 95} {
 254             r rpush mylist $x
 255         }
 256         r lset mylist 1 foo
 257         r lset mylist -1 bar
 258         r lrange mylist 0 -1
 259     } {99 foo 97 96 bar}
 260
 261     test {LSET out of range index} {
 262         catch {r lset mylist 10 foo} err
 263         format $err
 264     } {ERR*range*}
 265
 266     test {LSET against non existing key} {
 267         catch {r lset nosuchkey 10 foo} err
 268         format $err
 269     } {ERR*key*}
 270
 271     test {LSET against non list value} {
 272         r set nolist foobar
 273         catch {r lset nolist 0 foo} err
 274         format $err
 275     } {ERR*value*}
 276
 277     test {LREM, remove all the occurrences} {
 278         r flushdb
 279         r rpush mylist foo
 280         r rpush mylist bar
 281         r rpush mylist foobar
 282         r rpush mylist foobared
 283         r rpush mylist zap
 284         r rpush mylist bar
 285         r rpush mylist test
 286         r rpush mylist foo
 287         set res [r lrem mylist 0 bar]
 288         list [r lrange mylist 0 -1] $res
 289     } {{foo foobar foobared zap test foo} 2}
 290
 291     test {LREM, remove the first occurrence} {
 292         set res [r lrem mylist 1 foo]
 293         list [r lrange mylist 0 -1] $res
 294     } {{foobar foobared zap test foo} 1}
 295
 296     test {LREM, remove non existing element} {
 297         set res [r lrem mylist 1 nosuchelement]
 298         list [r lrange mylist 0 -1] $res
 299     } {{foobar foobared zap test foo} 0}
 300
 301     test {LREM, starting from tail with negative count} {
 302         r flushdb
 303         r rpush mylist foo
 304         r rpush mylist bar
 305         r rpush mylist foobar
 306         r rpush mylist foobared
 307         r rpush mylist zap
 308         r rpush mylist bar
 309         r rpush mylist test
 310         r rpush mylist foo
 311         r rpush mylist foo
 312         set res [r lrem mylist -1 bar]
 313         list [r lrange mylist 0 -1] $res
 314     } {{foo bar foobar foobared zap test foo foo} 1}
 315
 316     test {LREM, starting from tail with negative count (2)} {
 317         set res [r lrem mylist -2 foo]
 318         list [r lrange mylist 0 -1] $res
 319     } {{foo bar foobar foobared zap test} 2}
 320
 321     test {LREM, deleting objects that may be encoded as integers} {
 322         r lpush myotherlist 1
 323         r lpush myotherlist 2
 324         r lpush myotherlist 3
 325         r lrem myotherlist 1 2
 326         r llen myotherlist
 327     } {2}
 328 }