Rename RingBuffer to Queue

CMakeLists.txt

@@ -15,9 +15,9 @@ set(SRC
     "src/Matrix.c"
     "src/Plane.c"
     "src/Quaternion.c"
+    "src/Queue.c"
     "src/Random.c"
     "src/ReadLine.c"
-    "src/RingBuffer.c"
     "src/SpinLock.c"
     "src/Test.c"
     "src/ToString.c"
@@ -38,9 +38,9 @@ set(SRC_TESTS
     "test/modules/MatrixTests.c"
     "test/modules/PlaneTests.c"
     "test/modules/QuaternionTests.c"
+    "test/modules/QueueTests.c"
     "test/modules/RandomTests.c"
     "test/modules/ReadLineTests.c"
-    "test/modules/RingBufferTests.c"
     "test/modules/SpinLockTests.c"
     "test/modules/TestTests.c"
     "test/modules/UtilityTests.c"
@@ -112,9 +112,9 @@ target_sources(core PUBLIC
         ./include/core/Matrix.h
         ./include/core/Plane.h
         ./include/core/Quaternion.h
+        ./include/core/Queue.h
         ./include/core/Random.h
         ./include/core/ReadLine.h
-        ./include/core/RingBuffer.h
         ./include/core/SpinLock.h
         ./include/core/Test.h
         ./include/core/ToString.h

include/core/Queue.h

@@ -0,0 +1,31 @@
+#ifndef CORE_QUEUE_H
+#define CORE_QUEUE_H
+
+#include "core/Types.h"
+
+struct CoreQueueT {
+    size_t writeIndex;
+    size_t readIndex;
+    size_t length;
+    size_t capacity;
+    size_t dataSize;
+    void* data;
+};
+typedef struct CoreQueueT CoreQueue;
+
+void coreInitQueue(CoreQueue* r, size_t capacity, size_t dataSize);
+void coreDestroyQueue(CoreQueue* r);
+void coreQueueAddPointer(CoreQueue* r, const void* data);
+#define coreQueueAdd(l, type, ...) coreQueueAddPointer(l, &(type){__VA_ARGS__})
+void* coreQueueGetVoidPointer(const CoreQueue* r, size_t index);
+#define coreQueueGetPointer(r, index, type)                                    \
+    ((type*)coreQueueGetVoidPointer(r, index))
+#define coreQueueGet(r, index, type) (*coreQueueGetPointer(r, index, type))
+const void* coreQueueGetVoidPointerC(const CoreQueue* r, size_t index);
+#define coreQueueGetPointerC(r, index, type)                                   \
+    ((const type*)coreQueueGetVoidPointerC(r, index))
+#define coreQueueGetC(r, index, type) (*coreQueueGetPointerC(r, index, type))
+void coreClearQueue(CoreQueue* r);
+void coreQueueRemove(CoreQueue* r);
+
+#endif

include/core/RingBuffer.h

@@ -1,38 +0,0 @@
-#ifndef CORE_RINGBUFFER_H
-#define CORE_RINGBUFFER_H
-
-#include "core/Types.h"
-
-typedef struct {
-    size_t writeIndex;
-    size_t readIndex;
-    size_t length;
-    size_t capacity;
-    size_t dataSize;
-    void* data;
-} CoreRingBuffer;
-
-#define CORE_RING_BUFFER(capacity, dataSize)                                   \
-    ((CoreRingBuffer){0, 0, 0, capacity, dataSize, nullptr})
-void coreDestroyRingBuffer(CoreRingBuffer* r);
-CoreRingBuffer* coreRingBufferAddPointer(CoreRingBuffer* r, const void* data);
-#define coreRingBufferAdd(l, type, ...)                                        \
-    coreRingBufferAddPointer(l, &(type){__VA_ARGS__})
-void* coreRingBufferGetVoidPointer(CoreRingBuffer* r, size_t index);
-#define coreRingBufferGetPointer(r, index, type)                               \
-    ((type*)coreRingBufferGetVoidPointer(r, index))
-#define coreRingBufferGet(r, index, type)                                      \
-    (*coreRingBufferGetPointer(r, index, type))
-const void* coreRingBufferGetVoidPointerC(const CoreRingBuffer* r,
-                                          size_t index);
-#define coreRingBufferGetPointerC(r, index, type)                              \
-    ((const type*)coreRingBufferGetVoidPointerC(r, index))
-#define coreRingBufferGetC(r, index, type)                                     \
-    (*coreRingBufferGetPointerC(r, index, type))
-void coreClearRingBuffer(CoreRingBuffer* r);
-void coreRingBufferRemove(CoreRingBuffer* r);
-size_t coreToStringRingBuffer(CoreRingBuffer* r, char* buffer, size_t n,
-                              CoreToString c);
-void coreSwapRingBuffer(CoreRingBuffer* a, CoreRingBuffer* b);
-
-#endif

include/core/ToString.h

@@ -13,6 +13,9 @@ void coreStringAdd(size_t* w, char** buffer, size_t* n, size_t shift);
 struct CoreListT;
 size_t coreToStringList(const struct CoreListT* l, char* buffer, size_t n,
                         CoreToString c);
+struct CoreQueueT;
+size_t coreToStringQueue(const struct CoreQueueT* r, char* buffer, size_t n,
+                         CoreToString c);
 
 #define CORE_STRUCT_TO_STRING(type)                                            \
     struct Core##type##T;                                                      \
@@ -29,6 +32,7 @@ CORE_STRUCT_TO_STRING(Plane)
 #define toStringInt coreToStringInt
 #define stringAdd coreStringAdd
 #define toStringList coreToStringList
+#define toStringQueue coreToStringQueue
 #define toStringBitArray coreToStringBitArray
 #define toStringBox coreToStringBox
 #define toStringMatrix coreToStringMatrix
@@ -48,7 +52,8 @@ CORE_STRUCT_TO_STRING(Plane)
         CORE_STRUCT_PAIR(Box),                                                 \
         CORE_STRUCT_PAIR(Matrix),                                              \
         CORE_STRUCT_PAIR(Plane),                                               \
-        CORE_STRUCT_PAIR(List))(t, __VA_ARGS__)
+        CORE_STRUCT_PAIR(List),                                                \
+        CORE_STRUCT_PAIR(Queue))(t, __VA_ARGS__)
 #endif
 
 #endif

src/List.c

@@ -1,10 +1,7 @@
 #include "core/List.h"
 
 #include <assert.h>
-#include <stdio.h>
-#include <string.h>
 
-#include "core/ToString.h"
 #include "core/Utility.h"
 
 static void ensureCapacity(List* l) {

src/Queue.c

@@ -0,0 +1,56 @@
+#include "core/Queue.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "core/ToString.h"
+#include "core/Utility.h"
+
+void coreInitQueue(CoreQueue* r, size_t capacity, size_t dataSize) {
+    *r = ((CoreQueue){0, 0, 0, capacity, dataSize, nullptr});
+}
+
+void coreDestroyQueue(CoreQueue* r) {
+    coreClearQueue(r);
+    r->dataSize = 0;
+    r->capacity = 0;
+    coreFree(r->data);
+    r->data = nullptr;
+}
+
+static void* getPointer(const CoreQueue* r, size_t index) {
+    return (char*)r->data + r->dataSize * index;
+}
+
+void coreQueueAddPointer(CoreQueue* r, const void* data) {
+    if(r->length >= r->capacity) {
+        return;
+    } else if(r->data == nullptr) {
+        r->data = coreAllocate(r->capacity * r->dataSize);
+    }
+    memcpy(getPointer(r, r->writeIndex), data, r->dataSize);
+    r->writeIndex = (r->writeIndex + 1) % r->capacity;
+    r->length++;
+}
+
+void* coreQueueGetVoidPointer(const CoreQueue* r, size_t index) {
+    return getPointer(r, (index + r->readIndex) % r->capacity);
+}
+
+const void* coreQueueGetVoidPointerC(const CoreQueue* r, size_t index) {
+    return (char*)r->data +
+           r->dataSize * ((index + r->readIndex) % r->capacity);
+}
+
+void coreClearQueue(CoreQueue* r) {
+    r->writeIndex = 0;
+    r->readIndex = 0;
+    r->length = 0;
+}
+
+void coreQueueRemove(CoreQueue* r) {
+    assert(r->length > 0);
+    r->length--;
+    r->readIndex = (r->readIndex + 1) % r->capacity;
+}

src/ReadLine.c

@@ -13,7 +13,7 @@
 
 #include "ErrorSimulator.h"
 #include "core/Logger.h"
-#include "core/RingBuffer.h"
+#include "core/Queue.h"
 
 #define HISTORY_LENGTH 10
 #define CONSOLE_BUFFER_SIZE 256
@@ -27,7 +27,7 @@ static atomic_bool running = true;
 static thrd_t readThread = {0};
 
 static struct termios original;
-static CoreRingBuffer buffer = {0};
+static CoreQueue buffer = {0};
 static ConsoleLine currentBuffer = {0};
 static int move = 0;
 static int cursorMove = 0;
@@ -116,7 +116,7 @@ static void unlock() {
 static void addLine() {
     addToHistory();
     lock();
-    coreRingBufferAddPointer(&buffer, &currentBuffer);
+    coreQueueAddPointer(&buffer, &currentBuffer);
     unlock();
     clear();
 }
@@ -260,7 +260,7 @@ bool coreStartReadLine(void) {
         CORE_LOG_WARNING("cannot set terminal attributes");
     }
 
-    buffer = CORE_RING_BUFFER(10, sizeof(ConsoleLine));
+    coreInitQueue(&buffer, 10, sizeof(ConsoleLine));
     atomic_store(&running, true);
     if(MUTEX_INIT_FAIL || mtx_init(&bufferMutex, mtx_plain) != thrd_success) {
         CORE_LOG_ERROR("cannot init buffer mutex");
@@ -280,9 +280,9 @@ bool coreReadLine(char* buffer_, size_t n) {
         return false;
     }
     lock();
-    ConsoleLine* line = coreRingBufferGetVoidPointer(&buffer, 0);
+    ConsoleLine* line = coreQueueGetVoidPointer(&buffer, 0);
     snprintf(buffer_, n, "%s", line->data);
-    coreRingBufferRemove(&buffer);
+    coreQueueRemove(&buffer);
     unlock();
     return true;
 }
@@ -291,6 +291,6 @@ void coreStopReadLine() {
     atomic_store(&running, false);
     thrd_join(readThread, nullptr);
     restoreAttributes();
-    coreDestroyRingBuffer(&buffer);
+    coreDestroyQueue(&buffer);
     mtx_destroy(&bufferMutex);
 }

src/RingBuffer.c

@@ -1,79 +0,0 @@
-#include "core/RingBuffer.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "core/ToString.h"
-#include "core/Utility.h"
-
-void coreDestroyRingBuffer(CoreRingBuffer* r) {
-    coreClearRingBuffer(r);
-    r->dataSize = 0;
-    r->capacity = 0;
-    coreFree(r->data);
-    r->data = nullptr;
-}
-
-static void* getPointer(CoreRingBuffer* r, size_t index) {
-    return (char*)r->data + r->dataSize * index;
-}
-
-CoreRingBuffer* coreRingBufferAddPointer(CoreRingBuffer* r, const void* data) {
-    if(r->length >= r->capacity) {
-        return nullptr;
-    } else if(r->data == nullptr) {
-        r->data = coreAllocate(r->capacity * r->dataSize);
-    }
-    memcpy(getPointer(r, r->writeIndex), data, r->dataSize);
-    r->writeIndex = (r->writeIndex + 1) % r->capacity;
-    r->length++;
-    return r;
-}
-
-void* coreRingBufferGetVoidPointer(CoreRingBuffer* r, size_t index) {
-    return getPointer(r, (index + r->readIndex) % r->capacity);
-}
-
-const void* coreRingBufferGetVoidPointerC(const CoreRingBuffer* r,
-                                          size_t index) {
-    return (char*)r->data +
-           r->dataSize * ((index + r->readIndex) % r->capacity);
-}
-
-void coreClearRingBuffer(CoreRingBuffer* r) {
-    r->writeIndex = 0;
-    r->readIndex = 0;
-    r->length = 0;
-}
-
-void coreRingBufferRemove(CoreRingBuffer* r) {
-    assert(r->length > 0);
-    r->length--;
-    r->readIndex = (r->readIndex + 1) % r->capacity;
-}
-
-size_t coreToStringRingBuffer(CoreRingBuffer* r, char* buffer, size_t n,
-                              CoreToString c) {
-    size_t w = 0;
-    coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "["));
-    size_t end = r->length;
-    if(end > 0) {
-        end--;
-        for(size_t i = 0; i < end; i++) {
-            coreStringAdd(&w, &buffer, &n,
-                          c(coreRingBufferGetVoidPointer(r, i), buffer, n));
-            coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, ", "));
-        }
-        coreStringAdd(&w, &buffer, &n,
-                      c(coreRingBufferGetVoidPointer(r, end), buffer, n));
-    }
-    coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "]"));
-    return w;
-}
-
-void coreSwapRingBuffer(CoreRingBuffer* a, CoreRingBuffer* b) {
-    CoreRingBuffer tmp = *a;
-    *a = *b;
-    *b = tmp;
-}

