path: root/tests/pke-test-serialization.cpp

#include "./pke-test-serialization.h"

#include "asset-manager.hpp"
#include "camera.hpp"
#include "ecs.hpp"
#include "font.hpp"
#include "game-settings.hpp"
#include "level.hpp"
#include "physics.hpp"
#include "pk.h"
#include "pke-test-stubs.h"
#include "scene.hpp"
#include "serialization-component.hpp"
#include "serialization.hpp"
#include "static-ui.hpp"
#include "thread-pool.hpp"
#include "vendor-glm-include.hpp"

#include <cstring>
#include <sstream>

static pk_membucket *bkt = nullptr;
const char *test_level_name = "srlztn_test_level";
pke_level *test_level = nullptr;
FontType *ft;

#define FAKE_UUID_GEN(oct) { .uuid = { oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct } }

const pk_uuid uuid_n[] = {
	FAKE_UUID_GEN(0x00),
	FAKE_UUID_GEN(0x01),
	FAKE_UUID_GEN(0x02),
	FAKE_UUID_GEN(0x03),
	FAKE_UUID_GEN(0x04),
	FAKE_UUID_GEN(0x05),
	FAKE_UUID_GEN(0x06),
	FAKE_UUID_GEN(0x07),
	FAKE_UUID_GEN(0x08),
	FAKE_UUID_GEN(0x09),
	FAKE_UUID_GEN(0x0a),
	FAKE_UUID_GEN(0x0b),
	FAKE_UUID_GEN(0x0c),
	FAKE_UUID_GEN(0x0d),
	FAKE_UUID_GEN(0x0e),
	FAKE_UUID_GEN(0x0f),
};
// const pk_uuid uuid_17 = FAKE_UUID_GEN(0x11);
// const pk_uuid uuid_34 = FAKE_UUID_GEN(0x22);

void pke_test_serialization_spinup() {
	pke_test_stub_init_vulkan();
	// pk_funcinstr_init();
	bkt = pk_mem_bucket_create("pke_test_serialization", PK_MEM_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);
	pk_mem_bucket_set_client_mem_bucket(bkt);
	pkeSettings.isSimulationPaused = true;
	pk_ev_init(nullptr);
	PkeThreads_Init();
	AM_Init();
	ECS_Init();
	Physics_Init();
	pke_level_init();
	PkeCamera_Init();
	pke_scene_master_init();
	pke_input_init();
	FontType_Init();
	pke_ui_init();
	test_level = pke_level_create(test_level_name, pk_uuid_zed, pk_uuid_zed);
	// pk_funcinstr_teardown();
};

void pke_test_serialization_teardown() {
	// pk_funcinstr_init();
	pke_level_teardown(test_level);
	test_level = nullptr;
	pke_ui_teardown();
	FontType_Teardown();
	pke_input_teardown();
	pke_scene_master_teardown();
	PkeCamera_Teardown();
	Physics_Teardown();
	pke_level_teardown();
	ECS_Teardown();
	AM_Teardown();
	PkeThreads_Teardown();
	pk_ev_teardown();
	pk_mem_bucket_destroy(bkt);
	pk_mem_bucket_set_client_mem_bucket(nullptr);
	bkt = nullptr;
	// pk_funcinstr_teardown();
	pke_test_stub_teardown_vulkan();
};

