tests: force malloc compatibility

10 files changed, 478 insertions, 307 deletions

diff --git a/test/pkarr.c b/test/pkarr.c
index 25ae171..8762aa9 100644
--- a/test/pkarr.c
+++ b/test/pkarr.c
@@ -39,6 +39,7 @@ test_spinup(struct pk_arr *arr, struct pk_membucket **bkt)
 void
 test_teardown(struct pk_arr *arr, struct pk_membucket **bkt)
 {
+	pk_arr_reset(arr);
 	pk_mem_bucket_destroy(*bkt);
 	*bkt = NULL;
 	arr->data = NULL;
diff --git a/test/pkarr.cpp b/test/pkarr.cpp
index 8879ca4..e61a2a7 100644
--- a/test/pkarr.cpp
+++ b/test/pkarr.cpp
@@ -195,6 +195,7 @@ int main(int argc, char *argv[])
 		res = pk_arr_iter_increment(&arr, &it);
 		if (res == true) exit(1);
 
+		pk_arr_reset(&arr);
 	}
 	fprintf(stdout, "[%s] Ending iter forward test\n\n", __FILE__);
 	test_teardown(&bkt);
@@ -238,6 +239,7 @@ int main(int argc, char *argv[])
 		res = pk_arr_iter_decrement(&arr, &it);
 		if (res == true) exit(1);
 
+		pk_arr_reset(&arr);
 	}
 	fprintf(stdout, "[%s] Ending iter reverse test\n\n", __FILE__);
 	test_teardown(&bkt);
diff --git a/test/pkbktarr.c b/test/pkbktarr.c
index 1b89b53..da8d888 100644
--- a/test/pkbktarr.c
+++ b/test/pkbktarr.c
@@ -4,6 +4,9 @@
 #define PK_IMPL_MEM
 #define PK_IMPL_BKTARR
 #include "../pkbktarr.h"
+#define PK_IMPL_TST
+#include "../pktst.h"
+
 
 #include <setjmp.h>
 #include <unistd.h>
@@ -71,9 +74,12 @@ int main(int argc, char *argv[])
 				handles[b][i].i = i;
 			}
 		}
-		if (v = pk_bkt_arr_handle_compare(handles[0][0], handles[0][0]), v != 0) exit(1);
-		if (v = pk_bkt_arr_handle_compare(handles[1][0], handles[1][1]), v <= 0) exit(1);
-		if (v = pk_bkt_arr_handle_compare(handles[1][1], handles[1][0]), v >= 0) exit(1);
+		v = pk_bkt_arr_handle_compare(handles[0][0], handles[0][0]);
+		PK_TEST_ASSERT_EQ_EXIT((int)0, v);
+		v = pk_bkt_arr_handle_compare(handles[1][0], handles[1][1]);
+		PK_TEST_ASSERT_LTE_EXIT((int)0, v);
+		v = pk_bkt_arr_handle_compare(handles[1][1], handles[1][0]);
+		PK_TEST_ASSERT_GTE_EXIT((int)0, v);
 	}
 
 	// test ancillary 2
@@ -85,25 +91,39 @@ int main(int argc, char *argv[])
 
 		h1.b = 0;
 		h1.i = 0;
-		if (h2 = pk_bkt_arr_handle_increment(&arr, h1), h2.b != 0 || h2.i != 1) exit(1);
+		h2 = pk_bkt_arr_handle_increment(&arr, h1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, h2.i);
 		h1.b = 1;
 		h1.i = 1;
-		if (h2 = pk_bkt_arr_handle_increment(&arr, h1), h2.b != 1 || h2.i != 2) exit(1);
+		h2 = pk_bkt_arr_handle_increment(&arr, h1);
+		PK_TEST_ASSERT_EQ_EXIT(1, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, h2.i);
 		h1.b = 1;
 		h1.i = 2;
-		if (h2 = pk_bkt_arr_handle_increment(&arr, h1), h2.b != 2 || h2.i != 0) exit(1);
+		h2 = pk_bkt_arr_handle_increment(&arr, h1);
+		PK_TEST_ASSERT_EQ_EXIT(2, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.i);
 		h1.b = 2;
 		h1.i = 2;
-		if (h2 = pk_bkt_arr_handle_increment(&arr, h1), h2.b != 2 || h2.i != 2) exit(1);
+		h2 = pk_bkt_arr_handle_increment(&arr, h1);
+		PK_TEST_ASSERT_EQ_EXIT(2, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, h2.i);
 		h1.b = 0;
 		h1.i = 0;
-		if (h2 = pk_bkt_arr_handle_decrement(&arr, h1), h2.b != 0 || h2.i != 0) exit(1);
+		h2 = pk_bkt_arr_handle_decrement(&arr, h1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.i);
 		h1.b = 2;
 		h1.i = 2;
-		if (h2 = pk_bkt_arr_handle_decrement(&arr, h1), h2.b != 2 || h2.i != 1) exit(1);
+		h2 = pk_bkt_arr_handle_decrement(&arr, h1);
+		PK_TEST_ASSERT_EQ_EXIT(2, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, h2.i);
 		h1.b = 2;
 		h1.i = 0;
-		if (h2 = pk_bkt_arr_handle_decrement(&arr, h1), h2.b != 1 || h2.i != 2) exit(1);
+		h2 = pk_bkt_arr_handle_decrement(&arr, h1);
+		PK_TEST_ASSERT_EQ_EXIT(1, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, h2.i);
 	}
 
 	// test it works
@@ -115,26 +135,30 @@ int main(int argc, char *argv[])
 		pk_bkt_arr_init(&arr, sizeof(int), alignof(int), pk_bkt_arr_handle_MAX, bkt_buckets, bkt_data);
 
 		struct pk_bkt_arr_handle h = pk_bkt_arr_new_handle(&arr);
-		if (h.b != 0) exit(1);
-		if (h.i != 0) exit(1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 1) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 1) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		pk_bkt_arr_free_handle(&arr, h);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 0) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 1) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		pk_bkt_arr_teardown(&arr);
-		if (bkt_buckets->alloc_count != 0) exit(1);
-		if (bkt_data->alloc_count != 0) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_data->alloc_count);
 	}
 	test_teardown(&bkt_buckets, &bkt_data);
 
@@ -147,36 +171,42 @@ int main(int argc, char *argv[])
 		pk_bkt_arr_init(&arr, sizeof(int), alignof(int), pk_bkt_arr_handle_MAX, bkt_buckets, bkt_data);
 
 		struct pk_bkt_arr_handle h = pk_bkt_arr_new_handle(&arr);
