test: added tests for set

src/arraylist.c

@@ -162,9 +162,9 @@ ArrayListErr arraylist_push_front(ArrayList *arr, void *data) {
 
     // No problem if array is full because  it grows if it's full
     memmove(
-        arr->buffer,
         arr->buffer + arr->elem_size,
-        (arr->len - 1) * arr->elem_size
+        arr->buffer,
+        (arr->len) * arr->elem_size
     );
 
     memcpy(
@@ -260,8 +260,8 @@ ArrayListErr arraylist_pop_front(ArrayList *arr, void *out) {
     }
 
     memmove(
-        arr->buffer + arr->elem_size,
         arr->buffer,
+        arr->buffer + arr->elem_size,
         (arr->len - 1) * arr->elem_size);
 
     arr->len--;
@@ -290,13 +290,10 @@ ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out) {
         );
     }
 
-    for (size_t i = index; i < arr->len; i++) {
-        memcpy(
-            arr->buffer + (index * arr->elem_size),
-            arr->buffer + ((i + 1) * arr->elem_size),
-            arr->elem_size
-        );
-    }
+    memmove(
+        arr->buffer + (index * arr->elem_size),
+        arr->buffer + ((index + 1) * arr->elem_size),
+        (arr->len - index) * arr->elem_size);
 
     arr->len--;
 

test/test_arraylist.c

@@ -254,6 +254,635 @@ static void test_push_back_null_data(void **state) {
     arraylist_destroy(&arr);
 }
 