int pke_test_serialization_999() {
	pke_kve_container kvec{};
	pke_kve kve{};
	const pk_handle zed_handle = {0,0};
	PK_TEST_ASSERT_EQ_RET(zed_handle.bucketIndex, kvec.srlztn_handle.bucketIndex);
	PK_TEST_ASSERT_EQ_RET(zed_handle.itemIndex, kvec.srlztn_handle.itemIndex);

	PK_TEST_ASSERT_EQ_RET(0, kvec.type_code.length);
	PK_TEST_ASSERT_EQ_RET(0, kvec.type_code.reserved);
	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.type_code.val);

	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.bkt);

	PK_TEST_ASSERT_EQ_RET(0, kvec.child_handles.next);
	PK_TEST_ASSERT_EQ_RET(0, kvec.child_handles.reserved);
	PK_TEST_ASSERT_EQ_RET(sizeof(pk_handle), kvec.child_handles.stride);
	PK_TEST_ASSERT_EQ_RET(alignof(pk_handle), kvec.child_handles.alignment);
	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.child_handles.bkt);
	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.child_handles.data);

	PK_TEST_ASSERT_EQ_RET(0, kvec.children.next);
	PK_TEST_ASSERT_EQ_RET(0, kvec.children.reserved);
	PK_TEST_ASSERT_EQ_RET(sizeof(pke_kve_container*), kvec.children.stride);
	PK_TEST_ASSERT_EQ_RET(alignof(pke_kve_container*), kvec.children.alignment);
	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.children.bkt);
	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.children.data);

	PK_TEST_ASSERT_EQ_RET(0, kvec.arr.next);
	PK_TEST_ASSERT_EQ_RET(0, kvec.arr.reserved);
	PK_TEST_ASSERT_EQ_RET(sizeof(pke_kve), kvec.arr.stride);
	PK_TEST_ASSERT_EQ_RET(alignof(pke_kve), kvec.arr.alignment);
	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.arr.bkt);
	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.arr.data);

	PK_TEST_ASSERT_EQ_RET(nullptr, kve.key);
	PK_TEST_ASSERT_EQ_RET(nullptr, kve.val);
	PK_TEST_ASSERT_EQ_RET(nullptr, kve.end);
	return 0;
}

const char *const test_001_str = R"VOGON(:PKFB:
:0:

InstPos:00000000!00000000
Position:0.000000;1.000000;2.000000
Rotation:7.000000;8.000000;9.000000;6.000000
Scale:5.000000;4.000000;3.000000

:PKFE:)VOGON";
int pke_test_serialization_001() {
	int i;
	pk_funcinstr_init();
	srlztn_serialize_helper *h;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		glm::vec3 pos = glm::vec3(0,1,2);
		glm::quat rot = glm::quat(6,7,8,9);
		glm::vec3 scale = glm::vec3(5,4,3);
		pke_serialize_inst_pos(h, pos, rot, scale);

		pke_serialize_scene_to_stream(ss, h);

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers.next);
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[0].arr.next);
		for (i = 0; i < 3; ++i) {
			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].key);
			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].val);
			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].end);
		}

		std::string s = ss.str();
		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_001_str, s.c_str()));

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	pk_funcinstr_teardown();
	return 0;
}

int pke_test_deserialization_101() {
	int64_t err_index = 0, i;
	srlztn_deserialize_helper *h;
	std::stringstream ss(test_001_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers.next);
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[0].arr.next);
		for (i = 0; i < 3; ++i) {
			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].key);
			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].val);
			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].end);
		}

		glm::vec3 pos;
		glm::quat rot;
		glm::vec3 scale;
		pke_deserialize_inst_pos(h, &h->kvp_containers[0], pos, rot, scale);

		const glm::vec3 Spos(0,1,2);
		const glm::quat Srot(6,7,8,9);
		const glm::vec3 Scle(5,4,3);

		PK_TEST_ASSERT_EQ_RET(Spos[0], pos[0]);
		PK_TEST_ASSERT_EQ_RET(Spos[1], pos[1]);
		PK_TEST_ASSERT_EQ_RET(Spos[2], pos[2]);

		PK_TEST_ASSERT_EQ_RET(Srot[0], rot[0]);
		PK_TEST_ASSERT_EQ_RET(Srot[1], rot[1]);
		PK_TEST_ASSERT_EQ_RET(Srot[2], rot[2]);
		PK_TEST_ASSERT_EQ_RET(Srot[3], rot[3]);

		PK_TEST_ASSERT_EQ_RET(Scle[0], scale[0]);
		PK_TEST_ASSERT_EQ_RET(Scle[1], scale[1]);
		PK_TEST_ASSERT_EQ_RET(Scle[2], scale[2]);

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

const char *const test_002_str = R"VOGON(:PKFB:
:0:

InstPos:00000000!00000000
Rotation:0.000000;0.000000;0.000000;1.000000

Instance:00000000!00000001
ChildId:00000000!00000000
UUID:01010101-0101-0101-0101-010101010101
Mass:1.000000
CollisionLayer:0x0000000000000001
CollisionMask:0x0000000000000001

InstPos:00000000!00000002
Position:0.000000;-10.000000;-10.000000
Rotation:0.000000;0.000000;0.000000;1.000000
Scale:5.000000;4.000000;3.000000