-		if (h.b != 0) exit(1);
-		if (h.i != 0) exit(1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 1) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 1) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		pk_bkt_arr_clear(&arr);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 0) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 0) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		h = pk_bkt_arr_new_handle(&arr);
-		if (h.b != 0) exit(1);
-		if (h.i != 0) exit(1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 1) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 1) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		pk_bkt_arr_teardown(&arr);
-		if (bkt_buckets->alloc_count != 0) exit(1);
-		if (bkt_data->alloc_count != 0) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_data->alloc_count);
 	}
 	test_teardown(&bkt_buckets, &bkt_data);
 
@@ -189,23 +219,25 @@ int main(int argc, char *argv[])
 		pk_bkt_arr_init(&arr, sizeof(int), alignof(int), pk_bkt_arr_handle_MAX, bkt_buckets, bkt_data);
 
 		struct pk_bkt_arr_handle h = pk_bkt_arr_new_handle(&arr);
-		if (h.b != 0) exit(1);
-		if (h.i != 0) exit(1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 1) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 1) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		int val = 69;
 		((int**)arr.bucketed_data)[h.b][h.i] = val;
 		struct pk_bkt_arr_handle found_h = pk_bkt_arr_find_first_handle(&arr, find_int_val, NULL, &val);
-		if (pk_bkt_arr_handle_compare(h, found_h) != 0) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, pk_bkt_arr_handle_compare(h, found_h));
 
 		pk_bkt_arr_teardown(&arr);
-		if (bkt_buckets->alloc_count != 0) exit(1);
-		if (bkt_data->alloc_count != 0) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_data->alloc_count);
 	}
 	test_teardown(&bkt_buckets, &bkt_data);
 
@@ -218,21 +250,23 @@ int main(int argc, char *argv[])
 		pk_bkt_arr_init(&arr, sizeof(int), alignof(int), pk_bkt_arr_handle_MAX, bkt_buckets, bkt_data);
 
 		struct pk_bkt_arr_handle h = pk_bkt_arr_new_handle(&arr);
-		if (h.b != 0) exit(1);
-		if (h.i != 0) exit(1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 1) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 1) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		pk_bkt_arr_iterate(&arr, iter, NULL);
-		if (global_counter != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(1, global_counter);
 
 		pk_bkt_arr_teardown(&arr);
-		if (bkt_buckets->alloc_count != 0) exit(1);
-		if (bkt_data->alloc_count != 0) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_data->alloc_count);
 	}
 	test_teardown(&bkt_buckets, &bkt_data);
 
@@ -247,41 +281,47 @@ int main(int argc, char *argv[])
 
 		h1 = pk_bkt_arr_new_handle(&arr);
 		h2 = pk_bkt_arr_new_handle(&arr);
-		if (h1.b != 0) exit(1);
-		if (h1.i != 0) exit(1);
-		if (h2.b != 0) exit(1);
-		if (h2.i != 1) exit(1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 2) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 2) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFFFC) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h1.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h1.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, h2.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFC, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		pk_bkt_arr_free_handle(&arr, h1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 0) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 2) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFFFD) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFD, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		h2 = pk_bkt_arr_new_handle(&arr);
-		if (h2.b != 0) exit(1);
-		if (h2.i != 0) exit(1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 2) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 2) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFFFC) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFC, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 
 		pk_bkt_arr_teardown(&arr);
-		if (bkt_buckets->alloc_count != 0) exit(1);
-		if (bkt_data->alloc_count != 0) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_data->alloc_count);
 	}
 	test_teardown(&bkt_buckets, &bkt_data);
 
@@ -299,75 +339,85 @@ int main(int argc, char *argv[])
 
 		for (i = 0; i < limits.i; ++i) {
 			handles[0][i] = pk_bkt_arr_new_handle(&arr);
-			if (handles[0][i].b != 0) exit(1);
-			if (handles[0][i].i != i) exit(1);
+			PK_TEST_ASSERT_EQ_EXIT(0, handles[0][i].b);
+			PK_TEST_ASSERT_EQ_EXIT(i, handles[0][i].i);
 			if (i == limits.i - 1) {
-				if (arr.head_l.b != 1) exit(1);
-				if (arr.head_l.i != 0) exit(1);
-				if (arr.head_r.b != 1) exit(1);
-				if (arr.head_r.i != 0) exit(1);
+				PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.b);
+				PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.i);
+				PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.b);
+				PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.i);
 			} else {
-				if (arr.head_l.b != 0) exit(1);
-				if (arr.head_l.i != i + 1) exit(1);
-				if (arr.head_r.b != 0) exit(1);
-				if (arr.head_r.i != i + 1) exit(1);
+				PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+				PK_TEST_ASSERT_EQ_EXIT(i+1, arr.head_l.i);
+				PK_TEST_ASSERT_EQ_EXIT(0, arr.head_r.b);
+				PK_TEST_ASSERT_EQ_EXIT(i+1, arr.head_r.i);
 			}
-			if (arr.reserved_buckets != 1) exit(1);
-			if (bkt_buckets->alloc_count != 2) exit(1);
-			if (bkt_data->alloc_count != 1) exit(1);
+#ifndef PK_MEMORY_FORCE_MALLOC
+			PK_TEST_ASSERT_EQ_EXIT(1, arr.reserved_buckets);
+			PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+			PK_TEST_ASSERT_EQ_EXIT(1, bkt_data->alloc_count);
+#endif
 		}
 
 		h1 = pk_bkt_arr_new_handle(&arr);
-		if (h1.b != 1) exit(1);
-		if (h1.i != 0) exit(1);
-		if (arr.head_l.b != 1) exit(1);
-		if (arr.head_l.i != 1) exit(1);
-		if (arr.head_r.b != 1) exit(1);
-		if (arr.head_r.i != 1) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFF00) exit(1);
-		if (arr.idx_unused[1] != 0xFFFFFFFFFFFFFFFE) exit(1);
-		if (arr.reserved_buckets != 2) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 2) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(1, h1.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h1.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFF00, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFE, arr.idx_unused[1]);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.reserved_buckets);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_data->alloc_count);
+#endif
 
 		h1 = pk_bkt_arr_new_handle(&arr);
