pktst: created + bump pk.h version to 0.9.4

6 files changed, 244 insertions, 52 deletions

diff --git a/Makefile b/Makefile
index 1f80c2a..5de676b 100644
--- a/Makefile
+++ b/Makefile
@@ -3,7 +3,7 @@
 
 include config.mk
 
-.PHONY: pkmacros pkmem-types pkmem pkstr pkev pkarr pkstn pktmr test
+.PHONY: pkmacros pkmem-types pkmem pkstr pkev pkiter pkarr pkstn pktmr pkuuid pkbktarr pkfuncinstr pktst test
 
 SRC =  \
 	pkmacros.h \
@@ -18,6 +18,7 @@ SRC =  \
 	pkbktarr.h \
 	pktmpln.h \
 	pkfuncinstr.h \
+	pktst.h \
 	test/pkmacros.c \
 	test/pkmacros.cpp \
 	test/pkmem-types.c \
@@ -58,6 +59,7 @@ all: options .WAIT clean .WAIT \
 	pkbktarr \
 	pktmpln \
 	pkfuncinstr \
+	pktst \
 	test/test-pkmem-types test/test-pkmem-types-cpp \
 	test/test-pkmem test/test-pkmem-cpp \
 	test/test-pkmacros test/test-pkmacros-cpp \
@@ -117,6 +119,8 @@ pktmpln: pktmpln.gch pktmpln.gchpp
 
 pkfuncinstr: pkfuncinstr.gch pkfuncinstr.gchpp
 
+pktst: pktst.gch pktst.gchpp
+
 build: pkmacros
 build: pkmem-types
 build: pkmem
@@ -129,6 +133,7 @@ build: pktmr
 build: pkuuid
 build: pkbktarr
 build: pkfuncinstr
+build: pktst
 	echo "#ifndef PK_SINGLE_HEADER_FILE_H\n#define PK_SINGLE_HEADER_FILE_H" > pk.h
 	cat pk.h.in \
 	pkmacros.h \
@@ -144,6 +149,7 @@ build: pkfuncinstr
 	pkuuid.h \
 	pkbktarr.h \
 	pkfuncinstr.h \
+	pktst.h \
 	>> pk.h
 	echo "#endif /* PK_SINGLE_HEADER_FILE_H */" >> pk.h
 	sed -i -r \
@@ -228,6 +234,7 @@ test: pkuuid test/test-pkuuid test/test-pkuuid-cpp
 test: pkbktarr test/test-pkbktarr test/test-pkbktarr-cpp
 test: pktmpln
 test: pkfuncinstr
+test: pktst
 test:
 	@echo ""
 	./test/test-pkmacros ; echo Result: $$? "\n"
diff --git a/config.mk b/config.mk
index dbc4fcd..ffc5f49 100644
--- a/config.mk
+++ b/config.mk
@@ -1,5 +1,5 @@
 # pk.h version
-VERSION = 0.9.3
+VERSION = 0.9.4
 
 # paths
 PREFIX = /usr/local