Camera:00000000!00000003
ChildId:00000000!00000002
UUID:02020202-0202-0202-0202-020202020202
Type:0x01
Orientation:0x01
TargetUUID:01010101-0101-0101-0101-010101010101
IsPrimary:1

:PKFE:)VOGON";
int pke_test_serialization_002() {
	uint32_t i, k;
	srlztn_serialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		// reminder that 'targeting' moves and rotates the camera, so we shouldn't see these values in the output
		InstPos cam_inst_pos{};
		cam_inst_pos.posRot.setIdentity();
		cam_inst_pos.posRot.setOrigin(btVector3(0,0,0));
		cam_inst_pos.posRot.setRotation(btQuaternion(0.f,0.f,0.f,1));
		cam_inst_pos.scale = btVector3(1,1,1);
		cam_inst_pos.mass = 1.f;

		Entity_Base *target_ent = ECS_CreateGenericEntity();
		CompInstance *target_ent_comp_inst = ECS_CreateInstance(target_ent, uuid_n[1], nullptr, &cam_inst_pos);

		cam_inst_pos.scale = btVector3(5,4,3);
		PkeCamera &cam = PkeCamera_Register(uuid_n[2], cam_inst_pos);
		cam.type = PKE_CAMERA_TYPE_PERSPECTIVE;
		cam.view = PKE_CAMERA_VIEW_TARGET;
		PkeCamera_SetPrimary(cam.camHandle);
		PkeCamera_TargetInstance(cam.camHandle, target_ent_comp_inst);

		pke_serialize_scene(h);
		pke_serialize_scene_to_stream(ss, h);
		std::string s = ss.str();

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers.next);
		// instpos
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[0].arr.next);
		// instance
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers[1].arr.next);
		// instpos
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[2].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[2].arr.next);
		// camera
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[3].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(5, h->kvp_containers[3].arr.next);

		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				kve = &h->kvp_containers[k].arr[i];
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
			}
		}

		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_002_str, s.c_str()));

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

int pke_test_deserialization_102() {
	uint32_t i, k;
	pke_kve *kve;
	srlztn_deserialize_helper *h;
	std::stringstream ss(test_002_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers.next);
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[2].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[3].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[0].arr.next);
		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers[1].arr.next);
		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[2].arr.next);
		PK_TEST_ASSERT_EQ_RET(5, h->kvp_containers[3].arr.next);

		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				kve = &h->kvp_containers[k].arr[i];
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key );
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val );
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end );
			}
		}

		glm::vec3 pos = glm::vec3(0,0,0);
		glm::quat rot = glm::quat(1,0,0,0);
		glm::vec3 scale = glm::vec3(1,1,1);

		glm::vec3 Spos = glm::vec3(0,0,0);
		glm::quat Srot = glm::quat(1,0,0,0);
		glm::vec3 Sscl = glm::vec3(1,1,1);

		pke_deserialize_inst_pos(h, &h->kvp_containers[0], pos, rot, scale);

		PK_TEST_ASSERT_EQ_RET(Spos[0], pos[0]);
		PK_TEST_ASSERT_EQ_RET(Spos[1], pos[1]);
		PK_TEST_ASSERT_EQ_RET(Spos[2], pos[2]);

		PK_TEST_ASSERT_EQ_RET(Srot[0], rot[0]);
		PK_TEST_ASSERT_EQ_RET(Srot[1], rot[1]);
		PK_TEST_ASSERT_EQ_RET(Srot[2], rot[2]);
		PK_TEST_ASSERT_EQ_RET(Srot[3], rot[3]);

		PK_TEST_ASSERT_EQ_RET(Sscl[0], scale[0]);
		PK_TEST_ASSERT_EQ_RET(Sscl[1], scale[1]);
		PK_TEST_ASSERT_EQ_RET(Sscl[2], scale[2]);

		pke_deserialize_inst_pos(h, &h->kvp_containers[2], pos, rot, scale);

		Spos = glm::vec3(0,-10,-10);
		Srot = glm::quat(1,0,0,0);
		Sscl = glm::vec3(5,4,3);

		PK_TEST_ASSERT_EQ_RET(Spos[0], pos[0]);
		PK_TEST_ASSERT_EQ_RET(Spos[1], pos[1]);
		PK_TEST_ASSERT_EQ_RET(Spos[2], pos[2]);

		PK_TEST_ASSERT_EQ_RET(Srot[0], rot[0]);
		PK_TEST_ASSERT_EQ_RET(Srot[1], rot[1]);
		PK_TEST_ASSERT_EQ_RET(Srot[2], rot[2]);
		PK_TEST_ASSERT_EQ_RET(Srot[3], rot[3]);

		PK_TEST_ASSERT_EQ_RET(Sscl[0], scale[0]);
		PK_TEST_ASSERT_EQ_RET(Sscl[1], scale[1]);
		PK_TEST_ASSERT_EQ_RET(Sscl[2], scale[2]);

		pke_deserialize_scene(h);

		PkeCamera *des_cam = PkeCamera_Get(CameraHandle{0,0});
		PK_TEST_ASSERT_NEQ_RET(nullptr, des_cam );
		PK_TEST_ASSERT_EQ_RET(uuid_n[2], des_cam->uuid);
		PK_TEST_ASSERT_EQ_RET(static_cast<PkeCameraType_T>(PKE_CAMERA_TYPE_PERSPECTIVE), static_cast<PkeCameraType_T>(des_cam->type));
		PK_TEST_ASSERT_EQ_RET(static_cast<PkeCameraType_T>(PKE_CAMERA_VIEW_TARGET), static_cast<PkeCameraType_T>(des_cam->view));
		PK_TEST_ASSERT_EQ_RET(uuid_n[1], des_cam->phys.target_inst_uuid);
		PK_TEST_ASSERT_EQ_RET(true, des_cam->isPrimary);

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

