LinkedList-ADT/tests/test_linkedlist.c

#include "linkedlist.h"
#include <stdlib.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <setjmp.h>
#include <cmocka.h>

static void linkedlist_test_append_3_int(void **state) {
    (void) state;

    LinkedList *ll;
    linkedlist_create(&ll, sizeof(int));
    for (int i = 10; i < 13; i++) {
        linkedlist_append(ll, &i);
    }
    for (int i = 0; i < 3; i++) {
        int n;
        linkedlist_get(ll, i, &n);
        assert_int_equal(n, i + 10);
    }
    linkedlist_destroy(ll);
}

static void linkedlist_test_delete_head(void **state) {
    (void) state;

    LinkedList *ll;
    linkedlist_create(&ll, sizeof(int));
    for (int i = 0; i < 3; i++) {
        linkedlist_append(ll, &i);
    }
    linkedlist_delete(ll, 0);
    size_t len;
    linkedlist_len(ll,&len);
    assert_int_equal(len, 2);
    for (int i = 0; i < 2; i++) {
        int n;
        linkedlist_get(ll, i, &n);
        assert_int_equal(n, i + 1);
    }
    linkedlist_destroy(ll);
}

static void linkedlist_test_delete_end(void **state) {
    (void) state;

    LinkedList *ll;
    linkedlist_create(&ll, sizeof(int));
    for (int i = 0; i < 3; i++) {
        linkedlist_append(ll, &i);
    }

    linkedlist_delete(ll, 2);

    size_t len;
    linkedlist_len(ll, &len);
    assert_int_equal(len, 2);

    for (int i = 0; i < 2; i++) {
        int n;
        linkedlist_get(ll, i, &n);
        assert_int_equal(n, i);
    }
    linkedlist_destroy(ll);
}

static void linkedlist_test_delete_middle(void **state) {
    (void) state;

    LinkedList *ll;
    linkedlist_create(&ll, sizeof(int));
    for (int i = 0; i < 3; i++) {
        linkedlist_append(ll, &i);
    }

    linkedlist_delete(ll, 1);

    size_t len;
    linkedlist_len(ll, &len);
    assert_int_equal(len, 2);

    int n1;
    int n2;
    linkedlist_get(ll, 0, &n1);
    linkedlist_get(ll, 1, &n2);
    assert_int_equal(n1, 0);
    assert_int_equal(n2, 2);

    linkedlist_destroy(ll);
}

static void linkedlist_test_insert_head(void **state) {
    (void) state;

    LinkedList *ll;
    linkedlist_create(&ll, sizeof(int));
    for (int i = 0; i < 3; i++) {
        linkedlist_append(ll, &i);
    }

    int val = 3;
    linkedlist_insert(ll, 0, &val);

    size_t len;
    linkedlist_len(ll, &len);
    assert_int_equal(len, 4);

    int n;
    linkedlist_get(ll, 0, &n);
    assert_int_equal(n, 3);

    linkedlist_get(ll, 1, &n);
    assert_int_equal(n, 0);

    linkedlist_get(ll, 2, &n);
    assert_int_equal(n, 1);

    linkedlist_get(ll, 3, &n);
    assert_int_equal(n, 2);
 
    linkedlist_destroy(ll);
}

static void linkedlist_test_insert_end(void **state) {
    (void) state;

    LinkedList *ll;
    linkedlist_create(&ll, sizeof(int));
    for (int i = 0; i < 3; i++) {
        linkedlist_append(ll, &i);
    }

    int val = 3;
    linkedlist_insert(ll, 2, &val);

    size_t len;
    linkedlist_len(ll, &len);
    assert_int_equal(len, 4);

    int n;
    linkedlist_get(ll, 0, &n);
    assert_int_equal(n, 0);

    linkedlist_get(ll, 1, &n);
    assert_int_equal(n, 1);

    linkedlist_get(ll, 2, &n);
    assert_int_equal(n, 2);

    linkedlist_get(ll, 3, &n);
    assert_int_equal(n, 3);
    
    linkedlist_destroy(ll);
}

static void linkedlist_test_insert_middle(void **state) {
    (void) state;

    LinkedList *ll;
    linkedlist_create(&ll, sizeof(int));
    for (int i = 0; i < 4; i++) {
        linkedlist_append(ll, &i);
    }

    int val = 5;
    linkedlist_insert(ll, 2, &val);

    size_t len;
    linkedlist_len(ll, &len);
    assert_int_equal(len, 5);

    int n;
    linkedlist_get(ll, 0, &n);
    assert_int_equal(n, 0);

    linkedlist_get(ll, 1, &n);
    assert_int_equal(n, 1);

    linkedlist_get(ll, 2, &n);
    assert_int_equal(n, 2);

    linkedlist_get(ll, 3, &n);
    assert_int_equal(n, 5);

    linkedlist_get(ll, 4, &n);
    assert_int_equal(n, 3);

    linkedlist_destroy(ll);
}

int main(void) {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(linkedlist_test_append_3_int),
        cmocka_unit_test(linkedlist_test_delete_head),
        cmocka_unit_test(linkedlist_test_delete_end),
        cmocka_unit_test(linkedlist_test_delete_middle),   
        cmocka_unit_test(linkedlist_test_insert_head),   
        cmocka_unit_test(linkedlist_test_insert_middle),   
        cmocka_unit_test(linkedlist_test_insert_end),   
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}