-		if (h1.b != 1) exit(1);
-		if (h1.i != 1) exit(1);
-		if (arr.head_l.b != 1) exit(1);
-		if (arr.head_l.i != 2) exit(1);
-		if (arr.head_r.b != 1) exit(1);
-		if (arr.head_r.i != 2) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFF00) exit(1);
-		if (arr.idx_unused[1] != 0xFFFFFFFFFFFFFFFC) exit(1);
-		if (arr.reserved_buckets != 2) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 2) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(1, h1.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, h1.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFF00, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFC, arr.idx_unused[1]);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.reserved_buckets);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_data->alloc_count);
+#endif
 
 		h1.b = 0;
 		h1.i = 3;
 		pk_bkt_arr_free_handle(&arr, h1);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 3) exit(1);
-		if (arr.head_r.b != 1) exit(1);
-		if (arr.head_r.i != 2) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFF08) exit(1);
-		if (arr.idx_unused[1] != 0xFFFFFFFFFFFFFFFC) exit(1);
-		if (arr.reserved_buckets != 2) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 2) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(3, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFF08, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFC, arr.idx_unused[1]);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.reserved_buckets);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_data->alloc_count);
+#endif
 
 		h2 = pk_bkt_arr_new_handle(&arr);
-		if (h2.b != 0) exit(1);
-		if (h2.i != 3) exit(1);
-		if (arr.head_l.b != 1) exit(1);
-		if (arr.head_l.i != 2) exit(1);
-		if (arr.head_r.b != 1) exit(1);
-		if (arr.head_r.i != 2) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFF00) exit(1);
-		if (arr.idx_unused[1] != 0xFFFFFFFFFFFFFFFC) exit(1);
-		if (arr.reserved_buckets != 2) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 2) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(3, h2.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFF00, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFC, arr.idx_unused[1]);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.reserved_buckets);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_data->alloc_count);
+#endif
 
 		h1.b = 1;
 		h1.i = 0;
@@ -375,32 +425,36 @@ int main(int argc, char *argv[])
 		h2.i = 1;
 		pk_bkt_arr_free_handle(&arr, h1);
 		pk_bkt_arr_free_handle(&arr, h2);
-		if (arr.head_l.b != 1) exit(1);
-		if (arr.head_l.i != 0) exit(1);
-		if (arr.head_r.b != 1) exit(1);
-		if (arr.head_r.i != 2) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFF00) exit(1);
-		if (arr.idx_unused[1] != 0xFFFFFFFFFFFFFFFF) exit(1);
-		if (arr.reserved_buckets != 2) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 2) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFF00, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFF, arr.idx_unused[1]);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.reserved_buckets);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_data->alloc_count);
+#endif
 
 		h2 = pk_bkt_arr_new_handle(&arr);
-		if (h2.b != 1) exit(1);
-		if (h2.i != 0) exit(1);
-		if (arr.head_l.b != 1) exit(1);
-		if (arr.head_l.i != 1) exit(1);
-		if (arr.head_r.b != 1) exit(1);
-		if (arr.head_r.i != 2) exit(1);
-		if (arr.idx_unused[0] != 0xFFFFFFFFFFFFFF00) exit(1);
-		if (arr.idx_unused[1] != 0xFFFFFFFFFFFFFFFE) exit(1);
-		if (arr.reserved_buckets != 2) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 2) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(1, h2.b);
+		PK_TEST_ASSERT_EQ_EXIT(0, h2.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFF00, arr.idx_unused[0]);
+		PK_TEST_ASSERT_EQ_EXIT(0xFFFFFFFFFFFFFFFE, arr.idx_unused[1]);
+		PK_TEST_ASSERT_EQ_EXIT(2, arr.reserved_buckets);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_data->alloc_count);
+#endif
 
 		pk_bkt_arr_teardown(&arr);
-		if (bkt_buckets->alloc_count != 0) exit(1);
-		if (bkt_data->alloc_count != 0) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, bkt_data->alloc_count);
 	}
 	test_teardown(&bkt_buckets, &bkt_data);
 
@@ -425,6 +479,7 @@ int main(int argc, char *argv[])
 			if (expected_exit == true && caught == true) {
 				expected_exit = false;
 				caught = false;
+				pk_bkt_arr_teardown(&arr);
 				PK_LOGV_INF("%s: successfully caught err.\n", __FILE__);
 				fflush(stdout);
 				fflush(stderr);
@@ -441,32 +496,20 @@ int main(int argc, char *argv[])
 				handles[b][i] = pk_bkt_arr_new_handle(&arr);
 			}
 		}
-		if (arr.head_l.b != 1) exit(1);
-		if (arr.head_l.i != 7) exit(1);
-		if (arr.head_r.b != 1) exit(1);
-		if (arr.head_r.i != 7) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 2) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_l.b);
+		PK_TEST_ASSERT_EQ_EXIT(7, arr.head_l.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, arr.head_r.b);
+		PK_TEST_ASSERT_EQ_EXIT(7, arr.head_r.i);
+#ifndef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_buckets->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(2, bkt_data->alloc_count);
+#endif
 
 		expected_exit = true;
 		caught = false;
 		struct pk_bkt_arr_handle h = pk_bkt_arr_new_handle(&arr);
 		(void)h;
 		exit(1);
-
-		/*
-		pk_bkt_arr_free_handle(&arr, h);
-		if (arr.head_l.b != 0) exit(1);
-		if (arr.head_l.i != 0) exit(1);
-		if (arr.head_r.b != 0) exit(1);
-		if (arr.head_r.i != 1) exit(1);
-		if (bkt_buckets->alloc_count != 2) exit(1);
-		if (bkt_data->alloc_count != 1) exit(1);
-
-		pk_bkt_arr_teardown(&arr);
-		if (bkt_buckets->alloc_count != 0) exit(1);
-		if (bkt_data->alloc_count != 0) exit(1);
-		*/
 	}
 	while (false);
 	test_teardown(&bkt_buckets, &bkt_data);
@@ -503,27 +546,27 @@ int main(int argc, char *argv[])
 
 		struct pk_iter it;
 		b = pk_bkt_arr_iter_begin(&arr, &it);
-		if (b == false) exit(1);
-		if (it.data == nullptr) exit(1);
-		if (it.id.bkt.b != 0) exit(1);
-		if (it.id.bkt.i != 1) exit(1);
-		if (*(uint8_t*)it.data != 1) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(false, b);
+		PK_TEST_ASSERT_NEQ_EXIT(nullptr, it.data);
+		PK_TEST_ASSERT_EQ_EXIT(0, it.id.bkt.b);
+		PK_TEST_ASSERT_EQ_EXIT(1, it.id.bkt.i);
+		PK_TEST_ASSERT_EQ_EXIT(1, *(uint8_t*)it.data);
 		fprintf(stdout, "it.data: %p, val: %i\n", it.data, *(uint8_t*)it.data);
 
 		b = pk_bkt_arr_iter_increment(&arr, &it);