const char *const test_003_str = R"VOGON(:PKFB:
:0:

FontRenderSettings:00000000!00000000
CharScale:1.000000
LineHeightScale:1.000000
CharSpacingScale:1.000000
SurfaceAreaSize:250;250
SurfaceAreaPos:0;0
SurfaceAreaFlags:0x03
Flags:0x00
ColorForeground:0.400000;0.900000;0.500000;0.800000
ColorBackground:0.000000;0.000000;0.000000;0.000000

FontRender:00000000!00000001
ChildId:00000000!00000000
UUID:01010101-0101-0101-0101-010101010101
FontTypeTitle:fnt_mquin_7y
TextBegin::
asdf
:MULTILINE_END:

UIBoxTypeData:00000000!00000002
FontRenderUUID:01010101-0101-0101-0101-010101010101

UIBox:00000000!00000003
ChildId:00000000!00000002
UUID:02020202-0202-0202-0202-020202020202
Flags:0x84
PosTopLeft:0.100000;0.100000
MaxSize:0.800000;0.800000
Type:0x32
Layer:0x00

:PKFE:)VOGON";
int pke_test_serialization_003() {
	uint32_t i, k;
	srlztn_serialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		FontRenderSettings frs;
		frs.char_scale = 1.0;
		frs.char_spacing_scale = 1.0;
		frs.line_height_scale = 1.0;
		frs.surface_area_size = glm::ivec2(250, 250);
		frs.surface_area_pos = glm::ivec2(0, 0);
		frs.surface_area_type_flags = FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH;
		frs.flags = FONT_RENDER_FLAG_NONE;
		FontTypeRender fr_handle = FontType_AddStringRender({0,0}, std::move(cstring_to_pk_cstr("asdf")), &frs, nullptr, uuid_n[1]);

		pke_ui_box *ui_box = pke_ui_box_new_root(PKE_UI_BOX_TYPE_TEXT, uuid_n[2]);
		ui_box->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC;
		ui_box->pos_top_left.x = 0.1;
		ui_box->pos_top_left.y = 0.1;
		ui_box->max_size.x = 0.8;
		ui_box->max_size.y = 0.8;
		ui_box->type_data->text.font_type_render = fr_handle;

		pke_serialize_scene(h);
		pke_serialize_scene_to_stream(ss, h);
		std::string s = ss.str();

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers.next);
		// FontRenderSettings
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[0].arr.next);
		// FontRender
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[1].arr.next);
		// ui box type text
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[2].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[2].arr.next);
		// ui box
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[3].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(6, h->kvp_containers[3].arr.next);

		// 12
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 12 + (3 * (8 + 3 + 1 + 6))
				kve = &h->kvp_containers[k].arr[i];
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
			}
		}

		// 66
		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_003_str, s.c_str()));

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

