#define PK_IMPL_MEM

#include "../pkmem.h"

#include <new>

class FreeTest {
	public:
	pk_membucket *bkt;
	int cnt;
	size_t sz[4];
	size_t al[4];
	void *ptrs[4];

	FreeTest() :
	bkt(pk_bucket_create("freetest", 1024 * 1024, false)) { }
	virtual ~FreeTest() {
		pk_bucket_destroy(this->bkt);
	}

	void setup() {
		int i;
		for (i = 0; i < this->cnt; ++i) {
			ptrs[i] = pk_new(sz[i], al[i], bkt);
		}
	}

	virtual void ensureState() {};
};

class FreeTest01 : public FreeTest {
	public:

	FreeTest01() : FreeTest()
	{
		cnt = 4;
		sz[0] = 2;
		sz[1] = 16;
		sz[2] = 16;
		sz[3] = 4;
		al[0] = 1;
		al[1] = 64;
		al[2] = 16;
		al[3] = 8;
		this->setup();
	}
	virtual ~FreeTest01() {}

	virtual void ensureState() override {
		assert(3 == bkt->lastEmptyBlockIndex);
		assert(80 == bkt->head);
		assert(bkt->ptr + 00 == ptrs[0]);
		assert(bkt->ptr + 64 == ptrs[1]);
		assert(bkt->ptr + 16 == ptrs[2]);
		assert(bkt->ptr +  8 == ptrs[3]);
	}
};

/*
	 [00-18] (19) ptr0
	 [19-31] (13) memblock
	 [ 32  ] ( 1) ptr2
	 [33-63] (31) memblock
	 [ 64  ] ( 1) ptr2
	 [ 65  ] ( 0) HEAD
*/
class FreeTest02 : public FreeTest {
	public:

	FreeTest02() : FreeTest()
	{
		cnt = 3;
		sz[0] = 19;
		sz[1] = 1;
		sz[2] = 1;
		al[0] = 1;
		al[1] = 64;
		al[2] = 32;
		this->setup();
	}
	virtual ~FreeTest02() {}

	virtual void ensureState() override {
		assert(2 == bkt->lastEmptyBlockIndex);
		assert(65 == bkt->head);
		assert(bkt->ptr + 00 == ptrs[0]);
		assert(bkt->ptr + 64 == ptrs[1]);
		assert(bkt->ptr + 32 == ptrs[2]);

		assert(bkt->ptr + 19 == bkt->blocks[0].data);
		assert(13 == bkt->blocks[0].size);

		assert(bkt->ptr + 33 == bkt->blocks[1].data);
		assert(31 == bkt->blocks[1].size);
	}
};

const char *test_misalignment01 = "test_misalignment01";
const char *test_misalignment02 = "test_misalignment02";
const char *test_free_0000      = "test_free_0000";
const char *test_free_1000      = "test_free_1000";
const char *test_free_0100      = "test_free_0100";
const char *test_free_0010      = "test_free_0010";
const char *test_free_0001      = "test_free_0001";
const char *test_free_after     = "test_free_after";
const char *test_free_before    = "test_free_before";
const char *test_free_between   = "test_free_between";
const char *test_alloc_strings  = "test_alloc_strings";
const char *test_bucket_count01 = "test_bucket_count01";
const char *test_bucket_count02 = "test_bucket_count02";
const char *test_bucket_count03 = "test_bucket_count03";
const char *test_bucket_count04 = "test_bucket_count04";
const char *test_bucket_count05 = "test_bucket_count05";

/*
static bool expected_exit = false;
static bool caught = false;
static jmp_buf jmp_env;
void
exit(int code)
{
	if (expected_exit) {
		caught = true;
		longjmp(jmp_env, 1);
	} else {
		_exit(code);
	}
}
// assert() calls abort(), handle
void
handle_assert_abort(int sig)
{
	(void)sig;
	if (expected_exit) {
		caught = true;
		longjmp(jmp_env, 1);
	} else {
		_exit(1);
	}
}
*/