-		if (b == false) exit(1);
-		if (it.data == nullptr) exit(1);
-		if (it.id.bkt.b != 0) exit(1);
-		if (it.id.bkt.i != 3) exit(1);
-		if (*(uint8_t*)it.data != 3) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(false, b);
+		PK_TEST_ASSERT_NEQ_EXIT(nullptr, it.data);
+		PK_TEST_ASSERT_EQ_EXIT(0, it.id.bkt.b);
+		PK_TEST_ASSERT_EQ_EXIT(3, it.id.bkt.i);
+		PK_TEST_ASSERT_EQ_EXIT(3, *(uint8_t*)it.data);
 		fprintf(stdout, "it.data: %p, val: %i\n", it.data, *(uint8_t*)it.data);
 
 		b = pk_bkt_arr_iter_increment(&arr, &it);
-		if (b == false) exit(1);
-		if (it.data == nullptr) exit(1);
-		if (it.id.bkt.b != 0) exit(1);
-		if (it.id.bkt.i != 4) exit(1);
-		if (*(uint8_t*)it.data != 4) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(false, b);
+		PK_TEST_ASSERT_NEQ_EXIT(nullptr, it.data);
+		PK_TEST_ASSERT_EQ_EXIT(0, it.id.bkt.b);
+		PK_TEST_ASSERT_EQ_EXIT(4, it.id.bkt.i);
+		PK_TEST_ASSERT_EQ_EXIT(4, *(uint8_t*)it.data);
 		fprintf(stdout, "it.data: %p, val: %i\n", it.data, *(uint8_t*)it.data);
 
 		b = pk_bkt_arr_iter_increment(&arr, &it);
diff --git a/test/pkbktarr.cpp b/test/pkbktarr.cpp
index f4bc9c9..34d83f7 100644
--- a/test/pkbktarr.cpp
+++ b/test/pkbktarr.cpp
@@ -4,7 +4,6 @@
 #define PK_IMPL_ITER
 #define PK_IMPL_MEM
 #define PK_IMPL_BKTARR
-#define PK_MEMORY_FORCE_MALLOC
 #include "../pkbktarr.h"
 
 void test_spinup(struct pk_membucket **bkt_buckets, struct pk_membucket **bkt_data)
@@ -63,7 +62,7 @@ int main(int argc, char *argv[])
 		if (bkt_data->alloc_count != 1) exit(1);
 #endif
 
-		arr.~pk_bkt_arr_t<int>();
+		pk_bkt_arr_teardown(&arr);
 #ifndef PK_MEMORY_FORCE_MALLOC
 		if (bkt_buckets->alloc_count != 0) exit(1);
 		if (bkt_data->alloc_count != 0) exit(1);
@@ -109,7 +108,7 @@ int main(int argc, char *argv[])
 		if (pk_bkt_arr_handle_compare(found_h, h) != 0) exit(1);
 		if (count != 1) exit(1);
 
-		arr.~pk_bkt_arr_t<int>();
+		pk_bkt_arr_teardown(&arr);
 #ifndef PK_MEMORY_FORCE_MALLOC
 		if (bkt_buckets->alloc_count != 0) exit(1);
 		if (bkt_data->alloc_count != 0) exit(1);
@@ -151,7 +150,7 @@ int main(int argc, char *argv[])
 		pk_bkt_arr_iterate(&arr, &pk_bkt_arr_t<int>::FN_Iter::invoke, &cb_wrapper);
 		if (some_counter != 1) exit(1);
 
-		arr.~pk_bkt_arr_t<int>();
+		pk_bkt_arr_teardown(&arr);
 #ifndef PK_MEMORY_FORCE_MALLOC
 		if (bkt_buckets->alloc_count != 0) exit(1);
 		if (bkt_data->alloc_count != 0) exit(1);
@@ -189,7 +188,7 @@ int main(int argc, char *argv[])
 		};
 		pk_bkt_arr_iterate(&arr, &pk_bkt_arr_t<int>::FN_Iter::invoke, &cb_wrapper);
 
-		arr.~pk_bkt_arr_t<int*>();
+		pk_bkt_arr_teardown(&arr);
 #ifndef PK_MEMORY_FORCE_MALLOC
 		if (bkt_buckets->alloc_count != 0) exit(1);
 		if (bkt_data->alloc_count != 0) exit(1);
diff --git a/test/pkev.cpp b/test/pkev.cpp
index 61835df..a577e66 100644
--- a/test/pkev.cpp
+++ b/test/pkev.cpp
@@ -6,6 +6,9 @@
 
 #include "../pkev.h"
 
+#define PK_IMPL_TST
+#include "../pktst.h"
+
 #include <csetjmp>
 #include <future>
 #include <stdatomic.h>
@@ -103,11 +106,13 @@ int main(int argc, char *argv[])
 		pk_ev_emit(evmgr, ev_two.evid, &handle_ev_two);
 		PK_LOGV_INF("%s: ev_one: %lu, ev_two: %lu\n", __FILE__, ev_one.evid, ev_two.evid);
 		PK_LOGV_INF("%s: ev_one: %s, ev_two: %s\n", __FILE__, ev_one.handled ? "true" : "false", ev_two.handled ? "true" : "false");
-		pk_ev_teardown();
+		test_teardown();
 		fflush(stdout);
 		fflush(stderr);
-		if (ev_one.evid != 0 || ev_two.evid != 1) exit(1);
-		if (ev_one.handled == false || ev_two.handled == false) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, ev_one.evid);
+		PK_TEST_ASSERT_EQ_EXIT(1, ev_two.evid);
+		PK_TEST_ASSERT_NEQ_EXIT(false, ev_one.handled);
+		PK_TEST_ASSERT_NEQ_EXIT(false, ev_two.handled);
 	}
 
 	// register, emit, clear
@@ -125,10 +130,11 @@ int main(int argc, char *argv[])
 		pk_ev_emit(evmgr, ev_one.evid, &handle_ev_one);
 		pk_ev_emit(evmgr, ev_two.evid, &handle_ev_two);
 		PK_LOGV_INF("%s: ev_one: %s, ev_two: %s\n", __FILE__, ev_one.handled ? "true" : "false", ev_two.handled ? "true" : "false");
