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

diff --git a/redis.c b/redis.c
index 4f5f68a7c9a1caaf78e119931b928c159553c1cb..544bc6a813240138fd6087fbb0ce5979bcef9ab1 100644 (file)
--- a/redis.c
+++ b/redis.c
@@ -130,11 +130,11 @@
 #define REDIS_ENCODING_INT 1     /* Encoded as integer */
 #define REDIS_ENCODING_HT 2      /* Encoded as hash table */
 #define REDIS_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
 #define REDIS_ENCODING_INT 1     /* Encoded as integer */
 #define REDIS_ENCODING_HT 2      /* Encoded as hash table */
 #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 */
 
 static char* strencoding[] = {
 #define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
 
 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();
     robj *o = createObject(REDIS_LIST,l);
     listSetFreeMethod(l,decrRefCount);
     list *l = listCreate();
     robj *o = createObject(REDIS_LIST,l);
     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) {
     switch (o->encoding) {
 
 static void freeListObject(robj *o) {
     switch (o->encoding) {

-    case REDIS_ENCODING_LIST:
+    case REDIS_ENCODING_LINKEDLIST:

         listRelease((list*) o->ptr);
         break;
     case REDIS_ENCODING_ZIPLIST:
         listRelease((list*) o->ptr);
         break;
     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;
             listIter li;
             listNode *ln;
             list *list = o->ptr;
             listIter li;
             listNode *ln;


@@ -4186,7 +4186,7 @@ static robj *rdbLoadObject(int type, FILE *fp) {
             if (o->encoding == REDIS_ENCODING_ZIPLIST &&
                 ele->encoding == REDIS_ENCODING_RAW &&
                 sdslen(ele->ptr) > server.list_max_ziplist_value)
             if (o->encoding == REDIS_ENCODING_ZIPLIST &&
                 ele->encoding == REDIS_ENCODING_RAW &&
                 sdslen(ele->ptr) > server.list_max_ziplist_value)

-                    listTypeConvert(o,REDIS_ENCODING_LIST);
+                    listTypeConvert(o,REDIS_ENCODING_LINKEDLIST);

 
             if (o->encoding == REDIS_ENCODING_ZIPLIST) {
                 dec = getDecodedObject(ele);
 
             if (o->encoding == REDIS_ENCODING_ZIPLIST) {
                 dec = getDecodedObject(ele);


@@ -4926,7 +4926,7 @@ static void listTypeTryConversion(robj *subject, robj *value) {
     if (subject->encoding != REDIS_ENCODING_ZIPLIST) return;
     if (value->encoding == REDIS_ENCODING_RAW &&
         sdslen(value->ptr) > server.list_max_ziplist_value)
     if (subject->encoding != REDIS_ENCODING_ZIPLIST) return;
     if (value->encoding == REDIS_ENCODING_RAW &&
         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);
     if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
         ziplistLen(subject->ptr) >= server.list_max_ziplist_entries)
     listTypeTryConversion(subject,value);
     if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
         ziplistLen(subject->ptr) >= server.list_max_ziplist_entries)

-            listTypeConvert(subject,REDIS_ENCODING_LIST);
+            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);

 
     if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
         int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
         value = getDecodedObject(value);
         subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos);
         decrRefCount(value);
 
     if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
         int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
         value = getDecodedObject(value);
         subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos);
         decrRefCount(value);

-    } else if (subject->encoding == REDIS_ENCODING_LIST) {
+    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {

         if (where == REDIS_HEAD) {
             listAddNodeHead(subject->ptr,value);
         } else {
         if (where == REDIS_HEAD) {
             listAddNodeHead(subject->ptr,value);
         } else {


@@ -4971,7 +4971,7 @@ static robj *listTypePop(robj *subject, int where) {
             /* We only need to delete an element when it exists */
             subject->ptr = ziplistDelete(subject->ptr,&p);
         }
             /* We only need to delete an element when it exists */
             subject->ptr = ziplistDelete(subject->ptr,&p);
         }

-    } else if (subject->encoding == REDIS_ENCODING_LIST) {
+    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {

         list *list = subject->ptr;
         listNode *ln;
         if (where == REDIS_HEAD) {
         list *list = subject->ptr;
         listNode *ln;
         if (where == REDIS_HEAD) {


@@ -4993,7 +4993,7 @@ static robj *listTypePop(robj *subject, int where) {
 static unsigned long listTypeLength(robj *subject) {
     if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
         return ziplistLen(subject->ptr);
 static unsigned long listTypeLength(robj *subject) {
     if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
         return ziplistLen(subject->ptr);

-    } else if (subject->encoding == REDIS_ENCODING_LIST) {
+    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {

         return listLength((list*)subject->ptr);
     } else {
         redisPanic("Unknown list encoding");
         return listLength((list*)subject->ptr);
     } else {
         redisPanic("Unknown list encoding");


@@ -5024,7 +5024,7 @@ static listTypeIterator *listTypeInitIterator(robj *subject, int index, unsigned
     li->direction = direction;
     if (li->encoding == REDIS_ENCODING_ZIPLIST) {
         li->zi = ziplistIndex(subject->ptr,index);
     li->direction = direction;
     if (li->encoding == REDIS_ENCODING_ZIPLIST) {
         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);
     } else {
         redisPanic("Unknown list encoding");
         li->ln = listIndex(subject->ptr,index);
     } else {
         redisPanic("Unknown list encoding");


@@ -5054,7 +5054,7 @@ static int listTypeNext(listTypeIterator *li, listTypeEntry *entry) {
                 li->zi = ziplistPrev(li->subject->ptr,li->zi);
             return 1;
         }
                 li->zi = ziplistPrev(li->subject->ptr,li->zi);
             return 1;
         }

-    } else if (li->encoding == REDIS_ENCODING_LIST) {
+    } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {

         entry->ln = li->ln;
         if (entry->ln != NULL) {
             if (li->direction == REDIS_TAIL)
         entry->ln = li->ln;
         if (entry->ln != NULL) {
             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);
         value = listNodeValue(entry->ln);
         incrRefCount(value);
         redisAssert(entry->ln != NULL);
         value = listNodeValue(entry->ln);
         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));
         }
         decrRefCount(value);
             subject->ptr = ziplistInsert(subject->ptr,entry->zi,value->ptr,sdslen(value->ptr));
         }
         decrRefCount(value);

-    } else if (entry->li->encoding == REDIS_ENCODING_LIST) {
+    } else if (entry->li->encoding == REDIS_ENCODING_LINKEDLIST) {

         if (where == REDIS_TAIL) {
             listInsertNode(subject->ptr,entry->ln,value,AL_START_TAIL);
         } else {
         if (where == REDIS_TAIL) {
             listInsertNode(subject->ptr,entry->ln,value,AL_START_TAIL);
         } else {


@@ -5131,7 +5131,7 @@ static int listTypeEqual(listTypeEntry *entry, robj *o) {
     if (li->encoding == REDIS_ENCODING_ZIPLIST) {
         redisAssert(o->encoding == REDIS_ENCODING_RAW);
         return ziplistCompare(entry->zi,o->ptr,sdslen(o->ptr));
     if (li->encoding == REDIS_ENCODING_ZIPLIST) {
         redisAssert(o->encoding == REDIS_ENCODING_RAW);
         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));
     } else {
         redisPanic("Unknown list encoding");
         return equalStringObjects(o,listNodeValue(entry->ln));
     } else {
         redisPanic("Unknown list encoding");


@@ -5150,7 +5150,7 @@ static void listTypeDelete(listTypeEntry *entry) {
             li->zi = p;
         else
             li->zi = ziplistPrev(li->subject->ptr,p);
             li->zi = p;
         else
             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;
         if (li->direction == REDIS_TAIL)
             next = entry->ln->next;
         listNode *next;
         if (li->direction == REDIS_TAIL)
             next = entry->ln->next;


@@ -5168,7 +5168,7 @@ static void listTypeConvert(robj *subject, int enc) {
     listTypeEntry entry;
     redisAssert(subject->type == REDIS_LIST);
 
     listTypeEntry entry;
     redisAssert(subject->type == REDIS_LIST);
 

-    if (enc == REDIS_ENCODING_LIST) {
+    if (enc == REDIS_ENCODING_LINKEDLIST) {

         list *l = listCreate();
         listSetFreeMethod(l,decrRefCount);
 
         list *l = listCreate();
         listSetFreeMethod(l,decrRefCount);
 


@@ -5177,7 +5177,7 @@ static void listTypeConvert(robj *subject, int enc) {
         while (listTypeNext(li,&entry)) listAddNodeTail(l,listTypeGet(&entry));
         listTypeReleaseIterator(li);
 
         while (listTypeNext(li,&entry)) listAddNodeTail(l,listTypeGet(&entry));
         listTypeReleaseIterator(li);
 

-        subject->encoding = REDIS_ENCODING_LIST;
+        subject->encoding = REDIS_ENCODING_LINKEDLIST;

         zfree(subject->ptr);
         subject->ptr = l;
     } else {
         zfree(subject->ptr);
         subject->ptr = l;
     } 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. */
             if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
                 ziplistLen(subject->ptr) > server.list_max_ziplist_entries)
             /* Check if the length exceeds the ziplist length threshold. */
             if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
                 ziplistLen(subject->ptr) > server.list_max_ziplist_entries)

-                    listTypeConvert(subject,REDIS_ENCODING_LIST);
+                    listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);

             server.dirty++;
         } else {
             /* Notify client of a failed insert */
             server.dirty++;
         } else {
             /* Notify client of a failed insert */


@@ -5315,7 +5315,7 @@ static void lindexCommand(redisClient *c) {
         } else {
             addReply(c,shared.nullbulk);
         }
         } else {
             addReply(c,shared.nullbulk);
         }

-    } else if (o->encoding == REDIS_ENCODING_LIST) {
+    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {

         listNode *ln = listIndex(o->ptr,index);
         if (ln != NULL) {
             value = listNodeValue(ln);
         listNode *ln = listIndex(o->ptr,index);
         if (ln != NULL) {
             value = listNodeValue(ln);


@@ -5348,7 +5348,7 @@ static void lsetCommand(redisClient *c) {
             addReply(c,shared.ok);
             server.dirty++;
         }
             addReply(c,shared.ok);
             server.dirty++;
         }

-    } else if (o->encoding == REDIS_ENCODING_LIST) {
+    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {

         listNode *ln = listIndex(o->ptr,index);
         if (ln == NULL) {
             addReply(c,shared.outofrangeerr);
         listNode *ln = listIndex(o->ptr,index);
         if (ln == NULL) {
             addReply(c,shared.outofrangeerr);


@@ -5460,7 +5460,7 @@ static void ltrimCommand(redisClient *c) {
     if (o->encoding == REDIS_ENCODING_ZIPLIST) {
         o->ptr = ziplistDeleteRange(o->ptr,0,ltrim);
         o->ptr = ziplistDeleteRange(o->ptr,-rtrim,rtrim);
     if (o->encoding == REDIS_ENCODING_ZIPLIST) {
         o->ptr = ziplistDeleteRange(o->ptr,0,ltrim);
         o->ptr = ziplistDeleteRange(o->ptr,-rtrim,rtrim);

-    } else if (o->encoding == REDIS_ENCODING_LIST) {
+    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {

         list = o->ptr;
         for (j = 0; j < ltrim; j++) {
             ln = listFirst(list);
         list = o->ptr;
         for (j = 0; j < ltrim; j++) {
             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;
                     listNode *ln;
                     listIter li;
                     list *list = o->ptr;
                     listNode *ln;
                     listIter li;

diff --git a/tests/unit/type/list.tcl b/tests/unit/type/list.tcl
index 0865551071173ea6d9ff6d47cde317c8861ede32..ecae5d228f09f92e1b0fd6bce01d8bb1eea43864 100644 (file)
--- a/tests/unit/type/list.tcl
+++ b/tests/unit/type/list.tcl
@@ -33,7 +33,7 @@ start_server {
 
         # first lpush then rpush
         assert_equal 1 [r lpush mylist1 $large_value]
 
         # first lpush then rpush
         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 3 [r rpush mylist1 c]
         assert_equal 3 [r llen mylist1]
         assert_equal 2 [r rpush mylist1 b]
         assert_equal 3 [r rpush mylist1 c]
         assert_equal 3 [r llen mylist1]


@@ -43,7 +43,7 @@ start_server {
 
         # first rpush then lpush
         assert_equal 1 [r rpush mylist2 $large_value]
 
         # first rpush then lpush
         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 3 [r lpush mylist2 c]
         assert_equal 3 [r llen mylist2]
         assert_equal 2 [r lpush mylist2 b]
         assert_equal 3 [r lpush mylist2 c]
         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 rpush $key "aaaaaaaaaaaaaaaaa"
         foreach entry $entries { r rpush $key $entry }
         assert_equal "aaaaaaaaaaaaaaaaa" [r lpop $key]
         r del $key
         r rpush $key "aaaaaaaaaaaaaaaaa"
         foreach entry $entries { r rpush $key $entry }
         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" {
             create_$type xlist {b c}
             assert_equal 3 [r rpushx xlist d]
         test "LPUSHX, RPUSHX - $type" {
             create_$type xlist {b c}
             assert_equal 3 [r rpushx xlist d]


@@ -119,18 +119,18 @@ start_server {
         # convert when a large value is pushed
         create_ziplist xlist a
         assert_equal 2 [r rpushx xlist $large_value]
         # convert when a large value is pushed
         create_ziplist xlist a
         assert_equal 2 [r rpushx xlist $large_value]

-        assert_encoding list xlist
+        assert_encoding linkedlist xlist

         create_ziplist xlist a
         assert_equal 2 [r lpushx xlist $large_value]
         create_ziplist xlist a
         assert_equal 2 [r lpushx xlist $large_value]

-        assert_encoding list xlist
+        assert_encoding linkedlist xlist

 
         # convert when the length threshold is exceeded
         create_ziplist xlist [lrepeat 256 a]
         assert_equal 257 [r rpushx xlist b]
 
         # convert when the length threshold is exceeded
         create_ziplist xlist [lrepeat 256 a]
         assert_equal 257 [r rpushx xlist b]

-        assert_encoding list xlist
+        assert_encoding linkedlist xlist

         create_ziplist xlist [lrepeat 256 a]
         assert_equal 257 [r lpushx xlist b]
         create_ziplist xlist [lrepeat 256 a]
         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
         create_ziplist xlist a
         assert_equal 2 [r linsert xlist before a $large_value]
         # convert when a large value is inserted
         create_ziplist xlist a
         assert_equal 2 [r linsert xlist before a $large_value]

-        assert_encoding list xlist
+        assert_encoding linkedlist xlist

         create_ziplist xlist a
         assert_equal 2 [r linsert xlist after a $large_value]
         create_ziplist xlist a
         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
         create_ziplist xlist [lrepeat 256 a]
         assert_equal 257 [r linsert xlist before a a]
 
         # convert when the length threshold is exceeded
         create_ziplist xlist [lrepeat 256 a]
         assert_equal 257 [r linsert xlist before a a]

-        assert_encoding list xlist
+        assert_encoding linkedlist xlist

         create_ziplist xlist [lrepeat 256 a]
         assert_equal 257 [r linsert xlist after a a]
         create_ziplist xlist [lrepeat 256 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
         create_ziplist xlist [lrepeat 256 a]
 
         # don't convert when the value could not be inserted
         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} {
             set len [r llen $key]
             for {set i 0} {$i < $len} {incr i} {
         proc check_numbered_list_consistency {key} {
             set len [r llen $key]
             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" {
             r del mylist1 mylist2
             create_$type mylist1 {a b c d}
         test "RPOPLPUSH base case - $type" {
             r del mylist1 mylist2
             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" {
                 create_$type srclist {a b c d}
                 create_$othertype dstlist {x}
             test "RPOPLPUSH with $type source and existing target $othertype" {
                 create_$type srclist {a b c d}
                 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" {
             create_$type mylist {0 1 2}
             assert_equal 0 [r lpop mylist]
         test "Basic LPOP/RPOP - $type" {
             create_$type mylist {0 1 2}
             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" {
             r del mylist
             set sum1 0
         test "Mass RPOP/LPOP - $type" {
             r del mylist
             set sum1 0


@@ -323,7 +323,7 @@ start_server {
         }
     }
 
         }
     }
 

-    foreach type {ziplist list} {
+    foreach type {ziplist linkedlist} {

         test "LRANGE basics - $type" {
             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]
         test "LRANGE basics - $type" {
             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]


@@ -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} {
             r del mylist
             create_$type mylist {1 2 3 4 5}
         proc trim_list {type min max} {
             r del mylist
             create_$type mylist {1 2 3 4 5}


@@ -384,10 +384,10 @@ start_server {
                 if {$type eq "list"} {
                     r rpush mylist "aaaaaaaaaaaaaaaaa"
                     r rpop mylist
                 if {$type eq "list"} {
                     r rpush mylist "aaaaaaaaaaaaaaaaa"
                     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 max [expr {$min+int(rand()*$startlen)}]
                     set mylist [lrange $mylist $min $max]
                     set min [expr {int(rand()*$startlen)}]
                     set max [expr {$min+int(rand()*$startlen)}]
                     set mylist [lrange $mylist $min $max]


@@ -404,7 +404,7 @@ start_server {
         }
     }
 
         }
     }
 

-    foreach type {ziplist list} {
+    foreach type {ziplist linkedlist} {

         test "LSET - $type" {
             create_$type mylist {99 98 97 96 95}
             r lset mylist 1 foo
         test "LSET - $type" {
             create_$type mylist {99 98 97 96 95}
             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" {
             create_$type mylist {foo bar foobar foobared zap bar test foo}
             assert_equal 2 [r lrem mylist 0 bar]
         test "LREM remove all the occurrences - $type" {
             create_$type mylist {foo bar foobar foobared zap bar test foo}
             assert_equal 2 [r lrem mylist 0 bar]