int pke_test_deserialization_103() {
	uint32_t i, k;
	pke_kve *kve;
	srlztn_deserialize_helper *h;
	std::stringstream ss(test_003_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers.next);
		// FontRenderSettings
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[0].arr.next);
		// FontRender
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[1].arr.next);
		// ui box type text
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[2].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[2].arr.next);
		// ui box
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[3].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(6, h->kvp_containers[3].arr.next);

		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				kve = &h->kvp_containers[k].arr[i];
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
			}
		}

		pke_deserialize_scene(h);

		pk_bkt_arr_t<FontType> ft_bkt = *static_cast<pk_bkt_arr_t<FontType>*>(FontType_GetFonts());
		FontRender *fr = &ft_bkt[{0,0}].renders[{0,0}];

		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.char_scale);
		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.line_height_scale);
		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.char_spacing_scale);
		PK_TEST_ASSERT_EQ_RET(250, fr->settings.surface_area_size.x);
		PK_TEST_ASSERT_EQ_RET(250, fr->settings.surface_area_size.y);
		PK_TEST_ASSERT_EQ_RET(0, fr->settings.surface_area_pos.x);
		PK_TEST_ASSERT_EQ_RET(0, fr->settings.surface_area_pos.y);
		PK_TEST_ASSERT_EQ_RET(static_cast<FONT_RENDER_FLAG_T>(FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH), static_cast<FONT_RENDER_FLAG_T>(fr->settings.surface_area_type_flags));
		// auto equal_4 = glm::epsilonEqual(fr->settings.color_foreground, glm::vec4(0.4, 0.9, 0.5, 0.8), epsilon_4);
		// PKE_TEST_ASSERT(equal_4 == bool_4, err_index);
		PK_TEST_ASSERT_EQ_RET(0.4f, fr->settings.color_foreground.x);
		PK_TEST_ASSERT_EQ_RET(0.9f, fr->settings.color_foreground.y);
		PK_TEST_ASSERT_EQ_RET(0.5f, fr->settings.color_foreground.z);
		PK_TEST_ASSERT_EQ_RET(0.8f, fr->settings.color_foreground.w);
		PK_TEST_ASSERT_EQ_RET(0.0, fr->settings.color_background.x);
		PK_TEST_ASSERT_EQ_RET(0.0, fr->settings.color_background.y);
		PK_TEST_ASSERT_EQ_RET(0.0, fr->settings.color_background.z);
		PK_TEST_ASSERT_EQ_RET(0.0, fr->settings.color_background.w);

		PK_TEST_ASSERT_EQ_RET(uuid_n[1], fr->uuid);
		PK_TEST_ASSERT_NEQ_RET(nullptr, fr->text.val);
		PK_TEST_ASSERT_EQ_RET('a', fr->text.val[0]);
		PK_TEST_ASSERT_EQ_RET('s', fr->text.val[1]);
		PK_TEST_ASSERT_EQ_RET('d', fr->text.val[2]);
		PK_TEST_ASSERT_EQ_RET('f', fr->text.val[3]);
		PK_TEST_ASSERT_EQ_RET('\0', fr->text.val[4]);

		pke_ui_box_count_T count;
		pke_ui_box **boxes = pke_ui_get_root_boxes(&count);
		pke_ui_box *box = boxes[0];
		PK_TEST_ASSERT_EQ_RET(1, count)
		PK_TEST_ASSERT_EQ_RET(0, box->internal.h_children)
		PK_TEST_ASSERT_EQ_RET(static_cast<PKE_UI_BOX_TYPE_T>(PKE_UI_BOX_TYPE_TEXT), static_cast<PKE_UI_BOX_TYPE_T>(box->type));
		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC));
		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_VISIBILITY_INVISIBLE));

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

const char *const test_004_str = R"VOGON(:PKFB:
:0:

UIBox:00000000!00000000
ChildId:00000000!00000001
UUID:02020202-0202-0202-0202-020202020202
Flags:0x02
PosTopLeft:1.000000;1.000000
MaxSize:1278.000000;718.000000
Type:0x00
Layer:0x00
ColorBorder:1.000000;0.000000;0.000000;1.000000
ColorBackground:0.200000;0.300000;0.200000;0.500000