-		pk_ev_teardown();
+		test_teardown();
 		fflush(stdout);
 		fflush(stderr);
-		if (ev_one.handled == true || ev_two.handled == false) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(true,  ev_one.handled);
+		PK_TEST_ASSERT_NEQ_EXIT(false, ev_two.handled);
 	}
 
 	// register, emit, clear, register
@@ -145,7 +151,8 @@ int main(int argc, char *argv[])
 		PK_LOGV_INF("%s: ev_one: %lu, ev_two: %lu\n", __FILE__, ev_one.evid, ev_two.evid);
 		fflush(stdout);
 		fflush(stderr);
-		if (ev_one.evid != 0 || ev_two.evid != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, ev_one.evid);
+		PK_TEST_ASSERT_EQ_EXIT(1, ev_two.evid);
 		pk_ev_unregister_ev(ev_one.evmgr, ev_one.evid);
 
 		pk_ev_emit(evmgr, ev_one.evid, &handle_ev_one);
@@ -153,7 +160,8 @@ int main(int argc, char *argv[])
 		PK_LOGV_INF("%s: ev_one: %s, ev_two: %s\n", __FILE__, ev_one.handled ? "true" : "false", ev_two.handled ? "true" : "false");
 		fflush(stdout);
 		fflush(stderr);
-		if (ev_one.handled == true || ev_two.handled == false) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(true,  ev_one.handled);
+		PK_TEST_ASSERT_NEQ_EXIT(false, ev_two.handled);
 		pk_ev_unregister_ev(ev_two.evmgr, ev_two.evid);
 
 		std::packaged_task<void()> handle_ev_thr([](){ ev_one.handled = true; });
@@ -167,16 +175,18 @@ int main(int argc, char *argv[])
 		PK_LOGV_INF("%s: ev_one: %lu, ev_two: %lu\n", __FILE__, ev_one.evid, ev_two.evid);
 		fflush(stdout);
 		fflush(stderr);
-		if (ev_one.evid != 0 || ev_two.evid != 1) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, ev_one.evid);
+		PK_TEST_ASSERT_EQ_EXIT(1, ev_two.evid);
 
 		pk_ev_emit(evmgr, ev_one.evid, &handle_ev_thr);
 		pk_ev_emit(evmgr, ev_two.evid, &handle_ev_for);
 		PK_LOGV_INF("%s: ev_one: %s, ev_two: %s\n", __FILE__, ev_one.handled ? "true" : "false", ev_two.handled ? "true" : "false");
 		fflush(stdout);
 		fflush(stderr);
-		if (ev_one.handled == false || ev_two.handled == false) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(false,  ev_one.handled);
+		PK_TEST_ASSERT_NEQ_EXIT(false, ev_two.handled);
 
-		pk_ev_teardown();
+		test_teardown();
 	}
 
 	// threaded register, emit
@@ -198,11 +208,13 @@ int main(int argc, char *argv[])
 		t2.join();
 		PK_LOGV_INF("%s: ev_one: %lu, ev_two: %lu\n", __FILE__, ev_one.evid, ev_two.evid);
 		PK_LOGV_INF("%s: ev_one: %s, ev_two: %s\n", __FILE__, ev_one.handled ? "true" : "false", ev_two.handled ? "true" : "false");
-		pk_ev_teardown();
+		test_teardown();
 		fflush(stdout);
 		fflush(stderr);
-		if (ev_one.evid != 0 || ev_two.evid != 1) exit(1);
-		if (ev_one.handled == false || ev_two.handled == false) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(0, ev_one.evid);
+		PK_TEST_ASSERT_EQ_EXIT(1, ev_two.evid);
+		PK_TEST_ASSERT_NEQ_EXIT(false, ev_one.handled);
+		PK_TEST_ASSERT_NEQ_EXIT(false, ev_two.handled);
 	}
 
 	// overload cbs and evs (grow once)
@@ -232,16 +244,16 @@ int main(int argc, char *argv[])
 			PK_LOGV_INF("%s: ev# %.2zu: %s, called count: %i\n", __FILE__, i, evs[i].handled ? "true" : "false", atomic_load(&evs[i].count));
 			any_false = any_false || !evs[i].handled;
 		}
-		pk_ev_teardown();
+		test_teardown();
 		fflush(stdout);
 		fflush(stderr);
-		if (any_false == true) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(true, any_false);
 	}
 
 	// overload cbs and evs (test limits)
 	{
 		const uint64_t cb_count = 255;
-		const uint64_t ev_count = 255;
+		const uint64_t ev_count = 64;
 		struct ev evs[ev_count] = {};
 		const pk_ev_mgr_id_T evmgr = test_setup();
 		for (i = 0; i < ev_count; ++i) {
@@ -271,10 +283,10 @@ int main(int argc, char *argv[])
 			any_false = any_false || !evs[i].handled;
 		}
 		PK_LOGV_INF("%s: #valid: %lu, #partial_valid: %lu, called count: %i\n", __FILE__, valid_count, partial_valid_count, atomic_load(&evs[0].count));
-		pk_ev_teardown();
+		test_teardown();
 		fflush(stdout);
 		fflush(stderr);
-		if (any_false == true) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(true, any_false);
 	}
 
 	// overload cbs and evs (enforce uint8_t limits)
@@ -291,7 +303,7 @@ int main(int argc, char *argv[])
 			if (expected_exit == true && caught == true) {
 				expected_exit = false;
 				caught = false;
-				pk_ev_teardown();
+				test_teardown();
 				PK_LOGV_INF("%s: successfully caught err.\n", __FILE__);
 				fflush(stdout);
 				fflush(stderr);
@@ -330,7 +342,7 @@ int main(int argc, char *argv[])
 			if (expected_exit == true && caught == true) {
 				expected_exit = false;
 				caught = false;
-				pk_ev_teardown();
+				test_teardown();
 				PK_LOGV_INF("%s: successfully caught err.\n", __FILE__);
 				fflush(stdout);
 				fflush(stderr);
@@ -377,7 +389,7 @@ int main(int argc, char *argv[])
 			pk_ev_destroy_mgr(pk_ev_mgr_id_T{i});
 		}
 
-		pk_ev_teardown();
+		test_teardown();
 	}
 	while (false);
 
