基本上完善到我理想中的样子了

.vscode/settings.json

@@ -27,6 +27,8 @@
         "unicstl_config.h": "c",
         "iter.h": "c",
         "iterator.h": "c",
-        "assert.h": "c"
+        "assert.h": "c",
+        "limits.h": "c",
+        "cstdint": "c"
     }
 }

include/common.h

@@ -39,4 +39,9 @@
  */
 typedef int (*compare_fun_t)(void* obj, void* obj2);
 
+
+// default function
+int default_compare(void* obj1, void* obj2);
+void default_print_obj(void* obj);
+
 #endif // _COMMON_H_

include/list.h

@@ -18,6 +18,8 @@
 #include "common.h"
 #include "iterator.h"
 
+#define LIST_UNLIMITED  INT32_MAX
+
 struct _list
 {
     // -------------------- private --------------------
@@ -56,13 +58,13 @@ struct _list
     // iter
     iterator_t (*iter)(struct _list *self);
 
-    // config
-    compare_fun_t compare;      // !!! you have to implement this function
-
-    // copy
+    // others
     struct _list* (*slice)(struct _list *self, int start, int end, int step);
     // struct _list* (*copy)(struct _list *self);
     
+    // config
+    compare_fun_t compare;      // !!! you have to implement this function
+
     // -------------------- debug --------------------
     void (*print)(struct _list *self);
     void (*print_obj)(void *obj);

src/list.c

@@ -15,7 +15,7 @@ static bool list_insert(struct _list* self, int index, void* obj)
 {
     // assert(index >= 0 && index < (int)self->size(self));
     // assert(index >= 0 && index <= (int)self->size(self));
-    if(index < 0 || index > (int)self->size(self))
+    if (index < 0 || index >(int)self->size(self))
     {
         return false;
     }
@@ -23,7 +23,7 @@ static bool list_insert(struct _list* self, int index, void* obj)
     if (self->size(self) == self->_capacity)
     {
         int capacity = self->_capacity * self->_ratio;
-        void* obj_new = (void *)realloc(self->obj, capacity * self->_obj_size);
+        void* obj_new = (void*)realloc(self->obj, capacity * self->_obj_size);
         if (obj_new == NULL)
         {
             return false;
@@ -47,7 +47,7 @@ static bool list_delete(struct _list* self, int index, void* obj)
 {
     assert(self != NULL);
     // assert(index >= (int)(0 - self->size(self)) && index < (int)self->size(self));
-    if(index < (int)(0 - self->size(self)) || index >= (int)self->size(self))
+    if (index < (int)(0 - self->size(self)) || index >= (int)self->size(self))
     {
         return false;
     }
@@ -92,14 +92,14 @@ static int list_index(struct _list* self, void* obj)
 {
     assert(self != NULL);
     int index = 0;
-    if(obj == NULL)
+    if (obj == NULL)
     {
         return -1;
     }
 
-    while(index < (int)self->size(self))
+    while (index < (int)self->size(self))
     {
-        if(self->compare(self->obj + index * self->_obj_size, obj) == 0)
+        if (self->compare(self->obj + index * self->_obj_size, obj) == 0)
         {
             return index;
         }
@@ -189,11 +189,154 @@ static void list_print(struct _list* self)
     }
 }
 
+static int list_index_exchange(struct _list* self, int index)
+{
+    assert(self != NULL);
+    int size = (int)self->size(self);
+
+    if (index < 0)
+    {
+        index += size;
+        if (index < 0)
+        {
+            index = 0;
+        }
+    }
+    else
+    {
+        if (index > size)
+        {
+            index = size;
+        }
+    }
+    return index;
+}
+
+
+/**
+ * @brief list slice
+ *  if index < 0, from the end of list. for example:
+ *  list[-1] is the last element in list.
+ *
+ * @param self
+ * @param start start index
+ * @param end end index
+ * @param step step, if step < 0, return a reverse list.
+ * @return struct _list*
+ *  a copy of the list, from start to end, step by step.
+ *      if step < 0, return a reverse list.
+ *      if step > 0, return a forward list.
+ *      if step == 0, return NULL.
+ */
+struct _list* list_slice(struct _list* self, int start, int end, int step)
+{
+    assert(self != NULL);
+    int i = 0;
+    bool contains_last_obj = false;
+    int size = (int)self->size(self);
+    int capicity = 1;
+    list_t list = NULL;
+
+    if (step == 0)
+    {
+        return NULL;
+    }
+
+    if (step > 0)
+    {
+        if (start == LIST_UNLIMITED)
+        {
+            start = 0;
+        }
+
+        if (end == LIST_UNLIMITED)
+        {
+            end = size;
+        }
+    }
+    else
+    {
+        if (start == LIST_UNLIMITED)
+        {
+            start = size - 1;
+        }
+
+        if (end == LIST_UNLIMITED)
+        {
+            end = 0;
+            contains_last_obj = true;
+        }
+    }
+
+    start = list_index_exchange(self, start);
+    end = list_index_exchange(self, end);
+
+    if(abs(end - start) != 0)
+    {
+        capicity = abs(end - start);
+    }
+    list = list_new2(self->_obj_size, capicity);
+    if (list == NULL)
+    {
+        return NULL;
+    }
+    list->compare = self->compare;
+    list->print_obj = self->print_obj;
+
+    if (step > 0)
+    {
+        if (start >= end)
+        {
+            goto done;
+        }
+
+        if (contains_last_obj != true)
+        {
+            for (i = start; i < end; i += step)
+            {
+                list->append(list, (char*)self->obj + i * self->_obj_size);
+            }
+        }
+        else
+        {
+            for (i = start; i <= end; i += step)
+            {
+                list->append(list, (char*)self->obj + i * self->_obj_size);
+            }
+        }
+    }
+    else /*if(step < 0)*/
+    {
+        if (start <= end)
+        {
+            goto done;
+        }
+
+        if (contains_last_obj != true)
+        {
+            for (i = start; i > end; i += step)
+            {
+                list->append(list, (char*)self->obj + i * self->_obj_size);
+            }
+        }
+        else
+        {
+            for (i = start; i >= end; i += step)
+            {
+                list->append(list, (char*)self->obj + i * self->_obj_size);
+            }
+        }
+    }
+
+done:
+    return list;
+}
+
 static bool list_iter_hasnext(struct _iterator* iter)
 {
     list_t self = (list_t)iter->_container;
 
-    if(iter->_index < self->size(self))
+    if (iter->_index < self->size(self))
     {
         return true;
     }
@@ -203,7 +346,7 @@ static bool list_iter_hasnext(struct _iterator* iter)
 static const void* list_iter_next(struct _iterator* iter)
 {
     list_t self = (list_t)iter->_container;
-    void *obj = self->obj + iter->_index * self->_obj_size;
+    void* obj = self->obj + iter->_index * self->_obj_size;
     iter->_index += 1;
     return obj;
 }
@@ -224,7 +367,7 @@ iterator_t list_iter(struct _list* self)
 static bool list_init2(struct _list* list, uint32_t obj_size, uint32_t capacity)
 {
     assert(list != NULL);
-    if(list == NULL || obj_size == 0 || capacity == 0)
+    if (list == NULL || obj_size == 0 || capacity == 0)
     {
         return false;
     }
@@ -270,7 +413,13 @@ static bool list_init2(struct _list* list, uint32_t obj_size, uint32_t capacity)
     // iter
     list->iter = list_iter;
 
+    // others
+    list->slice = list_slice;
+
+    // config
+    list->compare = default_compare;
     // -------------------- debug --------------------
+    list->print_obj = default_print_obj;
     list->print = list_print;
 
     return true;
@@ -280,12 +429,12 @@ list_t list_new2(uint32_t obj_size, uint32_t capacity)
 {
     struct _list* list = NULL;
     list = (struct _list*)calloc(1, sizeof(struct _list));
-    if(list == NULL)
+    if (list == NULL)
     {
         return NULL;
     }
 
-    if(list_init2(list, obj_size, capacity) != true)
+    if (list_init2(list, obj_size, capacity) != true)
     {
         free(list);
         return NULL;
@@ -296,9 +445,9 @@ list_t list_new2(uint32_t obj_size, uint32_t capacity)
 void list_free(list_t* list)
 {
     assert(list != NULL);
-    if(list != NULL && *list != NULL)
+    if (list != NULL && *list != NULL)
     {
-        if((*list)->_destory != NULL)
+        if ((*list)->_destory != NULL)
         {
             (*list)->_destory(*list);
         }

src/unicstl_internal.c

@@ -0,0 +1,23 @@
+/**
+ * @file unicstl_internal.c
+ * @author wenjf (Orig5826@163.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-04-29
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#include "common.h"
+
+int default_compare(void* obj1, void* obj2)
+{
+    printf("compare is not implemented!\n");
+    assert(0);
+}
+
+void default_print_obj(void* obj)
+{
+    printf("print_obj is not implemented!\n");
+    assert(0);
+}

test/test_list.c

@@ -26,7 +26,6 @@ static void test_list_new(void)
     TEST_ASSERT_NULL(list_new2(sizeof(int), 0));
 }
 
-
 static void test_list_append(void)
 {
     int temp = 0;
@@ -62,7 +61,6 @@ static void test_list_append(void)
     list_free(&list);
 }
 
-
 static void test_list_pop(void)
 {
     int temp = 0;
@@ -87,6 +85,78 @@ static void test_list_pop(void)
     list_free(&list);
 }
 
+static void test_list_insert(void)
+{
+    int temp = 0;
+    int data[] = { 1,2,3,4,5,6,7,8,9,10 };
+    uint32_t len = sizeof(data) / sizeof(data[0]);
+    uint32_t i = 0;
+
+    list_t list = NULL;
+
+    // ------------------------------
+    list = list_new2(sizeof(int), len);
+    list->print_obj = print_num;
+
+    TEST_ASSERT_TRUE(list->empty(list));
+    for (i = 0; i < len; i++)
+    {
+        TEST_ASSERT_TRUE(list->insert(list, i, &data[i]));
+        TEST_ASSERT_EQUAL_INT(i + 1, list->size(list));
+
+        TEST_ASSERT_TRUE(list->get(list, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+
+        // list->print(list);
+        // printf("\n");
+    }
+    list->clear(list);
+    TEST_ASSERT_TRUE(list->empty(list));
+
+    for (i = 0; i < len; i++)
+    {
+        TEST_ASSERT_TRUE(list->insert(list, 0, &data[i]));
+        TEST_ASSERT_EQUAL_INT(i + 1, list->size(list));
+
+        TEST_ASSERT_TRUE(list->get(list, 0, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+
+        // list->print(list);
+        // printf("\n");
+    }
+
+    TEST_ASSERT_FALSE(list->empty(list));
+    list_free(&list);
+}
+
+static void test_list_delete(void)
+{
+    int temp = 0;
+    int data[] = { 1,2,3,4,5,6,7,8,9,10 };
+    uint32_t len = sizeof(data) / sizeof(data[0]);
+    uint32_t i = 0;
+
+    list_t list = NULL;
+
+    // ------------------------------
+    list = list_new2(sizeof(int), len);
+    for (i = 0; i < len; i++)
+    {
+        list->append(list, &data[i]);
+    }
+
+    TEST_ASSERT_TRUE(list->delete(list, len - 1, &temp));
+    TEST_ASSERT_EQUAL_INT(data[len - 1], temp);
+
+    for (i = 0; i < len - 1; i++)
+    {
+        TEST_ASSERT_TRUE(list->delete(list, 0, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+    }
+    TEST_ASSERT_TRUE(list->empty(list));
+    TEST_ASSERT_FALSE(list->pop(list, &temp));
+    list_free(&list);
+}
 
 static void test_list_clear(void)
 {
@@ -322,7 +392,6 @@ void test_list_iter(void)
     list_free(&list);
 }
 
-
 static void test_list_index(void)
 {
     int temp = 0;
@@ -350,13 +419,350 @@ static void test_list_index(void)
     list_free(&list);
 }
 
+static void test_list_slice_empty(void)
+{
+    int temp = 0;
+    int data[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    uint32_t len = sizeof(data) / sizeof(data[0]);
+    uint32_t i = 0;
+
+    list_t list = NULL;
+    list_t list2 = NULL;
+
+    // ------------------------------
+    list = list_new2(sizeof(int), len);
+    list->compare = compare_num;
+    list->print_obj = print_num;
+
+    for (i = 0; i < len; i++)
+    {
+        TEST_ASSERT_TRUE(list->append(list, &data[i]));
+    }
+
+    // -------------------- NULL --------------------
+    // python: list[0:] -> []
+    list2 = list->slice(list, 1, 5, 0); // if step == 0
+    TEST_ASSERT_NULL(list2);
+    // list_free(&list2);
+
+    // -------------------- empty --------------------
+    list2 = list->slice(list, 0, 0, 1); // if start == end
+    TEST_ASSERT_NOT_NULL(list2);
+    TEST_ASSERT_TRUE(list2->empty(list2));
+    list_free(&list2);
+
+    list2 = list->slice(list, len, LIST_UNLIMITED, 1); // if start == end
+    TEST_ASSERT_NOT_NULL(list2);
+    TEST_ASSERT_TRUE(list2->empty(list2));
+    list_free(&list2);
+
+    list2 = list->slice(list, 1, 5, -1); // if start < end && step < 0
+    TEST_ASSERT_NOT_NULL(list2);
+    TEST_ASSERT_TRUE(list2->empty(list2));
+    list_free(&list2);
+
+    list2 = list->slice(list, 5, 1, 1); // if start > end && step > 0
+    TEST_ASSERT_NOT_NULL(list2);
+    TEST_ASSERT_TRUE(list2->empty(list2));
+    list_free(&list2);
+
+    list2 = list->slice(list, -1, -5, 1); // if start < end && step < 0
+    TEST_ASSERT_NOT_NULL(list2);
+    TEST_ASSERT_TRUE(list2->empty(list2));
+    list_free(&list2);
+
+    list2 = list->slice(list, -5, -1, -1); // if start > end && step > 0
+    TEST_ASSERT_NOT_NULL(list2);
+    TEST_ASSERT_TRUE(list2->empty(list2));
+    list_free(&list2);
+
+    // -------------------- empty --------------------
+    list2 = list->slice(list, len, len + 1, 1); // if start > start_max
+    TEST_ASSERT_NOT_NULL(list2);
+    TEST_ASSERT_TRUE(list2->empty(list2));
+    list_free(&list2);
+
+    list2 = list->slice(list, -len - 1, -len, 1); // if end < end_min
+    TEST_ASSERT_NOT_NULL(list2);
+    TEST_ASSERT_TRUE(list2->empty(list2));
+    list_free(&list2);
+
+    list_free(&list);
+}
+
+static void test_list_slice_positive(void)
+{
+    int temp = 0;
+    int data[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    uint32_t len = sizeof(data) / sizeof(data[0]);
+    uint32_t i = 0;
+
+    list_t list = NULL;
+    list_t list2 = NULL;
+
+    // ------------------------------
+    list = list_new2(sizeof(int), len);
+    list->compare = compare_num;
+    list->print_obj = print_num;
+
+    for (i = 0; i < len; i++)
+    {
+        TEST_ASSERT_TRUE(list->append(list, &data[i]));
+    }
+
+    // -------------------- elements --------------------
+    // python: list[0:]
+    list2 = list->slice(list, 0, len, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(len, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+    }
+    list_free(&list2);
+
+    // python: list[0:11] if len(list) == 10
+    list2 = list->slice(list, 0, len + 1, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    // list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(len, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+    }
+    list_free(&list2);
+
+    // python: list[-6:8] or list[-6:-2] or list[4:8]
+    list2 = list->slice(list, 4, 8, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(4, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[len - 6 + i], temp);
+    }
+    list_free(&list2);
+
+    // python: list[4:0:-1]
+    list2 = list->slice(list, 4, 0, -1);
+    TEST_ASSERT_NOT_NULL(list2);
+    // list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(4, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[list2->size(list2) - i], temp);
+    }
+    list_free(&list2);
+
+    // python: list[::2]
+    list2 = list->slice(list, 0, len, 2);
+    TEST_ASSERT_NOT_NULL(list2);
+    // list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(5, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i * 2], temp);
+    }
+    list_free(&list2);
+
+    list_free(&list);
+}
+
+static void test_list_slice_negative(void)
+{
+    int temp = 0;
+    int data[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    uint32_t len = sizeof(data) / sizeof(data[0]);
+    uint32_t i = 0;
+
+    list_t list = NULL;
+    list_t list2 = NULL;
+
+    // ------------------------------
+    list = list_new2(sizeof(int), len);
+    list->compare = compare_num;
+    list->print_obj = print_num;
+
+    for (i = 0; i < len; i++)
+    {
+        TEST_ASSERT_TRUE(list->append(list, &data[i]));
+    }
+
+    // -------------------- elements --------------------
+    // python: list[:-1]
+    list2 = list->slice(list, 0, -1, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(len - 1, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+    }
+    list_free(&list2);
+
+    // python: list[:-1]
+    list2 = list->slice(list, -1, len, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(1, list2->size(list2));
+    TEST_ASSERT_TRUE(list2->get(list2, 0, &temp));
+    TEST_ASSERT_EQUAL_INT(data[len - 1], temp);
+    list_free(&list2);
+
+    // python: list[-6:8] or list[-6:-2]
+    // list2 = list->slice(list, -6, 8, 1);   // It can be executed, but it's not intuitive
+    list2 = list->slice(list, -6, -2, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(4, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[len - 6 + i], temp);
+    }
+    list_free(&list2);
+
+    // -------------------- step == 2 --------------------
+    // python: list[::-2]
+    list2 = list->slice(list, len-1, 0, -2);
+    TEST_ASSERT_NOT_NULL(list2);
+    // list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(5, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[9 - i * 2], temp);
+    }
+    list_free(&list2);
+
+    // -------------------- start_limit --------------------
+    // list[-len-1:-1]
+    list2 = list->slice(list, -len-1, -1, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    // list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(len - 1, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+    }
+    list_free(&list2);
+
+    list_free(&list);
+}
+
+
+static void test_list_slice_unlimited(void)
+{
+    int temp = 0;
+    int data[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    uint32_t len = sizeof(data) / sizeof(data[0]);
+    uint32_t i = 0;
+
+    list_t list = NULL;
+    list_t list2 = NULL;
+
+    // ------------------------------
+    list = list_new2(sizeof(int), len);
+    list->compare = compare_num;
+    list->print_obj = print_num;
+
+    for (i = 0; i < len; i++)
+    {
+        TEST_ASSERT_TRUE(list->append(list, &data[i]));
+    }
+
+    // -------------------- umlimited --------------------
+    // python: list[0:]
+    list2 = list->slice(list, 0, LIST_UNLIMITED, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(len, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+    }
+    list_free(&list2);
+    
+    // python: list[4::-1]
+    list2 = list->slice(list, 4, LIST_UNLIMITED, -1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(5, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[list2->size(list2) - 1 - i], temp);
+    }
+    list_free(&list2);
+
+    list2 = list->slice(list, LIST_UNLIMITED, LIST_UNLIMITED, 1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(len, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i], temp);
+    }
+    list_free(&list2);
+
+    list2 = list->slice(list, LIST_UNLIMITED, LIST_UNLIMITED, -1);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(len, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[list2->size(list2) - 1 - i], temp);
+    }
+    list_free(&list2);
+
+    // -------------------- step == 2 --------------------
+    list2 = list->slice(list, LIST_UNLIMITED, LIST_UNLIMITED, 2);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(5, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[i * 2], temp);
+    }
+    list_free(&list2);
+
+    list2 = list->slice(list, LIST_UNLIMITED, LIST_UNLIMITED, -2);
+    TEST_ASSERT_NOT_NULL(list2);
+    //list2->print(list2); printf("\n");
+    TEST_ASSERT_EQUAL_INT(5, list2->size(list2));
+    for(i = 0; i < list2->size(list2); i++)
+    {
+        TEST_ASSERT_TRUE(list2->get(list2, i, &temp));
+        TEST_ASSERT_EQUAL_INT(data[9 - i*2], temp);
+    }
+    list_free(&list2);
+
+    list_free(&list);
+}
+
 void test_list(void)
 {
     UnitySetTestFile(__FILE__);
 
     RUN_TEST(test_list_new);
+
     RUN_TEST(test_list_append);
     RUN_TEST(test_list_pop);
+    RUN_TEST(test_list_insert);
+    RUN_TEST(test_list_delete);
+
     RUN_TEST(test_list_clear);
 
     RUN_TEST(test_list_num);
@@ -365,4 +771,9 @@ void test_list(void)
     RUN_TEST(test_list_iter);
 
     RUN_TEST(test_list_index);
+
+    RUN_TEST(test_list_slice_empty);
+    RUN_TEST(test_list_slice_positive);
+    RUN_TEST(test_list_slice_negative);
+    RUN_TEST(test_list_slice_unlimited);
 }