implement type checking

maybe not perfect, but better than no things

1 files changed, 99 insertions, 5 deletions

diff --git a/src/simple-test.h b/src/simple-test.h
index 9a8d73e..4480ac8 100644
--- a/src/simple-test.h
+++ b/src/simple-test.h
@@ -20,9 +20,7 @@
 typedef enum {
 	SIMPLE_TEST_BOOL,
 	SIMPLE_TEST_INT,
-	SIMPLE_TEST_LINT,
 	SIMPLE_TEST_UINT,
-	SIMPLE_TEST_LUINT,
 	SIMPLE_TEST_FLOAT,
 	SIMPLE_TEST_PTR,
 	SIMPLE_TEST_CHAR,
@@ -167,9 +165,9 @@ do { \
 
 #define SIMPLE_TEST_INTERN_ERR(file, line) \
 do { \
-	fprintf(stderr, "\e[1m    :: "); \
-	fprintf(stderr, "%s:%i: \e[31;1merr:\e[m ", file, line); \
-	fprintf(stderr, "bad call to internal func\n"); \
+	printf("\e[1m    :: "); \
+	printf("%s:%i: \e[31;1merr:\e[m ", file, line); \
+	printf("bad call to internal func\n"); \
 	exit(1); \
 } while(0)
 
@@ -613,6 +611,30 @@ void simple_test_assert_wstr(char *sarg1, char *sarg2,
 	}
 }
 
+#define SIMPLE_TEST_TYPE_ENUM_VAL(arg) \
+	_Generic((arg), \
+			bool: SIMPLE_TEST_BOOL, \
+			int8_t: SIMPLE_TEST_INT, int16_t: SIMPLE_TEST_INT, \
+			int32_t: SIMPLE_TEST_INT, int64_t: SIMPLE_TEST_INT, \
+			uint8_t: SIMPLE_TEST_UINT, uint16_t: SIMPLE_TEST_UINT, \
+			uint32_t: SIMPLE_TEST_UINT, uint64_t: SIMPLE_TEST_UINT, \
+			float: SIMPLE_TEST_FLOAT, double: SIMPLE_TEST_FLOAT, \
+			long double: SIMPLE_TEST_FLOAT, \
+			void*: SIMPLE_TEST_PTR, \
+			char*: SIMPLE_TEST_STR, \
+			wchar_t*: SIMPLE_TEST_WSTR \
+			)
+
+#define SIMPLE_TEST_TYPE_CHECK(arg1, arg2) \
+do { \
+	if(SIMPLE_TEST_TYPE_ENUM_VAL(arg1) != SIMPLE_TEST_TYPE_ENUM_VAL(arg2)) { \
+		printf("\e[1m    :: "); \
+		printf("%s:%i: \e[31;1merr:\e[m ", __FILE__, __LINE__); \
+		printf("type mismatch\n"); \
+		exit(1); \
+	} \
+} while(0)
+
 #define SIMPLE_TEST_GENERIC_CAST(arg) \
 	_Generic((arg), \
 			bool: (bool)(arg), \
@@ -696,26 +718,32 @@ do { \
 			SIMPLE_TEST_GENERIC_NOT(arg), arg, SIMPLE_TEST_TRUE)
 
 #define ASSERT_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \
 			arg1, arg2, SIMPLE_TEST_EQ)
 
 #define ASSERT_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \
 			arg1, arg2, SIMPLE_TEST_NEQ)
 
 #define ASSERT_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \
 			arg1, arg2, SIMPLE_TEST_G)
 
 #define ASSERT_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \
 			arg1, arg2, SIMPLE_TEST_GEQ)
 
 #define ASSERT_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \
 			arg1, arg2, SIMPLE_TEST_L)
 
 #define ASSERT_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \
 			arg1, arg2, SIMPLE_TEST_LEQ)
 