diff --git a/test/pkmacros.c b/test/pkmacros.c
index 02885f6..9702eee 100644
--- a/test/pkmacros.c
+++ b/test/pkmacros.c
@@ -16,8 +16,8 @@ int main(int argc, char *argv[])
 	uint64_t u64;
 	// MISC
 	{
-		PK_LOGV_INF("PK_HAS_FLAG 000: %b\n", PK_HAS_FLAG(0xFF, 5));
-		PK_LOGV_INF("PK_HAS_FLAG 001: %b\n", PK_HAS_FLAG(0x0F, 5));
+		PK_LOGV_INF("PK_HAS_FLAG 000: %s\n", PK_HAS_FLAG(0xFF, 5) ? "true" : "false");
+		PK_LOGV_INF("PK_HAS_FLAG 001: %s\n", PK_HAS_FLAG(0x0F, 5) ? "true" : "false");
 		PK_LOGV_INF("PK_CLAMP 000: %i\n", PK_CLAMP(0, -10, 10));
 		PK_LOGV_INF("PK_CLAMP 001: %i\n", PK_CLAMP(-20, -10, 10));
 		PK_LOGV_INF("PK_CLAMP 002: %i\n", PK_CLAMP(20, -10, 10));
diff --git a/test/pkmem.c b/test/pkmem.c
index 36bf0eb..38a7c1b 100644
--- a/test/pkmem.c
+++ b/test/pkmem.c
@@ -3,6 +3,9 @@
 
 #include "../pkmem.h"
 
+#define PK_IMPL_TST
+#include "../pktst.h"
+
 #define PK_IMPL_FUNCINSTR
 #include "../pkfuncinstr.h"
 
@@ -40,7 +43,8 @@ int main(int argc, char *argv[])
 		spinup_w_instr();
 		pk_mem_bucket_set_client_mem_bucket(mt.bkt1);
 		char *some_dang_string = (char*)pk_new_base(64, alignof(char*));
-		fprintf(stdout, "some_dang_string: %s: %p\n", some_dang_string, (void *)some_dang_string);
+		memset(some_dang_string, '\0', 64);
+		fprintf(stdout, "some_dang_string: \"%s\": %p\n", some_dang_string, (void *)some_dang_string);
 		pk_delete_base(some_dang_string, 64);
 		teardown();
 	}
@@ -62,13 +66,24 @@ int main(int argc, char *argv[])
 		three_length_string = pk_new_bkt(3, 0, mt.bkt1);
 		three_length_string[0] = '1';
 		three_length_string[1] = '2';
-
-		if (zero_length_string != NULL) exit(1);
-		if (strlen(three_length_string) != 2) exit(1);
-		if (mt.bkt1->alloc_count != 1) exit(1);
-		if (mt.bkt1->head != 3) exit(1);
-		if (mt.bkt1->block_head_r != 0) exit(1);
-
+		three_length_string[2] = '\0';
+
+#ifdef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_NEQ_EXIT(NULL, zero_length_string);
+		PK_TEST_ASSERT_EQ_EXIT(2, strlen(three_length_string));
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+		pk_delete(zero_length_string, 0, mt.bkt1);
+#else
+		PK_TEST_ASSERT_EQ_EXIT(NULL, zero_length_string);
+		PK_TEST_ASSERT_EQ_EXIT(2, strlen(three_length_string));
+		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(3, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#endif
+
+		pk_delete(three_length_string, 3, mt.bkt1);
 		PK_LOGV_INF("%s: %s\n", __FILE__, "handles zero-length alloc");
 		teardown();
 	}
@@ -79,35 +94,67 @@ int main(int argc, char *argv[])
 
 		struct pk_memblock *blk;
 
+		void *ptrs[16];
+
 		for (size_t i = 0; i < 16; ++i) {
-			pk_new_bkt(7, 8, mt.bkt1);
+			ptrs[i] = pk_new_bkt(7, 8, mt.bkt1);
 		}
 
 		blk = mt.bkt1->blocks;
 
