1 files changed, 121 insertions, 0 deletions
diff --git a/test/test_allocator.c b/test/test_allocator.c
new file mode 100644
index 0000000..e146de6
--- /dev/null
+++ b/test/test_allocator.c
@@ -0,0 +1,121 @@
+// Copyright 2014-2021 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#undef NDEBUG
+
+#include "zix/allocator.h"
+#include "zix/bump_allocator.h"
+
+#include <assert.h>
+#include <stdint.h>
+
+static void
+test_allocator(void)
+{
+  // Just a basic smoke test to check that things seem to be working
+
+  ZixAllocator* const allocator = zix_default_allocator();
+
+  char* const malloced = (char*)zix_malloc(allocator, 4);
+  malloced[0]          = 0;
+  malloced[3]          = 3;
+  assert(malloced[0] == 0);
+  assert(malloced[3] == 3);
+
+  char* const calloced = (char*)zix_calloc(allocator, 4, 1);
+  assert(calloced[0] == 0);
+  assert(calloced[1] == 0);
+  assert(calloced[2] == 0);
+  assert(calloced[3] == 0);
+
+  char* const realloced = (char*)zix_realloc(allocator, calloced, 8);
+  assert(realloced[0] == 0);
+  assert(realloced[1] == 0);
+  assert(realloced[2] == 0);
+  assert(realloced[3] == 0);
+  realloced[4] = 4;
+  realloced[5] = 5;
+  realloced[6] = 6;
+  realloced[7] = 7;
+  assert(realloced[4] == 4);
+  assert(realloced[5] == 5);
+  assert(realloced[6] == 6);
+  assert(realloced[7] == 7);
+
+  char* const aligned = (char*)zix_aligned_alloc(allocator, 4096, 4096);
+  assert((uintptr_t)aligned % 4096 == 0);
+  aligned[0] = 0;
+  aligned[3] = 3;
+  assert(aligned[0] == 0);
+  assert(aligned[3] == 3);
+
+  zix_aligned_free(allocator, aligned);
+  zix_free(allocator, realloced);
+  zix_free(allocator, malloced);
+}
+
+static void
+test_bump_allocator(void)
+{
+  char             buffer[1024] = {0};
+  ZixBumpAllocator allocator    = zix_bump_allocator(sizeof(buffer), buffer);
+
+  assert(!zix_malloc(&allocator.base, 1025));
+
+  char* const malloced = (char*)zix_malloc(&allocator.base, 3);
+  assert(malloced >= buffer);
+  assert(malloced <= buffer + sizeof(buffer));
+  assert((uintptr_t)malloced % sizeof(uintmax_t) == 0U);
+
+  assert(!zix_calloc(&allocator.base, 1017, 1));
+
+  char* const calloced = (char*)zix_calloc(&allocator.base, 4, 1);
+  assert(calloced > malloced);
+  assert(calloced <= buffer + sizeof(buffer));
+  assert((uintptr_t)calloced % sizeof(uintmax_t) == 0U);
+  assert(!calloced[0]);
+  assert(!calloced[1]);
+  assert(!calloced[2]);
+  assert(!calloced[3]);
+
+  char* const realloced = (char*)zix_realloc(&allocator.base, calloced, 8);
+  assert(realloced == calloced);
+
+  assert(!zix_realloc(&allocator.base, malloced, 8));     // Not the top
+  assert(!zix_realloc(&allocator.base, realloced, 4089)); // No space
+
+  zix_free(&allocator.base, realloced);
+
+  char* const reclaimed = (char*)zix_malloc(&allocator.base, 512);
+  assert(reclaimed);
+  assert(reclaimed == realloced);
+
+  assert(!zix_aligned_alloc(&allocator.base, sizeof(uintmax_t), 1024));
+  assert(!zix_aligned_alloc(&allocator.base, 1024, 1024));
+  assert(!zix_aligned_alloc(&allocator.base, 2048, 2048));
+  assert(!zix_aligned_alloc(&allocator.base, 4096, 4096));
+  assert(!zix_aligned_alloc(&allocator.base, 8192, 8192));
+  assert(!zix_aligned_alloc(&allocator.base, 4096, 4096));
+  assert(!zix_aligned_alloc(&allocator.base, 2048, 2048));
+  assert(!zix_aligned_alloc(&allocator.base, 1024, 1024));
+  assert(!zix_aligned_alloc(&allocator.base, 512, 512));
+
+  char* const aligned = (char*)zix_aligned_alloc(&allocator.base, 128, 128);
+  assert(aligned);
+  assert(aligned >= reclaimed);
+  assert(aligned <= buffer + sizeof(buffer));
+  assert((uintptr_t)aligned % 128 == 0U);
+
+  zix_aligned_free(&allocator.base, aligned);
+  zix_free(&allocator.base, reclaimed); // Correct, but a noop
+  zix_free(&allocator.base, malloced);  // Correct, but a noop
+}
+
+int
+main(void)
+{
+  test_allocator();
+  test_bump_allocator();
+
+  return 0;
+}