#define PK_IMPL_MEM

#include "../pkmem.h"

#define PK_IMPL_FUNCINSTR
#include "../pkfuncinstr.h"

#ifndef PK_MEMORY_FORCE_MALLOC
 #define pk_mem_assert(expr) assert(expr)
#else
 #define pk_mem_assert(expr) (void)0;
#endif

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

	FreeTest() :
	bkt(pk_mem_bucket_create("freetest", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE)) {
		pk_mem_bucket_set_client_mem_bucket(this->bkt);
	}
	virtual ~FreeTest() {
		pk_mem_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 {
		pk_mem_assert(3 == bkt->block_head_r);
		pk_mem_assert(80 == bkt->head);
		pk_mem_assert(&bkt->data[0] + 00 == ptrs[0]);
		pk_mem_assert(&bkt->data[0] + 64 == ptrs[1]);
		pk_mem_assert(&bkt->data[0] + 16 == ptrs[2]);
		pk_mem_assert(&bkt->data[0] +  8 == ptrs[3]);
	}
};

/*
	 [00-18] (19) ptr0
	 [19-31] (13) memblock
	 [ 32  ] ( 1) ptr2
	 [33-63] (31) memblock
	 [ 64  ] ( 1) ptr1
	 [ 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 {
		pk_mem_assert(2 == bkt->block_head_r);
		pk_mem_assert(65 == bkt->head);
		pk_mem_assert(&bkt->data[0] + 00 == ptrs[0]);
		pk_mem_assert(&bkt->data[0] + 64 == ptrs[1]);
		pk_mem_assert(&bkt->data[0] + 32 == ptrs[2]);

		pk_mem_assert(&bkt->data[0] + 19 == bkt->blocks[15].data);
		pk_mem_assert(13 == bkt->blocks[15].size);

		pk_mem_assert(&bkt->data[0] + 33 == bkt->blocks[14].data);
		pk_mem_assert(31 == bkt->blocks[14].size);
	}
};

const char *test_basic_alloc    = "test_basic_alloc";
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";
const char *test_generic_01     = "test_generic_01";

void pk_test_pkmem_spinup(bool init_funcinstr = false) {
	if (init_funcinstr) pk_funcinstr_init();
}
void pk_test_pkmem_teardown() {
	pk_funcinstr_teardown();
}

/*
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);
	}
}
// pk_mem_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>
	pk_test_pkmem_spinup(true);
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_basic_alloc);
	{
		pk_membucket *bkt = pk_mem_bucket_create("test-some-dang-string", 1024, PK_MEMBUCKET_FLAG_NONE);
		pk_mem_bucket_set_client_mem_bucket(bkt);

		char *some_dang_string = pk_new_arr<char>(64);

		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);
		pk_mem_assert(64 == bkt->debug_blocks[0].size);
		pk_mem_assert((char*)bkt + EXPECTED_PK_MEMBLOCK_SIZE == bkt->debug_blocks[0].data);
#endif

		fprintf(stdout, "bkt->head           : %lu\n", bkt->head);
		pk_mem_assert(64 == bkt->head);

		fprintf(stdout, "blocks[15].data     : %p\n", bkt->blocks[15].ptr);
		pk_mem_assert(&bkt->data[0] + 64 == bkt->blocks[15].data);

		fprintf(stdout, "blocks[15].size     : %li\n", bkt->blocks[15].size);
		// 576 == 1024 - EXPECTED_PK_MEMBLOCK_SIZE - (sizeof(pk_memblock) * bkt->block_capacity) - 64
		pk_mem_assert(576 == bkt->blocks[15].size);

		pk_delete_arr<char>(some_dang_string, 64);

		pk_mem_bucket_destroy(bkt);
	}
	pk_test_pkmem_teardown();
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_basic_alloc);

	// assert misalignment
	pk_test_pkmem_spinup(true);
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment01);
	{
		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);

		fprintf(stdout, "block_head_r: %u\n", bkt->block_head_r);
		pk_mem_assert(1 == bkt->block_head_r);

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

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

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

		pk_mem_bucket_destroy(bkt);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment01);
	pk_test_pkmem_teardown();

	// assert misalignment + blank block test
	pk_test_pkmem_spinup();
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment02);
	{
		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);

		fprintf(stdout, "block_head_r: %u\n", bkt->block_head_r);
		pk_mem_assert(2 == bkt->block_head_r);

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

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

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

		fprintf(stdout, "blocks[14].data     : %p\n", (void *)bkt->blocks[14].data);
		pk_mem_assert(&bkt->data[0] + 25 == bkt->blocks[14].data);

		fprintf(stdout, "blocks[14].size     : %li\n", bkt->blocks[14].size);
		pk_mem_assert(39 == bkt->blocks[14].size);

		pk_mem_bucket_destroy(bkt);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment02);
	pk_test_pkmem_teardown();

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

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

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

		fprintf(stdout, "blocks[13].data     : %p\n", (void *)ft.bkt->blocks[13].data);
		pk_mem_assert(&ft.bkt->data[0] + 32 == ft.bkt->blocks[13].data);
		fprintf(stdout, "blocks[13].size     : %li\n", ft.bkt->blocks[13].size);
		pk_mem_assert(32 == ft.bkt->blocks[13].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0000);
	pk_test_pkmem_teardown();

	// predictable free 1000
	pk_test_pkmem_spinup();
	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, "block_head_r: %u\n", ft.bkt->block_head_r);
		pk_mem_assert(3 == ft.bkt->block_head_r);
		fprintf(stdout, "head                : %li\n", ft.bkt->head);
		pk_mem_assert(expected_head == ft.bkt->head);

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

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

		fprintf(stdout, "blocks[13].data     : %p\n", (void *)ft.bkt->blocks[13].data);
		pk_mem_assert(&ft.bkt->data[0] + 32 == ft.bkt->blocks[13].data);
		fprintf(stdout, "blocks[13].size     : %li\n", ft.bkt->blocks[13].size);
		pk_mem_assert(32 == ft.bkt->blocks[13].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_1000);
	pk_test_pkmem_teardown();

	// predictable free 0100
	pk_test_pkmem_spinup();
	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, "block_head_r: %u\n", ft.bkt->block_head_r);
		pk_mem_assert(2 == ft.bkt->block_head_r);
		fprintf(stdout, "head                : %li\n", ft.bkt->head);
		pk_mem_assert(expected_head == ft.bkt->head);

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

		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
		pk_mem_assert(&ft.bkt->data[0] + 12 == ft.bkt->blocks[14].data);
		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
		pk_mem_assert(4 == ft.bkt->blocks[14].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0100);
	pk_test_pkmem_teardown();

	// predictable free 0010
	pk_test_pkmem_spinup();
	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, "block_head_r: %u\n", ft.bkt->block_head_r);
		pk_mem_assert(2 == ft.bkt->block_head_r);
		fprintf(stdout, "head                : %li\n", ft.bkt->head);
		pk_mem_assert(expected_head == ft.bkt->head);

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

		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
		pk_mem_assert(&ft.bkt->data[0] + 12 == ft.bkt->blocks[14].data);
		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
		pk_mem_assert(52 == ft.bkt->blocks[14].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0010);
	pk_test_pkmem_teardown();

	// predictable free 0001
	pk_test_pkmem_spinup();
	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, "block_head_r: %u\n", ft.bkt->block_head_r);
		pk_mem_assert(2 == ft.bkt->block_head_r);
		fprintf(stdout, "head                : %li\n", ft.bkt->head);
		pk_mem_assert(expected_head == ft.bkt->head);

		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
		pk_mem_assert(&ft.bkt->data[0] + 2 == 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);

		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
		pk_mem_assert(&ft.bkt->data[0] + 32 == ft.bkt->blocks[14].data);
		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
		pk_mem_assert(32 == ft.bkt->blocks[14].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0001);
	pk_test_pkmem_teardown();

	// ensure free touching after only
	pk_test_pkmem_spinup();
	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, "block_head_r: %u\n", ft.bkt->block_head_r);
		pk_mem_assert(2 == ft.bkt->block_head_r);
		fprintf(stdout, "head                : %li\n", ft.bkt->head);
		pk_mem_assert(65 == ft.bkt->head);

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

		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
		pk_mem_assert(&ft.bkt->data[0] + 33 == ft.bkt->blocks[14].data);
		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
		pk_mem_assert(31 == ft.bkt->blocks[14].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_after);
	pk_test_pkmem_teardown();

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

		pk_mem_assert(3 == ft.bkt->alloc_count);
		pk_mem_assert(3 == ft.bkt->debug_head_l);
		pk_mem_assert(3 == ft.bkt->debug_head_r);

		/* fill everything, then allocate [65], moving HEAD
			 [00-18] (19) ptr0
			 [19-31] (13) ptr3
			 [ 32  ] ( 1) ptr2
			 [33-63] (31) ptr4
			 [ 64  ] ( 1) ptr1
			 [ 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);

		pk_mem_assert(6 == ft.bkt->alloc_count);
		pk_mem_assert(6 == ft.bkt->debug_head_l);
		pk_mem_assert(6 == ft.bkt->debug_head_r);

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

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

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

		pk_mem_assert(5 == ft.bkt->alloc_count);
		pk_mem_assert(3 == ft.bkt->debug_head_l);
		pk_mem_assert(6 == ft.bkt->debug_head_r);

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

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

		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
		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(13 == ft.bkt->blocks[15].size);

		/* free [32] which gets absorbed into 19-32
			 [00-18] (19) ptr0
			 [19-32] (13) memblock
			 [33-63] (31) ptr4
			 [ 64  ] ( 1) ptr1
			 [ 65  ] ( 0) ptr5
			 [ 66  ] ( 0) HEAD
		*/
		pk_delete(ft.ptrs[2], ft.sz[2], ft.bkt);
		ft.ptrs[2] = nullptr;

		pk_mem_assert(4 == ft.bkt->alloc_count);
		pk_mem_assert(2 == ft.bkt->debug_head_l);
		pk_mem_assert(6 == ft.bkt->debug_head_r);

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

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

		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
		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);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_before);
	pk_test_pkmem_teardown();

	// ensure free touching before and after
	pk_test_pkmem_spinup();
	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, "block_head_r: %u\n", ft.bkt->block_head_r);
		pk_mem_assert(1 == ft.bkt->block_head_r);
		fprintf(stdout, "head                : %li\n", ft.bkt->head);
		pk_mem_assert(65 == ft.bkt->head);

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

		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
		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(45 == ft.bkt->blocks[15].size);
	}
	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_between);
	pk_test_pkmem_teardown();

	pk_test_pkmem_spinup();
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_alloc_strings);
	{
		size_t diff;
		pk_membucket *bkt = pk_mem_bucket_create(test_free_between, PK_MEM_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);

		char *str1 = pk_new_arr<char>(16, bkt);
		char *str2 = pk_new_arr<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->data[0]);
		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->data[0];
		fprintf(stdout, "str1 - ptr          : %zu\n", diff);
		pk_mem_assert(diff == 0);

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

		diff = str2 - &bkt->data[0];
		fprintf(stdout, "str2 - ptr          : %zu\n", diff);
		pk_mem_assert(diff == 16);

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

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

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

	// ensures that pk_delete resets the bkt when alloc_count falls to 0
	pk_test_pkmem_spinup();
	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_generic_01);
	{
		pk_membucket *bkt = pk_mem_bucket_create(test_free_between, PK_MEM_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);

		float *flts1 = pk_new_arr<float>(48000, bkt);
		pk_delete_arr<float>(flts1, 48000, bkt);
		float *flts2 = pk_new_arr<float>(48000, bkt);
		pk_delete_arr<float>(flts2, 48000, bkt);

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

	return 0;
}