fluencelabs/redis
1
0
Fork 0
mirror of https://github.com/fluencelabs/redis synced 2025-03-24 19:40:53 +00:00
Code Issues Projects Releases Wiki Activity

rename "list" to "linkedlist" to be more verbose

Browse Source
This commit is contained in:
Pieter Noordhuis 2010-06-14 10:21:23 +02:00
parent 08b5920750
commit 7e79de541a
2 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
redis.c
View File

@ -130,11 +130,11 @@
#define REDIS_ENCODING_INT 1 /* Encoded as integer */ #define REDIS_ENCODING_INT 1 /* Encoded as integer */
#define REDIS_ENCODING_HT 2 /* Encoded as hash table */ #define REDIS_ENCODING_HT 2 /* Encoded as hash table */
#define REDIS_ENCODING_ZIPMAP 3 /* Encoded as zipmap */ #define REDIS_ENCODING_ZIPMAP 3 /* Encoded as zipmap */
#define REDIS_ENCODING_LIST 4 /* Encoded as zipmap */ #define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
#define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */ #define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
static char* strencoding[] = { static char* strencoding[] = {
"raw", "int", "hashtable", "zipmap", "list", "ziplist" "raw", "int", "hashtable", "zipmap", "linkedlist", "ziplist"
}; };
/* Object types only used for dumping to disk */ /* Object types only used for dumping to disk */
@ -3058,7 +3058,7 @@ static robj *createListObject(void) {
list *l = listCreate(); list *l = listCreate();
robj *o = createObject(REDIS_LIST,l); robj *o = createObject(REDIS_LIST,l);
listSetFreeMethod(l,decrRefCount); listSetFreeMethod(l,decrRefCount);
o->encoding = REDIS_ENCODING_LIST; o->encoding = REDIS_ENCODING_LINKEDLIST;
return o; return o;
} }
@ -3100,7 +3100,7 @@ static void freeStringObject(robj *o) {
static void freeListObject(robj *o) { static void freeListObject(robj *o) {
switch (o->encoding) { switch (o->encoding) {
case REDIS_ENCODING_LIST: case REDIS_ENCODING_LINKEDLIST:
listRelease((list*) o->ptr); listRelease((list*) o->ptr);
break; break;
case REDIS_ENCODING_ZIPLIST: case REDIS_ENCODING_ZIPLIST:
@ -3776,7 +3776,7 @@ static int rdbSaveObject(FILE *fp, robj *o) {
} }
p = ziplistNext(o->ptr,p); p = ziplistNext(o->ptr,p);
} }
} else if (o->encoding == REDIS_ENCODING_LIST) { } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
list *list = o->ptr; list *list = o->ptr;
listIter li; listIter li;
listNode *ln; listNode *ln;
@ -4186,7 +4186,7 @@ static robj *rdbLoadObject(int type, FILE *fp) {
if (o->encoding == REDIS_ENCODING_ZIPLIST && if (o->encoding == REDIS_ENCODING_ZIPLIST &&
ele->encoding == REDIS_ENCODING_RAW && ele->encoding == REDIS_ENCODING_RAW &&
sdslen(ele->ptr) > server.list_max_ziplist_value) sdslen(ele->ptr) > server.list_max_ziplist_value)
listTypeConvert(o,REDIS_ENCODING_LIST); listTypeConvert(o,REDIS_ENCODING_LINKEDLIST);
if (o->encoding == REDIS_ENCODING_ZIPLIST) { if (o->encoding == REDIS_ENCODING_ZIPLIST) {
dec = getDecodedObject(ele); dec = getDecodedObject(ele);
@ -4926,7 +4926,7 @@ static void listTypeTryConversion(robj *subject, robj *value) {
if (subject->encoding != REDIS_ENCODING_ZIPLIST) return; if (subject->encoding != REDIS_ENCODING_ZIPLIST) return;
if (value->encoding == REDIS_ENCODING_RAW && if (value->encoding == REDIS_ENCODING_RAW &&
sdslen(value->ptr) > server.list_max_ziplist_value) sdslen(value->ptr) > server.list_max_ziplist_value)
listTypeConvert(subject,REDIS_ENCODING_LIST); listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
} }
static void listTypePush(robj *subject, robj *value, int where) { static void listTypePush(robj *subject, robj *value, int where) {
@ -4934,14 +4934,14 @@ static void listTypePush(robj *subject, robj *value, int where) {
listTypeTryConversion(subject,value); listTypeTryConversion(subject,value);
if (subject->encoding == REDIS_ENCODING_ZIPLIST && if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
ziplistLen(subject->ptr) >= server.list_max_ziplist_entries) ziplistLen(subject->ptr) >= server.list_max_ziplist_entries)
listTypeConvert(subject,REDIS_ENCODING_LIST); listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
if (subject->encoding == REDIS_ENCODING_ZIPLIST) { if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL; int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
value = getDecodedObject(value); value = getDecodedObject(value);
subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos); subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos);
decrRefCount(value); decrRefCount(value);
} else if (subject->encoding == REDIS_ENCODING_LIST) { } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
if (where == REDIS_HEAD) { if (where == REDIS_HEAD) {
listAddNodeHead(subject->ptr,value); listAddNodeHead(subject->ptr,value);
} else { } else {
@ -4971,7 +4971,7 @@ static robj *listTypePop(robj *subject, int where) {
/* We only need to delete an element when it exists */ /* We only need to delete an element when it exists */
subject->ptr = ziplistDelete(subject->ptr,&p); subject->ptr = ziplistDelete(subject->ptr,&p);
} }
} else if (subject->encoding == REDIS_ENCODING_LIST) { } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
list *list = subject->ptr; list *list = subject->ptr;
listNode *ln; listNode *ln;
if (where == REDIS_HEAD) { if (where == REDIS_HEAD) {
@ -4993,7 +4993,7 @@ static robj *listTypePop(robj *subject, int where) {
static unsigned long listTypeLength(robj *subject) { static unsigned long listTypeLength(robj *subject) {
if (subject->encoding == REDIS_ENCODING_ZIPLIST) { if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
return ziplistLen(subject->ptr); return ziplistLen(subject->ptr);
} else if (subject->encoding == REDIS_ENCODING_LIST) { } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
return listLength((list*)subject->ptr); return listLength((list*)subject->ptr);
} else { } else {
redisPanic("Unknown list encoding"); redisPanic("Unknown list encoding");
@ -5024,7 +5024,7 @@ static listTypeIterator *listTypeInitIterator(robj *subject, int index, unsigned
li->direction = direction; li->direction = direction;
if (li->encoding == REDIS_ENCODING_ZIPLIST) { if (li->encoding == REDIS_ENCODING_ZIPLIST) {
li->zi = ziplistIndex(subject->ptr,index); li->zi = ziplistIndex(subject->ptr,index);
} else if (li->encoding == REDIS_ENCODING_LIST) { } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
li->ln = listIndex(subject->ptr,index); li->ln = listIndex(subject->ptr,index);
} else { } else {
redisPanic("Unknown list encoding"); redisPanic("Unknown list encoding");
@ -5054,7 +5054,7 @@ static int listTypeNext(listTypeIterator *li, listTypeEntry *entry) {
li->zi = ziplistPrev(li->subject->ptr,li->zi); li->zi = ziplistPrev(li->subject->ptr,li->zi);
return 1; return 1;
} }
} else if (li->encoding == REDIS_ENCODING_LIST) { } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
entry->ln = li->ln; entry->ln = li->ln;
if (entry->ln != NULL) { if (entry->ln != NULL) {
if (li->direction == REDIS_TAIL) if (li->direction == REDIS_TAIL)
@ -5085,7 +5085,7 @@ static robj *listTypeGet(listTypeEntry *entry) {
value = createStringObjectFromLongLong(vlong); value = createStringObjectFromLongLong(vlong);
} }
} }
} else if (li->encoding == REDIS_ENCODING_LIST) { } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
redisAssert(entry->ln != NULL); redisAssert(entry->ln != NULL);
value = listNodeValue(entry->ln); value = listNodeValue(entry->ln);
incrRefCount(value); incrRefCount(value);
@ -5113,7 +5113,7 @@ static void listTypeInsert(listTypeEntry *entry, robj *value, int where) {
subject->ptr = ziplistInsert(subject->ptr,entry->zi,value->ptr,sdslen(value->ptr)); subject->ptr = ziplistInsert(subject->ptr,entry->zi,value->ptr,sdslen(value->ptr));
} }
decrRefCount(value); decrRefCount(value);
} else if (entry->li->encoding == REDIS_ENCODING_LIST) { } else if (entry->li->encoding == REDIS_ENCODING_LINKEDLIST) {
if (where == REDIS_TAIL) { if (where == REDIS_TAIL) {
listInsertNode(subject->ptr,entry->ln,value,AL_START_TAIL); listInsertNode(subject->ptr,entry->ln,value,AL_START_TAIL);
} else { } else {
@ -5131,7 +5131,7 @@ static int listTypeEqual(listTypeEntry *entry, robj *o) {
if (li->encoding == REDIS_ENCODING_ZIPLIST) { if (li->encoding == REDIS_ENCODING_ZIPLIST) {
redisAssert(o->encoding == REDIS_ENCODING_RAW); redisAssert(o->encoding == REDIS_ENCODING_RAW);
return ziplistCompare(entry->zi,o->ptr,sdslen(o->ptr)); return ziplistCompare(entry->zi,o->ptr,sdslen(o->ptr));
} else if (li->encoding == REDIS_ENCODING_LIST) { } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
return equalStringObjects(o,listNodeValue(entry->ln)); return equalStringObjects(o,listNodeValue(entry->ln));
} else { } else {
redisPanic("Unknown list encoding"); redisPanic("Unknown list encoding");
@ -5150,7 +5150,7 @@ static void listTypeDelete(listTypeEntry *entry) {
li->zi = p; li->zi = p;
else else
li->zi = ziplistPrev(li->subject->ptr,p); li->zi = ziplistPrev(li->subject->ptr,p);
} else if (entry->li->encoding == REDIS_ENCODING_LIST) { } else if (entry->li->encoding == REDIS_ENCODING_LINKEDLIST) {
listNode *next; listNode *next;
if (li->direction == REDIS_TAIL) if (li->direction == REDIS_TAIL)
next = entry->ln->next; next = entry->ln->next;
@ -5168,7 +5168,7 @@ static void listTypeConvert(robj *subject, int enc) {
listTypeEntry entry; listTypeEntry entry;
redisAssert(subject->type == REDIS_LIST); redisAssert(subject->type == REDIS_LIST);
if (enc == REDIS_ENCODING_LIST) { if (enc == REDIS_ENCODING_LINKEDLIST) {
list *l = listCreate(); list *l = listCreate();
listSetFreeMethod(l,decrRefCount); listSetFreeMethod(l,decrRefCount);
@ -5177,7 +5177,7 @@ static void listTypeConvert(robj *subject, int enc) {
while (listTypeNext(li,&entry)) listAddNodeTail(l,listTypeGet(&entry)); while (listTypeNext(li,&entry)) listAddNodeTail(l,listTypeGet(&entry));
listTypeReleaseIterator(li); listTypeReleaseIterator(li);
subject->encoding = REDIS_ENCODING_LIST; subject->encoding = REDIS_ENCODING_LINKEDLIST;
zfree(subject->ptr); zfree(subject->ptr);
subject->ptr = l; subject->ptr = l;
} else { } else {
@ -5253,7 +5253,7 @@ static void pushxGenericCommand(redisClient *c, robj *refval, robj *val, int whe
/* Check if the length exceeds the ziplist length threshold. */ /* Check if the length exceeds the ziplist length threshold. */
if (subject->encoding == REDIS_ENCODING_ZIPLIST && if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
ziplistLen(subject->ptr) > server.list_max_ziplist_entries) ziplistLen(subject->ptr) > server.list_max_ziplist_entries)
listTypeConvert(subject,REDIS_ENCODING_LIST); listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
server.dirty++; server.dirty++;
} else { } else {
/* Notify client of a failed insert */ /* Notify client of a failed insert */
@ -5315,7 +5315,7 @@ static void lindexCommand(redisClient *c) {
} else { } else {
addReply(c,shared.nullbulk); addReply(c,shared.nullbulk);
} }
} else if (o->encoding == REDIS_ENCODING_LIST) { } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
listNode *ln = listIndex(o->ptr,index); listNode *ln = listIndex(o->ptr,index);
if (ln != NULL) { if (ln != NULL) {
value = listNodeValue(ln); value = listNodeValue(ln);
@ -5348,7 +5348,7 @@ static void lsetCommand(redisClient *c) {
addReply(c,shared.ok); addReply(c,shared.ok);
server.dirty++; server.dirty++;
} }
} else if (o->encoding == REDIS_ENCODING_LIST) { } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
listNode *ln = listIndex(o->ptr,index); listNode *ln = listIndex(o->ptr,index);
if (ln == NULL) { if (ln == NULL) {
addReply(c,shared.outofrangeerr); addReply(c,shared.outofrangeerr);
@ -5460,7 +5460,7 @@ static void ltrimCommand(redisClient *c) {
if (o->encoding == REDIS_ENCODING_ZIPLIST) { if (o->encoding == REDIS_ENCODING_ZIPLIST) {
o->ptr = ziplistDeleteRange(o->ptr,0,ltrim); o->ptr = ziplistDeleteRange(o->ptr,0,ltrim);
o->ptr = ziplistDeleteRange(o->ptr,-rtrim,rtrim); o->ptr = ziplistDeleteRange(o->ptr,-rtrim,rtrim);
} else if (o->encoding == REDIS_ENCODING_LIST) { } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
list = o->ptr; list = o->ptr;
for (j = 0; j < ltrim; j++) { for (j = 0; j < ltrim; j++) {
ln = listFirst(list); ln = listFirst(list);
@ -9150,7 +9150,7 @@ static int rewriteAppendOnlyFile(char *filename) {
} }
p = ziplistNext(zl,p); p = ziplistNext(zl,p);
} }
} else if (o->encoding == REDIS_ENCODING_LIST) { } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
list *list = o->ptr; list *list = o->ptr;
listNode *ln; listNode *ln;
listIter li; listIter li;

48
tests/unit/type/list.tcl
View File

@ -33,7 +33,7 @@ start_server {
# first lpush then rpush # first lpush then rpush
assert_equal 1 [r lpush mylist1 $large_value] assert_equal 1 [r lpush mylist1 $large_value]
assert_encoding list mylist1 assert_encoding linkedlist mylist1
assert_equal 2 [r rpush mylist1 b] assert_equal 2 [r rpush mylist1 b]
assert_equal 3 [r rpush mylist1 c] assert_equal 3 [r rpush mylist1 c]
assert_equal 3 [r llen mylist1] assert_equal 3 [r llen mylist1]
@ -43,7 +43,7 @@ start_server {
# first rpush then lpush # first rpush then lpush
assert_equal 1 [r rpush mylist2 $large_value] assert_equal 1 [r rpush mylist2 $large_value]
assert_encoding list mylist2 assert_encoding linkedlist mylist2
assert_equal 2 [r lpush mylist2 b] assert_equal 2 [r lpush mylist2 b]
assert_equal 3 [r lpush mylist2 c] assert_equal 3 [r lpush mylist2 c]
assert_equal 3 [r llen mylist2] assert_equal 3 [r llen mylist2]
@ -70,12 +70,12 @@ start_server {
assert_encoding ziplist $key assert_encoding ziplist $key
} }
proc create_list {key entries} { proc create_linkedlist {key entries} {
r del $key r del $key
r rpush $key "aaaaaaaaaaaaaaaaa" r rpush $key "aaaaaaaaaaaaaaaaa"
foreach entry $entries { r rpush $key $entry } foreach entry $entries { r rpush $key $entry }
assert_equal "aaaaaaaaaaaaaaaaa" [r lpop $key] assert_equal "aaaaaaaaaaaaaaaaa" [r lpop $key]
assert_encoding list $key assert_encoding linkedlist $key
} }
test {LPUSHX, RPUSHX - generic} { test {LPUSHX, RPUSHX - generic} {
@ -86,7 +86,7 @@ start_server {
assert_equal 0 [r llen xlist] assert_equal 0 [r llen xlist]
} }
foreach type {ziplist list} { foreach type {ziplist linkedlist} {
test "LPUSHX, RPUSHX - $type" { test "LPUSHX, RPUSHX - $type" {
create_$type xlist {b c} create_$type xlist {b c}
assert_equal 3 [r rpushx xlist d] assert_equal 3 [r rpushx xlist d]
@ -119,18 +119,18 @@ start_server {
# convert when a large value is pushed # convert when a large value is pushed
create_ziplist xlist a create_ziplist xlist a
assert_equal 2 [r rpushx xlist $large_value] assert_equal 2 [r rpushx xlist $large_value]
assert_encoding list xlist assert_encoding linkedlist xlist
create_ziplist xlist a create_ziplist xlist a
assert_equal 2 [r lpushx xlist $large_value] assert_equal 2 [r lpushx xlist $large_value]
assert_encoding list xlist assert_encoding linkedlist xlist
# convert when the length threshold is exceeded # convert when the length threshold is exceeded
create_ziplist xlist [lrepeat 256 a] create_ziplist xlist [lrepeat 256 a]
assert_equal 257 [r rpushx xlist b] assert_equal 257 [r rpushx xlist b]
assert_encoding list xlist assert_encoding linkedlist xlist
create_ziplist xlist [lrepeat 256 a] create_ziplist xlist [lrepeat 256 a]
assert_equal 257 [r lpushx xlist b] assert_equal 257 [r lpushx xlist b]
assert_encoding list xlist assert_encoding linkedlist xlist
} }
test {LINSERT convert from ziplist to list} { test {LINSERT convert from ziplist to list} {
@ -139,18 +139,18 @@ start_server {
# convert when a large value is inserted # convert when a large value is inserted
create_ziplist xlist a create_ziplist xlist a
assert_equal 2 [r linsert xlist before a $large_value] assert_equal 2 [r linsert xlist before a $large_value]
assert_encoding list xlist assert_encoding linkedlist xlist
create_ziplist xlist a create_ziplist xlist a
assert_equal 2 [r linsert xlist after a $large_value] assert_equal 2 [r linsert xlist after a $large_value]
assert_encoding list xlist assert_encoding linkedlist xlist
# convert when the length threshold is exceeded # convert when the length threshold is exceeded
create_ziplist xlist [lrepeat 256 a] create_ziplist xlist [lrepeat 256 a]
assert_equal 257 [r linsert xlist before a a] assert_equal 257 [r linsert xlist before a a]
assert_encoding list xlist assert_encoding linkedlist xlist
create_ziplist xlist [lrepeat 256 a] create_ziplist xlist [lrepeat 256 a]
assert_equal 257 [r linsert xlist after a a] assert_equal 257 [r linsert xlist after a a]
assert_encoding list xlist assert_encoding linkedlist xlist
# don't convert when the value could not be inserted # don't convert when the value could not be inserted
create_ziplist xlist [lrepeat 256 a] create_ziplist xlist [lrepeat 256 a]
@ -161,7 +161,7 @@ start_server {
assert_encoding ziplist xlist assert_encoding ziplist xlist
} }
foreach {type num} {ziplist 250 list 500} { foreach {type num} {ziplist 250 linkedlist 500} {
proc check_numbered_list_consistency {key} { proc check_numbered_list_consistency {key} {
set len [r llen $key] set len [r llen $key]
for {set i 0} {$i < $len} {incr i} { for {set i 0} {$i < $len} {incr i} {
@ -227,7 +227,7 @@ start_server {
assert_error ERR* {r rpush mylist 0} assert_error ERR* {r rpush mylist 0}
} }
foreach type {ziplist list} { foreach type {ziplist linkedlist} {
test "RPOPLPUSH base case - $type" { test "RPOPLPUSH base case - $type" {
r del mylist1 mylist2 r del mylist1 mylist2
create_$type mylist1 {a b c d} create_$type mylist1 {a b c d}
@ -245,7 +245,7 @@ start_server {
assert_equal {c a b} [r lrange mylist 0 -1] assert_equal {c a b} [r lrange mylist 0 -1]
} }
foreach othertype {ziplist list} { foreach othertype {ziplist linkedlist} {
test "RPOPLPUSH with $type source and existing target $othertype" { test "RPOPLPUSH with $type source and existing target $othertype" {
create_$type srclist {a b c d} create_$type srclist {a b c d}
create_$othertype dstlist {x} create_$othertype dstlist {x}
@ -285,7 +285,7 @@ start_server {
assert_equal {} [r rpoplpush srclist dstlist] assert_equal {} [r rpoplpush srclist dstlist]
} {} } {}
foreach type {ziplist list} { foreach type {ziplist linkedlist} {
test "Basic LPOP/RPOP - $type" { test "Basic LPOP/RPOP - $type" {
create_$type mylist {0 1 2} create_$type mylist {0 1 2}
assert_equal 0 [r lpop mylist] assert_equal 0 [r lpop mylist]
@ -305,7 +305,7 @@ start_server {
assert_error ERR*kind* {r rpop notalist} assert_error ERR*kind* {r rpop notalist}
} }
foreach {type num} {ziplist 250 list 500} { foreach {type num} {ziplist 250 linkedlist 500} {
test "Mass RPOP/LPOP - $type" { test "Mass RPOP/LPOP - $type" {
r del mylist r del mylist
set sum1 0 set sum1 0
@ -323,7 +323,7 @@ start_server {
} }
} }
foreach type {ziplist list} { foreach type {ziplist linkedlist} {
test "LRANGE basics - $type" { test "LRANGE basics - $type" {
create_$type mylist {0 1 2 3 4 5 6 7 8 9} create_$type mylist {0 1 2 3 4 5 6 7 8 9}
assert_equal {1 2 3 4 5 6 7 8} [r lrange mylist 1 -2] assert_equal {1 2 3 4 5 6 7 8} [r lrange mylist 1 -2]
@ -346,7 +346,7 @@ start_server {
assert_equal {} [r lrange nosuchkey 0 1] assert_equal {} [r lrange nosuchkey 0 1]
} }
foreach type {ziplist list} { foreach type {ziplist linkedlist} {
proc trim_list {type min max} { proc trim_list {type min max} {
r del mylist r del mylist
create_$type mylist {1 2 3 4 5} create_$type mylist {1 2 3 4 5}
@ -384,10 +384,10 @@ start_server {
if {$type eq "list"} { if {$type eq "list"} {
r rpush mylist "aaaaaaaaaaaaaaaaa" r rpush mylist "aaaaaaaaaaaaaaaaa"
r rpop mylist r rpop mylist
assert_encoding list mylist assert_encoding linkedlist mylist
} }
for {set i 0} {$i < 1000} {incr i} { for {set i 0} {$i < 10000} {incr i} {
set min [expr {int(rand()*$startlen)}] set min [expr {int(rand()*$startlen)}]
set max [expr {$min+int(rand()*$startlen)}] set max [expr {$min+int(rand()*$startlen)}]
set mylist [lrange $mylist $min $max] set mylist [lrange $mylist $min $max]
@ -404,7 +404,7 @@ start_server {
} }
} }
foreach type {ziplist list} { foreach type {ziplist linkedlist} {
test "LSET - $type" { test "LSET - $type" {
create_$type mylist {99 98 97 96 95} create_$type mylist {99 98 97 96 95}
r lset mylist 1 foo r lset mylist 1 foo
@ -426,7 +426,7 @@ start_server {
assert_error ERR*value* {r lset nolist 0 foo} assert_error ERR*value* {r lset nolist 0 foo}
} }
foreach type {ziplist list} { foreach type {ziplist linkedlist} {
test "LREM remove all the occurrences - $type" { test "LREM remove all the occurrences - $type" {
create_$type mylist {foo bar foobar foobared zap bar test foo} create_$type mylist {foo bar foobar foobared zap bar test foo}
assert_equal 2 [r lrem mylist 0 bar] assert_equal 2 [r lrem mylist 0 bar]