Own module for to string ops, simplify BitArray

CMakeLists.txt

@@ -21,6 +21,7 @@ set(SRC
     "src/RingBuffer.c"
     "src/SpinLock.c"
     "src/Test.c"
+    "src/ToString.c"
     "src/Utility.c"
     "src/Vector.c"
     "src/View.c"
@@ -119,6 +120,7 @@ target_sources(core PUBLIC
         ./include/core/RingBuffer.h
         ./include/core/SpinLock.h
         ./include/core/Test.h
+        ./include/core/ToString.h
         ./include/core/Types.h
         ./include/core/Utility.h
         ./include/core/Vector.h

include/core/BitArray.h

@@ -3,41 +3,31 @@
 
 #include "core/Types.h"
 
-typedef struct {
+struct CoreBitArrayT {
     u64 length : 56;
     u64 bits : 8;
     u64* data;
-} CoreBitArray;
-
+};
+typedef struct CoreBitArrayT CoreBitArray;
 static_assert(sizeof(CoreBitArray) == 16, "invalid bit array size");
 
-#define CORE_BIT_ARRAY ((CoreBitArray){0, 0, nullptr})
-void coreCopyBitArray(CoreBitArray* a, const CoreBitArray* other);
-void coreMoveBitArray(CoreBitArray* a, CoreBitArray* other);
+void coreInitBitArray(CoreBitArray* a, size_t length, size_t bits);
 void coreDestroyBitArray(CoreBitArray* a);
-CoreBitArray* coreSetBitsBitArray(CoreBitArray* a, size_t index, u64 value);
-u64 coreGetBitsBitArray(const CoreBitArray* a, size_t index);
-size_t coreGetBytesBitArray(const CoreBitArray* a);
-i64 coreSelectBitsBitArray(const CoreBitArray* a, size_t index);
-void coreResizeBitArray(CoreBitArray* a, size_t newLength, size_t newBits);
-void coreFillBitArray(CoreBitArray* a, u64 value);
-size_t coreToStringBitArray(const CoreBitArray* a, char* buffer, size_t n);
-void coreSwapBitArray(CoreBitArray* a, CoreBitArray* b);
+void coreSetBits(CoreBitArray* a, size_t index, u64 value);
+void coreSetAllBits(CoreBitArray* a, u64 value);
+u64 coreGetBits(const CoreBitArray* a, size_t index);
+i64 coreSelectBits(const CoreBitArray* a, size_t index);
+void coreSetBitLength(CoreBitArray* a, size_t newLength, size_t newBits);
 
 #ifdef IMPORT_CORE
 #define BitArray CoreBitArray
-#define BIT_ARRAY CORE_BIT_ARRAY
-#define copyBitArray coreCopyBitArray
-#define moveBitArray coreMoveBitArray
+#define initBitArray coreInitBitArray
 #define destroyBitArray coreDestroyBitArray
-#define setBitsBitArray coreSetBitsBitArray
-#define getBitsBitArray coreGetBitsBitArray
-#define getBytesBitArray coreGetBytesBitArray
-#define selectBitsBitArray coreSelectBitsBitArray
-#define resizeBitArray coreResizeBitArray
-#define fillBitArray coreFillBitArray
-#define toStringBitArray coreToStringBitArray
-#define swapBitArray coreSwapBitArray
+#define setBits coreSetBits
+#define setAllBits coreSetAllBits
+#define getBits coreGetBits
+#define selectBits coreSelectBits
+#define setBitLength coreSetBitLength
 #endif
 
 #endif

include/core/ToString.h

@@ -0,0 +1,37 @@
+#ifndef CORE_TO_STRING_H
+#define CORE_TO_STRING_H
+
+#include "core/Check.h"
+#include "core/Types.h"
+
+check_format(3, 4) size_t
+    coreToString(char* buffer, size_t n, const char* format, ...);
+size_t coreToStringSize(const void* p, char* buffer, size_t n);
+size_t coreToStringInt(const void* p, char* buffer, size_t n);
+void coreStringAdd(size_t* w, char** buffer, size_t* n, size_t shift);
+
+#define CORE_STRUCT_TO_STRING(type)                                            \
+    struct Core##type##T;                                                      \
+    size_t coreToString##type(const struct Core##type##T* a, char* buffer,     \
+                              size_t n);
+
+CORE_STRUCT_TO_STRING(BitArray)
+
+#ifdef IMPORT_CORE
+#define toStringSize coreToStringSize
+#define toStringInt coreToStringInt
+#define stringAdd coreStringAdd
+#define toStringBitArray coreToStringBitArray
+// clang-format off
+#define CORE_PAIR(a, b) a: b
+// clang-format on
+#define CORE_STRUCT_PAIR(name)                                                 \
+    CORE_PAIR(const struct Core##name##T*, toString##name),                    \
+        CORE_PAIR(struct Core##name##T*, toString##name)
+
+#define toString(t, ...)                                                       \
+    _Generic((t), char*: coreToString, CORE_STRUCT_PAIR(BitArray))(            \
+        t, __VA_ARGS__)
+#endif
+
+#endif

include/core/Utility.h

@@ -1,7 +1,8 @@
 #ifndef CORE_UTILITY_H
 #define CORE_UTILITY_H
 
-#include "core/Check.h"
+#include <string.h>
+
 #include "core/Types.h"
 
 size_t corePopCount(u64 u);
@@ -18,12 +19,6 @@ inline size_t coreMinSize(size_t a, size_t b) {
     return a < b ? a : b;
 }
 
-check_format(3, 4) size_t
-    coreToString(char* buffer, size_t n, const char* format, ...);
-size_t coreToStringSize(const void* p, char* buffer, size_t n);
-size_t coreToStringInt(const void* p, char* buffer, size_t n);
-void coreStringAdd(size_t* w, char** buffer, size_t* n, size_t shift);
-
 typedef void (*CoreExitHandler)(int, void*);
 [[noreturn]] void coreExitWithHandler(const char* file, int line, int value);
 void coreSetExitHandler(CoreExitHandler h, void* data);
@@ -50,6 +45,14 @@ void coreFree(void* p);
 bool coreSleepNanos(i64 nanos);
 i64 coreGetNanos(void);
 
+// TODO: replace typeof with auto when available
+#define coreSwap(a, b)                                                         \
+    do {                                                                       \
+        typeof(*a) tmp = *(a);                                                 \
+        *(a) = *(b);                                                           \
+        *(b) = tmp;                                                            \
+    } while(0)
+
 #ifdef IMPORT_CORE
 #define popCount corePopCount
 #define interpolate coreInterpolate
@@ -58,10 +61,6 @@ i64 coreGetNanos(void);
 #define degreeToRadian coreDegreeToRadian
 #define maxSize coreMaxSize
 #define minSize coreMinSize
-#define toString coreToString
-#define toStringSize coreToStringSize
-#define toStringInt coreToStringInt
-#define stringAdd coreStringAdd
 #define ExitHandler CoreExitHandler
 #define setExitHandler coreSetExitHandler
 #define EXIT CORE_EXIT
@@ -73,6 +72,7 @@ i64 coreGetNanos(void);
 #define cFree coreFree
 #define sleepNanos coreSleepNanos
 #define getNanos coreGetNanos
+#define swap coreSwap
 #endif
 
 #endif

src/BitArray.c

@@ -26,7 +26,7 @@ static u64 readBits(const u64* data, size_t index, u64 bits) {
     return r;
 }
 
-static void setBits(u64* data, size_t index, size_t bits, u64 value) {
+static void writeBits(u64* data, size_t index, size_t bits, u64 value) {
     u64 mask = (1lu << bits) - 1lu;
     value &= mask;
     u64 dataIndexA = (index * bits) >> DIVIDE_BITS;
@@ -45,51 +45,38 @@ static size_t getArrayLength(size_t length, size_t bits) {
     return roundUpDivide(length * bits, U64_BITS);
 }
 
-void copyBitArray(BitArray* a, const BitArray* other) {
-    if(a == other) {
-        return;
-    }
-    resizeBitArray(a, other->length, other->bits);
-    size_t length = a->length;
-    for(size_t i = 0; i < length; i++) {
-        setBitsBitArray(a, i, getBitsBitArray(other, i));
-    }
-}
-
-void moveBitArray(BitArray* a, BitArray* other) {
-    if(a == other) {
-        return;
+void initBitArray(CoreBitArray* a, size_t length, size_t bits) {
+    *a = (CoreBitArray){0};
+    if(length > 0 && bits > 0) {
+        setBitLength(a, length, bits);
     }
-    swapBitArray(a, other);
-    destroyBitArray(other);
 }
 
 void destroyBitArray(BitArray* a) {
     coreFree(a->data);
-    *a = CORE_BIT_ARRAY;
+    *a = (CoreBitArray){0};
 }
 
-BitArray* setBitsBitArray(BitArray* a, size_t index, u64 value) {
+void setBits(BitArray* a, size_t index, u64 value) {
     assert(a->data != nullptr);
     assert(index < a->length);
-    setBits(a->data, index, a->bits, value);
-    return a;
+    writeBits(a->data, index, a->bits, value);
 }
 
-u64 getBitsBitArray(const BitArray* a, size_t index) {
+void setAllBits(BitArray* a, u64 value) {
+    size_t length = a->length;
+    for(size_t i = 0; i < length; i++) {
+        setBits(a, i, value);
+    }
+}
+
+u64 getBits(const BitArray* a, size_t index) {
     assert(a->data != nullptr);
     assert(index < a->length);
     return readBits(a->data, index, a->bits);
 }
 
-size_t getBytesBitArray(const BitArray* a) {
-    if(a->length <= 0 || a->bits <= 0) {
-        return 0;
-    }
-    return getArrayLength(a->length, a->bits) * sizeof(u64);
-}
-
-i64 selectBitsBitArray(const BitArray* a, size_t index) {
+i64 selectBits(const BitArray* a, size_t index) {
     if(index <= 0) {
         return -1;
     }
@@ -113,7 +100,7 @@ i64 selectBitsBitArray(const BitArray* a, size_t index) {
     return -1;
 }
 
-void resizeBitArray(BitArray* a, size_t newLength, size_t newBits) {
+void setBitLength(BitArray* a, size_t newLength, size_t newBits) {
     if(newLength == 0 || newBits == 0) {
         destroyBitArray(a);
         return;
@@ -126,43 +113,13 @@ void resizeBitArray(BitArray* a, size_t newLength, size_t newBits) {
 
     size_t end = coreMinSize(a->length, newLength);
     for(size_t i = 0; i < end; i++) {
-        setBits(newData, i, newBits, getBitsBitArray(a, i));
+        writeBits(newData, i, newBits, getBits(a, i));
     }
     for(size_t i = end; i < newLength; i++) {
-        setBits(newData, i, newBits, 0);
+        writeBits(newData, i, newBits, 0);
     }
     coreFree(a->data);
     a->data = newData;
     a->length = newLength & 0xFFFFFFFFFFFFFF;
     a->bits = newBits & 0xFF;
 }
-
-void fillBitArray(BitArray* a, u64 value) {
-    size_t length = a->length;
-    for(size_t i = 0; i < length; i++) {
-        setBitsBitArray(a, i, value);
-    }
-}
-
-size_t toStringBitArray(const BitArray* a, char* buffer, size_t n) {
-    size_t w = 0;
-    coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "["));
-    size_t length = a->length;
-    if(length > 0) {
-        length--;
-        for(size_t i = 0; i < length; i++) {
-            u64 v = getBitsBitArray(a, i);
-            coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "%lu, ", v));
-        }
-        u64 v = getBitsBitArray(a, length);
-        coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "%lu", v));
-    }
-    coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "]"));
-    return w;
-}
-
-void swapBitArray(BitArray* a, BitArray* b) {
-    BitArray tmp = *a;
-    *a = *b;
-    *b = tmp;
-}

src/Box.c

@@ -1,5 +1,6 @@
 #include "core/Box.h"
 
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 CoreBox* coreSetBox(CoreBox* box, const CoreVector3* size) {

src/Frustum.c

@@ -3,6 +3,7 @@
 #include <math.h>
 #include <stdio.h>
 
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 #define CV30 (&CORE_VECTOR3)

src/HashMap.c

@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 static bool isInvalidKey(const CoreHashMap* m, const void* key) {

src/LinkedList.c

@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 void coreDestroyLinkedList(CoreLinkedList* l) {

src/List.c

@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 static void ensureCapacity(CoreList* l) {

src/Matrix.c

@@ -2,6 +2,7 @@
 #include <stdio.h>
 
 #include "core/Generic.h"
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 #define M(m, x, y) ((m)->data[x].data[y])

src/Plane.c

@@ -1,5 +1,6 @@
 #include "core/Plane.h"
 
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 #define CV30 (&CORE_VECTOR3)

src/Quaternion.c

@@ -1,6 +1,7 @@
 #include <math.h>
 
 #include "core/Generic.h"
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 #define mulC(a, b) mul(&VECTOR3, (a), (b))

src/RingBuffer.c

@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 void coreDestroyRingBuffer(CoreRingBuffer* r) {

src/ToString.c

@@ -0,0 +1,50 @@
+#include "core/ToString.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "core/BitArray.h"
+#include "core/Utility.h"
+
+size_t coreToString(char* buffer, size_t n, const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    int w = vsnprintf(buffer, n, format, args);
+    va_end(args);
+    return w < 0 ? 0 : (size_t)w;
+}
+
+size_t toStringSize(const void* p, char* buffer, size_t n) {
+    return toString(buffer, n, "%zu", *(const size_t*)p);
+}
+
+size_t toStringInt(const void* p, char* buffer, size_t n) {
+    return toString(buffer, n, "%d", *(const int*)p);
+}
+
+void stringAdd(size_t* w, char** buffer, size_t* n, size_t shift) {
+    *w += shift;
+    if(*n > shift) {
+        *buffer += shift;
+        *n -= shift;
+    } else {
+        *n = 0;
+    }
+}
+
+size_t toStringBitArray(const BitArray* a, char* buffer, size_t n) {
+    size_t w = 0;
+    coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "["));
+    size_t length = a->length;
+    if(length > 0) {
+        length--;
+        for(size_t i = 0; i < length; i++) {
+            u64 v = getBits(a, i);
+            coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "%lu, ", v));
+        }
+        u64 v = getBits(a, length);
+        coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "%lu", v));
+    }
+    coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "]"));
+    return w;
+}

src/Utility.c

@@ -1,7 +1,5 @@
 #include "core/Utility.h"
 
-#include <stdarg.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <threads.h>
@@ -27,32 +25,6 @@ size_t popCount(u64 u) {
     return sum;
 }
 
-size_t toString(char* buffer, size_t n, const char* format, ...) {
-    va_list args;
-    va_start(args, format);
-    int w = vsnprintf(buffer, n, format, args);
-    va_end(args);
-    return w < 0 ? 0 : (size_t)w;
-}
-
-size_t toStringSize(const void* p, char* buffer, size_t n) {
-    return toString(buffer, n, "%zu", *(const size_t*)p);
-}
-
-size_t toStringInt(const void* p, char* buffer, size_t n) {
-    return toString(buffer, n, "%d", *(const int*)p);
-}
-
-void stringAdd(size_t* w, char** buffer, size_t* n, size_t shift) {
-    *w += shift;
-    if(*n > shift) {
-        *buffer += shift;
-        *n -= shift;
-    } else {
-        *n = 0;
-    }
-}
-
 [[noreturn]] void coreExitWithHandler(const char* file, int line, int value) {
     if(value != 0) {
         file = getShortFileName(file);

src/Vector.c

@@ -3,6 +3,7 @@
 #include <math.h>
 #include <stdio.h>
 
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 typedef Vector2 V2;

test/modules/BitArrayTests.c

@@ -1,179 +1,145 @@
 #include "../Tests.h"
 #include "core/BitArray.h"
+#include "core/ToString.h"
 
 static void testSetRead() {
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 4, 3);
-    setBitsBitArray(&bits, 0, 1);
-    setBitsBitArray(&bits, 1, 2);
-    setBitsBitArray(&bits, 2, 3);
-    setBitsBitArray(&bits, 3, 4);
-    TEST_U64(1, getBitsBitArray(&bits, 0));
-    TEST_U64(2, getBitsBitArray(&bits, 1));
-    TEST_U64(3, getBitsBitArray(&bits, 2));
-    TEST_U64(4, getBitsBitArray(&bits, 3));
+    BitArray bits;
+    initBitArray(&bits, 4, 3);
+    setBits(&bits, 0, 1);
+    setBits(&bits, 1, 2);
+    setBits(&bits, 2, 3);
+    setBits(&bits, 3, 4);
+    TEST_U64(1, getBits(&bits, 0));
+    TEST_U64(2, getBits(&bits, 1));
+    TEST_U64(3, getBits(&bits, 2));
+    TEST_U64(4, getBits(&bits, 3));
     destroyBitArray(&bits);
 }
 
 static void testBigSetRead() {
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 100, 13);
+    BitArray bits;
+    initBitArray(&bits, 100, 13);
     for(size_t i = 0; i < bits.length; i++) {
-        setBitsBitArray(&bits, i, i);
+        setBits(&bits, i, i);
     }
     for(size_t i = 0; i < bits.length; i++) {
-        TEST_U64(i, getBitsBitArray(&bits, i));
+        TEST_U64(i, getBits(&bits, i));
     }
     destroyBitArray(&bits);
 }
 
 static void testRandomSetReadResize() {
     u64 data[100];
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 100, 13);
+    BitArray bits;
+    initBitArray(&bits, 100, 13);
     u64 seed = 534;
     for(int k = 0; k < 20; k++) {
         for(u64 i = 0; i < bits.length; i++) {
             seed = seed * 636455 + 53453;
-            setBitsBitArray(&bits, i, seed);
+            setBits(&bits, i, seed);
             data[i] = seed & 0x1FFF;
         }
     }
     for(size_t i = 0; i < bits.length; i++) {
-        TEST_U64(data[i], getBitsBitArray(&bits, i));
+        TEST_U64(data[i], getBits(&bits, i));
     }
-    resizeBitArray(&bits, bits.length, bits.bits + 1u);
+    setBitLength(&bits, bits.length, bits.bits + 1u);
     TEST_U64(14, bits.bits);
     TEST_U64(100, bits.length);
     for(size_t i = 0; i < bits.length; i++) {
-        TEST_U64(data[i], getBitsBitArray(&bits, i));
+        TEST_U64(data[i], getBits(&bits, i));
     }
     destroyBitArray(&bits);
 }
 
-static void testCopy() {
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 4, 3);
-    setBitsBitArray(&bits, 0, 1);
-    setBitsBitArray(&bits, 1, 2);
-    setBitsBitArray(&bits, 2, 3);
-    setBitsBitArray(&bits, 3, 4);
-    BitArray copy = BIT_ARRAY;
-    copyBitArray(&copy, &bits);
-    copyBitArray(&copy, &copy);
-    TEST_U64(1, getBitsBitArray(&copy, 0));
-    TEST_U64(2, getBitsBitArray(&copy, 1));
-    TEST_U64(3, getBitsBitArray(&copy, 2));
-    TEST_U64(4, getBitsBitArray(&copy, 3));
-    destroyBitArray(&copy);
-    destroyBitArray(&bits);
-}
-
 static void testSelect() {
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 90, 1);
-    fillBitArray(&bits, 0);
-    setBitsBitArray(&bits, 0, 1);
-    setBitsBitArray(&bits, 5, 1);
-    setBitsBitArray(&bits, 20, 1);
-    setBitsBitArray(&bits, 31, 1);
-    setBitsBitArray(&bits, 32, 1);
-    setBitsBitArray(&bits, 33, 1);
-    setBitsBitArray(&bits, 60, 1);
-    TEST_I64(-1, selectBitsBitArray(&bits, 0));
-    TEST_I64(0, selectBitsBitArray(&bits, 1));
-    TEST_I64(5, selectBitsBitArray(&bits, 2));
-    TEST_I64(20, selectBitsBitArray(&bits, 3));
-    TEST_I64(31, selectBitsBitArray(&bits, 4));
-    TEST_I64(32, selectBitsBitArray(&bits, 5));
-    TEST_I64(33, selectBitsBitArray(&bits, 6));
-    TEST_I64(60, selectBitsBitArray(&bits, 7));
-    TEST_I64(-1, selectBitsBitArray(&bits, 8));
+    BitArray bits;
+    initBitArray(&bits, 90, 1);
+    setAllBits(&bits, 0);
+    setBits(&bits, 0, 1);
+    setBits(&bits, 5, 1);
+    setBits(&bits, 20, 1);
+    setBits(&bits, 31, 1);
+    setBits(&bits, 32, 1);
+    setBits(&bits, 33, 1);
+    setBits(&bits, 60, 1);
+    TEST_I64(-1, selectBits(&bits, 0));
+    TEST_I64(0, selectBits(&bits, 1));
+    TEST_I64(5, selectBits(&bits, 2));
+    TEST_I64(20, selectBits(&bits, 3));
+    TEST_I64(31, selectBits(&bits, 4));
+    TEST_I64(32, selectBits(&bits, 5));
+    TEST_I64(33, selectBits(&bits, 6));
+    TEST_I64(60, selectBits(&bits, 7));
+    TEST_I64(-1, selectBits(&bits, 8));
     destroyBitArray(&bits);
 }
 
 static void testToString1() {
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 4, 3);
-    setBitsBitArray(&bits, 0, 1);
-    setBitsBitArray(&bits, 1, 2);
-    setBitsBitArray(&bits, 2, 3);
-    setBitsBitArray(&bits, 3, 4);
+    BitArray bits;
+    initBitArray(&bits, 4, 3);
+    setBits(&bits, 0, 1);
+    setBits(&bits, 1, 2);
+    setBits(&bits, 2, 3);
+    setBits(&bits, 3, 4);
     char buffer[128];
