diff --git a/test/test.c b/test/test.c index 403511d..ac4330a 100644 --- a/test/test.c +++ b/test/test.c @@ -32,86 +32,54 @@ #pragma warning(disable : 4127) #endif -TESTCASE(c, ASSERT_TRUE) { - ASSERT_TRUE(1); -} +TESTCASE(c, ASSERT_TRUE) { ASSERT_TRUE(1); } -TESTCASE(c, ASSERT_FALSE) { - ASSERT_FALSE(0); -} +TESTCASE(c, ASSERT_FALSE) { ASSERT_FALSE(0); } -TESTCASE(c, ASSERT_EQ) { - ASSERT_EQ(1, 1); -} +TESTCASE(c, ASSERT_EQ) { ASSERT_EQ(1, 1); } -TESTCASE(c, ASSERT_NE) { - ASSERT_NE(1, 2); -} +TESTCASE(c, ASSERT_NE) { ASSERT_NE(1, 2); } -TESTCASE(c, ASSERT_LT) { - ASSERT_LT(1, 2); -} +TESTCASE(c, ASSERT_LT) { ASSERT_LT(1, 2); } TESTCASE(c, ASSERT_LE) { ASSERT_LE(1, 1); ASSERT_LE(1, 2); } -TESTCASE(c, ASSERT_GT) { - ASSERT_GT(2, 1); -} +TESTCASE(c, ASSERT_GT) { ASSERT_GT(2, 1); } TESTCASE(c, ASSERT_GE) { ASSERT_GE(1, 1); ASSERT_GE(2, 1); } -TESTCASE(c, ASSERT_STREQ) { - ASSERT_STREQ("foo", "foo"); -} +TESTCASE(c, ASSERT_STREQ) { ASSERT_STREQ("foo", "foo"); } -TESTCASE(c, ASSERT_STRNE) { - ASSERT_STRNE("foo", "bar"); -} +TESTCASE(c, ASSERT_STRNE) { ASSERT_STRNE("foo", "bar"); } -TESTCASE(c, EXPECT_TRUE) { - EXPECT_TRUE(1); -} +TESTCASE(c, EXPECT_TRUE) { EXPECT_TRUE(1); } -TESTCASE(c, EXPECT_FALSE) { - EXPECT_FALSE(0); -} +TESTCASE(c, EXPECT_FALSE) { EXPECT_FALSE(0); } -TESTCASE(c, EXPECT_EQ) { - EXPECT_EQ(1, 1); -} +TESTCASE(c, EXPECT_EQ) { EXPECT_EQ(1, 1); } -TESTCASE(c, EXPECT_NE) { - EXPECT_NE(1, 2); -} +TESTCASE(c, EXPECT_NE) { EXPECT_NE(1, 2); } -TESTCASE(c, EXPECT_LT) { - EXPECT_LT(1, 2); -} +TESTCASE(c, EXPECT_LT) { EXPECT_LT(1, 2); } TESTCASE(c, EXPECT_LE) { EXPECT_LE(1, 1); EXPECT_LE(1, 2); } -TESTCASE(c, EXPECT_GT) { - EXPECT_GT(2, 1); -} +TESTCASE(c, EXPECT_GT) { EXPECT_GT(2, 1); } TESTCASE(c, EXPECT_GE) { EXPECT_GE(1, 1); EXPECT_GE(2, 1); } -TESTCASE(c, EXPECT_STREQ) { - EXPECT_STREQ("foo", "foo"); -} +TESTCASE(c, EXPECT_STREQ) { EXPECT_STREQ("foo", "foo"); } -TESTCASE(c, EXPECT_STRNE) { - EXPECT_STRNE("foo", "bar"); -} +TESTCASE(c, EXPECT_STRNE) { EXPECT_STRNE("foo", "bar"); } diff --git a/test/test.c b/test/test.c index 403511d..ac4330a 100644 --- a/test/test.c +++ b/test/test.c @@ -32,86 +32,54 @@ #pragma warning(disable : 4127) #endif -TESTCASE(c, ASSERT_TRUE) { - ASSERT_TRUE(1); -} +TESTCASE(c, ASSERT_TRUE) { ASSERT_TRUE(1); } -TESTCASE(c, ASSERT_FALSE) { - ASSERT_FALSE(0); -} +TESTCASE(c, ASSERT_FALSE) { ASSERT_FALSE(0); } -TESTCASE(c, ASSERT_EQ) { - ASSERT_EQ(1, 1); -} +TESTCASE(c, ASSERT_EQ) { ASSERT_EQ(1, 1); } -TESTCASE(c, ASSERT_NE) { - ASSERT_NE(1, 2); -} +TESTCASE(c, ASSERT_NE) { ASSERT_NE(1, 2); } -TESTCASE(c, ASSERT_LT) { - ASSERT_LT(1, 2); -} +TESTCASE(c, ASSERT_LT) { ASSERT_LT(1, 2); } TESTCASE(c, ASSERT_LE) { ASSERT_LE(1, 1); ASSERT_LE(1, 2); } -TESTCASE(c, ASSERT_GT) { - ASSERT_GT(2, 1); -} +TESTCASE(c, ASSERT_GT) { ASSERT_GT(2, 1); } TESTCASE(c, ASSERT_GE) { ASSERT_GE(1, 1); ASSERT_GE(2, 1); } -TESTCASE(c, ASSERT_STREQ) { - ASSERT_STREQ("foo", "foo"); -} +TESTCASE(c, ASSERT_STREQ) { ASSERT_STREQ("foo", "foo"); } -TESTCASE(c, ASSERT_STRNE) { - ASSERT_STRNE("foo", "bar"); -} +TESTCASE(c, ASSERT_STRNE) { ASSERT_STRNE("foo", "bar"); } -TESTCASE(c, EXPECT_TRUE) { - EXPECT_TRUE(1); -} +TESTCASE(c, EXPECT_TRUE) { EXPECT_TRUE(1); } -TESTCASE(c, EXPECT_FALSE) { - EXPECT_FALSE(0); -} +TESTCASE(c, EXPECT_FALSE) { EXPECT_FALSE(0); } -TESTCASE(c, EXPECT_EQ) { - EXPECT_EQ(1, 1); -} +TESTCASE(c, EXPECT_EQ) { EXPECT_EQ(1, 1); } -TESTCASE(c, EXPECT_NE) { - EXPECT_NE(1, 2); -} +TESTCASE(c, EXPECT_NE) { EXPECT_NE(1, 2); } -TESTCASE(c, EXPECT_LT) { - EXPECT_LT(1, 2); -} +TESTCASE(c, EXPECT_LT) { EXPECT_LT(1, 2); } TESTCASE(c, EXPECT_LE) { EXPECT_LE(1, 1); EXPECT_LE(1, 2); } -TESTCASE(c, EXPECT_GT) { - EXPECT_GT(2, 1); -} +TESTCASE(c, EXPECT_GT) { EXPECT_GT(2, 1); } TESTCASE(c, EXPECT_GE) { EXPECT_GE(1, 1); EXPECT_GE(2, 1); } -TESTCASE(c, EXPECT_STREQ) { - EXPECT_STREQ("foo", "foo"); -} +TESTCASE(c, EXPECT_STREQ) { EXPECT_STREQ("foo", "foo"); } -TESTCASE(c, EXPECT_STRNE) { - EXPECT_STRNE("foo", "bar"); -} +TESTCASE(c, EXPECT_STRNE) { EXPECT_STRNE("foo", "bar"); } diff --git a/test/test.cpp b/test/test.cpp index 43d291f..4d7ef3a 100644 --- a/test/test.cpp +++ b/test/test.cpp @@ -32,86 +32,54 @@ #pragma warning(disable : 4127) #endif -TESTCASE(cpp, ASSERT_TRUE) { - ASSERT_TRUE(1); -} +TESTCASE(cpp, ASSERT_TRUE) { ASSERT_TRUE(1); } -TESTCASE(cpp, ASSERT_FALSE) { - ASSERT_FALSE(0); -} +TESTCASE(cpp, ASSERT_FALSE) { ASSERT_FALSE(0); } -TESTCASE(cpp, ASSERT_EQ) { - ASSERT_EQ(1, 1); -} +TESTCASE(cpp, ASSERT_EQ) { ASSERT_EQ(1, 1); } -TESTCASE(cpp, ASSERT_NE) { - ASSERT_NE(1, 2); -} +TESTCASE(cpp, ASSERT_NE) { ASSERT_NE(1, 2); } -TESTCASE(cpp, ASSERT_LT) { - ASSERT_LT(1, 2); -} +TESTCASE(cpp, ASSERT_LT) { ASSERT_LT(1, 2); } TESTCASE(cpp, ASSERT_LE) { ASSERT_LE(1, 1); ASSERT_LE(1, 2); } -TESTCASE(cpp, ASSERT_GT) { - ASSERT_GT(2, 1); -} +TESTCASE(cpp, ASSERT_GT) { ASSERT_GT(2, 1); } TESTCASE(cpp, ASSERT_GE) { ASSERT_GE(1, 1); ASSERT_GE(2, 1); } -TESTCASE(c, ASSERT_STREQ) { - ASSERT_STREQ("foo", "foo"); -} +TESTCASE(c, ASSERT_STREQ) { ASSERT_STREQ("foo", "foo"); } -TESTCASE(c, ASSERT_STRNE) { - ASSERT_STRNE("foo", "bar"); -} +TESTCASE(c, ASSERT_STRNE) { ASSERT_STRNE("foo", "bar"); } -TESTCASE(cpp, EXPECT_TRUE) { - EXPECT_TRUE(1); -} +TESTCASE(cpp, EXPECT_TRUE) { EXPECT_TRUE(1); } -TESTCASE(cpp, EXPECT_FALSE) { - EXPECT_FALSE(0); -} +TESTCASE(cpp, EXPECT_FALSE) { EXPECT_FALSE(0); } -TESTCASE(cpp, EXPECT_EQ) { - EXPECT_EQ(1, 1); -} +TESTCASE(cpp, EXPECT_EQ) { EXPECT_EQ(1, 1); } -TESTCASE(cpp, EXPECT_NE) { - EXPECT_NE(1, 2); -} +TESTCASE(cpp, EXPECT_NE) { EXPECT_NE(1, 2); } -TESTCASE(cpp, EXPECT_LT) { - EXPECT_LT(1, 2); -} +TESTCASE(cpp, EXPECT_LT) { EXPECT_LT(1, 2); } TESTCASE(cpp, EXPECT_LE) { EXPECT_LE(1, 1); EXPECT_LE(1, 2); } -TESTCASE(cpp, EXPECT_GT) { - EXPECT_GT(2, 1); -} +TESTCASE(cpp, EXPECT_GT) { EXPECT_GT(2, 1); } TESTCASE(cpp, EXPECT_GE) { EXPECT_GE(1, 1); EXPECT_GE(2, 1); } -TESTCASE(c, EXPECT_STREQ) { - EXPECT_STREQ("foo", "foo"); -} +TESTCASE(c, EXPECT_STREQ) { EXPECT_STREQ("foo", "foo"); } -TESTCASE(c, EXPECT_STRNE) { - EXPECT_STRNE("foo", "bar"); -} +TESTCASE(c, EXPECT_STRNE) { EXPECT_STRNE("foo", "bar"); } diff --git a/test/test.c b/test/test.c index 403511d..ac4330a 100644 --- a/test/test.c +++ b/test/test.c @@ -32,86 +32,54 @@ #pragma warning(disable : 4127) #endif -TESTCASE(c, ASSERT_TRUE) { - ASSERT_TRUE(1); -} +TESTCASE(c, ASSERT_TRUE) { ASSERT_TRUE(1); } -TESTCASE(c, ASSERT_FALSE) { - ASSERT_FALSE(0); -} +TESTCASE(c, ASSERT_FALSE) { ASSERT_FALSE(0); } -TESTCASE(c, ASSERT_EQ) { - ASSERT_EQ(1, 1); -} +TESTCASE(c, ASSERT_EQ) { ASSERT_EQ(1, 1); } -TESTCASE(c, ASSERT_NE) { - ASSERT_NE(1, 2); -} +TESTCASE(c, ASSERT_NE) { ASSERT_NE(1, 2); } -TESTCASE(c, ASSERT_LT) { - ASSERT_LT(1, 2); -} +TESTCASE(c, ASSERT_LT) { ASSERT_LT(1, 2); } TESTCASE(c, ASSERT_LE) { ASSERT_LE(1, 1); ASSERT_LE(1, 2); } -TESTCASE(c, ASSERT_GT) { - ASSERT_GT(2, 1); -} +TESTCASE(c, ASSERT_GT) { ASSERT_GT(2, 1); } TESTCASE(c, ASSERT_GE) { ASSERT_GE(1, 1); ASSERT_GE(2, 1); } -TESTCASE(c, ASSERT_STREQ) { - ASSERT_STREQ("foo", "foo"); -} +TESTCASE(c, ASSERT_STREQ) { ASSERT_STREQ("foo", "foo"); } -TESTCASE(c, ASSERT_STRNE) { - ASSERT_STRNE("foo", "bar"); -} +TESTCASE(c, ASSERT_STRNE) { ASSERT_STRNE("foo", "bar"); } -TESTCASE(c, EXPECT_TRUE) { - EXPECT_TRUE(1); -} +TESTCASE(c, EXPECT_TRUE) { EXPECT_TRUE(1); } -TESTCASE(c, EXPECT_FALSE) { - EXPECT_FALSE(0); -} +TESTCASE(c, EXPECT_FALSE) { EXPECT_FALSE(0); } -TESTCASE(c, EXPECT_EQ) { - EXPECT_EQ(1, 1); -} +TESTCASE(c, EXPECT_EQ) { EXPECT_EQ(1, 1); } -TESTCASE(c, EXPECT_NE) { - EXPECT_NE(1, 2); -} +TESTCASE(c, EXPECT_NE) { EXPECT_NE(1, 2); } -TESTCASE(c, EXPECT_LT) { - EXPECT_LT(1, 2); -} +TESTCASE(c, EXPECT_LT) { EXPECT_LT(1, 2); } TESTCASE(c, EXPECT_LE) { EXPECT_LE(1, 1); EXPECT_LE(1, 2); } -TESTCASE(c, EXPECT_GT) { - EXPECT_GT(2, 1); -} +TESTCASE(c, EXPECT_GT) { EXPECT_GT(2, 1); } TESTCASE(c, EXPECT_GE) { EXPECT_GE(1, 1); EXPECT_GE(2, 1); } -TESTCASE(c, EXPECT_STREQ) { - EXPECT_STREQ("foo", "foo"); -} +TESTCASE(c, EXPECT_STREQ) { EXPECT_STREQ("foo", "foo"); } -TESTCASE(c, EXPECT_STRNE) { - EXPECT_STRNE("foo", "bar"); -} +TESTCASE(c, EXPECT_STRNE) { EXPECT_STRNE("foo", "bar"); } diff --git a/test/test.cpp b/test/test.cpp index 43d291f..4d7ef3a 100644 --- a/test/test.cpp +++ b/test/test.cpp @@ -32,86 +32,54 @@ #pragma warning(disable : 4127) #endif -TESTCASE(cpp, ASSERT_TRUE) { - ASSERT_TRUE(1); -} +TESTCASE(cpp, ASSERT_TRUE) { ASSERT_TRUE(1); } -TESTCASE(cpp, ASSERT_FALSE) { - ASSERT_FALSE(0); -} +TESTCASE(cpp, ASSERT_FALSE) { ASSERT_FALSE(0); } -TESTCASE(cpp, ASSERT_EQ) { - ASSERT_EQ(1, 1); -} +TESTCASE(cpp, ASSERT_EQ) { ASSERT_EQ(1, 1); } -TESTCASE(cpp, ASSERT_NE) { - ASSERT_NE(1, 2); -} +TESTCASE(cpp, ASSERT_NE) { ASSERT_NE(1, 2); } -TESTCASE(cpp, ASSERT_LT) { - ASSERT_LT(1, 2); -} +TESTCASE(cpp, ASSERT_LT) { ASSERT_LT(1, 2); } TESTCASE(cpp, ASSERT_LE) { ASSERT_LE(1, 1); ASSERT_LE(1, 2); } -TESTCASE(cpp, ASSERT_GT) { - ASSERT_GT(2, 1); -} +TESTCASE(cpp, ASSERT_GT) { ASSERT_GT(2, 1); } TESTCASE(cpp, ASSERT_GE) { ASSERT_GE(1, 1); ASSERT_GE(2, 1); } -TESTCASE(c, ASSERT_STREQ) { - ASSERT_STREQ("foo", "foo"); -} +TESTCASE(c, ASSERT_STREQ) { ASSERT_STREQ("foo", "foo"); } -TESTCASE(c, ASSERT_STRNE) { - ASSERT_STRNE("foo", "bar"); -} +TESTCASE(c, ASSERT_STRNE) { ASSERT_STRNE("foo", "bar"); } -TESTCASE(cpp, EXPECT_TRUE) { - EXPECT_TRUE(1); -} +TESTCASE(cpp, EXPECT_TRUE) { EXPECT_TRUE(1); } -TESTCASE(cpp, EXPECT_FALSE) { - EXPECT_FALSE(0); -} +TESTCASE(cpp, EXPECT_FALSE) { EXPECT_FALSE(0); } -TESTCASE(cpp, EXPECT_EQ) { - EXPECT_EQ(1, 1); -} +TESTCASE(cpp, EXPECT_EQ) { EXPECT_EQ(1, 1); } -TESTCASE(cpp, EXPECT_NE) { - EXPECT_NE(1, 2); -} +TESTCASE(cpp, EXPECT_NE) { EXPECT_NE(1, 2); } -TESTCASE(cpp, EXPECT_LT) { - EXPECT_LT(1, 2); -} +TESTCASE(cpp, EXPECT_LT) { EXPECT_LT(1, 2); } TESTCASE(cpp, EXPECT_LE) { EXPECT_LE(1, 1); EXPECT_LE(1, 2); } -TESTCASE(cpp, EXPECT_GT) { - EXPECT_GT(2, 1); -} +TESTCASE(cpp, EXPECT_GT) { EXPECT_GT(2, 1); } TESTCASE(cpp, EXPECT_GE) { EXPECT_GE(1, 1); EXPECT_GE(2, 1); } -TESTCASE(c, EXPECT_STREQ) { - EXPECT_STREQ("foo", "foo"); -} +TESTCASE(c, EXPECT_STREQ) { EXPECT_STREQ("foo", "foo"); } -TESTCASE(c, EXPECT_STRNE) { - EXPECT_STRNE("foo", "bar"); -} +TESTCASE(c, EXPECT_STRNE) { EXPECT_STRNE("foo", "bar"); } diff --git a/utest.h b/utest.h index d562f9e..af41909 100644 --- a/utest.h +++ b/utest.h @@ -206,7 +206,8 @@ } UTEST_WEAK UTEST_OVERLOADABLE void utest_type_printer(long long unsigned int i); -UTEST_WEAK UTEST_OVERLOADABLE void utest_type_printer(long long unsigned int i) { +UTEST_WEAK UTEST_OVERLOADABLE void +utest_type_printer(long long unsigned int i) { printf("%llu", i); } #endif @@ -217,26 +218,26 @@ #endif #define UTEST_EXPECT(x, y, cond) \ -if (!((x)cond(y))) { \ - printf("%s:%u: Failure\n", __FILE__, __LINE__); \ - *utest_result = 1; \ -} + if (!((x)cond(y))) { \ + printf("%s:%u: Failure\n", __FILE__, __LINE__); \ + *utest_result = 1; \ + } #define EXPECT_TRUE(x) \ -if (!(x)) { \ - printf("%s:%u: Failure\n", __FILE__, __LINE__); \ - printf(" Expected : true\n"); \ - printf(" Actual : %s\n", (x) ? "true" : "false"); \ - *utest_result = 1; \ -} + if (!(x)) { \ + printf("%s:%u: Failure\n", __FILE__, __LINE__); \ + printf(" Expected : true\n"); \ + printf(" Actual : %s\n", (x) ? "true" : "false"); \ + *utest_result = 1; \ + } #define EXPECT_FALSE(x) \ -if (x) { \ - printf("%s:%u: Failure\n", __FILE__, __LINE__); \ - printf(" Expected : false\n"); \ - printf(" Actual : %s\n", (x) ? "true" : "false"); \ - *utest_result = 1; \ -} + if (x) { \ + printf("%s:%u: Failure\n", __FILE__, __LINE__); \ + printf(" Expected : false\n"); \ + printf(" Actual : %s\n", (x) ? "true" : "false"); \ + *utest_result = 1; \ + } #define EXPECT_EQ(x, y) UTEST_EXPECT(x, y, == ) #define EXPECT_NE(x, y) UTEST_EXPECT(x, y, != ) @@ -246,20 +247,20 @@ #define EXPECT_GE(x, y) UTEST_EXPECT(x, y, >= ) #define EXPECT_STREQ(x, y) \ -if (0 != strcmp(x, y)) { \ - printf("%s:%u: Failure\n", __FILE__, __LINE__); \ - printf(" Expected : \"%s\"\n", x); \ - printf(" Actual : \"%s\"\n", y); \ - *utest_result = 1; \ -} + if (0 != strcmp(x, y)) { \ + printf("%s:%u: Failure\n", __FILE__, __LINE__); \ + printf(" Expected : \"%s\"\n", x); \ + printf(" Actual : \"%s\"\n", y); \ + *utest_result = 1; \ + } #define EXPECT_STRNE(x, y) \ -if (0 == strcmp(x, y)) { \ - printf("%s:%u: Failure\n", __FILE__, __LINE__); \ - printf(" Expected : \"%s\"\n", x); \ - printf(" Actual : \"%s\"\n", y); \ - *utest_result = 1; \ -} + if (0 == strcmp(x, y)) { \ + printf("%s:%u: Failure\n", __FILE__, __LINE__); \ + printf(" Expected : \"%s\"\n", x); \ + printf(" Actual : \"%s\"\n", y); \ + *utest_result = 1; \ + } #define UTEST_ASSERT(x, y, cond) \ UTEST_EXPECT(x, y, cond); \ @@ -318,14 +319,15 @@ // extern to the global state utest needs to execute UTEST_EXTERN struct utest_state_s utest_state; -UTEST_WEAK int utest_main(int argc, const char* const argv[]); -UTEST_WEAK int utest_main(int argc, const char* const argv[]) { +UTEST_WEAK int utest_main(int argc, const char *const argv[]); +UTEST_WEAK int utest_main(int argc, const char *const argv[]) { size_t failed = 0; size_t index = 0; size_t *failed_testcases = 0; size_t failed_testcases_length = 0; - (void)argc; (void)argv; + (void)argc; + (void)argv; printf("\033[32m[==========]\033[0m Running %" UTEST_PRIu64 " test cases.\n", UTEST_CAST(uint64_t, utest_state.testcases_length)); for (index = 0; index < utest_state.testcases_length; index++) { @@ -338,8 +340,9 @@ ns = utest_ns() - ns; if (0 != result) { const size_t failed_testcase_index = failed_testcases_length++; - failed_testcases = UTEST_PTR_CAST(size_t*, realloc(UTEST_PTR_CAST(void *, - failed_testcases), sizeof(size_t) * failed_testcases_length)); + failed_testcases = UTEST_PTR_CAST( + size_t *, realloc(UTEST_PTR_CAST(void *, failed_testcases), + sizeof(size_t) * failed_testcases_length)); failed_testcases[failed_testcase_index] = index; failed++; printf("\033[31m[ FAILED ]\033[0m %s (%" UTEST_PRId64 "ns)\n", @@ -354,7 +357,8 @@ printf("\033[32m[ PASSED ]\033[0m %" UTEST_PRIu64 " tests.\n", UTEST_CAST(uint64_t, utest_state.testcases_length - failed)); if (0 != failed) { - printf("\033[31m[ FAILED ]\033[0m %" UTEST_PRIu64 " tests, listed below:\n", + printf("\033[31m[ FAILED ]\033[0m %" UTEST_PRIu64 + " tests, listed below:\n", UTEST_CAST(uint64_t, failed)); for (index = 0; index < failed_testcases_length; index++) { printf("\033[31m[ FAILED ]\033[0m %s\n", @@ -380,7 +384,7 @@ // utest requires. #define UTEST_MAIN() \ UTEST_STATE(); \ - int main(int argc, const char* const argv[]) { \ + int main(int argc, const char *const argv[]) { \ return utest_main(argc, argv); \ }