UIBox:00000000!00000001
UUID:01010101-0101-0101-0101-010101010101
ParentUUID:02020202-0202-0202-0202-020202020202
Flags:0x04
PosTopLeft:0.100000;0.100000
MaxSize:0.800000;0.800000
Type:0x00
Layer:0x00
ColorBorder:1.000000;0.000000;0.000000;1.000000
ColorBackground:0.200000;0.300000;0.200000;0.500000

:PKFE:)VOGON";
int pke_test_serialization_004() {
	uint32_t i, k;
	srlztn_serialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		pke_ui_box *ui_box_p = pke_ui_box_new_root(PKE_UI_BOX_TYPE_STANDARD, uuid_n[2]);
		ui_box_p->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC;
		ui_box_p->pos_top_left.x = 1.f;
		ui_box_p->pos_top_left.y = 1.f;
		ui_box_p->max_size.x = 1278.f;
		ui_box_p->max_size.y = 718.f;

		pke_ui_box *ui_box_c = pke_ui_box_new_child(ui_box_p, PKE_UI_BOX_TYPE_STANDARD, uuid_n[1]);
		ui_box_c->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC;
		ui_box_c->pos_top_left.x = 0.1;
		ui_box_c->pos_top_left.y = 0.1;
		ui_box_c->max_size.x = 0.8;
		ui_box_c->max_size.y = 0.8;

		pke_serialize_scene(h);
		pke_serialize_scene_to_stream(ss, h);
		std::string s = ss.str();

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(2, h->kvp_containers.next);
		// ui box
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(8, h->kvp_containers[0].arr.next);
		// ui box
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[1].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[1].arr.next);

		// 8
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 8 + (3 * (9 + 8))
				kve = &h->kvp_containers[k].arr[i];
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
			}
		}

		// 59
		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_004_str, s.c_str()));

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

int pke_test_deserialization_104() {
	uint32_t i, k;
	srlztn_deserialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss(test_004_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(2, h->kvp_containers.next);
		// ui box
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(8, h->kvp_containers[0].arr.next);
		// ui box
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[1].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[1].arr.next);

		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				kve = &h->kvp_containers[k].arr[i];
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
			}
		}

		pke_deserialize_scene(h);

		pke_ui_box_count_T box_count;
		pke_ui_box **root_boxes = pke_ui_get_root_boxes(&box_count);
		PK_TEST_ASSERT_NEQ_RET(nullptr, root_boxes);
		PK_TEST_ASSERT_EQ_RET(1, box_count);
		PK_TEST_ASSERT_NEQ_RET(nullptr, root_boxes[0]);

		PK_TEST_ASSERT_EQ_RET(uuid_n[2], root_boxes[0]->uuid);
		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(root_boxes[0]->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC));
		PK_TEST_ASSERT_EQ_RET(1.f, root_boxes[0]->pos_top_left.x);
		PK_TEST_ASSERT_EQ_RET(1.f, root_boxes[0]->pos_top_left.y);
		PK_TEST_ASSERT_EQ_RET(1278.f, root_boxes[0]->max_size.x);
		PK_TEST_ASSERT_EQ_RET(718.f, root_boxes[0]->max_size.y);
		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(root_boxes[0]->type, PKE_UI_BOX_TYPE_STANDARD));
		PK_TEST_ASSERT_EQ_RET(0, root_boxes[0]->layer);
		PK_TEST_ASSERT_EQ_RET(nullptr, root_boxes[0]->internal.parent);
		PK_TEST_ASSERT_EQ_RET(1, root_boxes[0]->internal.h_children);
		PK_TEST_ASSERT_NEQ_RET(nullptr, root_boxes[0]->internal.children);
		PK_TEST_ASSERT_NEQ_RET(nullptr, root_boxes[0]->internal.children[0]);
		PK_TEST_ASSERT_EQ_RET(1.0f, root_boxes[0]->color_border.x);
		PK_TEST_ASSERT_EQ_RET(0.0f, root_boxes[0]->color_border.y);
		PK_TEST_ASSERT_EQ_RET(0.0f, root_boxes[0]->color_border.z);
		PK_TEST_ASSERT_EQ_RET(1.0f, root_boxes[0]->color_border.w);
		PK_TEST_ASSERT_EQ_RET(0.2f, root_boxes[0]->color_background.x);
		PK_TEST_ASSERT_EQ_RET(0.3f, root_boxes[0]->color_background.y);
		PK_TEST_ASSERT_EQ_RET(0.2f, root_boxes[0]->color_background.z);
		PK_TEST_ASSERT_EQ_RET(0.5f, root_boxes[0]->color_background.w);

		pke_ui_box *box_c = root_boxes[0]->internal.children[0];
		PK_TEST_ASSERT_EQ_RET(uuid_n[1], box_c->uuid);
		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(box_c->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC));
		PK_TEST_ASSERT_EQ_RET(0.1f, box_c->pos_top_left.x);
		PK_TEST_ASSERT_EQ_RET(0.1f, box_c->pos_top_left.y);
		PK_TEST_ASSERT_EQ_RET(0.8f, box_c->max_size.x);
		PK_TEST_ASSERT_EQ_RET(0.8f, box_c->max_size.y);
		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(box_c->type, PKE_UI_BOX_TYPE_STANDARD));
		PK_TEST_ASSERT_EQ_RET(0, box_c->layer);
		PK_TEST_ASSERT_EQ_RET(root_boxes[0], box_c->internal.parent);
		PK_TEST_ASSERT_EQ_RET(0, box_c->internal.h_children);
		PK_TEST_ASSERT_EQ_RET(nullptr, box_c->internal.children);
		PK_TEST_ASSERT_EQ_RET(1.0f, box_c->color_border.x);
		PK_TEST_ASSERT_EQ_RET(0.0f, box_c->color_border.y);
		PK_TEST_ASSERT_EQ_RET(0.0f, box_c->color_border.z);
		PK_TEST_ASSERT_EQ_RET(1.0f, box_c->color_border.w);
		PK_TEST_ASSERT_EQ_RET(0.2f, box_c->color_background.x);
		PK_TEST_ASSERT_EQ_RET(0.3f, box_c->color_background.y);
		PK_TEST_ASSERT_EQ_RET(0.2f, box_c->color_background.z);
		PK_TEST_ASSERT_EQ_RET(0.5f, box_c->color_background.w);

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

