From e5eb3845eff1ea080ffdc08102f7d1a6dee1179f Mon Sep 17 00:00:00 2001
From: 3gg <3gg@shellblade.net>
Date: Tue, 19 Aug 2025 18:22:34 +0200
Subject: Add tests for clearing uninitialized memory allocators

---
 mem/src/mem.c                 | 18 ++++++++++--------
 mem/test/mem_test.c           |  6 ++++++
 mempool/src/mempool.c         | 11 +++++------
 mempool/test/mempool_test.c   | 10 ++++++++--
 memstack/test/memstack_test.c |  8 +++++++-
 5 files changed, 36 insertions(+), 17 deletions(-)

diff --git a/mem/src/mem.c b/mem/src/mem.c
index 9169a9f..70648c9 100644
--- a/mem/src/mem.c
+++ b/mem/src/mem.c
@@ -57,14 +57,16 @@ void mem_del_(Memory* mem) {
 
 void mem_clear_(Memory* mem) {
   assert(mem);
-  mem->num_used_blocks = 0;
-  mem->next_free_chunk = 0;
-  memset(mem->blocks, 0, mem->num_blocks * mem->block_size_bytes);
-  memset(mem->chunks, 0, mem->num_blocks * sizeof(Chunk));
-
-  // Initialize the head as one large free chunk.
-  Chunk* head      = &mem->chunks[0];
-  head->num_blocks = mem->num_blocks;
+  if (mem->num_blocks > 0) {
+    mem->num_used_blocks = 0;
+    mem->next_free_chunk = 0;
+    memset(mem->blocks, 0, mem->num_blocks * mem->block_size_bytes);
+    memset(mem->chunks, 0, mem->num_blocks * sizeof(Chunk));
+
+    // Initialize the head as one large free chunk.
+    Chunk* head      = &mem->chunks[0];
+    head->num_blocks = mem->num_blocks;
+  }
 }
 
 void* mem_alloc_(Memory* mem, size_t num_blocks) {
diff --git a/mem/test/mem_test.c b/mem/test/mem_test.c
index a8d482f..52ce5a9 100644
--- a/mem/test/mem_test.c
+++ b/mem/test/mem_test.c
@@ -32,6 +32,12 @@ TEST_CASE(mem_create_dyn) {
   mem_make_dyn(&mem, NUM_BLOCKS, sizeof(int));
 }
 
+// Clear an uninitialized allocator.
+TEST_CASE(mem_clear_uninitialized) {
+  test_mem mem = {0};
+  mem_clear(&mem);
+}
+
 // Allocate N chunks of 1 block each.
 TEST_CASE(mem_fully_allocate) {
   test_mem mem;
diff --git a/mempool/src/mempool.c b/mempool/src/mempool.c
index bae4fc9..2c3c725 100644
--- a/mempool/src/mempool.c
+++ b/mempool/src/mempool.c
@@ -65,15 +65,14 @@ void mempool_del_(mempool* pool) {
   }
 }
 
-// TODO: Add a unit test for clearing a pool that has not been initialized.
 void mempool_clear_(mempool* pool) {
   assert(pool);
-  pool->head            = 0;
-  pool->used            = 0;
-  pool->num_used_blocks = 0;
-  memset(pool->blocks, 0, pool->num_blocks * pool->block_size_bytes);
-  memset(pool->block_info, 0, pool->num_blocks * sizeof(BlockInfo));
   if (pool->num_blocks > 0) {
+    pool->head            = 0;
+    pool->used            = 0;
+    pool->num_used_blocks = 0;
+    memset(pool->blocks, 0, pool->num_blocks * pool->block_size_bytes);
+    memset(pool->block_info, 0, pool->num_blocks * sizeof(BlockInfo));
     init_free_list(pool);
   }
 }
diff --git a/mempool/test/mempool_test.c b/mempool/test/mempool_test.c
index 6d904bc..69658b9 100644
--- a/mempool/test/mempool_test.c
+++ b/mempool/test/mempool_test.c
@@ -25,13 +25,19 @@ TEST_CASE(mempool_create) {
 }
 
 // Create a dynamically-backed pool.
-TEST_CASE(mem_create_dyn) {
+TEST_CASE(mempool_create_dyn) {
   DEF_MEMPOOL_DYN(dyn_pool, int);
 
   dyn_pool pool;
   mempool_make_dyn(&pool, NUM_BLOCKS, sizeof(int));
 }
 
+// Clear an uninitialized pool.
+TEST_CASE(mempool_clear_uninitialized) {
+  test_pool pool = {0};
+  mempool_clear(&pool);
+}
+
 // Allocate all N blocks.
 TEST_CASE(mempool_allocate_until_full) {
   test_pool pool;
@@ -172,7 +178,7 @@ TEST_CASE(mempool_get_block) {
 }
 
 // Clear and re-use an allocator.
-TEST_CASE(mem_clear_then_reuse) {
+TEST_CASE(mempool_clear_then_reuse) {
   test_pool mem;
   mempool_make(&mem);
 
diff --git a/memstack/test/memstack_test.c b/memstack/test/memstack_test.c
index 5308be3..2bcffcd 100644
--- a/memstack/test/memstack_test.c
+++ b/memstack/test/memstack_test.c
@@ -15,12 +15,18 @@ TEST_CASE(memstack_create) {
 }
 
 // Create and destroy a dynamically-backed stack.
-TEST_CASE(mem_create_dyn) {
+TEST_CASE(memstack_create_dyn) {
   memstack stack = {0};
   memstack_make(&stack, CAPACITY, nullptr);
   memstack_del(&stack);
 }
 
+// Clear an uninitialized stack.
+TEST_CASE(memstack_clear_uninitialized) {
+  memstack stack = {0};
+  memstack_clear(&stack);
+}
+
 // Allocate all N ints.
 TEST_CASE(memstack_allocate_until_full) {
   memstack stack = {0};
-- 
cgit v1.2.3