+// Push front
+static void test_push_front_single_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 1);
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(m, 8);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_push_front_multiple_elements(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    int n = 8;
+    int m;
+
+    for (size_t i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), i + 1);
+        assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+        assert_uint_equal(m, n);
+        n++;
+    }
+
+    arraylist_destroy(&arr);
+}
+
+static void test_push_front_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    int n = 8;
+    assert_int_equal(arraylist_push_front(arr, &n), ARRLIST_NULL_ARG);
+}
+
+static void test_push_front_null_data(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG);
+
+    arraylist_destroy(&arr);
+}
+
+// Insert
+static void test_insert_at_beginning(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 11);
+    assert_uint_equal(n, m);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_insert_at_middle(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_insert(arr, 5, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 5, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 11);
+    assert_uint_equal(n, m);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_insert_at_end(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_insert(arr, 10, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 10, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 11);
+    assert_uint_equal(n, m);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_insert_at_invalid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+
+    int n = 8;
+    assert_uint_equal(arraylist_insert(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_insert_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    int n = 8;
+    assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_NULL_ARG);
+}
+
+static void test_insert_null_data(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+
+    assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG);
+
+    arraylist_destroy(&arr);
+}
+
+// Pop back
+static void test_pop_back_single_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
+    assert_uint_equal(m, 9);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_pop_back_multiple_elements(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    for (int i = 9; i >= 5; i--) {
+        assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), i);
+        assert_uint_equal(m, i);
+    }
+
+    arraylist_destroy(&arr);
+}
+
+static void test_pop_back_until_empty(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    for (int i = 9; i >= 0; i--) {
+        assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), i);
+        assert_uint_equal(m, i);
+    }
+
+    assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_EMPTY);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_pop_back_empty_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    int n;
+    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_EMPTY);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_pop_back_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    int n;
+    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_NULL_ARG);
+}
+
+static void test_pop_back_null_out(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+
+    assert_uint_equal(arraylist_pop_back(arr, NULL), ARRLIST_OK);
+
+    arraylist_destroy(&arr);
+}
+
+// Pop front
+static void test_pop_front_single_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
+    assert_uint_equal(m, 0);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_pop_front_multiple_elements(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    size_t size = arraylist_size(arr);
+    for (int i = 0; i < 6; i++) {
+        assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), size - (i + 1));
+        assert_uint_equal(m, i);
+    }
+
+    arraylist_destroy(&arr);
+}
+
+static void test_pop_front_until_empty(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    size_t size = arraylist_size(arr);
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), size - (i + 1));
+        assert_uint_equal(m, i);
+    }
+
+    assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_EMPTY);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_pop_front_empty_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    int n;
+    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_EMPTY);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_pop_front_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    int n;
+    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_NULL_ARG);
+}
+
+static void test_pop_front_null_out(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+
+    assert_uint_equal(arraylist_pop_front(arr, NULL), ARRLIST_OK);
+
+    arraylist_destroy(&arr);
+}
+
+// Remove at
+static void test_remove_at_beginning(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_remove_at(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 9);
+    assert_uint_equal(m, 0);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_remove_at_middle(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_remove_at(arr, 5, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 9);
+    assert_uint_equal(m, 5);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_remove_at_end(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_remove_at(arr, 9, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 9);
+    assert_uint_equal(m, 9);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_remove_at_invalid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+
+    int n = 8;
+    assert_uint_equal(arraylist_remove_at(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_remove_at_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    int n = 8;
+    assert_uint_equal(arraylist_remove_at(arr, 0, &n), ARRLIST_NULL_ARG);
+}
+
+static void test_remove_at_null_data(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+
+    assert_uint_equal(arraylist_remove_at(arr, 0, NULL), ARRLIST_OK);
+
+    arraylist_destroy(&arr);
+}
+
+// Get
+static void test_get_valid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK);
+    assert_uint_equal(m, 6);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_get_first_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(m, 0);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_get_last_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK);
+    assert_uint_equal(m, 9);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_get_invalid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_OUT_OF_BOUNDS);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_get_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_NULL_ARG);
+}
+
+static void test_get_null_out(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    assert_uint_equal(arraylist_get(arr, 8, NULL), ARRLIST_NULL_ARG);
+
+    arraylist_destroy(&arr);
+}
+
+// Set
+static void test_set_valid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 6, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_set_first_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 0, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_set_last_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 9, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_set_invalid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_set_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    int n = 8;
+    assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG);
+
+}
+
+static void test_set_null_data(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG);
+
+    arraylist_destroy(&arr);
+}
+
 int main(void) {
     const struct CMUnitTest init[] = {
         cmocka_unit_test(test_init_valid_parameters),
@@ -284,12 +913,80 @@ int main(void) {
         cmocka_unit_test(test_push_back_null_data),
     };
 
+    const struct CMUnitTest push_front[] = {
+        cmocka_unit_test(test_push_front_single_element),
+        cmocka_unit_test(test_push_front_multiple_elements),
+        cmocka_unit_test(test_push_front_null_array),
+        cmocka_unit_test(test_push_front_null_data),
+    };
+
+    const struct CMUnitTest insert[] = {
+        cmocka_unit_test(test_insert_at_beginning),
+        cmocka_unit_test(test_insert_at_middle),
+        cmocka_unit_test(test_insert_at_end),
+        cmocka_unit_test(test_insert_at_invalid_index),
+        cmocka_unit_test(test_insert_null_array),
+        cmocka_unit_test(test_insert_null_data),
+    };
+
+    const struct CMUnitTest pop_back[] = {
+        cmocka_unit_test(test_pop_back_single_element),
+        cmocka_unit_test(test_pop_back_multiple_elements),
+        cmocka_unit_test(test_pop_back_until_empty),
+        cmocka_unit_test(test_pop_back_empty_array),
+        cmocka_unit_test(test_pop_back_null_array),
+        cmocka_unit_test(test_pop_back_null_out),
+    };
+
+    const struct CMUnitTest pop_front[] = {
+        cmocka_unit_test(test_pop_front_single_element),
+        cmocka_unit_test(test_pop_front_multiple_elements),
+        cmocka_unit_test(test_pop_front_until_empty),
+        cmocka_unit_test(test_pop_front_empty_array),
+        cmocka_unit_test(test_pop_front_null_array),
+        cmocka_unit_test(test_pop_front_null_out),
+    };
+
+    const struct CMUnitTest remove_at[] = {
+        cmocka_unit_test(test_remove_at_beginning),
+        cmocka_unit_test(test_remove_at_middle),
+        cmocka_unit_test(test_remove_at_end),
+        cmocka_unit_test(test_remove_at_invalid_index),
+        cmocka_unit_test(test_remove_at_null_array),
+        cmocka_unit_test(test_remove_at_null_data),
+    };
+
+    const struct CMUnitTest get[] = {
+        cmocka_unit_test(test_get_valid_index),
+        cmocka_unit_test(test_get_first_element),
+        cmocka_unit_test(test_get_last_element),
+        cmocka_unit_test(test_get_invalid_index),
+        cmocka_unit_test(test_get_null_array),
+        cmocka_unit_test(test_get_null_out),
+    };
+
+    const struct CMUnitTest set[] = {
+        cmocka_unit_test(test_set_valid_index),
+        cmocka_unit_test(test_set_first_element),
+        cmocka_unit_test(test_set_last_element),
+        cmocka_unit_test(test_set_invalid_index),
+        cmocka_unit_test(test_set_null_array),
+        cmocka_unit_test(test_set_null_data),
+    };
+
     int rc = 0;
 
     rc += cmocka_run_group_tests(init, NULL, NULL);
     rc += cmocka_run_group_tests(destroy, NULL, NULL);
     rc += cmocka_run_group_tests(state, NULL, NULL);
     rc += cmocka_run_group_tests(push_back, NULL, NULL);
+    rc += cmocka_run_group_tests(push_front, NULL, NULL);
+    rc += cmocka_run_group_tests(insert, NULL, NULL);
+    rc += cmocka_run_group_tests(pop_back, NULL, NULL);
+    rc += cmocka_run_group_tests(pop_front, NULL, NULL);
+    rc += cmocka_run_group_tests(remove_at, NULL, NULL);
+    rc += cmocka_run_group_tests(get, NULL, NULL);
+    rc += cmocka_run_group_tests(set, NULL, NULL);
 
     return rc;
 }