/* Test empty FontRender text */
const char *const test_005_str = R"VOGON(:PKFB:
:0:

FontRenderSettings:00000000!00000000
CharScale:1.000000
LineHeightScale:1.000000
CharSpacingScale:1.000000
SurfaceAreaSize:250;250
SurfaceAreaPos:0;0
SurfaceAreaFlags:0x03
Flags:0x00
ColorForeground:0.400000;0.900000;0.500000;0.800000
ColorBackground:0.000000;0.000000;0.000000;0.000000

FontRender:00000000!00000001
ChildId:00000000!00000000
UUID:01010101-0101-0101-0101-010101010101
FontTypeTitle:fnt_mquin_7y
TextBegin::

:MULTILINE_END:

:PKFE:)VOGON";
int pke_test_serialization_005() {
	uint32_t i, k;
	srlztn_serialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		FontRenderSettings frs;
		frs.char_scale = 1.0;
		frs.char_spacing_scale = 1.0;
		frs.line_height_scale = 1.0;
		frs.surface_area_size = glm::ivec2(250, 250);
		frs.surface_area_pos = glm::ivec2(0, 0);
		frs.surface_area_type_flags = FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH;
		frs.flags = FONT_RENDER_FLAG_NONE;
		FontType_AddStringRender({0,0}, cstring_to_pk_cstr(""), &frs, nullptr, uuid_n[1]);

		pke_serialize_scene(h);
		pke_serialize_scene_to_stream(ss, h);
		std::string s = ss.str();

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(2, h->kvp_containers.next);
		// FontRenderSettings
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[0].arr.next);
		// FontRender
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[1].arr.next);

		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				kve = &h->kvp_containers[k].arr[i];
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
			}
		}

		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_005_str, s.c_str()));

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