-		if (mt.bkt1->alloc_count != 16) exit(1);
-		if (mt.bkt1->head != (8*16)-1) exit(1);
-		if (mt.bkt1->block_head_r != 15) exit(1);
-		if (mt.bkt1->block_capacity != 16) exit(1);
-		if (mt.bkt1->blocks != blk) exit(1);
-
-		pk_new_bkt(7, 8, mt.bkt1);
-
-		if (mt.bkt1->alloc_count != 17) exit(1);
-		if (mt.bkt1->head != (8*17)-1) exit(1);
-		if (mt.bkt1->block_head_r != 16) exit(1);
-		if (mt.bkt1->block_capacity != 17) exit(1);
-		if (mt.bkt1->blocks == blk) exit(1);
+#ifdef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_capacity);
+		PK_TEST_ASSERT_EQ_EXIT(blk, mt.bkt1->blocks);
+#else
+		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT((8*16)-1, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(15, mt.bkt1->block_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_capacity);
+		PK_TEST_ASSERT_EQ_EXIT(blk, mt.bkt1->blocks);
+#endif
+
+		void *ptr2 = pk_new_bkt(7, 8, mt.bkt1);
+
+#ifdef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_capacity);
+		PK_TEST_ASSERT_EQ_EXIT(blk, mt.bkt1->blocks);
+#else
+		PK_TEST_ASSERT_EQ_EXIT(17, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT((8*17)-1, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(17, mt.bkt1->block_capacity);
+		PK_TEST_ASSERT_NEQ_EXIT(blk, mt.bkt1->blocks);
+#endif
 
 		blk = mt.bkt1->blocks;
 
-		pk_new_bkt(7, 8, mt.bkt1);
-
-		if (mt.bkt1->alloc_count != 18) exit(1);
-		if (mt.bkt1->head != (8*18)-1) exit(1);
-		if (mt.bkt1->block_head_r != 17) exit(1);
-		if (mt.bkt1->block_capacity != 18) exit(1);
-		if (mt.bkt1->blocks == blk) exit(1);
+		void *ptr3 = pk_new_bkt(7, 8, mt.bkt1);
+
+#ifdef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(16, mt.bkt1->block_capacity);
+		PK_TEST_ASSERT_EQ_EXIT(blk, mt.bkt1->blocks);
+#else
+		PK_TEST_ASSERT_EQ_EXIT(18, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT((8*18)-1, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(17, mt.bkt1->block_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(18, mt.bkt1->block_capacity);
+		PK_TEST_ASSERT_NEQ_EXIT(blk, mt.bkt1->blocks);
+#endif
+
+		pk_delete(ptr3, 7, mt.bkt1);
+		pk_delete(ptr2, 7, mt.bkt1);
+		for (int i = 15; i >= 0; --i) {
+			pk_delete(ptrs[i], 7, mt.bkt1);
+		}
 
 		PK_LOGV_INF("%s: %s\n", __FILE__, "handles block growth");
 		teardown();
@@ -125,13 +172,23 @@ int main(int argc, char *argv[])
 		void *ptr1 = pk_new_bkt(48, 1, mt.bkt1);
 		(void)ptr1;
 
-		if ((void*)&mt.bkt1->data[0] != ptr1) exit(1);
-		if (mt.bkt1->alloc_count != 1) exit(1);
-		if (mt.bkt1->head != 48) exit(1);
-		if (mt.bkt1->debug_head_l != 1) exit(1);
-		if (mt.bkt1->debug_head_r != 1) exit(1);
-		if (mt.bkt1->block_head_l != 0) exit(1);
-		if (mt.bkt1->block_head_r != 0) exit(1);
+#ifdef PK_MEMORY_FORCE_MALLOC
+		// PK_TEST_ASSERT_EQ_EXIT(ptr1, (void*)&mt.bkt1->data[0]);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#else
+		PK_TEST_ASSERT_EQ_EXIT(ptr1, (void*)&mt.bkt1->data[0]);
+		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(48, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->debug_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->debug_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#endif
 
 		/*
 		 * [00-47] (48) ptr1
@@ -140,13 +197,23 @@ int main(int argc, char *argv[])
 		 */
 		void *ptr2 = pk_new_bkt(1, 1, mt.bkt1);
 
-		if ((void*)(&mt.bkt1->data[0]+48) != ptr2) exit(1);
-		if (mt.bkt1->alloc_count != 2) exit(1);
-		if (mt.bkt1->head != 49) exit(1);
-		if (mt.bkt1->debug_head_l != 2) exit(1);
-		if (mt.bkt1->debug_head_r != 2) exit(1);
-		if (mt.bkt1->block_head_l != 0) exit(1);
-		if (mt.bkt1->block_head_r != 0) exit(1);
+#ifdef PK_MEMORY_FORCE_MALLOC
+		// PK_TEST_ASSERT_EQ_EXIT(ptr2, (void*)(&mt.bkt1->data[0]+48));
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#else
+		PK_TEST_ASSERT_EQ_EXIT(ptr2, (void*)(&mt.bkt1->data[0]+48));
+		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(49, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#endif
 
 		/*
 		 * [00-47] (48) ptr1
@@ -154,12 +221,21 @@ int main(int argc, char *argv[])
 		 */
 		pk_delete_bkt(ptr2, 1, mt.bkt1);
 
-		if (mt.bkt1->alloc_count != 1) exit(1);
-		if (mt.bkt1->head != 48) exit(1);
-		if (mt.bkt1->debug_head_l != 1) exit(1);
-		if (mt.bkt1->debug_head_r != 2) exit(1);
-		if (mt.bkt1->block_head_l != 0) exit(1);
-		if (mt.bkt1->block_head_r != 0) exit(1);
+#ifdef PK_MEMORY_FORCE_MALLOC
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#else
+		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(48, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(1, mt.bkt1->debug_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#endif
 
 		/*
 		 * [00-47] (48) ptr1
@@ -168,14 +244,26 @@ int main(int argc, char *argv[])
 		 */
 		ptr2 = pk_new_bkt(1, 1, mt.bkt1);
 
-		if ((void*)(&mt.bkt1->data[0]+48) != ptr2) exit(1);
-		if (mt.bkt1->alloc_count != 2) exit(1);
-		if (mt.bkt1->head != 49) exit(1);
-		if (mt.bkt1->debug_head_l != 2) exit(1);
-		if (mt.bkt1->debug_head_r != 2) exit(1);
-		if (mt.bkt1->block_head_l != 0) exit(1);
-		if (mt.bkt1->block_head_r != 0) exit(1);
-
+#ifdef PK_MEMORY_FORCE_MALLOC
+		// PK_TEST_ASSERT_EQ_EXIT(ptr2, (void*)(&mt.bkt1->data[0]+48));
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->debug_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#else
+		PK_TEST_ASSERT_EQ_EXIT(ptr2, (void*)(&mt.bkt1->data[0]+48));
+		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->alloc_count);
+		PK_TEST_ASSERT_EQ_EXIT(49, mt.bkt1->head);
+		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(2, mt.bkt1->debug_head_r);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_l);
+		PK_TEST_ASSERT_EQ_EXIT(0, mt.bkt1->block_head_r);
+#endif
+
+		pk_delete(ptr1, 48, mt.bkt1);
+		pk_delete(ptr2,  1, mt.bkt1);
 		PK_LOGV_INF("%s: %s\n", __FILE__, "handles free last + new");
 		teardown();
 	}
diff --git a/test/pkmem.cpp b/test/pkmem.cpp
index 4ef1947..b430438 100644
--- a/test/pkmem.cpp
+++ b/test/pkmem.cpp
@@ -25,6 +25,11 @@ class FreeTest {
 		pk_mem_bucket_set_client_mem_bucket(this->bkt);
 	}
 	virtual ~FreeTest() {
+		int i;
+		for (i = 0; i < this->cnt; ++i) {
+			if (ptrs[i] == nullptr) continue;
+			pk_delete(ptrs[i], sz[i], bkt);
+		}
 		pk_mem_bucket_destroy(this->bkt);
 	}
 
@@ -174,8 +179,9 @@ int main(int argc, char *argv[])
 		pk_mem_bucket_set_client_mem_bucket(bkt);
 
 		char *some_dang_string = pk_new_arr<char>(64);
+		memset(some_dang_string, '\0', 64);
 
-		fprintf(stdout, "some_dang_string: %s: %p\n", some_dang_string, (void *)some_dang_string);
+		fprintf(stdout, "some_dang_string: \"%s\": %p\n", some_dang_string, (void *)some_dang_string);
 
 #ifdef PK_MEMORY_DEBUGGER
 		fprintf(stdout, "debug block         : size: %zu, data: %p\n", bkt->debug_blocks[0].size, bkt->debug_blocks[0].ptr);
@@ -206,9 +212,9 @@ int main(int argc, char *argv[])
 	{
 		pk_membucket *bkt = pk_mem_bucket_create("misalignment", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
 		pk_mem_bucket_set_client_mem_bucket(bkt);
-		pk_new(1, 1, bkt);
-		pk_new(1, 64, bkt);
-		pk_new(9, 1, bkt);
+		void *ptr1 = pk_new(1, 1, bkt);
+		void *ptr2 = pk_new(1, 64, bkt);
+		void *ptr3 = pk_new(9, 1, bkt);
 
 		fprintf(stdout, "block_head_r: %u\n", bkt->block_head_r);
 		pk_mem_assert(1 == bkt->block_head_r);
@@ -222,6 +228,9 @@ int main(int argc, char *argv[])
 		fprintf(stdout, "blocks[15].size     : %li\n", bkt->blocks[15].size);
 		pk_mem_assert(54 == bkt->blocks[15].size);
 
+		pk_delete(ptr1, 1, bkt);
+		pk_delete(ptr2, 1, bkt);
+		pk_delete(ptr3, 9, bkt);
 		pk_mem_bucket_destroy(bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment01);
@@ -233,9 +242,9 @@ int main(int argc, char *argv[])
 	{
 		pk_membucket *bkt = pk_mem_bucket_create("misalignment", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
 		pk_mem_bucket_set_client_mem_bucket(bkt);
-		pk_new(1, 1, bkt);
-		pk_new(1, 64, bkt);
-		pk_new(9, 16, bkt);
+		void *ptr1 = pk_new(1, 1, bkt);
+		void *ptr2 = pk_new(1, 64, bkt);
+		void *ptr3 = pk_new(9, 16, bkt);
 
 		fprintf(stdout, "block_head_r: %u\n", bkt->block_head_r);
 		pk_mem_assert(2 == bkt->block_head_r);
@@ -255,6 +264,9 @@ int main(int argc, char *argv[])
 		fprintf(stdout, "blocks[14].size     : %li\n", bkt->blocks[14].size);
 		pk_mem_assert(39 == bkt->blocks[14].size);
 
+		pk_delete(ptr1, 1, bkt);
+		pk_delete(ptr2, 1, bkt);
+		pk_delete(ptr3, 9, bkt);
 		pk_mem_bucket_destroy(bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment02);
@@ -298,6 +310,7 @@ int main(int argc, char *argv[])
 		 * 1st = ptr +00, size 02, memblock { +00, 08 }
 		 */
 		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
+		ft.ptrs[free_index] = nullptr;
 
 		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
 		pk_mem_assert(3 == ft.bkt->block_head_r);
@@ -335,6 +348,7 @@ int main(int argc, char *argv[])
 		 * 1st = ptr +64, size 16, move head ( =32 ), memblock { +02, 06 } memblock { +12, 4 }
 		 */
 		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
+		ft.ptrs[free_index] = nullptr;
 
 		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
 		pk_mem_assert(2 == ft.bkt->block_head_r);
@@ -368,6 +382,7 @@ int main(int argc, char *argv[])
 		 *                         memblock { +02, 06 } memblock { +12, 52 }
 		 */
 		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
+		ft.ptrs[free_index] = nullptr;
 
 		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
 		pk_mem_assert(2 == ft.bkt->block_head_r);
@@ -401,6 +416,7 @@ int main(int argc, char *argv[])
 		 *                         memblock { +02, 14 } memblock { +32, 32 }
 		 */
 		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
+		ft.ptrs[free_index] = nullptr;
 
 		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
 		pk_mem_assert(2 == ft.bkt->block_head_r);
@@ -430,6 +446,7 @@ int main(int argc, char *argv[])
 		// frees [00-18] which gets absorbed into [19-31]
 		// [00-31 memblock
 		pk_delete(ft.ptrs[0], ft.sz[0], ft.bkt);
+		ft.ptrs[0] = nullptr;
 
 		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
 		pk_mem_assert(2 == ft.bkt->block_head_r);
@@ -571,6 +588,9 @@ int main(int argc, char *argv[])
 		pk_mem_assert(&ft.bkt->data[0] + 19 == ft.bkt->blocks[15].data);
 		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
 		pk_mem_assert(14 == ft.bkt->blocks[15].size);
+
+		pk_delete(ptr4, 31, ft.bkt);
+		pk_delete(ptr5,  1, ft.bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_before);
 	pk_test_pkmem_teardown();
@@ -644,6 +664,10 @@ int main(int argc, char *argv[])
 		fprintf(stdout, "handle2 - handle1   : %zu\n", diff);
 		pk_mem_assert(diff == 8);
 
+		pk_delete(str1, 16, bkt);
+		pk_delete(str2, 16, bkt);
+		pk_delete(handle1, sizeof(pk_handle), bkt);
+		pk_delete(handle2, sizeof(pk_handle), bkt);
 		pk_mem_bucket_destroy(bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_alloc_strings);
diff --git a/test/pkstr.c b/test/pkstr.c
index 8e7193b..ac174e1 100644
--- a/test/pkstr.c
+++ b/test/pkstr.c
@@ -67,6 +67,7 @@ int main(int argc, char *argv[])
 		if (s.val == os.val) return 1;
 		if (os.val == nullptr) return 1;
 		PK_LOGV_INF("pk_clone_pk_str, ('%s' to '%s')\n", s.val, os.val);
+		pk_delete(os.val, os.reserved, nullptr);
 	}
 
 	// pk_clone_pk_cstr
@@ -78,6 +79,7 @@ int main(int argc, char *argv[])
 		if (cs.val == ocs.val) return 1;
 		if (ocs.val == nullptr) return 1;
 		PK_LOGV_INF("pk_clone_pk_cstr, ('%s' to '%s')\n", cs.val, ocs.val);
+		pk_delete(ocs.val, ocs.reserved, nullptr);
 	}
 
 	pk_mem_bucket_destroy(bkt);
diff --git a/test/pkuuid.c b/test/pkuuid.c
index 932d6c3..d618c53 100644
--- a/test/pkuuid.c
+++ b/test/pkuuid.c
@@ -86,12 +86,12 @@ main(int argc, char *argv[])
 		id1 = pk_uuid_zed;
 		id2 = pk_uuid_zed;
 		equals = pk_uuid_equals(id1, id2);
-		fprintf(stdout, "[%s] equals (zed, zed): %b\n", __FILE__, equals);
+		fprintf(stdout, "[%s] equals (zed, zed): %s\n", __FILE__, equals ? "true" : "false");
 		if (equals != true) exit(1);
 		id1 = pk_uuid_new_v7();
 		id2 = pk_uuid_new_v7();
 		equals = pk_uuid_equals(id1, id2);
-		fprintf(stdout, "[%s] equals (rand, rand): %b\n", __FILE__, equals);
+		fprintf(stdout, "[%s] equals (rand, rand): %s\n", __FILE__, equals ? "true" : "false");
 		if (equals != false) exit(1);
 	}