-    size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
+    size_t n = toString(&bits, buffer, sizeof(buffer));
     TEST_SIZE(12, n);
     TEST_STRING("[1, 2, 3, 4]", buffer);
     destroyBitArray(&bits);
 }
 
 static void testToString2() {
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 1, 3);
-    setBitsBitArray(&bits, 0, 1);
+    BitArray bits;
+    initBitArray(&bits, 1, 3);
+    setBits(&bits, 0, 1);
     char buffer[128];
-    size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
+    size_t n = toString(&bits, buffer, sizeof(buffer));
     TEST_SIZE(3, n);
     TEST_STRING("[1]", buffer);
     destroyBitArray(&bits);
 }
 
 static void testToString3() {
-    BitArray bits = BIT_ARRAY;
+    BitArray bits;
+    initBitArray(&bits, 0, 0);
     char buffer[128];
-    size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
+    size_t n = toString(&bits, buffer, sizeof(buffer));
     TEST_SIZE(2, n);
     TEST_STRING("[]", buffer);
     destroyBitArray(&bits);
 }
 
 static void testResizeExact() {
-    BitArray bits = BIT_ARRAY;
-    TEST_U64(0, getBytesBitArray(&bits));
+    BitArray bits;
     // the size in bytes matches the internal storage type
     size_t elements = sizeof(u64);
-    resizeBitArray(&bits, elements, 8);
+    initBitArray(&bits, elements, 8);
     for(size_t i = 0; i < elements; i++) {
-        setBitsBitArray(&bits, i, i);
+        setBits(&bits, i, i);
     }
     for(size_t i = 0; i < elements; i++) {
-        TEST_U64(i, getBitsBitArray(&bits, i));
-    }
-    TEST_U64(sizeof(u64), getBytesBitArray(&bits));
-    destroyBitArray(&bits);
-}
-
-static void testMove() {
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 8, 8);
-    for(size_t i = 0; i < bits.length; i++) {
-        setBitsBitArray(&bits, i, i);
-    }
-    BitArray m = BIT_ARRAY;
-    moveBitArray(&m, &bits);
-    moveBitArray(&m, &m);
-    TEST_U64(8, m.length);
-    for(size_t i = 0; i < m.length; i++) {
-        TEST_U64(i, getBitsBitArray(&m, i));
+        TEST_U64(i, getBits(&bits, i));
     }