int pke_test_deserialization_105() {
	uint32_t i, k;
	pke_kve *kve;
	srlztn_deserialize_helper *h;
	std::stringstream ss(test_005_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
		PK_TEST_ASSERT_EQ_RET(2, h->kvp_containers.next);
		// FontRenderSettings
		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[0].arr.next);
		// FontRender
		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[1].arr.next);

		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				kve = &h->kvp_containers[k].arr[i];
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
			}
		}

		pke_deserialize_scene(h);

		pk_bkt_arr_t<FontType> ft_bkt = *static_cast<pk_bkt_arr_t<FontType>*>(FontType_GetFonts());
		FontRender *fr = &ft_bkt[{0,0}].renders[{0,0}];

		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.char_scale);
		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.line_height_scale);
		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.char_spacing_scale);
		PK_TEST_ASSERT_EQ_RET(250, fr->settings.surface_area_size.x);
		PK_TEST_ASSERT_EQ_RET(250, fr->settings.surface_area_size.y);
		PK_TEST_ASSERT_EQ_RET(0, fr->settings.surface_area_pos.x);
		PK_TEST_ASSERT_EQ_RET(0, fr->settings.surface_area_pos.y);
		PK_TEST_ASSERT_EQ_RET(static_cast<FONT_RENDER_SURFACE_AREA_TYPE_FLAG_T>(FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH), static_cast<FONT_RENDER_SURFACE_AREA_TYPE_FLAG_T>(fr->settings.surface_area_type_flags));
		// auto equal_4 = glm::epsilonEqual(fr->settings.color_foreground, glm::vec4(0.4, 0.9, 0.5, 0.8), epsilon_4);
		// PKE_TEST_ASSERT(equal_4 == bool_4, err_index);
		PK_TEST_ASSERT_EQ_RET(0.4f, fr->settings.color_foreground.x);
		PK_TEST_ASSERT_EQ_RET(0.9f, fr->settings.color_foreground.y);
		PK_TEST_ASSERT_EQ_RET(0.5f, fr->settings.color_foreground.z);
		PK_TEST_ASSERT_EQ_RET(0.8f, fr->settings.color_foreground.w);
		PK_TEST_ASSERT_EQ_RET(0.0f, fr->settings.color_background.x);
		PK_TEST_ASSERT_EQ_RET(0.0f, fr->settings.color_background.y);
		PK_TEST_ASSERT_EQ_RET(0.0f, fr->settings.color_background.z);
		PK_TEST_ASSERT_EQ_RET(0.0f, fr->settings.color_background.w);

		PK_TEST_ASSERT_EQ_RET(uuid_n[1], fr->uuid);
		PK_TEST_ASSERT_NEQ_RET(nullptr, fr->text.val);
		PK_TEST_ASSERT_EQ_RET('\0', fr->text.val[0]);

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

struct pk_test_group *pke_test_serialization_get_group() {
	static const uint64_t test_count = 11;
	static struct pk_test tests[test_count] = {
		{
			.title = "test 999",
			.func = pke_test_serialization_999,
			.expected_result = 0,
		},
		{
			.title = "test 001",
			.func = pke_test_serialization_001,
			.expected_result = 0,
		},
		{
			.title = "test 101",
			.func = pke_test_deserialization_101,
			.expected_result = 0,
		},
		{
			.title = "test 002",
			.func = pke_test_serialization_002,
			.expected_result = 0,
		},
		{
			.title = "test 102",
			.func = pke_test_deserialization_102,
			.expected_result = 0,
		},
		{
			.title = "test 003",
			.func = pke_test_serialization_003,
			.expected_result = 0,
		},
		{
			.title = "test 103",
			.func = pke_test_deserialization_103,
			.expected_result = 0,
		},
		{
			.title = "test 004",
			.func = pke_test_serialization_004,
			.expected_result = 0,
		},
		{
			.title = "test 104",
			.func = pke_test_deserialization_104,
			.expected_result = 0,
		},
		{
			.title = "test 005",
			.func = pke_test_serialization_005,
			.expected_result = 0,
		},
		{
			.title = "test 105",
			.func = pke_test_deserialization_105,
			.expected_result = 0,
		},
	};
	static struct pk_test_group group = {};
	group.title = "de/serialization";
	group.group_setup = nullptr;
	group.group_teardown = nullptr;
	group.test_setup = pke_test_serialization_spinup;
	group.test_teardown = pke_test_serialization_teardown;
	group.n_tests = test_count;
	group.tests = &tests[0];

	return &group;
}