pktst: created + bump pk.h version to 0.9.4

2 files changed, 54 insertions, 50 deletions

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);
 	}
 };