diff --git a/pk.h.in b/pk.h.in
index 7e95dd7..fcbbe32 100644
--- a/pk.h.in
+++ b/pk.h.in
@@ -288,6 +288,18 @@
 * }
 * ```
 *
+********************************************************************************
+* pktst.h: define PK_IMPL_TST before including pk.h to enable ad-hoc.
+*
+* Provides a simple testing framework
+*
+* Examples:
+* ```c
+* main() {
+*   pk_test_run_test_groups(&my_get_test_group_func, 1);
+* }
+* ```
+*
 *******************************************************************************/
 
 #define PK_VERSION "@@PK_VERSION@@"
@@ -320,4 +332,7 @@
 # ifndef PK_IMPL_FUNCINSTR
 #  define PK_IMPL_FUNCINSTR
 # endif
+# ifndef PK_IMPL_TST
+#  define PK_IMPL_TST
+# endif
 #endif
diff --git a/pktst.h b/pktst.h
new file mode 100644
index 0000000..7d04c5b
--- /dev/null
+++ b/pktst.h
@@ -0,0 +1,166 @@
+#ifndef PK_PKTST_H
+#define PK_PKTST_H
+
+#include "pkmacros.h" /* deleteme */
+
+typedef int (pk_test_func)();
+struct pk_test_group;
+typedef struct pk_test_group *(pk_test_group_get)();
+
+typedef void (pk_test_group_setup)();
+typedef void (pk_test_group_teardown)();
+typedef void (pk_test_setup)();
+typedef void (pk_test_teardown)();
+
+struct pk_test {
+	const char *title;
+	pk_test_func *func;
+	int expected_result;
+};
+
+struct pk_test_group {
+	const char *title;
+	pk_test_group_setup *group_setup;
+	pk_test_group_teardown *group_teardown;
+	pk_test_setup *test_setup;
+	pk_test_teardown *test_teardown;
+	struct pk_test *tests;
+	unsigned char n_tests;
+};
+
+void pk_test_run_test_groups(pk_test_group_get **group_get_fns, unsigned long n_groups);
+
+#if defined(__cplusplus)
+#include <iostream>
+#define PK_TEST_ASSERT_BODY(expected, value)                                   \
+  std::cerr << "[pk-test] ";                                                   \
+  std::cerr << "(" << __FILE__ << ":" << __LINE__ << ")";                      \
+  std::cerr << PK_CLR_FG_RED " Failed. " PK_CLR_RESET;                         \
+  std::cerr << "Condition: \"";                                                \
+  std::cerr << PK_CLR_FG_BRIGHT_BLUE << #value << PK_CLR_RESET;                \
+  std::cerr << "\", Expected: \"";                                             \
+  std::cerr << PK_CLR_FG_GREEN << (expected) << PK_CLR_RESET;                  \
+  std::cerr << "\", Got: \"";                                                  \
+  std::cerr << PK_CLR_FG_RED << (value) << PK_CLR_RESET;                       \
+  std::cerr << "\"." << std::endl;
+template<typename T>
+inline bool flt_equal(T a, T b, T epsilon) {
+	return abs(a - b) < epsilon;
+}
+#else /* __cplusplus */
+#include <stdio.h>
+#define PK_TEST_ASSERT_BODY(expected, value)                                   \
+  fprintf(stderr,"[pk-test] (%s:%i) ", __FILE__, __LINE__);                    \
+  fprintf(stderr,"%s ", PK_CLR_FG_RED "Failed. " PK_CLR_RESET);                \
+  fprintf(stderr,"Test condition \"");                                         \
+  fprintf(stderr,"%s\"\n",PK_CLR_FG_BRIGHT_BLUE #value PK_CLR_RESET);
+#endif /* __cplusplus */
+
+#define PK_TEST_ASSERT_EQ(expected, value) {                                   \
+  if ((value) != (expected)) {                                                 \
+    PK_TEST_ASSERT_BODY(expected, value)                                       \
+  }                                                                            \
+}
+#define PK_TEST_ASSERT_EQ_RET(expected, value) {                               \
+  if ((value) != (expected)) {                                                 \
+    PK_TEST_ASSERT_BODY(expected, value)                                       \
+    return -1;                                                                 \
+  }                                                                            \
+}
+#define PK_TEST_ASSERT_EQ_EXIT(expected, value) {                              \
+  if ((value) != (expected)) {                                                 \
+    PK_TEST_ASSERT_BODY(expected, value)                                       \
+    exit(1);                                                                   \
+  }                                                                            \
+}
+#define PK_TEST_ASSERT_NEQ(expected, value) {                                  \
+  if ((value) == (expected)) {                                                 \
+    PK_TEST_ASSERT_BODY(expected, value)                                       \
+  }                                                                            \
+}
+#define PK_TEST_ASSERT_NEQ_RET(expected, value) {                              \
+  if ((value) == (expected)) {                                                 \
+    PK_TEST_ASSERT_BODY(expected, value)                                       \
+    return -1;                                                                 \
+  }                                                                            \
+}
+#define PK_TEST_ASSERT_NEQ_EXIT(expected, value) {                             \
+  if ((value) == (expected)) {                                                 \
+    PK_TEST_ASSERT_BODY(expected, value)                                       \
+    exit(1);                                                                   \
+  }                                                                            \
+}
+
+#ifdef PK_IMPL_TST
+
+#include "../pktmr.h" /* deleteme */
+
+void pk_test_run_test_groups(pk_test_group_get **group_get_fns, unsigned long n_groups) {
+	int result;
+	unsigned long i;
+	unsigned int k, pass_count, total_test_count, total_test_pass_count, test_group_count, test_group_pass_count;
+	double elapsed_ms, group_ms, total_ms;
+	pk_tmr func_tmr, total_tmr;
+	pk_test_group *group;
+
+	fprintf(stdout, "\r\n");
+	fprintf(stdout, "[pk-test] Begin..\n");
+	fprintf(stdout, "[pk-test] Running %04ld tests..\n", n_groups);
+
+	i = 0;
+	total_ms = 0;
+	total_test_count = 0;
+	total_test_pass_count = 0;
+	test_group_count = 0;
+	test_group_pass_count = 0;
+	pk_tmr_start(total_tmr);
+	fprintf(stdout, "\r\n");
+	for (i = 0; i < n_groups; ++i) {
+		test_group_count += 1;
+		pass_count = 0;
+		group_ms = 0;
+		group = group_get_fns[i]();
+		fprintf(stdout, "[pk-test][%s] Begin..\n", group->title);
+		if (group->group_setup != NULL) (group->group_setup)();
+		for (k = 0; k < group->n_tests; ++k) {
+			total_test_count += 1;
+			fprintf(stdout, "[pk-test][%s][%s] Begin..\n", group->title, group->tests[k].title);
+			if (group->test_setup != NULL) (group->test_setup)();
+			pk_tmr_start(func_tmr);
+			result = (group->tests[k].func)();
+			pk_tmr_stop(func_tmr);
+			elapsed_ms = pk_tmr_duration_dbl_mili(func_tmr);
+			fprintf(stdout, "[pk-test][%s][%s] End.\n", group->title, group->tests[k].title);
+			group_ms += elapsed_ms;
+			total_ms += elapsed_ms;
+			fprintf(stdout, "[pk-test][%s][%s] Elapsed ms: '%f'.\n", group->title, group->tests[k].title, elapsed_ms);
+			if (result == group->tests[k].expected_result){
+				total_test_pass_count += 1;
+				pass_count += 1;
+				fprintf(stdout, "[pk-test][%s][%s] %sPassed.%s\n", group->title, group->tests[k].title, PK_CLR_FG_GREEN, PK_CLR_RESET);
+			} else {
+				fprintf(stdout, "[pk-test][%s][%s] %sFailed.%s\n", group->title, group->tests[k].title, PK_CLR_FG_RED, PK_CLR_RESET);
+				fprintf(stdout, "[pk-test][%s][%s] Expected: '" PK_CLR_FG_GREEN "%i" PK_CLR_RESET "', Got: '" PK_CLR_FG_RED "%i" PK_CLR_RESET "'.\n", group->title, group->tests[k].title, group->tests[k].expected_result, result);
+			}
+			if (group->test_teardown != NULL) (group->test_teardown)();
+		}
+		if (group->group_teardown != NULL) (group->group_teardown)();
+		fprintf(stdout, "[pk-test][%s] End.\n", group->title);
+		fprintf(stdout, "[pk-test][%s] Tests completed: ( %s%04d%s / %04d ).\n", group->title, pass_count == group->n_tests ? PK_CLR_FG_GREEN : PK_CLR_FG_RED, pass_count, PK_CLR_RESET, group->n_tests);
+		fprintf(stdout, "[pk-test][%s] Elapsed ms: '%f'.\n\n", group->title, group_ms);
+		if (pass_count == group->n_tests) {
+			test_group_pass_count += 1;
+		}
+	}
+	pk_tmr_stop(total_tmr);
+
+	fprintf(stdout, "[pk-test] End.\n");
+	fprintf(stdout, "[pk-test] Tests completed:       ( %s%04d%s / %04d ).\n", total_test_count == total_test_pass_count ? PK_CLR_FG_GREEN : PK_CLR_FG_RED, total_test_pass_count, PK_CLR_RESET, total_test_count);
+	fprintf(stdout, "[pk-test] Test groups completed: ( %s%04d%s / %04d ).\n", test_group_count == test_group_pass_count ? PK_CLR_FG_GREEN : PK_CLR_FG_RED, test_group_pass_count, PK_CLR_RESET, test_group_count);
+	fprintf(stdout, "[pk-test] Elapsed ms: '%f' (test fn sum).\n", total_ms);
+	fprintf(stdout, "[pk-test] Elapsed ms: '%f' (actual).\n\n", pk_tmr_duration_dbl_mili(total_tmr));
+}
+
+#endif /* PK_IMPL_TST */
+
+#endif /* PK_PKTST_H */
diff --git a/test/pkstn.c b/test/pkstn.c
index 92d982f..789a2be 100644
--- a/test/pkstn.c
+++ b/test/pkstn.c
@@ -2,6 +2,7 @@
 #define PK_IMPL_STN
 
 #include "../pkstn.h"
+#include "../pktst.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -18,8 +19,8 @@ int main(int argc, char *argv[])
 		int64_t i = {0};
 		res = pk_stn_int64_t(&i, "-1", &s, 0);
 		fprintf(stdout, "pkstn: stn_int64_t res: %ld\n", i);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (-1 != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(-1, i)
 	}
 
 	// stn_uint64_t
@@ -27,8 +28,8 @@ int main(int argc, char *argv[])
 		uint64_t i = {0};
 		res = pk_stn_uint64_t(&i, "1", &s, 0);
 		fprintf(stdout, "pkstn: stn_uint64_t res: %lu\n", i);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (1 != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(1, i)
 	}
 
 	// stn_int32_t
@@ -36,8 +37,8 @@ int main(int argc, char *argv[])
 		int32_t i = {0};
 		res = pk_stn_int32_t(&i, "-1", &s, 0);
 		fprintf(stdout, "pkstn: stn_int32_t res: %d\n", i);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (-1 != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(-1, i)
 	}
 
 	// stn_uint32_t
@@ -45,8 +46,8 @@ int main(int argc, char *argv[])
 		uint32_t i = {0};
 		res = pk_stn_uint32_t(&i, "1", &s, 0);
 		fprintf(stdout, "pkstn: stn_uint32_t res: %u\n", i);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (1 != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(1, i)
 	}
 
 	// stn_int16_t
@@ -54,8 +55,8 @@ int main(int argc, char *argv[])
 		int16_t i = {0};
 		res = pk_stn_int16_t(&i, "-1", &s, 0);
 		fprintf(stdout, "pkstn: stn_int16_t res: %d\n", i);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (-1 != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(-1, i)
 	}
 
 	// stn_uint16_t
@@ -63,8 +64,8 @@ int main(int argc, char *argv[])
 		uint16_t i = {0};
 		res = pk_stn_uint16_t(&i, "1", &s, 0);
 		fprintf(stdout, "pkstn: stn_uint16_t res: %u\n", i);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (1 != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(1, i)
 	}
 
 	// stn_int8_t
@@ -72,8 +73,8 @@ int main(int argc, char *argv[])
 		int8_t i = {0};
 		res = pk_stn_int8_t(&i, "-1", &s, 0);
 		fprintf(stdout, "pkstn: stn_int8_t res: %d\n", i);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (-1 != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(-1, i)
 	}
 
 	// stn_uint8_t
@@ -81,8 +82,8 @@ int main(int argc, char *argv[])
 		uint8_t i = {0};
 		res = pk_stn_uint8_t(&i, "1", &s, 0);
 		fprintf(stdout, "pkstn: stn_uint8_t res: %u\n", i);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (1 != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(1, i)
 	}
 
 	// stn_float
@@ -90,8 +91,8 @@ int main(int argc, char *argv[])
 		float f = {0};
 		res = pk_stn_float(&f, "-1", &s);
 		fprintf(stdout, "pkstn: stn_float res: %f\n", f);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (-1 != f) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(-1, f)
 	}
 
 	// stn_double
@@ -99,8 +100,8 @@ int main(int argc, char *argv[])
 		double f = {0};
 		res = pk_stn_double(&f, "-1", &s);
 		fprintf(stdout, "pkstn: stn_double res: %f\n", f);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (-1 != f) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res)
+		PK_TEST_ASSERT_EQ_EXIT(-1, f)
 	}
 
 	return 0;
diff --git a/test/pkstn.cpp b/test/pkstn.cpp
index 21f0319..443e4a5 100644
--- a/test/pkstn.cpp
+++ b/test/pkstn.cpp
@@ -2,6 +2,7 @@
 #define PK_IMPL_STN
 
 #include "../pkstn.h"
+#include "../pktst.h"
 
 #include <cstring>
 #include <iostream>
@@ -58,49 +59,49 @@ void test() {
 	if constexpr (t & TEST_SCALAR_NIL) {
 		res = pk_stn(&i, STRNUM_NIL, &s);
 		std::cout << "pkstn: TEST_SCALAR_NIL res: " << i << "\n";
-		if (s != STRNUM_NIL) exit(1);
-		if (res != PK_STN_RES_INCONVERTIBLE) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_NIL, s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_INCONVERTIBLE, res);
 	}
 	if constexpr (t & TEST_FLOATING_NIL) {
 		res = pk_stn(&i, STRNUM_FLOAT_NIL, &s);
 		std::cout << "pkstn: TEST_FLOATING_NIL res: " << i << "\n";
-		if (s != STRNUM_FLOAT_NIL) exit(1);
-		if (res != PK_STN_RES_INCONVERTIBLE) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_FLOAT_NIL, s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_INCONVERTIBLE, res);
 	}
 	if constexpr (t & TEST_SCALAR_ZED) {
 		res = pk_stn(&i, STRNUM_ZED, &s);
 		std::cout << "pkstn: TEST_SCALAR_ZED res: " << i << "\n";
-		if (s != STRNUM_ZED + strlen(STRNUM_ZED)) exit(1);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (T(VAL_SCALAR_ZED) != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_ZED + strlen(STRNUM_ZED), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
+		PK_TEST_ASSERT_EQ_EXIT(T(VAL_SCALAR_ZED), i);
 	}
 	if constexpr (t & TEST_FLOATING_ZED) {
 		res = pk_stn(&i, STRNUM_FLOAT_ZED, &s);
 		std::cout << "pkstn: TEST_FLOATING_ZED res: " << i << "\n";
-		if (s != STRNUM_FLOAT_ZED + strlen(STRNUM_FLOAT_ZED)) exit(1);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (T(VAL_FLOATING_ZED) != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_FLOAT_ZED + strlen(STRNUM_FLOAT_ZED), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
+		PK_TEST_ASSERT_EQ_EXIT(T(VAL_FLOATING_ZED), i);
 	}
 	if constexpr (t & TEST_SCALAR_ONE) {
 		res = pk_stn(&i, STRNUM_ONE, &s);
 		std::cout << "pkstn: TEST_SCALAR_ONE res: " << i << "\n";
-		if (s != STRNUM_ONE + strlen(STRNUM_ONE)) exit(1);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (T(VAL_SCALAR_ONE) != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_ONE + strlen(STRNUM_ONE), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
+		PK_TEST_ASSERT_EQ_EXIT(T(VAL_SCALAR_ONE), i);
 	}
 	if constexpr (t & TEST_FLOATING_ONE) {
 		res = pk_stn(&i, STRNUM_FLOAT_ONE, &s);
 		std::cout << "pkstn: TEST_FLOATING_ONE res: " << i << "\n";
-		if (s != STRNUM_FLOAT_ONE + strlen(STRNUM_FLOAT_ONE)) exit(1);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (T(VAL_FLOATING_ONE) != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_FLOAT_ONE + strlen(STRNUM_FLOAT_ONE), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
+		PK_TEST_ASSERT_EQ_EXIT(T(VAL_FLOATING_ONE), i);
 	}
 	if constexpr (t & TEST_SCALAR_ONE_MINUS) {
 		res = pk_stn(&i, STRNUM_ONE_MINUS, &s);
 		std::cout << "pkstn: TEST_SCALAR_ONE_MINUS res: " << i << "\n";
-		if (s != STRNUM_ONE_MINUS + strlen(STRNUM_ONE_MINUS)) exit(1);
-		if (res != PK_STN_RES_SUCCESS) exit(1);
-		if (T(VAL_SCALAR_ONE_MINUS) != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_ONE_MINUS + strlen(STRNUM_ONE_MINUS), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
+		PK_TEST_ASSERT_EQ_EXIT(T(VAL_SCALAR_ONE_MINUS), i);
 	}
 	if constexpr (t & TEST_FLOATING_ONE_MINUS) {
 		res = pk_stn(&i, STRNUM_FLOAT_ONE_MINUS, &s);
@@ -108,40 +109,42 @@ void test() {
 		if (s != STRNUM_FLOAT_ONE_MINUS + strlen(STRNUM_FLOAT_ONE_MINUS)) exit(1);
 		if (res != PK_STN_RES_SUCCESS) exit(1);
 		if (T(VAL_FLOATING_ONE_MINUS) != i) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_FLOAT_ONE_MINUS + strlen(STRNUM_FLOAT_ONE_MINUS), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_SUCCESS, res);
 	}
 	if constexpr (t & TEST_SCALAR_UNDERFLOW) {
 		res = pk_stn(&i, STRNUM_UNDERFLOW, &s);
 		std::cout << "pkstn: TEST_SCALAR_UNDERFLOW res: " << i << "\n";
-		if (s != STRNUM_UNDERFLOW + strlen(STRNUM_UNDERFLOW)) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_UNDERFLOW + strlen(STRNUM_UNDERFLOW), s);
 		if constexpr(std::is_unsigned_v<T> == true) {
-			if (res != PK_STN_RES_OVERFLOW) exit(1);
+			PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_OVERFLOW, res);
 		} else {
-			if (res != PK_STN_RES_UNDERFLOW) exit(1);
+			PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_UNDERFLOW, res);
 		}
 	}
 	if constexpr (t & TEST_FLOATING_UNDERFLOW) {
 		res = pk_stn(&i, STRNUM_UNDERFLOW_FLOAT, &s);
 		std::cout << "pkstn: TEST_FLOATING_UNDERFLOW res: " << i << "\n";
-		if (s != STRNUM_UNDERFLOW_FLOAT + strlen(STRNUM_UNDERFLOW_FLOAT)) exit(1);
-		if (res != PK_STN_RES_UNDERFLOW) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_UNDERFLOW_FLOAT + strlen(STRNUM_UNDERFLOW_FLOAT), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_UNDERFLOW, res);
 	}
 	if constexpr (t & TEST_SCALAR_OVERFLOW) {
 		res = pk_stn(&i, STRNUM_OVERFLOW, &s);
 		std::cout << "pkstn: TEST_SCALAR_OVERFLOW res: " << i << "\n";
-		if (s != STRNUM_OVERFLOW + strlen(STRNUM_OVERFLOW)) exit(1);
-		if (res != PK_STN_RES_OVERFLOW) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_OVERFLOW + strlen(STRNUM_OVERFLOW), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_OVERFLOW, res);
 	}
 	if constexpr (t & TEST_FLOATING_OVERFLOW) {
 		res = pk_stn(&i, STRNUM_OVERFLOW_FLOAT, &s);
 		std::cout << "pkstn: TEST_FLOATING_OVERFLOW res: " << i << "\n";
-		if (s != STRNUM_OVERFLOW_FLOAT + strlen(STRNUM_OVERFLOW_FLOAT)) exit(1);
-		if (res != PK_STN_RES_OVERFLOW) exit(1);
+		PK_TEST_ASSERT_EQ_EXIT(STRNUM_OVERFLOW_FLOAT + strlen(STRNUM_OVERFLOW_FLOAT), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_OVERFLOW, res);
 	}
 	if constexpr (t & TEST_INCONVERTIBLE) {
 		res = pk_stn(&i, STRNUM_INCONVERTIBLE, &s);
 		std::cout << "pkstn: TEST_INCONVERTIBLE res: " << i << "\n";
-		if (s != STRNUM_INCONVERTIBLE) exit(1);
-		if (res != PK_STN_RES_INCONVERTIBLE) exit(1);
+		PK_TEST_ASSERT_NEQ_EXIT(STRNUM_INCONVERTIBLE + strlen(STRNUM_INCONVERTIBLE), s);
+		PK_TEST_ASSERT_EQ_EXIT(PK_STN_RES_INCONVERTIBLE, res);
 	}
 };