2 files changed, 24 insertions, 20 deletions

diff --git a/mem/src/mem.c b/mem/src/mem.c
index 4f5e5ef..9169a9f 100644
--- a/mem/src/mem.c
+++ b/mem/src/mem.c
@@ -46,17 +46,18 @@ void mem_del_(Memory* mem) {
   if (mem->dynamic) {
     if (mem->chunks) {
       free(mem->chunks);
-      mem->chunks = 0;
+      mem->chunks = nullptr;
     }
     if (mem->blocks) {
       free(mem->blocks);
-      mem->blocks = 0;
+      mem->blocks = nullptr;
     }
   }
 }
 
 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));
@@ -113,10 +114,11 @@ void* mem_alloc_(Memory* mem, size_t num_blocks) {
     return &mem->blocks[chunk_idx * mem->block_size_bytes];
   } else {
     if (mem->trap) {
-      FAIL("Memory allocation failed, increase the allocator's capacity or "
-           "avoid fragmentation.");
+      FAIL(
+          "Memory allocation failed, increase the allocator's capacity or "
+          "avoid fragmentation.");
     }
-    return 0; // Large-enough free chunk not found.
+    return nullptr; // Large-enough free chunk not found.
   }
 }
 
@@ -172,7 +174,7 @@ void mem_free_(Memory* mem, void** chunk_ptr) {
 
   mem->num_used_blocks--;
 
-  *chunk_ptr = 0;
+  *chunk_ptr = nullptr;
 }
 
 // The handle is the chunk's index. We don't call it an index in the public API
diff --git a/mem/test/mem_test.c b/mem/test/mem_test.c
index 14718a5..a8d482f 100644
--- a/mem/test/mem_test.c
+++ b/mem/test/mem_test.c
@@ -39,7 +39,7 @@ TEST_CASE(mem_fully_allocate) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     const int* block = mem_alloc(&mem, 1);
-    TEST_TRUE(block != 0);
+    TEST_TRUE(block != nullptr);
   }
 
   TEST_TRUE(mem_size(&mem) == NUM_BLOCKS);
@@ -50,15 +50,15 @@ TEST_CASE(mem_fill_then_free) {
   test_mem mem;
   mem_make(&mem);
 
-  int* blocks[NUM_BLOCKS] = {0};
+  int* blocks[NUM_BLOCKS] = {nullptr};
   for (int i = 0; i < NUM_BLOCKS; i++) {
     blocks[i] = mem_alloc(&mem, 1);
-    TEST_TRUE(blocks[i] != 0);
+    TEST_TRUE(blocks[i] != nullptr);
   }
 
   for (int i = 0; i < NUM_BLOCKS; i++) {
     mem_free(&mem, &blocks[i]);
-    TEST_EQUAL(blocks[i], 0); // Pointer should be set to 0 on free.
+    TEST_EQUAL(blocks[i], nullptr); // Pointer should be set to 0 on free.
   }
 
   TEST_EQUAL(count(&mem), 0);
@@ -74,12 +74,12 @@ TEST_CASE(mem_allocate_beyond_max_size) {
 
   // Fully allocate the mem.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
-    TEST_TRUE(mem_alloc(&mem, 1) != 0);
+    TEST_TRUE(mem_alloc(&mem, 1) != nullptr);
   }
 
   // Past the end.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
-    TEST_EQUAL(mem_alloc(&mem, 1), 0);
+    TEST_EQUAL(mem_alloc(&mem, 1), nullptr);
   }
 
   TEST_TRUE(mem_size(&mem) == NUM_BLOCKS);
@@ -105,7 +105,7 @@ TEST_CASE(mem_zero_free_block_after_free) {
   mem_make(&mem);
 
   int* val = mem_alloc(&mem, 1);
-  TEST_TRUE(val != 0);
+  TEST_TRUE(val != nullptr);
   *val = 177;
 
   int* old_val = val;
@@ -131,7 +131,7 @@ TEST_CASE(mem_traverse_partially_full) {
 
   for (int i = 0; i < N; ++i) {
     int* val = mem_alloc(&mem, 1);
-    TEST_TRUE(val != 0);
+    TEST_TRUE(val != nullptr);
     *val = i + 1;
   }
 
@@ -146,7 +146,7 @@ TEST_CASE(mem_traverse_full) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* val = mem_alloc(&mem, 1);
-    TEST_TRUE(val != 0);
+    TEST_TRUE(val != nullptr);
     *val = i + 1;
   }
 
@@ -161,7 +161,7 @@ TEST_CASE(mem_get_block) {
 
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* block = mem_alloc(&mem, 1);
-    TEST_TRUE(block != 0);
+    TEST_TRUE(block != nullptr);
     *block = i;
     TEST_EQUAL(mem_get_chunk_handle(&mem, block), (size_t)i);
   }
@@ -179,7 +179,7 @@ TEST_CASE(mem_fragmentation) {
   test_mem mem;
   mem_make(&mem);
 
-  int* blocks[NUM_BLOCKS] = {0};
+  int* blocks[NUM_BLOCKS] = {nullptr};
   int  next_block         = 0;
 
 #define ALLOC(num_blocks)                           \
@@ -205,7 +205,7 @@ TEST_CASE(mem_fragmentation) {
 
   // Should be able to allocate 1 chunk of N blocks.
   const void* chunk = mem_alloc(&mem, NUM_BLOCKS);
-  TEST_TRUE(chunk != 0);
+  TEST_TRUE(chunk != nullptr);
 }
 
 // Clear and re-use an allocator.
@@ -216,15 +216,17 @@ TEST_CASE(mem_clear_then_reuse) {
   // Allocate chunks, contents not important.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* chunk = mem_alloc(&mem, 1);
-    TEST_TRUE(chunk != 0);
+    TEST_TRUE(chunk != nullptr);
   }
 
   mem_clear(&mem);
+  TEST_EQUAL(mem_size(&mem), 0);
+  TEST_EQUAL(mem_capacity(&mem), NUM_BLOCKS);
 
   // Allocate chunks and assign values 0..N.
   for (int i = 0; i < NUM_BLOCKS; ++i) {
     int* chunk = mem_alloc(&mem, 1);
-    TEST_TRUE(chunk != 0);
+    TEST_TRUE(chunk != nullptr);
     *chunk = i + 1;
   }