List and tests

CMakeLists.txt

@@ -7,6 +7,7 @@ set(SRC
     "src/Box.c"
     "src/Buffer.c"
     "src/Frustum.c"
+    "src/List.c"
     "src/Logger.c"
     "src/Matrix.c"
     "src/Plane.c"
@@ -25,6 +26,7 @@ set(SRC_TESTS
     "test/modules/BoxTests.c"
     "test/modules/BufferTests.c"
     "test/modules/FrustumTests.c"
+    "test/modules/ListTests.c"
     "test/modules/MatrixTests.c"
     "test/modules/PlaneTests.c"
     "test/modules/QuaternionTests.c"
@@ -37,7 +39,6 @@ set(SRC_TESTS
     #"test/modules/ComponentsTests.cpp"
     #"test/modules/HashMapTests.cpp"
     #"test/modules/LinkedListTests.cpp"
-    #"test/modules/ListTests.cpp"
     #"test/modules/MatrixStackTests.cpp"
     #"test/modules/RingBufferTests.cpp"
     #"test/modules/StackTests.cpp"
@@ -100,6 +101,7 @@ target_sources(core PUBLIC
         ./include/core/Buffer.h
         ./include/core/Check.h
         ./include/core/Frustum.h
+        ./include/core/List.h
         ./include/core/Logger.h
         ./include/core/Matrix.h
         ./include/core/Plane.h
@@ -113,7 +115,6 @@ target_sources(core PUBLIC
 #        ./include/core/Components.hpp
 #        ./include/core/HashMap.hpp
 #        ./include/core/LinkedList.hpp
-#        ./include/core/List.hpp
 #        ./include/core/MatrixStack.hpp
 #        ./include/core/ProbingHashMap.hpp
 #        ./include/core/RingBuffer.hpp

include/core/List.h

@@ -0,0 +1,36 @@
+#ifndef CORE_LIST_H
+#define CORE_LIST_H
+
+#include "core/Types.h"
+
+typedef struct {
+    size_t length;
+    size_t capacity;
+    size_t dataSize;
+    void* data;
+} CoreList;
+
+#define CORE_LIST(dataSize) ((CoreList){0, 0, dataSize, nullptr})
+void coreCopyList(CoreList* l, const CoreList* other);
+void coreMoveList(CoreList* l, CoreList* other);
+void coreDestroyList(CoreList* l);
+void coreListReserve(CoreList* l, size_t n);
+void coreShrinkList(CoreList* l);
+void coreResizeList(CoreList* l, size_t n);
+void coreResizeListPointer(CoreList* l, size_t n, const void* data);
+#define coreResizeListV(l, n, data, type)                                      \
+    coreResizeListPointer(l, n, &(type){data})
+CoreList* coreListAddPointer(CoreList* l, const void* data);
+#define coreListAdd(l, data, type) coreListAddPointer(l, &(type){data})
+void* coreListGetPointer(CoreList* l, size_t index);
+#define coreListGet(l, index, type) *(type*)coreListGetPointer(l, index)
+const void* coreListGetPointerC(const CoreList* l, size_t index);
+#define coreListGetC(l, index, type) *(const type*)coreListGetPointerC(l, index)
+void coreClearList(CoreList* l);
+void coreListRemoveBySwap(CoreList* l, size_t index);
+void coreListRemove(CoreList* l, size_t index);
+void coreListRemoveLast(CoreList* l);
+size_t coreToStringList(CoreList* l, char* buffer, size_t n, CoreToString c);
+void coreSwapList(CoreList* a, CoreList* b);
+
+#endif

include/core/Types.h

@@ -14,4 +14,6 @@ typedef uint16_t u16;
 typedef uint8_t u8;
 #define CORE_ARRAY_LENGTH(array) (sizeof(array) / sizeof(*array))
 
+typedef size_t (*CoreToString)(const void* data, char* buffer, size_t n);
+
 #endif

include/core/Utility.h

@@ -10,6 +10,30 @@ size_t corePopCount(u64 u);
 #define coreRadianToDegree(radians) (radians * (180.0f / CORE_PI))
 #define coreDegreeToRadian(degrees) (degrees * (CORE_PI / 180.0f))
 
+inline size_t coreMaxSize(size_t a, size_t b) {
+    return a > b ? a : b;
+}
+
+inline size_t coreMinSize(size_t a, size_t b) {
+    return a < b ? a : b;
+}
+
+#define CORE_SWAP(a, b, type)                                                  \
+    {                                                                          \
+        type tmp = *a;                                                         \
+        *a = *b;                                                               \
+        *b = tmp;                                                              \
+    }
+
+inline void coreSwapSize(size_t* a, size_t* b) {
+    CORE_SWAP(a, b, size_t)
+}
+inline void coreSwapPointer(void** a, void** b){CORE_SWAP(a, b, void*)}
+
+size_t coreToStringSize(const void* p, char* buffer, size_t n);
+void coreStringAdd(size_t* w, char** buffer, size_t* n, size_t shift);
+void coreStringAddI(size_t* w, char** buffer, size_t* n, int shift);
+
 typedef void (*CoreExitHandler)(int, void*);
 [[noreturn]] void coreExitWithHandler(const char* file, int line, int value);
 void coreSetExitHandler(CoreExitHandler h, void* data);

src/List.c

@@ -0,0 +1,185 @@
+#include "core/List.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "core/Utility.h"
+
+static void ensureCapacity(CoreList* l) {
+    if(l->length >= l->capacity) {
+        coreListReserve(l, l->capacity + coreMaxSize(4lu, l->capacity / 4));
+    }
+}
+
+static void setSize(CoreList* l, size_t n) {
+    l->capacity = n;
+    l->data = coreReallocate(l->data, l->dataSize * n);
+}
+
+static void* getPointer(CoreList* l, size_t index) {
+    return (char*)l->data + (l->dataSize * index);
+}
+
+static const void* getPointerC(const CoreList* l, size_t index) {
+    return (const char*)l->data + (l->dataSize * index);
+}
+
+void coreCopyList(CoreList* l, const CoreList* other) {
+    if(l == other) {
+        return;
+    }
+    coreDestroyList(l);
+    l->length = other->length;
+    l->dataSize = other->dataSize;
+    setSize(l, other->capacity);
+    memcpy(l->data, other->data, l->dataSize * l->length);
+}
+
+void coreMoveList(CoreList* l, CoreList* other) {
+    if(l == other) {
+        return;
+    }
+    coreSwapList(l, other);
+    coreDestroyList(other);
+}
+
+void coreDestroyList(CoreList* l) {
+    coreFree(l->data);
+    *l = CORE_LIST(0);
+}
+
+void coreListReserve(CoreList* l, size_t n) {
+    if(n > l->capacity) {
+        setSize(l, n);
+    }
+}
+
+void coreShrinkList(CoreList* l) {
+    if(l->length != l->capacity) {
+        setSize(l, l->length);
+    }
+}
+
+void coreResizeList(CoreList* l, size_t n) {
+    if(l->length < n) {
+        coreListReserve(l, n);
+        memset(getPointer(l, l->length), 0, (n - l->length) * l->dataSize);
+    }
+    l->length = n;
+}
+
+void coreResizeListPointer(CoreList* l, size_t n, const void* data) {
+    if(l->length < n) {
+        coreListReserve(l, n);
+        while(l->length < n) {
+            coreListAddPointer(l, data);
+        }
+    } else if(l->length > n) {
+        l->length = n;
+    }
+}
+
+CoreList* coreListAddPointer(CoreList* l, const void* data) {
+    ensureCapacity(l);
+    memcpy(getPointer(l, l->length++), data, l->dataSize);
+    return l;
+}
+
+void* coreListGetPointer(CoreList* l, size_t index) {
+    assert(index < l->length);
+    return getPointer(l, index);
+}
+
+const void* coreListGetPointerC(const CoreList* l, size_t index) {
+    assert(index < l->length);
+    return getPointerC(l, index);
+}
+
+void coreClearList(CoreList* l) {
+    l->length = 0;
+}
+
+void coreListRemoveBySwap(CoreList* l, size_t index) {
+    assert(index < l->length);
+    size_t length = l->length - 1;
+    if(index != length) {
+        memcpy(coreListGetPointer(l, index), coreListGetPointer(l, length),
+               l->dataSize);
+    }
+    l->length = length;
+}
+
+void coreListRemove(CoreList* l, size_t index) {
+    assert(index < l->length);
+    l->length--;
+    char* p = getPointer(l, index);
+    char* end = getPointer(l, l->length);
+    while(p != end) {
+        *p = *(p + l->dataSize);
+        p++;
+    }
+}
+
+void coreListRemoveLast(CoreList* l) {
+    coreListRemoveBySwap(l, l->length - 1);
+}
+
+size_t coreToStringList(CoreList* l, char* buffer, size_t n, CoreToString c) {
+    size_t w = 0;
+    coreStringAddI(&w, &buffer, &n, snprintf(buffer, n, "["));
+    char* end = getPointer(l, l->length);
+    char* p = l->data;
+    while(p != end) {
+        coreStringAdd(&w, &buffer, &n, c(p, buffer, n));
+        p += l->dataSize;
+        if(p != end) {
+            coreStringAddI(&w, &buffer, &n, snprintf(buffer, n, ", "));
+        }
+    }
+    coreStringAddI(&w, &buffer, &n, snprintf(buffer, n, "]"));
+    return w;
+}
+
+void coreSwapList(CoreList* a, CoreList* b) {
+    coreSwapSize(&a->length, &b->length);
+    coreSwapSize(&a->capacity, &b->capacity);
+    coreSwapSize(&a->dataSize, &b->dataSize);
+    coreSwapPointer(&a->data, &b->data);
+}
+
+/*
+    T* begin() {
+        return data;
+    }
+
+    T* end() {
+        return data + length;
+    }
+
+    const T* begin() const {
+        return data;
+    }
+
+    const T* end() const {
+        return data + length;
+    }
+
+    void resize(size_t n) {
+        if(length < n) {
+            reserve(n);
+            for(size_t i = n - length; i != 0; i--) {
+                unsafeAdd(T());
+            }
+        } else if(length > n) {
+            for(size_t i = n; i < length; i++) {
+                data[i].~T();
+            }
+            length = n;
+        }
+    }
+
+    void toString(BufferString& s) const {
+        Core::toString(s, *this);
+    }
+};*/

src/Matrix.c

@@ -132,41 +132,19 @@ CoreMatrix* coreRotateMatrix(CoreMatrix* m, const CoreQuaternion* q) {
     m->data[0] = (CoreVector4){{a.data[0], b.data[0], c.data[0], d.data[0]}};
     m->data[1] = (CoreVector4){{a.data[1], b.data[1], c.data[1], d.data[1]}};
     m->data[2] = (CoreVector4){{a.data[2], b.data[2], c.data[2], d.data[2]}};
-
-    //    Vector3 a = q * Vector3(data[0][0], data[1][0], data[2][0]);
-    //    Vector3 b = q * Vector3(data[0][1], data[1][1], data[2][1]);
-    //    Vector3 c = q * Vector3(data[0][2], data[1][2], data[2][2]);
-    //    Vector3 d = q * Vector3(data[0][3], data[1][3], data[2][3]);
-    //    set(0, Vector4(a[0], b[0], c[0], d[0]));
-    //    set(1, Vector4(a[1], b[1], c[1], d[1]));
-    //    set(2, Vector4(a[2], b[2], c[2], d[2]));
     return m;
 }
 
-static void add(size_t* w, char** buffer, size_t* n, size_t shift) {
-    *w += shift;
-    if(*n > shift) {
-        *buffer += shift;
-        *n -= shift;
-    } else {
-        *n = 0;
-    }
-}
-
-static void addI(size_t* w, char** buffer, size_t* n, int shift) {
-    add(w, buffer, n, shift < 0 ? 0 : (size_t)shift);
-}
-
 size_t coreToStringMatrix(const CoreMatrix* m, char* buffer, size_t n) {
     size_t w = 0;
-    addI(&w, &buffer, &n, snprintf(buffer, n, "["));
-    add(&w, &buffer, &n, coreToStringV4(m->data + 0, buffer, n));
-    addI(&w, &buffer, &n, snprintf(buffer, n, ", "));
-    add(&w, &buffer, &n, coreToStringV4(m->data + 1, buffer, n));
-    addI(&w, &buffer, &n, snprintf(buffer, n, ", "));
-    add(&w, &buffer, &n, coreToStringV4(m->data + 2, buffer, n));
-    addI(&w, &buffer, &n, snprintf(buffer, n, ", "));
-    add(&w, &buffer, &n, coreToStringV4(m->data + 3, buffer, n));
-    addI(&w, &buffer, &n, snprintf(buffer, n, "]"));
+    coreStringAddI(&w, &buffer, &n, snprintf(buffer, n, "["));
+    coreStringAdd(&w, &buffer, &n, coreToStringV4(m->data + 0, buffer, n));
+    coreStringAddI(&w, &buffer, &n, snprintf(buffer, n, ", "));
+    coreStringAdd(&w, &buffer, &n, coreToStringV4(m->data + 1, buffer, n));
+    coreStringAddI(&w, &buffer, &n, snprintf(buffer, n, ", "));
+    coreStringAdd(&w, &buffer, &n, coreToStringV4(m->data + 2, buffer, n));
+    coreStringAddI(&w, &buffer, &n, snprintf(buffer, n, ", "));
+    coreStringAdd(&w, &buffer, &n, coreToStringV4(m->data + 3, buffer, n));
+    coreStringAddI(&w, &buffer, &n, snprintf(buffer, n, "]"));
     return w;
 }

src/Utility.c

@@ -9,6 +9,11 @@
 #include "ErrorSimulator.h"
 #include "core/Logger.h"
 
+extern inline size_t coreMaxSize(size_t a, size_t b);
+extern inline size_t coreMinSize(size_t a, size_t b);
+extern inline void coreSwapSize(size_t* a, size_t* b);
+extern inline void coreSwapPointer(void** a, void** b);
+
 static CoreExitHandler exitHandler = nullptr;
 static void* exitData = nullptr;
 static CoreOutOfMemoryHandler outOfMemoryHandler = nullptr;
@@ -23,6 +28,25 @@ size_t corePopCount(u64 u) {
     return sum;
 }
 
+size_t coreToStringSize(const void* p, char* buffer, size_t n) {
+    int w = snprintf(buffer, n, "%zu", *(const size_t*)p);
+    return w < 0 ? 0 : (size_t)w;
+}
+
+void coreStringAdd(size_t* w, char** buffer, size_t* n, size_t shift) {
+    *w += shift;
+    if(*n > shift) {
+        *buffer += shift;
+        *n -= shift;
+    } else {
+        *n = 0;
+    }
+}
+
+void coreStringAddI(size_t* w, char** buffer, size_t* n, int shift) {
+    coreStringAdd(w, buffer, n, shift < 0 ? 0 : (size_t)shift);
+}
+
 [[noreturn]] void coreExitWithHandler(const char* file, int line, int value) {
     if(value != 0) {
         file = coreGetShortFileName(file);

test/Main.c

@@ -35,13 +35,13 @@ int main(int argAmount, const char** args) {
     // coreTestComponents();
     // coreTestHashMap(light);
     // coreTestLinkedList(light);
-    // coreTestList(light);
     // coreTestMatrixStack(light);
     // coreTestRingBuffer();
     // coreTestStack(light);
     coreTestBox();
     coreTestBuffer(light);
     coreTestFrustum();
+    coreTestList(light);
     coreTestMatrix();
     coreTestPlane();
     coreTestQuaternion();

test/modules/ListTests.c

@@ -0,0 +1,268 @@
+#include "../Tests.h"
+#include "core/List.h"
+#include "core/Utility.h"
+
+static void testAdd() {
+    CoreList list = CORE_LIST(sizeof(size_t));
+    coreListAdd(&list, 5, size_t);
+    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, 4, size_t);
+    coreListAdd(&list, 3, size_t);
+    coreListAdd(&list, 2, size_t);
+    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(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(3, list.length);
+    coreDestroyList(&list);
+}
+
+static void testAddReplace() {
+    CoreList list = CORE_LIST(sizeof(size_t));
+    coreListAdd(&list, 5, size_t);
+    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, 5, size_t);
+    coreListAdd(&list, 4, size_t);
+    coreClearList(&list);
+    CORE_TEST_SIZE(0, list.length);
+    coreDestroyList(&list);
+}
+
+static void testShrink() {
+    CoreList list = CORE_LIST(sizeof(size_t));
+    coreListAdd(&list, 5, size_t);
+    coreListAdd(&list, 4, size_t);
+    coreListAdd(&list, 3, size_t);
+    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, i, size_t);
+    }
+    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, 1, size_t);
+    coreListAdd(&list, 2, size_t);
+    coreListAdd(&list, 3, size_t);
+
+    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, 1, size_t);
+    coreListAdd(&list, 2, size_t);
+    coreListAdd(&list, 3, size_t);
+
+    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, 1, size_t);
+    coreListAdd(&list, 243, size_t);
+    coreListAdd(&list, 423, size_t);
+    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, 1, size_t);
+    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, 4, size_t);
+    coreListAdd(&list, 3, size_t);
+    coreListAdd(&list, 2, size_t);
+    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, 4, size_t);
+    coreListAdd(&list, 3, size_t);
+    coreListAdd(&list, 2, size_t);
+    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, 4, size_t);
+    coreListAdd(&list, 3, size_t);
+    coreListAdd(&list, 2, size_t);
+    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, 10, size_t);
+    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, 5, size_t);
+    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);
+}
+
+void coreTestList(bool light) {
+    testAdd();
+    testMultipleAdd();
+    testAddReplace();
+    testClear();
+    testShrink();
+    testBigAdd(light);
+    testCopy();
+    testMove();
+    testToString1();
+    testToString2();
+    testToString3();
+    testRemoveBySwap();
+    testRemove();
+    testRemoveLast();
+    testResize();
+    testDefaultResize();
+    testInvalidReserve();
+    testShrinkExact();
+    testShrinkResize();
+    testCopyEmpty();
+}