.vscode/settings.json

@@ -27,8 +27,6 @@
         "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,9 +39,4 @@
  */
 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,8 +18,6 @@
 #include "common.h"
 #include "iterator.h"
 
-#define LIST_UNLIMITED  INT32_MAX
-
 struct _list
 {
     // -------------------- private --------------------
@@ -58,13 +56,13 @@ struct _list
     // iter
     iterator_t (*iter)(struct _list *self);
 
-    // 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
 
+    // copy
+    struct _list* (*slice)(struct _list *self, int start, int end, int step);
+    // struct _list* (*copy)(struct _list *self);
+    
     // -------------------- debug --------------------
     void (*print)(struct _list *self);
     void (*print_obj)(void *obj);

src/list.c

@@ -1,12 +1,12 @@
 /**
  * @file list.c
  * @author wenjf (Orig5826@163.com)
- * @brief
+ * @brief 
  * @version 0.1
  * @date 2024-06-23
- *
+ * 
  * @copyright Copyright (c) 2024
- *
+ * 
  */
 #include "list.h"
 
@@ -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,154 +189,11 @@ 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;
     }
@@ -346,7 +203,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;
 }
@@ -367,7 +224,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;
     }
@@ -413,15 +270,9 @@ static bool list_init2(struct _list* list, uint32_t obj_size, uint32_t capacity)
     // iter
     list->iter = list_iter;
 
-    // others
+    // -------------------- debug -------------------- 
-    list->slice = list_slice;
-
-    // config
-    list->compare = default_compare;
-    // -------------------- debug --------------------
-    list->print_obj = default_print_obj;
     list->print = list_print;
-
+    
     return true;
 }
 
@@ -429,12 +280,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;
@@ -445,9 +296,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

@@ -1,23 +0,0 @@
-/**
- * @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,6 +26,7 @@ static void test_list_new(void)
     TEST_ASSERT_NULL(list_new2(sizeof(int), 0));
 }
 
+
 static void test_list_append(void)
 {
     int temp = 0;
@@ -61,6 +62,7 @@ static void test_list_append(void)
     list_free(&list);
 }
 
+
 static void test_list_pop(void)
 {
     int temp = 0;
@@ -85,78 +87,6 @@ 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)
 {
@@ -392,6 +322,7 @@ void test_list_iter(void)
     list_free(&list);
 }
 
+
 static void test_list_index(void)
 {
     int temp = 0;
@@ -419,350 +350,13 @@ 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);
@@ -771,9 +365,4 @@ 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);
 }