src/ToString.c

@@ -8,6 +8,7 @@
 #include "core/List.h"
 #include "core/Matrix.h"
 #include "core/Plane.h"
+#include "core/Queue.h"
 #include "core/Utility.h"
 
 size_t coreToString(char* buffer, size_t n, const char* format, ...) {
@@ -96,3 +97,22 @@ size_t toStringList(const List* l, char* buffer, size_t n, ToString c) {
     stringAdd(&w, &buffer, &n, coreToString(buffer, n, "]"));
     return w;
 }
+
+size_t coreToStringQueue(const CoreQueue* r, char* buffer, size_t n,
+                         CoreToString c) {
+    size_t w = 0;
+    coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "["));
+    size_t end = r->length;
+    if(end > 0) {
+        end--;
+        for(size_t i = 0; i < end; i++) {
+            coreStringAdd(&w, &buffer, &n,
+                          c(coreQueueGetVoidPointer(r, i), buffer, n));
+            coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, ", "));
+        }
+        coreStringAdd(&w, &buffer, &n,
+                      c(coreQueueGetVoidPointer(r, end), buffer, n));
+    }
+    coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "]"));
+    return w;
+}

test/Main.c

@@ -44,11 +44,11 @@ int main(int argAmount, const char** args) {
     testMatrix();
     testPlane();
     testQuaternion();
+    testQueue();
     testRandom(light);
     logLevel = LOG_ERROR;
     testReadLine();
     logLevel = LOG_DEBUG;
-    testRingBuffer();
     testSpinLock();
     testUtility(light);
     testVector();

test/Tests.h

@@ -17,9 +17,9 @@ void testPlane(void);
 void testPostCanary(void);
 void testPreCanary(void);
 void testQuaternion(void);
+void testQueue(void);
 void testRandom(bool light);
 void testReadLine(void);
-void testRingBuffer(void);
 void testSpinLock(void);
 void testTest(void);
 void testUtility(bool light);

test/modules/QueueTests.c

@@ -0,0 +1,128 @@
+#include "../Tests.h"
+#include "core/Queue.h"
+#include "core/ToString.h"
+#include "core/Utility.h"
+
+static void testReadAndWrite() {
+    CoreQueue r;
+    coreInitQueue(&r, 5, sizeof(size_t));
+    CORE_TEST_SIZE(0, r.length);
+    coreQueueAdd(&r, size_t, 4);
+    CORE_TEST_SIZE(1, r.length);
+    CORE_TEST_SIZE(4, coreQueueGet(&r, 0, size_t));
+    CORE_TEST_SIZE(4, coreQueueGetC(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(0, r.length);
+    coreDestroyQueue(&r);
+}
+
+static void testOverflow() {
+    CoreQueue r;
+    coreInitQueue(&r, 3, sizeof(size_t));
+    coreQueueAdd(&r, size_t, 1);
+    coreQueueAdd(&r, size_t, 2);
+    coreQueueAdd(&r, size_t, 3);
+    coreQueueAdd(&r, size_t, 4);
+    coreQueueAdd(&r, size_t, 5);
+    CORE_TEST_SIZE(3, r.length);
+    CORE_TEST_SIZE(1, coreQueueGet(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(2, r.length);
+    CORE_TEST_SIZE(2, coreQueueGet(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(1, r.length);
+    CORE_TEST_SIZE(3, coreQueueGet(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(0, r.length);
+    coreDestroyQueue(&r);
+}
+
+static void testRefill() {
+    CoreQueue r;
+    coreInitQueue(&r, 3, sizeof(size_t));
+    coreQueueAdd(&r, size_t, 1);
+    coreQueueAdd(&r, size_t, 2);
+    coreQueueAdd(&r, size_t, 3);
+    coreQueueAdd(&r, size_t, 4);
+    CORE_TEST_SIZE(3, r.length);
+    CORE_TEST_SIZE(1, coreQueueGet(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(2, coreQueueGet(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(3, coreQueueGet(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(0, r.length);
+    coreQueueAdd(&r, size_t, 5);
+    coreQueueAdd(&r, size_t, 6);
+    CORE_TEST_SIZE(2, r.length);
+    CORE_TEST_SIZE(5, coreQueueGet(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(6, coreQueueGet(&r, 0, size_t));
+    coreQueueRemove(&r);
+    CORE_TEST_SIZE(0, r.length);
+    coreDestroyQueue(&r);
+}
+
+static void testClear() {
+    CoreQueue r;
+    coreInitQueue(&r, 3, sizeof(size_t));
+    coreQueueAdd(&r, size_t, 1);
+    coreQueueAdd(&r, size_t, 2);
+    CORE_TEST_SIZE(2, r.length);
+    coreClearQueue(&r);
+    CORE_TEST_SIZE(0, r.length);
+    coreDestroyQueue(&r);
+}
+
+static void testOverall() {
+    CoreQueue r;
+    coreInitQueue(&r, 3, sizeof(size_t));
+    coreQueueAdd(&r, size_t, 1);
+    coreQueueAdd(&r, size_t, 2);
+    coreQueueAdd(&r, size_t, 3);
+
+    char buffer[128];
+    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
+    CORE_TEST_STRING("[1, 2, 3]", buffer);
+    CORE_TEST_SIZE(3, r.length);
+
+    coreQueueRemove(&r);
+    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
+    CORE_TEST_STRING("[2, 3]", buffer);
+    CORE_TEST_SIZE(2, r.length);
+
+    coreQueueAdd(&r, size_t, 4);
+    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
+    CORE_TEST_STRING("[2, 3, 4]", buffer);
+    CORE_TEST_SIZE(3, r.length);
+
+    coreQueueRemove(&r);
+    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
+    CORE_TEST_STRING("[3, 4]", buffer);
+    CORE_TEST_SIZE(2, r.length);
+
+    coreQueueAdd(&r, size_t, 5);
+    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
+    CORE_TEST_STRING("[3, 4, 5]", buffer);
+    CORE_TEST_SIZE(3, r.length);
+
+    coreQueueRemove(&r);
+    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
+    CORE_TEST_STRING("[4, 5]", buffer);
+    CORE_TEST_SIZE(2, r.length);
+
+    coreClearQueue(&r);
+    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
+    CORE_TEST_STRING("[]", buffer);
+    CORE_TEST_SIZE(0, r.length);
+
+    coreDestroyQueue(&r);
+}
+
+void testQueue() {
+    testReadAndWrite();
+    testOverflow();
+    testRefill();
+    testClear();
+    testOverall();
+}

test/modules/RingBufferTests.c

@@ -1,126 +0,0 @@
-#include "../Tests.h"
-#include "core/RingBuffer.h"
-#include "core/ToString.h"
-#include "core/Utility.h"
-
-static void testReadAndWrite() {
-    CoreRingBuffer r = CORE_RING_BUFFER(5, sizeof(size_t));
-    CORE_TEST_SIZE(0, r.length);
-    coreRingBufferAdd(&r, size_t, 4);
-    CORE_TEST_SIZE(1, r.length);
-    CORE_TEST_SIZE(4, coreRingBufferGet(&r, 0, size_t));
-    CORE_TEST_SIZE(4, coreRingBufferGetC(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreDestroyRingBuffer(&r);
-}
-
-static void testOverflow() {
-    CoreRingBuffer r = CORE_RING_BUFFER(3, sizeof(size_t));
-    coreRingBufferAdd(&r, size_t, 1);
-    coreRingBufferAdd(&r, size_t, 2);
-    coreRingBufferAdd(&r, size_t, 3);
-    coreRingBufferAdd(&r, size_t, 4);
-    coreRingBufferAdd(&r, size_t, 5);
-    CORE_TEST_SIZE(3, r.length);
-    CORE_TEST_SIZE(1, coreRingBufferGet(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(2, r.length);
-    CORE_TEST_SIZE(2, coreRingBufferGet(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(1, r.length);
-    CORE_TEST_SIZE(3, coreRingBufferGet(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreDestroyRingBuffer(&r);
-}
-
-static void testRefill() {
-    CoreRingBuffer r = CORE_RING_BUFFER(3, sizeof(size_t));
-    coreRingBufferAdd(&r, size_t, 1);
-    coreRingBufferAdd(&r, size_t, 2);
-    coreRingBufferAdd(&r, size_t, 3);
-    coreRingBufferAdd(&r, size_t, 4);
-    CORE_TEST_SIZE(3, r.length);
-    CORE_TEST_SIZE(1, coreRingBufferGet(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(2, coreRingBufferGet(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(3, coreRingBufferGet(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreRingBufferAdd(&r, size_t, 5);
-    coreRingBufferAdd(&r, size_t, 6);
-    CORE_TEST_SIZE(2, r.length);
-    CORE_TEST_SIZE(5, coreRingBufferGet(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(6, coreRingBufferGet(&r, 0, size_t));
-    coreRingBufferRemove(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreDestroyRingBuffer(&r);
-}
-
-static void testClear() {
-    CoreRingBuffer r = CORE_RING_BUFFER(3, sizeof(size_t));
-    coreRingBufferAdd(&r, size_t, 1);
-    coreRingBufferAdd(&r, size_t, 2);
-    CORE_TEST_SIZE(2, r.length);
-    coreClearRingBuffer(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreDestroyRingBuffer(&r);
-}
-
-static void testOverall() {
-    CoreRingBuffer ri = CORE_RING_BUFFER(3, sizeof(size_t));
-    coreRingBufferAdd(&ri, size_t, 1);
-    coreRingBufferAdd(&ri, size_t, 2);
-    coreRingBufferAdd(&ri, size_t, 3);
-
-    CoreRingBuffer r = CORE_RING_BUFFER(0, 0);
-    coreSwapRingBuffer(&r, &ri);
-    char buffer[128];
-    coreToStringRingBuffer(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[1, 2, 3]", buffer);
-    CORE_TEST_SIZE(3, r.length);
-
-    coreRingBufferRemove(&r);
-    coreToStringRingBuffer(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[2, 3]", buffer);
-    CORE_TEST_SIZE(2, r.length);
-
-    coreRingBufferAdd(&r, size_t, 4);
-    coreToStringRingBuffer(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[2, 3, 4]", buffer);
-    CORE_TEST_SIZE(3, r.length);
-
-    coreRingBufferRemove(&r);
-    coreToStringRingBuffer(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[3, 4]", buffer);
-    CORE_TEST_SIZE(2, r.length);
-
-    coreRingBufferAdd(&r, size_t, 5);
-    coreToStringRingBuffer(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[3, 4, 5]", buffer);
-    CORE_TEST_SIZE(3, r.length);
-
-    coreRingBufferRemove(&r);
-    coreToStringRingBuffer(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[4, 5]", buffer);
-    CORE_TEST_SIZE(2, r.length);
-
-    coreClearRingBuffer(&r);
-    coreToStringRingBuffer(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[]", buffer);
-    CORE_TEST_SIZE(0, r.length);
-
-    coreDestroyRingBuffer(&r);
-    coreDestroyRingBuffer(&ri);
-}
-
-void testRingBuffer() {
-    testReadAndWrite();
-    testOverflow();
-    testRefill();
-    testClear();
-    testOverall();
-}