int main(int argc, char *argv[])
{
	// signal(SIGABRT, handle_assert_abort);
	(void)argc;
	(void)argv;
	int i;

	// pk_new<T>
	{
		char *some_dang_string = pk_new<char>(64);
		fprintf(stdout, "some_dang_string: %s: %p\n", some_dang_string, (void *)some_dang_string);
		pk_delete<char>(some_dang_string, 64);
	}
	pk_memory_teardown_all();

	// assert misalignment
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment01);
	{
		pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, false);
		pk_new(1, 1, bkt);
		pk_new(1, 64, bkt);
		pk_new(9, 1, bkt);

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", bkt->lastEmptyBlockIndex);
		assert(1 == bkt->lastEmptyBlockIndex);

		fprintf(stdout, "head               : %li\n", bkt->head);
		assert(65 == bkt->head);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)bkt->blocks[0].data);
		assert(bkt->ptr + 10 == bkt->blocks[0].data);

		fprintf(stdout, "blocks[0].size     : %li\n", bkt->blocks[0].size);
		assert(54 == bkt->blocks[0].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment01);
	pk_memory_teardown_all();

	// assert misalignment + blank block test
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment02);
	{
		pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, false);
		pk_new(1, 1, bkt);
		pk_new(1, 64, bkt);
		pk_new(9, 16, bkt);

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", bkt->lastEmptyBlockIndex);
		assert(2 == bkt->lastEmptyBlockIndex);

		fprintf(stdout, "head               : %li\n", bkt->head);
		assert(65 == bkt->head);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)bkt->blocks[0].data);
		assert(bkt->ptr + 1 == bkt->blocks[0].data);

		fprintf(stdout, "blocks[0].size     : %li\n", bkt->blocks[0].size);
		assert(15 == bkt->blocks[0].size);

		fprintf(stdout, "blocks[1].data     : %p\n", (void *)bkt->blocks[1].data);
		assert(bkt->ptr + 25 == bkt->blocks[1].data);

		fprintf(stdout, "blocks[1].size     : %li\n", bkt->blocks[1].size);
		assert(39 == bkt->blocks[1].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment02);
	pk_memory_teardown_all();

	// predictable free 0000
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0000);
	{
		FreeTest01 ft{};
		ft.ensureState();

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(6 == ft.bkt->blocks[0].size);

		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
		assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
		assert(4 == ft.bkt->blocks[1].size);

		fprintf(stdout, "blocks[2].data     : %p\n", (void *)ft.bkt->blocks[2].data);
		assert(ft.bkt->ptr + 32 == ft.bkt->blocks[2].data);
		fprintf(stdout, "blocks[2].size     : %li\n", ft.bkt->blocks[2].size);
		assert(32 == ft.bkt->blocks[2].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0000);
	pk_memory_teardown_all();

	// predictable free 1000
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_1000);
	{
		size_t expected_head = 80;
		size_t free_index = 0;
		FreeTest01 ft{};
		ft.ensureState();

		/* free events
		 * 1st = ptr +00, size 02, memblock { +00, 08 }
		 */
		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(3 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(expected_head == ft.bkt->head);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 0 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(8 == ft.bkt->blocks[0].size);

		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
		assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
		assert(4 == ft.bkt->blocks[1].size);

		fprintf(stdout, "blocks[2].data     : %p\n", (void *)ft.bkt->blocks[2].data);
		assert(ft.bkt->ptr + 32 == ft.bkt->blocks[2].data);
		fprintf(stdout, "blocks[2].size     : %li\n", ft.bkt->blocks[2].size);
		assert(32 == ft.bkt->blocks[2].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_1000);
	pk_memory_teardown_all();

	// predictable free 0100
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0100);
	{
		size_t expected_head = 32;
		size_t free_index = 1;
		FreeTest01 ft{};
		ft.ensureState();

		/* free events
		 * 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);

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(2 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(expected_head == ft.bkt->head);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(6 == ft.bkt->blocks[0].size);

		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
		assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
		assert(4 == ft.bkt->blocks[1].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0100);
	pk_memory_teardown_all();

	// predictable free 0010
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0010);
	{
		size_t expected_head = 80;
		size_t free_index = 2;
		FreeTest01 ft{};
		ft.ensureState();

		/* free events
		 * 1st = ptr +16, size 16, memblock { +02, 06 } memblock { +12, 04 } memblock { +16, 48 }
		 *                         memblock { +02, 06 } memblock { +12, 52 }
		 */
		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(2 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(expected_head == ft.bkt->head);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(6 == ft.bkt->blocks[0].size);

		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
		assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
		assert(52 == ft.bkt->blocks[1].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0010);
	pk_memory_teardown_all();

	// predictable free 0001
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0001);
	{
		size_t expected_head = 80;
		size_t free_index = 3;
		FreeTest01 ft{};
		ft.ensureState();

		/* free events
		 * 1st = ptr +16, size 16, memblock { +02, 06 } memblock { +08, 08 } memblock { +32, 32 }
		 *                         memblock { +02, 14 } memblock { +32, 32 }
		 */
		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(2 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(expected_head == ft.bkt->head);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(14 == ft.bkt->blocks[0].size);

		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
		assert(ft.bkt->ptr + 32 == ft.bkt->blocks[1].data);
		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
		assert(32 == ft.bkt->blocks[1].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0001);
	pk_memory_teardown_all();

	// ensure free touching after only
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_after);
	{
		FreeTest02 ft{};
		ft.ensureState();

		// frees [00-18] which gets absorbed into [19-31]
		// [00-31 memblock
		pk_delete(ft.ptrs[0], ft.sz[0], ft.bkt);

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(2 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(65 == ft.bkt->head);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 0 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(32 == ft.bkt->blocks[0].size);

		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
		assert(ft.bkt->ptr + 33 == ft.bkt->blocks[1].data);
		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
		assert(31 == ft.bkt->blocks[1].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_after);
	pk_memory_teardown_all();

	// ensure free touching before only
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_before);
	{
		FreeTest02 ft{};
		ft.ensureState();

		/* fill everything, then allocate [65], moving HEAD
			 [00-18] (19) ptr0
			 [19-31] (13) ptr3
			 [ 32  ] ( 1) ptr2
			 [33-63] (31) ptr4
			 [ 64  ] ( 1) ptr2
			 [ 65  ] ( 1) ptr5
			 [ 66  ] ( 0) HEAD
		*/
		void *ptr3 = pk_new(13, 1, ft.bkt);
		void *ptr4 = pk_new(31, 1, ft.bkt);
		void *ptr5 = pk_new( 1, 1, ft.bkt);

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(0 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(66 == ft.bkt->head);

		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
		assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
		fprintf(stdout, "ptr3               : %p\n", ptr3);
		assert(ft.bkt->ptr + 19 == ptr3);
		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
		assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
		fprintf(stdout, "ptr4               : %p\n", ptr4);
		assert(ft.bkt->ptr + 33 == ptr4);
		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
		assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
		fprintf(stdout, "ptr5               : %p\n", ptr5);
		assert(ft.bkt->ptr + 65 == ptr5);

		/* free [19-31]
			 [00-18] (19) ptr0
			 [19-31] (13) memblock
			 [ 32  ] ( 1) ptr2
			 [33-63] (31) ptr4
			 [ 64  ] ( 1) ptr2
			 [ 65  ] ( 0) ptr5
			 [ 66  ] ( 0) HEAD
		*/
		pk_delete(ptr3, 13, ft.bkt);
		ptr3 = nullptr;

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(1 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(66 == ft.bkt->head);

		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
		assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
		fprintf(stdout, "ptr3               : %p\n", ptr3);
		assert(nullptr == ptr3);
		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
		assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
		fprintf(stdout, "ptr4               : %p\n", ptr4);
		assert(ft.bkt->ptr + 33 == ptr4);
		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
		assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
		fprintf(stdout, "ptr5               : %p\n", ptr5);
		assert(ft.bkt->ptr + 65 == ptr5);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(13 == ft.bkt->blocks[0].size);

		/* free [32] which gets absorbed into 19-32
			 [19-32] (13) memblock
			 [33-63] (31) ptr4
		*/
		pk_delete(ft.ptrs[2], ft.sz[2], ft.bkt);
		ft.ptrs[2] = nullptr;

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(1 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(66 == ft.bkt->head);

		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
		assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
		fprintf(stdout, "ptr3               : %p\n", ptr3);
		assert(nullptr == ptr3);
		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
		assert(nullptr == ft.ptrs[2]);
		fprintf(stdout, "ptr4               : %p\n", ptr4);
		assert(ft.bkt->ptr + 33 == ptr4);
		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
		assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
		fprintf(stdout, "ptr5               : %p\n", ptr5);
		assert(ft.bkt->ptr + 65 == ptr5);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(14 == ft.bkt->blocks[0].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_before);
	pk_memory_teardown_all();

	// ensure free touching before and after
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_between);
	{
		FreeTest02 ft{};
		ft.ensureState();

		// frees [00-18] which gets absorbed into [19-31]
		// [00-31 memblock
		pk_delete(ft.ptrs[2], ft.sz[2], ft.bkt);
		ft.ptrs[2] = nullptr;

		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
		assert(1 == ft.bkt->lastEmptyBlockIndex);
		fprintf(stdout, "head               : %li\n", ft.bkt->head);
		assert(65 == ft.bkt->head);

		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
		assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
		assert(nullptr == ft.ptrs[2]);
		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
		assert(ft.bkt->ptr + 64 == ft.ptrs[1]);

		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
		assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
		assert(45 == ft.bkt->blocks[0].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_between);
	pk_memory_teardown_all();

	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_alloc_strings);
	{
		size_t diff;
		pk_membucket *bkt = pk_bucket_create(test_free_between, PK_DEFAULT_BUCKET_SIZE, false);

		char *str1 = pk_new<char>(16, bkt);
		char *str2 = pk_new<char>(16, bkt);
		pk_handle *handle1 = pk_new<pk_handle>(bkt);
		pk_handle *handle2 = pk_new<pk_handle>(bkt);

		fprintf(stdout, "ptr                : %p\n", (void *)bkt->ptr);
		fprintf(stdout, "str1               : %p\n", (void *)str1);
		fprintf(stdout, "str2               : %p\n", (void *)str2);
		fprintf(stdout, "handle1            : %p\n", (void *)handle1);
		fprintf(stdout, "handle2            : %p\n", (void *)handle2);

		diff = str1 - bkt->ptr;
		fprintf(stdout, "str1 - ptr         : %zu\n", diff);
		assert(diff == 0);

		diff = str2 - str1;
		fprintf(stdout, "str2 - str1        : %zu\n", diff);
		assert(diff == 16);

		diff = str2 - bkt->ptr;
		fprintf(stdout, "str2 - ptr         : %zu\n", diff);
		assert(diff == 16);

		diff = (char *)handle1 - str1;
		fprintf(stdout, "handle1 - str1     : %zu\n", diff);
		assert(diff == 32);

		diff = (char *)handle2 - (char *)handle1;
		fprintf(stdout, "handle2 - handle1  : %zu\n", diff);
		assert(diff == 8);

		pk_bucket_destroy(bkt);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_alloc_strings);
	pk_memory_teardown_all();

	// assert bucket count
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count01);
	do
	{
		for (i = 0; i < PK_MAX_BUCKET_COUNT; ++i) {
			pk_membucket *bkt = pk_bucket_create("lol", 1024, false);
			assert(bkt != nullptr);
			(void)bkt;
		}
		pk_membucket *bkt = pk_bucket_create("lol", 1024, false);
		assert(bkt == nullptr);
	}
	while(false);
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count01);
	pk_memory_teardown_all();

	// assert no buckets available on pk_new with full memory
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count02);
	do
	{
		for (i = 0; i < PK_MAX_BUCKET_COUNT; ++i) {
			pk_membucket *bkt = pk_bucket_create("lol2", 1024, false);
			char *asdf = pk_new<char>(768, bkt);
			assert(asdf != nullptr);
		}
		char *asdf = pk_new<char>(768);
		assert(asdf == nullptr);
	}
	while(false);
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count02);
	pk_memory_teardown_all();

	// assert no buckets available on pk_new with full memory
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count03);
	do
	{
		pk_membucket *bkt = nullptr;
		for (i = 0; i < PK_MAX_BUCKET_COUNT; ++i) {
			bkt = pk_bucket_create("lol3", 1024, false);
			char *asdf = pk_new<char>(768, bkt);
			assert(asdf != nullptr);
		}
		char *asdf = pk_new<char>(768, bkt);
		assert(asdf == nullptr);
	}
	while(false);
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count03);
	pk_memory_teardown_all();

	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count04);
	{
		pk_membucket *bkt1 = pk_bucket_create("bucket1", 1024, false);
		pk_membucket *bkt2 = pk_bucket_create("bucket2", 1024, false);
		pk_membucket *bkt3 = pk_bucket_create("bucket3", 1024, false);
		pk_membucket *bkt4 = pk_bucket_create("bucket4", 1024, false);

		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(4 == pk_bucket_head);

		pk_bucket_destroy(bkt4);

		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(3 == pk_bucket_head);

		pk_bucket_destroy(bkt3);

		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(2 == pk_bucket_head);

		pk_bucket_destroy(bkt2);

		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(1 == pk_bucket_head);

		pk_bucket_destroy(bkt1);

		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(0 == pk_bucket_head);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count04);
	pk_memory_teardown_all();

	/* 2025-01-06 JCB
	 * buckets are stored in an array.
	 * pk_bucket_head is only an *indicator* of how many buckets have been
	 *  created total, and the index of the next available.
	 */
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count05);
	{
		pk_membucket *bkt1 = pk_bucket_create("bucket1", 1024, false);
		pk_membucket *bkt2 = pk_bucket_create("bucket2", 1024, false);
		pk_membucket *bkt3 = pk_bucket_create("bucket3", 1024, false);
		pk_membucket *bkt4 = pk_bucket_create("bucket4", 1024, false);

		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(4 == pk_bucket_head);

		pk_bucket_destroy(bkt1);
		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(4 == pk_bucket_head);

		pk_bucket_destroy(bkt2);
		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(4 == pk_bucket_head);

		pk_bucket_destroy(bkt3);
		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(4 == pk_bucket_head);

		pk_bucket_destroy(bkt4);
		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(3 == pk_bucket_head);

		pk_memory_flush();
		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
		assert(0 == pk_bucket_head);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count05);
	pk_memory_teardown_all();

	return 0;
}