ccore/test/modules/ListTests.c

#include "../Tests.h"
#include "core/List.h"
#include "core/ToString.h"
#include "core/Utility.h"
#include "core/Vector.h"

static void testAdd() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 5);
    CORE_TEST_SIZE(5, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(5, coreListGetC(&list, 0, size_t));
    CORE_TEST_SIZE(1, list.length);
    coreDestroyList(&list);
}

static void testMultipleAdd() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 4);
    coreListAdd(&list, size_t, 3);
    coreListAdd(&list, size_t, 2);
    CORE_TEST_SIZE(4, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(3, coreListGet(&list, 1, size_t));
    CORE_TEST_SIZE(2, coreListGet(&list, 2, size_t));
    CORE_TEST_SIZE(2, coreListLast(&list, size_t));
    CORE_TEST_SIZE(4, coreListGetC(&list, 0, size_t));
    CORE_TEST_SIZE(3, coreListGetC(&list, 1, size_t));
    CORE_TEST_SIZE(2, coreListGetC(&list, 2, size_t));
    CORE_TEST_SIZE(2, coreListLastC(&list, size_t));
    CORE_TEST_SIZE(3, list.length);
    coreDestroyList(&list);
}

static void testAddLast() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 4);
    coreListAdd(&list, size_t, 3);
    coreListAddLast(&list);
    CORE_TEST_SIZE(4, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(3, coreListGet(&list, 1, size_t));
    CORE_TEST_SIZE(3, coreListGet(&list, 2, size_t));
    CORE_TEST_SIZE(3, list.length);
    coreDestroyList(&list);
}

static void testAddReplace() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 5);
    coreListGet(&list, 0, size_t) = 3;
    CORE_TEST_SIZE(3, coreListGet(&list, 0, size_t));
    coreDestroyList(&list);
}

static void testClear() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 5);
    coreListAdd(&list, size_t, 4);
    coreClearList(&list);
    CORE_TEST_SIZE(0, list.length);
    coreDestroyList(&list);
}

static void testShrink() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 5);
    coreListAdd(&list, size_t, 4);
    coreListAdd(&list, size_t, 3);
    CORE_TEST_TRUE(list.capacity >= 3);
    coreShrinkList(&list);
    CORE_TEST_SIZE(3, list.length);
    CORE_TEST_SIZE(3, list.capacity);
    CORE_TEST_SIZE(5, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(4, coreListGet(&list, 1, size_t));
    CORE_TEST_SIZE(3, coreListGet(&list, 2, size_t));
    coreDestroyList(&list);
}

static void testBigAdd(bool light) {
    size_t limit = light ? 10000 : 100000;
    CoreList list = CORE_LIST(sizeof(size_t));
    for(size_t i = 0; i < limit; i++) {
        coreListAdd(&list, size_t, i);
    }
    for(size_t i = 0; i < list.length; i++) {
        CORE_TEST_SIZE(i, coreListGet(&list, i, size_t));
    }
    CORE_TEST_SIZE(limit, list.length);
    coreDestroyList(&list);
}

static void testCopy() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 1);
    coreListAdd(&list, size_t, 2);
    coreListAdd(&list, size_t, 3);

    CoreList copy = CORE_LIST(0);
    coreCopyList(&copy, &list);
    coreCopyList(&copy, &copy);
    CORE_TEST_SIZE(list.length, copy.length);
    size_t limit = coreMinSize(copy.length, list.length);
    for(size_t i = 0; i < limit; i++) {
        CORE_TEST_SIZE(coreListGet(&list, i, size_t),
                       coreListGet(&copy, i, size_t));
    }
    coreDestroyList(&copy);
    coreDestroyList(&list);
}

static void testMove() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 1);
    coreListAdd(&list, size_t, 2);
    coreListAdd(&list, size_t, 3);

    CoreList move = CORE_LIST(0);
    coreMoveList(&move, &list);
    coreMoveList(&move, &move);
    CORE_TEST_SIZE(0, list.length);
    CORE_TEST_SIZE(3, move.length);
    CORE_TEST_SIZE(1, coreListGet(&move, 0, size_t));
    CORE_TEST_SIZE(2, coreListGet(&move, 1, size_t));
    CORE_TEST_SIZE(3, coreListGet(&move, 2, size_t));
    coreDestroyList(&move);
}

static void testToString1() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 1);
    coreListAdd(&list, size_t, 243);
    coreListAdd(&list, size_t, 423);
    char buffer[128];
    size_t n =
        coreToStringList(&list, buffer, sizeof(buffer), coreToStringSize);
    CORE_TEST_SIZE(13, n);
    CORE_TEST_STRING("[1, 243, 423]", buffer);
    coreDestroyList(&list);
}