-    destroyBitArray(&m);
     destroyBitArray(&bits);
 }
 
 static void testInvalidArgument() {
-    BitArray bits = BIT_ARRAY;
-    resizeBitArray(&bits, 0, 5);
+    BitArray bits;
+    initBitArray(&bits, 0, 0);
+    setBitLength(&bits, 0, 5);
     TEST_SIZE(0, bits.length);
     TEST_SIZE(0, bits.bits);
-    resizeBitArray(&bits, 5, 0);
+    setBitLength(&bits, 5, 0);
     TEST_SIZE(0, bits.length);
     TEST_SIZE(0, bits.bits);
-    resizeBitArray(&bits, 0, 0);
+    setBitLength(&bits, 0, 0);
     TEST_SIZE(0, bits.length);
     TEST_SIZE(0, bits.bits);
-    resizeBitArray(&bits, 1, 65);
+    setBitLength(&bits, 1, 65);
     TEST_SIZE(1, bits.length);
     TEST_SIZE(64, bits.bits);
-    resizeBitArray(&bits, 5, 68);
+    setBitLength(&bits, 5, 68);
     TEST_SIZE(5, bits.length);
     TEST_SIZE(64, bits.bits);
     destroyBitArray(&bits);
@@ -183,12 +149,10 @@ void testBitArray() {
     testSetRead();
     testBigSetRead();
     testRandomSetReadResize();
-    testCopy();
     testSelect();
     testToString1();
     testToString2();
     testToString3();
     testResizeExact();
-    testMove();
     testInvalidArgument();
 }

test/modules/HashMapTests.c

@@ -1,5 +1,6 @@
 #include "../Tests.h"
 #include "core/HashMap.h"
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 static CoreHashMap createIntMap() {

test/modules/LinkedListTests.c

@@ -1,5 +1,6 @@
 #include "../Tests.h"
 #include "core/LinkedList.h"
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 static void testAdd() {

test/modules/ListTests.c

@@ -1,5 +1,6 @@
 #include "../Tests.h"
 #include "core/List.h"
+#include "core/ToString.h"
 #include "core/Utility.h"
 #include "core/Vector.h"
 

test/modules/RingBufferTests.c

@@ -1,5 +1,6 @@
 #include "../Tests.h"
 #include "core/RingBuffer.h"
+#include "core/ToString.h"
 #include "core/Utility.h"
 
 static void testReadAndWrite() {

test/modules/SpinLockTests.c

@@ -43,7 +43,7 @@ typedef struct {
 
 static int incrementSpinLockCounter(void* p) {
     SpinLockCounter* mcp = (SpinLockCounter*)p;
-    for(int i = 0; i < 10000; i++) {
+    for(int i = 0; i < 20000; i++) {
         coreLockSpinLock(&mcp->s);
         mcp->counter++;
         coreUnlockSpinLock(&mcp->s);
@@ -61,7 +61,7 @@ static void testSpinLockLoop() {
     thrd_create(t + 1, incrementSpinLockCounter, &sc);
     thrd_join(t[0], nullptr);
     thrd_join(t[1], nullptr);
-    CORE_TEST_INT(20000, sc.counter);
+    CORE_TEST_INT(40000, sc.counter);
 
     n += coreGetNanos();
     printf("%ldns SpinLock\n", n);

test/modules/UtilityTests.c

@@ -63,6 +63,21 @@ static void testSleep(i64 nanos) {
     TEST_TRUE(time >= nanos && time <= (nanos * 13) / 10);
 }
 
+typedef struct {
+    int i;
+    i64 d;
+} SwapTest;
+
+static void testSwap() {
+    SwapTest a = {3, 20};
+    SwapTest b = {7, 30};
+    coreSwap(&a, &b);
+    TEST_INT(7, a.i);
+    TEST_INT(3, b.i);
+    TEST_I64(30, a.d);
+    TEST_I64(20, b.d);
+}
+
 static void testFail() {
 #ifdef ERROR_SIMULATOR
     failTimeGet = true;
@@ -80,6 +95,7 @@ void testUtility(bool light) {
     testDegreeToRadian();
     testSleep(light ? 5'000'000 : 50'000'000);
     testSleep(light ? 50'000'000 : 1'300'000'000);
+    testSwap();
     testFail();
 }
 
@@ -106,7 +122,7 @@ void testInvalidReallocate(void) {
 }
 
 [[noreturn]] void testPreCanary(void) {
-#ifdef CHECK_MEMORY
+#ifdef CORE_CHECK_MEMORY
     char* p = cAllocate(16);
     p[-1] = 0;
     cFree(p);
@@ -117,7 +133,7 @@ void testInvalidReallocate(void) {
 }
 
 [[noreturn]] void testPostCanary(void) {
-#ifdef CHECK_MEMORY
+#ifdef CORE_CHECK_MEMORY
     char* p = cAllocate(16);
     p[17] = 0;
     cFree(p);