@@ -724,331 +752,397 @@ do { \
  *************************/
 
 #define ASSERT_BOOL(arg) \
+	SIMPLE_TEST_TYPE_CHECK(false, arg); \
 	simple_test_assert_bool("false", #arg, \
 			false, (bool)(arg), \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_BOOL_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_bool(#arg1, #arg2, \
 			(bool)(arg1), (bool)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_BOOL_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_bool(#arg1, #arg2, \
 			(bool)(arg1), (bool)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_INT(arg) \
+	SIMPLE_TEST_TYPE_CHECK(0, arg); \
 	simple_test_assert_int("0", #arg, \
 			(intmax_t)0, (intmax_t)(arg), \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_INT_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_int(#arg1, #arg2, \
 			(intmax_t)(arg1), (intmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_INT_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_int(#arg1, #arg2, \
 			(intmax_t)(arg1), (intmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_INT_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_int(#arg1, #arg2, \
 			(intmax_t)(arg1), (intmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_INT_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_int(#arg1, #arg2, \
 			(intmax_t)(arg1), (intmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_INT_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_int(#arg1, #arg2, \
 			(intmax_t)(arg1), (intmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_INT_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_int(#arg1, #arg2, \
 			(intmax_t)(arg1), (intmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)
 
 #define ASSERT_UINT(arg) \
+	SIMPLE_TEST_TYPE_CHECK(0, arg); \
 	simple_test_assert_uint("0", #arg, \
 			(uintmax_t)0, (uintmax_t)(arg), \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_UINT_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_uint(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_UINT_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_uint(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_UINT_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_uint(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_UINT_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_uint(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_UINT_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_uint(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_UINT_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_uint(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)
 
 #define ASSERT_HEX(arg) \
+	SIMPLE_TEST_TYPE_CHECK(0, arg2); \
 	simple_test_assert_uint("0", #arg, \
 			(uintmax_t)0, (uintmax_t)(arg), \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_HEX_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_uint(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_HEX_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_hex(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_HEX_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_hex(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_HEX_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_hex(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_HEX_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_hex(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_HEX_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_hex(#arg1, #arg2, \
 			(uintmax_t)(arg1), (uintmax_t)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)
 
 #define ASSERT_FLOAT(arg) \
+	SIMPLE_TEST_TYPE_CHECK(0.0, arg); \
 	simple_test_assert_float("0", #arg, \
 			(long double)0, (long double)(arg), \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_FLOAT_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_float(#arg1, #arg2, \
 			(long double)(arg1), (long double)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_FLOAT_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_float(#arg1, #arg2, \
 			(long double)(arg1), (long double)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_FLOAT_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_float(#arg1, #arg2, \
 			(long double)(arg1), (long double)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_FLOAT_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_float(#arg1, #arg2, \
 			(long double)(arg1), (long double)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_FLOAT_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_float(#arg1, #arg2, \
 			(long double)(arg1), (long double)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_FLOAT_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_float(#arg1, #arg2, \
 			(long double)(arg1), (long double)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)
 
 #define ASSERT_PTR(arg) \
+	SIMPLE_TEST_TYPE_CHECK(NULL, arg); \
 	simple_test_assert_ptr("NULL", #arg, \
 			NULL, (void *)(arg), \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_PTR_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_ptr(#arg1, #arg2, \
 			(void *)(arg1), (void *)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_PTR_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_ptr(#arg1, #arg2, \
 			(void *)(arg1), (void *)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_PTR_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_ptr(#arg1, #arg2, \
 			(void *)(arg1), (void *)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_PTR_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_ptr(#arg1, #arg2, \
 			(void *)(arg1), (void *)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_PTR_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_ptr(#arg1, #arg2, \
 			(void *)(arg1), (void *)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_PTR_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_ptr(#arg1, #arg2, \
 			(void *)(arg1), (void *)(arg2), \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)
 
 #define ASSERT_CHAR(arg) \
+	SIMPLE_TEST_TYPE_CHECK('\0', arg); \
 	simple_test_assert_char("\\0", #arg, \
 			'\0', arg, \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_CHAR_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_char(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_CHAR_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_char(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_CHAR_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_char(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_CHAR_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_char(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_CHAR_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_char(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_CHAR_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_char(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)
 
 #define ASSERT_STR(arg) \
+	SIMPLE_TEST_TYPE_CHECK("0", arg); \
 	simple_test_assert_str("0", #arg, \
 			0, (arg), \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_STR_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_str(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_STR_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_str(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_STR_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_str(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_STR_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_str(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_STR_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_str(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_STR_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_str(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)
 
 #define ASSERT_WCHAR(arg) \
+	SIMPLE_TEST_TYPE_CHECK(L'\0', arg2); \
 	simple_test_assert_wchar("\\0", #arg, \
 			L'\0', arg, \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_WCHAR_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wchar(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_WCHAR_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wchar(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_WCHAR_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wchar(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_WCHAR_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wchar(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_WCHAR_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wchar(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_WCHAR_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wchar(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)
 
 #define ASSERT_WSTR(arg) \
+	SIMPLE_TEST_TYPE_CHECK(L"0", arg); \
 	simple_test_assert_wstr("0", #arg, \
 			0, (arg), \
 			__FILE__, __LINE__, SIMPLE_TEST_TRUE)
 
 #define ASSERT_WSTR_EQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wstr(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_EQ)
 
 #define ASSERT_WSTR_NEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wstr(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_NEQ)
 
 #define ASSERT_WSTR_G(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wstr(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_G)
 
 #define ASSERT_WSTR_GEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wstr(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_GEQ)
 
 #define ASSERT_WSTR_L(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wstr(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_L)
 
 #define ASSERT_WSTR_LEQ(arg1, arg2) \
+	SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \
 	simple_test_assert_wstr(#arg1, #arg2, \
 			arg1, arg2, \
 			__FILE__, __LINE__, SIMPLE_TEST_LEQ)