static void testToString2() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 1);
    char buffer[128];
    size_t n =
        coreToStringList(&list, buffer, sizeof(buffer), coreToStringSize);
    CORE_TEST_SIZE(3, n);
    CORE_TEST_STRING("[1]", buffer);
    coreDestroyList(&list);
}

static void testToString3() {
    CoreList list = CORE_LIST(sizeof(size_t));
    char buffer[128];
    size_t n =
        coreToStringList(&list, buffer, sizeof(buffer), coreToStringSize);
    CORE_TEST_SIZE(2, n);
    CORE_TEST_STRING("[]", buffer);
    coreDestroyList(&list);
}

static void testRemoveBySwap() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 4);
    coreListAdd(&list, size_t, 3);
    coreListAdd(&list, size_t, 2);
    coreListRemoveBySwap(&list, 0);
    CORE_TEST_SIZE(2, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(3, coreListGet(&list, 1, size_t));
    CORE_TEST_SIZE(2, list.length);
    coreListRemoveBySwap(&list, 1);
    CORE_TEST_SIZE(2, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(1, list.length);
    coreListRemoveBySwap(&list, 0);
    CORE_TEST_SIZE(0, list.length);
    coreDestroyList(&list);
}

static void testRemove() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 4);
    coreListAdd(&list, size_t, 3);
    coreListAdd(&list, size_t, 2);
    coreListRemove(&list, 0);
    CORE_TEST_SIZE(3, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(2, coreListGet(&list, 1, size_t));
    CORE_TEST_SIZE(2, list.length);
    coreListRemove(&list, 1);
    CORE_TEST_SIZE(3, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(1, list.length);
    coreListRemove(&list, 0);
    CORE_TEST_SIZE(0, list.length);
    coreDestroyList(&list);
}

static void testRemoveLast() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListAdd(&list, size_t, 4);
    coreListAdd(&list, size_t, 3);
    coreListAdd(&list, size_t, 2);
    coreListRemoveLast(&list);
    CORE_TEST_SIZE(4, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(3, coreListGet(&list, 1, size_t));
    CORE_TEST_SIZE(2, list.length);
    coreListRemoveLast(&list);
    CORE_TEST_SIZE(4, coreListGet(&list, 0, size_t));
    CORE_TEST_SIZE(1, list.length);
    coreListRemoveLast(&list);
    CORE_TEST_SIZE(0, list.length);
    coreDestroyList(&list);
}

static void testResize() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreResizeListV(&list, 5, size_t, 10);
    CORE_TEST_SIZE(5, list.length);
    for(size_t i = 0; i < 5; i++) {
        CORE_TEST_SIZE(10, coreListGet(&list, i, size_t));
    }
    coreDestroyList(&list);
}

static void testDefaultResize() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreResizeList(&list, 5);
    CORE_TEST_SIZE(5, list.length);
    for(size_t i = 0; i < 5; i++) {
        CORE_TEST_SIZE(0, coreListGet(&list, i, size_t));
    }
    coreDestroyList(&list);
}

static void testInvalidReserve() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreListReserve(&list, 0);
    coreDestroyList(&list);
}

static void testShrinkExact() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreResizeList(&list, 50);
    coreShrinkList(&list);
    coreDestroyList(&list);
}

static void testShrinkResize() {
    CoreList list = CORE_LIST(sizeof(size_t));
    coreResizeList(&list, 50);
    CORE_TEST_SIZE(50, list.length);
    coreResizeListV(&list, 20, size_t, 5);
    CORE_TEST_SIZE(20, list.length);
    coreResizeList(&list, 10);
    CORE_TEST_SIZE(10, list.length);
    coreDestroyList(&list);
}

static void testCopyEmpty() {
    CoreList list = CORE_LIST(sizeof(size_t));
    CoreList copy = CORE_LIST(0);
    coreCopyList(&copy, &list);
    coreDestroyList(&copy);
    coreDestroyList(&list);
}

static void testStruct() {
    CoreList list = CORE_LIST(sizeof(CoreVector3));
    CoreVector3 v = {{1, 2, 3}};
    coreListAddPointer(&list, &v);
    coreListAdd(&list, CoreVector3, {2, 3, 4});
    CORE_TEST_V3(&v, coreListGetPointer(&list, 0, CoreVector3));
    coreDestroyList(&list);
}

void testList(bool light) {
    testAdd();
    testMultipleAdd();
    testAddLast();
    testAddReplace();
    testClear();
    testShrink();
    testBigAdd(light);
    testCopy();
    testMove();
    testToString1();
    testToString2();
    testToString3();
    testRemoveBySwap();
    testRemove();
    testRemoveLast();
    testResize();
    testDefaultResize();
    testInvalidReserve();
    testShrinkExact();
    testShrinkResize();
    testCopyEmpty();
    testStruct();
}