diff --git a/dqn_tester.h b/dqn_tester.h index af86259..45f992a 100644 --- a/dqn_tester.h +++ b/dqn_tester.h @@ -69,13 +69,15 @@ bool all_clear = (test)->num_tests_ok_in_group == (test)->num_tests_in_group; \ fprintf(stdout, \ "%s\n %02d/%02d tests passed -- %s\n\n" DQN_TESTER_COLOR_RESET, \ - all_clear ? DQN_TESTER_GOOD_COLOR : DQN_TESTER_BAD_COLOR, \ + all_clear ? DQN_TESTER_GOOD_COLOR : DQN_TESTER_BAD_COLOR, \ (test)->num_tests_ok_in_group, \ (test)->num_tests_in_group, \ all_clear ? "OK" : "FAILED"); \ } while (0) -#define DQN_TESTER_ASSERT(test, expr, fmt, ...) DQN_TESTER_ASSERT_AT((test), __FILE__, __LINE__, expr, fmt, ## __VA_ARGS__) +#define DQN_TESTER_ASSERTF(test, expr, fmt, ...) DQN_TESTER_ASSERTF_AT((test), __FILE__, __LINE__, (expr), fmt, ## __VA_ARGS__) + +#define DQN_TESTER_ASSERT(test, expr) DQN_TESTER_ASSERT_AT((test), __FILE__, __LINE__, (expr)) #define DQN_TESTER_LOG(test, fmt, ...) \ do \ @@ -84,7 +86,7 @@ fprintf(stdout, "%*s" fmt "\n", DQN_TESTER_SPACING * 2, "", ##__VA_ARGS__); \ } while (0) -#define DQN_TESTER_ASSERT_AT(test, file, line, expr, fmt, ...) \ +#define DQN_TESTER_ASSERTF_AT(test, file, line, expr, fmt, ...) \ do \ { \ if (!(expr)) \ @@ -107,6 +109,25 @@ } \ } while (0) +#define DQN_TESTER_ASSERT_AT(test, file, line, expr) \ + do \ + { \ + if (!(expr)) \ + { \ + if ((test)->log_count++ == 0) fprintf(stdout, "\n"); \ + (test)->failed = true; \ + fprintf(stderr, \ + "%*sFile: %s:%d\n" \ + "%*sExpression: [" #expr "]\n", \ + DQN_TESTER_SPACING * 2, \ + "", \ + file, \ + line, \ + DQN_TESTER_SPACING * 2, \ + ""); \ + } \ + } while (0) + // ----------------------------------------------------------------------------- // NOTE: Header // ----------------------------------------------------------------------------- diff --git a/dqn_tests.cpp b/dqn_tests.cpp index f18b44b..04be5a7 100644 --- a/dqn_tests.cpp +++ b/dqn_tests.cpp @@ -4,7 +4,6 @@ /* #define DQN_TEST_WITH_MAIN Define this to enable the main function and allow standalone compiling and running of the file. -#define DQN_TEST_NO_COLORS Define this to disable any ANSI terminal color codes from output */ #if defined(DQN_TEST_WITH_MAIN) @@ -26,452 +25,388 @@ #include "dqn_tests_helpers.cpp" -#if defined(DQN_TEST_NO_COLORS) - #define DQN_TEST_COLOR_RED - #define DQN_TEST_COLOR_GREEN - #define DQN_TEST_COLOR_YELLOW - #define DQN_TEST_COLOR_BLUE - #define DQN_TEST_COLOR_MAGENTA - #define DQN_TEST_COLOR_CYAN - #define DQN_TEST_COLOR_RESET -#else - #define DQN_TEST_COLOR_RED "\x1b[31m" - #define DQN_TEST_COLOR_GREEN "\x1b[32m" - #define DQN_TEST_COLOR_YELLOW "\x1b[33m" - #define DQN_TEST_COLOR_BLUE "\x1b[34m" - #define DQN_TEST_COLOR_MAGENTA "\x1b[35m" - #define DQN_TEST_COLOR_CYAN "\x1b[36m" - #define DQN_TEST_COLOR_RESET "\x1b[0m" -#endif +#define DQN_TESTER_IMPLEMENTATION +#include "dqn_tester.h" -#define DQN_TEST_GROUP(test, fmt, ...) \ - fprintf(stdout, fmt "\n", ##__VA_ARGS__); \ - DQN_DEFER \ - { \ - bool all_clear = test.num_tests_ok_in_group == test.num_tests_in_group; \ - fprintf(stdout, \ - "%s\n %02d/%02d tests passed -- %s\n\n" DQN_TEST_COLOR_RESET, \ - all_clear ? DQN_TEST_COLOR_GREEN : DQN_TEST_COLOR_RED, \ - test.num_tests_ok_in_group, \ - test.num_tests_in_group, \ - all_clear ? "OK" : "FAILED"); \ - } - -#define DQN_TEST(test, fmt, ...) \ - Dqn_TestBegin(&test, fmt, ##__VA_ARGS__); \ - DQN_DEFER \ - { \ - if (!test.failed) \ - { \ - fprintf(stdout, DQN_TEST_COLOR_GREEN " OK" DQN_TEST_COLOR_RESET "\n"); \ - test.num_tests_ok_in_group++; \ - } \ - }; - -#define DQN_TEST_ASSERT_MSG(test, expr, fmt, ...) \ - do \ - { \ - if (!(expr)) \ - { \ - if (!test.failed) \ - { \ - fprintf(stdout, DQN_TEST_COLOR_RED " FAILED" DQN_TEST_COLOR_RESET "\n"); \ - test.failed = true; \ - } \ - \ - fprintf(stderr, \ - " File: %s:%d\n" \ - " Expression: [" #expr "]\n" \ - " Reason: " fmt "\n\n", \ - __FILE__, \ - __LINE__, \ - ##__VA_ARGS__); \ - } \ - } while (0) - -#define DQN_TEST_ASSERT(test, expr) DQN_TEST_ASSERT_MSG(test, expr, "") - -struct Dqn_Test +Dqn_Tester Dqn_Test_Array() { - int num_tests_in_group; - int num_tests_ok_in_group; - int failed; -}; - -void Dqn_TestBegin(Dqn_Test *state, char const *fmt, ...) -{ - state->num_tests_in_group++; - state->failed = false; - - va_list args; - va_start(args, fmt); - - int size_required = 0; - { - va_list args_copy; - va_copy(args_copy, args); - size_required = vsnprintf(nullptr, 0, fmt, args_copy); - va_end(args_copy); - } - - printf(" "); - vprintf(fmt, args); - int const PAD_LENGTH = 90; - for (int pad = size_required; pad < PAD_LENGTH; pad++) - putc('.', stdout); - - va_end(args); -} - -Dqn_Test Dqn_Test_Array() -{ - Dqn_Test test = {}; - DQN_TEST_GROUP(test, "Dqn_Array"); + Dqn_Tester test = {}; + DQN_TESTER_BEGIN_GROUP("Dqn_Array"); // NOTE: Dqn_ArrayInitWithMemory { { - DQN_TEST(test, "Fixed Memory: Test add single item and can't allocate more"); + Dqn_TesterBegin(&test, "Fixed Memory: Test add single item and can't allocate more"); int memory[4] = {}; Dqn_Array array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/); Dqn_ArrayAdd(&array, 1); Dqn_ArrayAdd(&array, 2); Dqn_ArrayAdd(&array, 3); Dqn_ArrayAdd(&array, 4); - DQN_TEST_ASSERT_MSG(test, array.data[0] == 1, "array.data %d", array.data[0]); - DQN_TEST_ASSERT_MSG(test, array.data[1] == 2, "array.data %d", array.data[1]); - DQN_TEST_ASSERT_MSG(test, array.data[2] == 3, "array.data %d", array.data[2]); - DQN_TEST_ASSERT_MSG(test, array.data[3] == 4, "array.data %d", array.data[3]); - DQN_TEST_ASSERT_MSG(test, array.size == 4, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.data[0] == 1, "array.data %d", array.data[0]); + DQN_TESTER_ASSERTF(&test, array.data[1] == 2, "array.data %d", array.data[1]); + DQN_TESTER_ASSERTF(&test, array.data[2] == 3, "array.data %d", array.data[2]); + DQN_TESTER_ASSERTF(&test, array.data[3] == 4, "array.data %d", array.data[3]); + DQN_TESTER_ASSERTF(&test, array.size == 4, "array.size: %zu", array.size); int *added_item = Dqn_ArrayAdd(&array, 5); - DQN_TEST_ASSERT(test, added_item == nullptr); - DQN_TEST_ASSERT_MSG(test, array.size == 4, "array.size: %zu", array.size); - DQN_TEST_ASSERT_MSG(test, array.max == 4, "array.max: %zu", array.max); + DQN_TESTER_ASSERTF(&test, added_item == nullptr, "Failed to add item to array"); + DQN_TESTER_ASSERTF(&test, array.size == 4, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.max == 4, "array.max: %zu", array.max); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Fixed Memory: Test add array of items"); + Dqn_TesterBegin(&test, "Fixed Memory: Test add array of items"); int memory[4] = {}; int DATA[] = {1, 2, 3}; Dqn_Array array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/); Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA)); - DQN_TEST_ASSERT_MSG(test, array.data[0] == 1, "array.data %d", array.data[0]); - DQN_TEST_ASSERT_MSG(test, array.data[1] == 2, "array.data %d", array.data[1]); - DQN_TEST_ASSERT_MSG(test, array.data[2] == 3, "array.data %d", array.data[2]); - DQN_TEST_ASSERT_MSG(test, array.size == 3, "array.size: %zu", array.size); - DQN_TEST_ASSERT_MSG(test, array.max == 4, "array.max: %zu", array.max); + DQN_TESTER_ASSERTF(&test, array.data[0] == 1, "array.data %d", array.data[0]); + DQN_TESTER_ASSERTF(&test, array.data[1] == 2, "array.data %d", array.data[1]); + DQN_TESTER_ASSERTF(&test, array.data[2] == 3, "array.data %d", array.data[2]); + DQN_TESTER_ASSERTF(&test, array.size == 3, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.max == 4, "array.max: %zu", array.max); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Fixed Memory: Test clear and clear with memory zeroed"); + Dqn_TesterBegin(&test, "Fixed Memory: Test clear and clear with memory zeroed"); int memory[4] = {}; int DATA[] = {1, 2, 3}; Dqn_Array array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/); Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA)); Dqn_ArrayClear(&array, Dqn_ZeroMem::No); - DQN_TEST_ASSERT_MSG(test, array.size == 0, "array.size: %zu", array.size); - DQN_TEST_ASSERT_MSG(test, array.max == 4, "array.max: %zu", array.max); - DQN_TEST_ASSERT_MSG(test, array.data[0] == 1, "array.data %d. Clear but don't zero memory so old values should still remain", array.data[0]); + DQN_TESTER_ASSERTF(&test, array.size == 0, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.max == 4, "array.max: %zu", array.max); + DQN_TESTER_ASSERTF(&test, array.data[0] == 1, "array.data %d. Clear but don't zero memory so old values should still remain", array.data[0]); Dqn_ArrayClear(&array, Dqn_ZeroMem::Yes); - DQN_TEST_ASSERT_MSG(test, array.data[0] == 0, "array.data %d. Clear but zero memory old values should not remain", array.data[0]); + DQN_TESTER_ASSERTF(&test, array.data[0] == 0, "array.data %d. Clear but zero memory old values should not remain", array.data[0]); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Fixed Memory: Test erase stable and erase unstable"); + Dqn_TesterBegin(&test, "Fixed Memory: Test erase stable and erase unstable"); int memory[4] = {}; int DATA[] = {1, 2, 3, 4}; Dqn_Array array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/); Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA)); Dqn_ArrayEraseUnstable(&array, 1); - DQN_TEST_ASSERT_MSG(test, array.data[0] == 1, "array.data %d", array.data[0]); - DQN_TEST_ASSERT_MSG(test, array.data[1] == 4, "array.data %d", array.data[1]); - DQN_TEST_ASSERT_MSG(test, array.data[2] == 3, "array.data %d", array.data[2]); - DQN_TEST_ASSERT_MSG(test, array.size == 3, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.data[0] == 1, "array.data %d", array.data[0]); + DQN_TESTER_ASSERTF(&test, array.data[1] == 4, "array.data %d", array.data[1]); + DQN_TESTER_ASSERTF(&test, array.data[2] == 3, "array.data %d", array.data[2]); + DQN_TESTER_ASSERTF(&test, array.size == 3, "array.size: %zu", array.size); Dqn_ArrayEraseStable(&array, 0); - DQN_TEST_ASSERT_MSG(test, array.data[0] == 4, "array.data: %d", array.data[0]); - DQN_TEST_ASSERT_MSG(test, array.data[1] == 3, "array.data: %d", array.data[1]); - DQN_TEST_ASSERT_MSG(test, array.size == 2, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.data[0] == 4, "array.data: %d", array.data[0]); + DQN_TESTER_ASSERTF(&test, array.data[1] == 3, "array.data: %d", array.data[1]); + DQN_TESTER_ASSERTF(&test, array.size == 2, "array.size: %zu", array.size); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Fixed Memory: Test array pop and peek"); + Dqn_TesterBegin(&test, "Fixed Memory: Test array pop and peek"); int memory[4] = {}; int DATA[] = {1, 2, 3}; Dqn_Array array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/); Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA)); Dqn_ArrayPop(&array, 2); - DQN_TEST_ASSERT_MSG(test, array.data[0] == 1, "array.data: %d", array.data[0]); - DQN_TEST_ASSERT_MSG(test, array.size == 1, "array.size: %zu", array.size); - DQN_TEST_ASSERT_MSG(test, array.max == 4, "array.max: %zu", array.max); + DQN_TESTER_ASSERTF(&test, array.data[0] == 1, "array.data: %d", array.data[0]); + DQN_TESTER_ASSERTF(&test, array.size == 1, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.max == 4, "array.max: %zu", array.max); int *peek_item = Dqn_ArrayPeek(&array); - DQN_TEST_ASSERT_MSG(test, *peek_item == 1, "peek: %d", *peek_item); - DQN_TEST_ASSERT_MSG(test, array.size == 1, "array.size: %zu", array.size); - DQN_TEST_ASSERT_MSG(test, array.max == 4, "array.max: %zu", array.max); + DQN_TESTER_ASSERTF(&test, *peek_item == 1, "peek: %d", *peek_item); + DQN_TESTER_ASSERTF(&test, array.size == 1, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.max == 4, "array.max: %zu", array.max); + Dqn_TesterEnd(&test); } } // NOTE: Dynamic Memory: Dqn_Array { - DQN_TEST(test, "Dynamic Memory: Reserve and check over commit reallocates"); + Dqn_TesterBegin(&test, "Dynamic Memory: Reserve and check over commit reallocates"); Dqn_Arena arena = {}; Dqn_Array array = {}; array.arena = &arena; Dqn_ArrayReserve(&array, 4); - DQN_TEST_ASSERT_MSG(test, array.size == 0, "array.size: %zu", array.size); - DQN_TEST_ASSERT_MSG(test, array.max == 4, "array.max: %zu", array.max); + DQN_TESTER_ASSERTF(&test, array.size == 0, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.max == 4, "array.max: %zu", array.max); int DATA[] = {1, 2, 3, 4}; Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA)); - DQN_TEST_ASSERT_MSG(test, array.data[0] == 1, "array.data: %d", array.data[0]); - DQN_TEST_ASSERT_MSG(test, array.data[1] == 2, "array.data: %d", array.data[1]); - DQN_TEST_ASSERT_MSG(test, array.data[2] == 3, "array.data: %d", array.data[2]); - DQN_TEST_ASSERT_MSG(test, array.data[3] == 4, "array.data: %d", array.data[3]); - DQN_TEST_ASSERT_MSG(test, array.size == 4, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.data[0] == 1, "array.data: %d", array.data[0]); + DQN_TESTER_ASSERTF(&test, array.data[1] == 2, "array.data: %d", array.data[1]); + DQN_TESTER_ASSERTF(&test, array.data[2] == 3, "array.data: %d", array.data[2]); + DQN_TESTER_ASSERTF(&test, array.data[3] == 4, "array.data: %d", array.data[3]); + DQN_TESTER_ASSERTF(&test, array.size == 4, "array.size: %zu", array.size); int *added_item = Dqn_ArrayAdd(&array, 5); - DQN_TEST_ASSERT_MSG(test, *added_item == 5, "added_item: %d", *added_item); - DQN_TEST_ASSERT_MSG(test, array.data[4] == 5, "array.data: %d", array.data[4]); - DQN_TEST_ASSERT_MSG(test, array.size == 5, "array.size: %zu", array.size); - DQN_TEST_ASSERT_MSG(test, array.max >= 5, "array.max: %zu", array.max); + DQN_TESTER_ASSERTF(&test, *added_item == 5, "added_item: %d", *added_item); + DQN_TESTER_ASSERTF(&test, array.data[4] == 5, "array.data: %d", array.data[4]); + DQN_TESTER_ASSERTF(&test, array.size == 5, "array.size: %zu", array.size); + DQN_TESTER_ASSERTF(&test, array.max >= 5, "array.max: %zu", array.max); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } + + DQN_TESTER_END_GROUP(&test); return test; } -Dqn_Test Dqn_Test_File() +Dqn_Tester Dqn_Test_File() { - Dqn_Test test = {}; - DQN_TEST_GROUP(test, "Dqn_File"); + Dqn_Tester test = {}; + DQN_TESTER_BEGIN_GROUP("Dqn_File"); { Dqn_Arena arena = {}; - DQN_TEST(test, "Make directory recursive \"abcd/efgh\""); - Dqn_b32 success = Dqn_FileMakeDir(DQN_STRING("abcd/efgh"), &arena); - DQN_TEST_ASSERT(test, success); - DQN_TEST_ASSERT(test, Dqn_FileDirExists(DQN_STRING("abcd"))); - DQN_TEST_ASSERT(test, Dqn_FileDirExists(DQN_STRING("abcd/efgh"))); - DQN_TEST_ASSERT_MSG(test, Dqn_FileExists(DQN_STRING("abcd")) == false, "This function should only return true for files"); - DQN_TEST_ASSERT_MSG(test, Dqn_FileExists(DQN_STRING("abcd/efgh")) == false, "This function should only return true for files"); - - DQN_TEST_ASSERT(test, Dqn_FileDelete(DQN_STRING("abcd/efgh"))); - DQN_TEST_ASSERT_MSG(test, Dqn_FileDelete(DQN_STRING("abcd")), "Failed to cleanup directory"); + Dqn_TesterBegin(&test, "Make directory recursive \"abcd/efgh\""); + DQN_TESTER_ASSERTF(&test, Dqn_FileMakeDir(DQN_STRING("abcd/efgh"), &arena), "Failed to make directory"); + DQN_TESTER_ASSERTF(&test, Dqn_FileDirExists(DQN_STRING("abcd")), "Directory was not made"); + DQN_TESTER_ASSERTF(&test, Dqn_FileDirExists(DQN_STRING("abcd/efgh")), "Subdirectory was not made"); + DQN_TESTER_ASSERTF(&test, Dqn_FileExists(DQN_STRING("abcd")) == false, "This function should only return true for files"); + DQN_TESTER_ASSERTF(&test, Dqn_FileExists(DQN_STRING("abcd/efgh")) == false, "This function should only return true for files"); + DQN_TESTER_ASSERTF(&test, Dqn_FileDelete(DQN_STRING("abcd/efgh")), "Failed to delete directory"); + DQN_TESTER_ASSERTF(&test, Dqn_FileDelete(DQN_STRING("abcd")), "Failed to cleanup directory"); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { // NOTE: Write step Dqn_String const SRC_FILE = DQN_STRING("dqn_test_file"); - DQN_TEST(test, "Write file, read it, copy it, move it and delete it"); + Dqn_TesterBegin(&test, "Write file, read it, copy it, move it and delete it"); Dqn_b32 write_result = Dqn_FileWriteFile(SRC_FILE.str, SRC_FILE.size, "test", 4); - DQN_TEST_ASSERT(test, write_result); - DQN_TEST_ASSERT(test, Dqn_FileExists(SRC_FILE)); + DQN_TESTER_ASSERT(&test, write_result); + DQN_TESTER_ASSERT(&test, Dqn_FileExists(SRC_FILE)); // NOTE: Read step Dqn_Arena arena = {}; Dqn_String read_file = Dqn_FileArenaReadToString(SRC_FILE.str, SRC_FILE.size, &arena); - DQN_TEST_ASSERT(test, Dqn_StringIsValid(read_file)); - DQN_TEST_ASSERT(test, read_file.size == 4); - DQN_TEST_ASSERT_MSG(test, Dqn_StringEq(read_file, DQN_STRING("test")), "read(%zu): %.*s", read_file.size, DQN_STRING_FMT(read_file)); + DQN_TESTER_ASSERTF(&test, Dqn_StringIsValid(read_file), "Failed to load file"); + DQN_TESTER_ASSERTF(&test, read_file.size == 4, "File read wrong amount of bytes"); + DQN_TESTER_ASSERTF(&test, Dqn_StringEq(read_file, DQN_STRING("test")), "read(%zu): %.*s", read_file.size, DQN_STRING_FMT(read_file)); // NOTE: Copy step Dqn_String const COPY_FILE = DQN_STRING("dqn_test_file_copy"); Dqn_b32 copy_result = Dqn_FileCopy(SRC_FILE, COPY_FILE, true /*overwrite*/); - DQN_TEST_ASSERT(test, copy_result); - DQN_TEST_ASSERT(test, Dqn_FileExists(COPY_FILE)); + DQN_TESTER_ASSERT(&test, copy_result); + DQN_TESTER_ASSERT(&test, Dqn_FileExists(COPY_FILE)); // NOTE: Move step Dqn_String const MOVE_FILE = DQN_STRING("dqn_test_file_move"); Dqn_b32 move_result = Dqn_FileMove(COPY_FILE, MOVE_FILE, true /*overwrite*/); - DQN_TEST_ASSERT(test, move_result); - DQN_TEST_ASSERT(test, Dqn_FileExists(MOVE_FILE)); - DQN_TEST_ASSERT_MSG(test, Dqn_FileExists(COPY_FILE) == false, "Moving a file should remove the original"); + DQN_TESTER_ASSERT(&test, move_result); + DQN_TESTER_ASSERT(&test, Dqn_FileExists(MOVE_FILE)); + DQN_TESTER_ASSERTF(&test, Dqn_FileExists(COPY_FILE) == false, "Moving a file should remove the original"); // NOTE: Delete step Dqn_b32 delete_src_file = Dqn_FileDelete(SRC_FILE); Dqn_b32 delete_moved_file = Dqn_FileDelete(MOVE_FILE); - DQN_TEST_ASSERT(test, delete_src_file); - DQN_TEST_ASSERT(test, delete_moved_file); + DQN_TESTER_ASSERT(&test, delete_src_file); + DQN_TESTER_ASSERT(&test, delete_moved_file); // NOTE: Deleting non-existent file fails Dqn_b32 delete_non_existent_src_file = Dqn_FileDelete(SRC_FILE); Dqn_b32 delete_non_existent_moved_file = Dqn_FileDelete(MOVE_FILE); - DQN_TEST_ASSERT(test, delete_non_existent_moved_file == false); - DQN_TEST_ASSERT(test, delete_non_existent_src_file == false); + DQN_TESTER_ASSERT(&test, delete_non_existent_moved_file == false); + DQN_TESTER_ASSERT(&test, delete_non_existent_src_file == false); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); return test; } -Dqn_Test Dqn_Test_FixedArray() +Dqn_Tester Dqn_Test_FixedArray() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_WITH_FIXED_ARRAY) - DQN_TEST_GROUP(test, "Dqn_FixedArray"); + DQN_TESTER_BEGIN_GROUP("Dqn_FixedArray"); // NOTE: Dqn_FixedArrayInit { - DQN_TEST(test, "Initialise from raw array"); + Dqn_TesterBegin(&test, "Initialise from raw array"); int raw_array[] = {1, 2}; auto array = Dqn_FixedArrayInit(raw_array, (int)Dqn_ArrayCount(raw_array)); - DQN_TEST_ASSERT(test, array.size == 2); - DQN_TEST_ASSERT(test, array[0] == 1); - DQN_TEST_ASSERT(test, array[1] == 2); + DQN_TESTER_ASSERT(&test, array.size == 2); + DQN_TESTER_ASSERT(&test, array[0] == 1); + DQN_TESTER_ASSERT(&test, array[1] == 2); + Dqn_TesterEnd(&test); } // NOTE: Dqn_FixedArrayEraseStable { - DQN_TEST(test, "Erase stable 1 element from array"); + Dqn_TesterBegin(&test, "Erase stable 1 element from array"); int raw_array[] = {1, 2, 3}; auto array = Dqn_FixedArrayInit(raw_array, (int)Dqn_ArrayCount(raw_array)); Dqn_FixedArrayEraseStable(&array, 1); - DQN_TEST_ASSERT(test, array.size == 2); - DQN_TEST_ASSERT(test, array[0] == 1); - DQN_TEST_ASSERT(test, array[1] == 3); + DQN_TESTER_ASSERT(&test, array.size == 2); + DQN_TESTER_ASSERT(&test, array[0] == 1); + DQN_TESTER_ASSERT(&test, array[1] == 3); + Dqn_TesterEnd(&test); } // NOTE: Dqn_FixedArrayEraseUnstable { - DQN_TEST(test, "Erase unstable 1 element from array"); + Dqn_TesterBegin(&test, "Erase unstable 1 element from array"); int raw_array[] = {1, 2, 3}; auto array = Dqn_FixedArrayInit(raw_array, (int)Dqn_ArrayCount(raw_array)); Dqn_FixedArrayEraseUnstable(&array, 0); - DQN_TEST_ASSERT(test, array.size == 2); - DQN_TEST_ASSERT(test, array[0] == 3); - DQN_TEST_ASSERT(test, array[1] == 2); + DQN_TESTER_ASSERT(&test, array.size == 2); + DQN_TESTER_ASSERT(&test, array[0] == 3); + DQN_TESTER_ASSERT(&test, array[1] == 2); + Dqn_TesterEnd(&test); } // NOTE: Dqn_FixedArrayAdd { - DQN_TEST(test, "Add 1 element to array"); + Dqn_TesterBegin(&test, "Add 1 element to array"); int const ITEM = 2; int raw_array[] = {1}; auto array = Dqn_FixedArrayInit(raw_array, (int)Dqn_ArrayCount(raw_array)); Dqn_FixedArrayAdd(&array, ITEM); - DQN_TEST_ASSERT(test, array.size == 2); - DQN_TEST_ASSERT(test, array[0] == 1); - DQN_TEST_ASSERT(test, array[1] == ITEM); + DQN_TESTER_ASSERT(&test, array.size == 2); + DQN_TESTER_ASSERT(&test, array[0] == 1); + DQN_TESTER_ASSERT(&test, array[1] == ITEM); + Dqn_TesterEnd(&test); } // NOTE: Dqn_FixedArrayClear { - DQN_TEST(test, "Clear array"); + Dqn_TesterBegin(&test, "Clear array"); int raw_array[] = {1}; auto array = Dqn_FixedArrayInit(raw_array, (int)Dqn_ArrayCount(raw_array)); Dqn_FixedArrayClear(&array); - DQN_TEST_ASSERT(test, array.size == 0); + DQN_TESTER_ASSERT(&test, array.size == 0); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); #endif // DQN_WITH_FIXED_ARRAY return test; } -Dqn_Test Dqn_Test_FixedString() +Dqn_Tester Dqn_Test_FixedString() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_WITH_FIXED_STRING) - DQN_TEST_GROUP(test, "Dqn_FixedString"); + DQN_TESTER_BEGIN_GROUP("Dqn_FixedString"); // NOTE: Dqn_FixedStringAppend { - DQN_TEST(test, "Append too much fails"); + Dqn_TesterBegin(&test, "Append too much fails"); Dqn_FixedString<4> str = {}; - DQN_TEST_ASSERT_MSG(test, Dqn_FixedStringAppend(&str, "abcd") == false, "We need space for the null-terminator"); + DQN_TESTER_ASSERTF(&test, Dqn_FixedStringAppend(&str, "abcd") == false, "We need space for the null-terminator"); + Dqn_TesterEnd(&test); } // NOTE: Dqn_FixedStringAppendFmt { - DQN_TEST(test, "Append format string too much fails"); + Dqn_TesterBegin(&test, "Append format string too much fails"); Dqn_FixedString<4> str = {}; - DQN_TEST_ASSERT_MSG(test, Dqn_FixedStringAppendFmt(&str, "abcd") == false, "We need space for the null-terminator"); + DQN_TESTER_ASSERTF(&test, Dqn_FixedStringAppendFmt(&str, "abcd") == false, "We need space for the null-terminator"); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); #endif // DQN_WITH_FIXED_STRING return test; } -Dqn_Test Dqn_Test_Hex() +Dqn_Tester Dqn_Test_Hex() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_WITH_HEX) - DQN_TEST_GROUP(test, "Dqn_Hex"); + DQN_TESTER_BEGIN_GROUP("Dqn_Hex"); { - DQN_TEST(test, "Convert 0x123"); + Dqn_TesterBegin(&test, "Convert 0x123"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0x123")); - DQN_TEST_ASSERT_MSG(test, result == 0x123, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0x123, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert 0xFFFF"); + Dqn_TesterBegin(&test, "Convert 0xFFFF"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0xFFFF")); - DQN_TEST_ASSERT_MSG(test, result == 0xFFFF, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0xFFFF, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert FFFF"); + Dqn_TesterBegin(&test, "Convert FFFF"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("FFFF")); - DQN_TEST_ASSERT_MSG(test, result == 0xFFFF, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0xFFFF, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert abCD"); + Dqn_TesterBegin(&test, "Convert abCD"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("abCD")); - DQN_TEST_ASSERT_MSG(test, result == 0xabCD, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0xabCD, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert 0xabCD"); + Dqn_TesterBegin(&test, "Convert 0xabCD"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0xabCD")); - DQN_TEST_ASSERT_MSG(test, result == 0xabCD, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0xabCD, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert 0x"); + Dqn_TesterBegin(&test, "Convert 0x"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0x")); - DQN_TEST_ASSERT_MSG(test, result == 0x0, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0x0, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert 0X"); + Dqn_TesterBegin(&test, "Convert 0X"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0X")); - DQN_TEST_ASSERT_MSG(test, result == 0x0, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0x0, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert 3"); + Dqn_TesterBegin(&test, "Convert 3"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("3")); - DQN_TEST_ASSERT_MSG(test, result == 3, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 3, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert f"); + Dqn_TesterBegin(&test, "Convert f"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("f")); - DQN_TEST_ASSERT_MSG(test, result == 0xf, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0xf, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert g"); + Dqn_TesterBegin(&test, "Convert g"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("g")); - DQN_TEST_ASSERT_MSG(test, result == 0, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Convert -0x3"); + Dqn_TesterBegin(&test, "Convert -0x3"); Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("-0x3")); - DQN_TEST_ASSERT_MSG(test, result == 0, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); #endif // DQN_WITH_HEX return test; } -Dqn_Test Dqn_Test_M4() +Dqn_Tester Dqn_Test_M4() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_WITH_MATH) - DQN_TEST_GROUP(test, "Dqn_M4"); + DQN_TESTER_BEGIN_GROUP("Dqn_M4"); { - DQN_TEST(test, "Simple translate and scale matrix"); + Dqn_TesterBegin(&test, "Simple translate and scale matrix"); Dqn_M4 translate = Dqn_M4TranslateF(1, 2, 3); Dqn_M4 scale = Dqn_M4ScaleF(2, 2, 2); Dqn_M4 result = Dqn_M4Mul(translate, scale); @@ -483,486 +418,526 @@ Dqn_Test Dqn_Test_M4() {1, 2, 3, 1}, }}; - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, memcmp(result.columns, EXPECT.columns, sizeof(EXPECT)) == 0, "\nresult =\n%s\nexpected =\n%s", Dqn_M4ColumnMajorString(result).str, Dqn_M4ColumnMajorString(EXPECT).str); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); #endif // DQN_WITH_MATH return test; } -Dqn_Test Dqn_Test_DSMap() +Dqn_Tester Dqn_Test_DSMap() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_WITH_DSMAP) - DQN_TEST_GROUP(test, "Dqn_DSMap"); + DQN_TESTER_BEGIN_GROUP("Dqn_DSMap"); { - DQN_TEST(test, "Add r-value item to map"); + Dqn_TesterBegin(&test, "Add r-value item to map"); Dqn_DSMap map = Dqn_DSMapInit(128); Dqn_DSMapEntry *entry = Dqn_DSMapAddCopy(&map, 3 /*hash*/, 5 /*value*/); - DQN_TEST_ASSERT_MSG(test, map.size == 128, "size: %I64d", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, entry->hash == 3, "hash: %zu", entry->hash); - DQN_TEST_ASSERT_MSG(test, entry->value == 5, "value: %d", entry->value); + DQN_TESTER_ASSERTF(&test, map.size == 128, "size: %I64d", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, entry->hash == 3, "hash: %zu", entry->hash); + DQN_TESTER_ASSERTF(&test, entry->value == 5, "value: %d", entry->value); Dqn_DSMapFree(&map); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Add l-value item to map"); + Dqn_TesterBegin(&test, "Add l-value item to map"); Dqn_DSMap map = Dqn_DSMapInit(128); int value = 5; Dqn_DSMapEntry *entry = Dqn_DSMapAdd(&map, 3 /*hash*/, value); - DQN_TEST_ASSERT_MSG(test, map.size == 128, "size: %I64d", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, entry->hash == 3, "hash: %zu", entry->hash); - DQN_TEST_ASSERT_MSG(test, entry->value == 5, "value: %d", entry->value); + DQN_TESTER_ASSERTF(&test, map.size == 128, "size: %I64d", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, entry->hash == 3, "hash: %zu", entry->hash); + DQN_TESTER_ASSERTF(&test, entry->value == 5, "value: %d", entry->value); Dqn_DSMapFree(&map); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Get item from map"); + Dqn_TesterBegin(&test, "Get item from map"); Dqn_DSMap map = Dqn_DSMapInit(128); Dqn_DSMapEntry *entry = Dqn_DSMapAddCopy(&map, 3 /*hash*/, 5 /*value*/); Dqn_DSMapEntry *get_entry = Dqn_DSMapGet(&map, 3 /*hash*/); - DQN_TEST_ASSERT_MSG(test, get_entry == entry, "get_entry: %p, entry: %p", get_entry, entry); + DQN_TESTER_ASSERTF(&test, get_entry == entry, "get_entry: %p, entry: %p", get_entry, entry); Dqn_DSMapFree(&map); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Get non-existent item from map"); + Dqn_TesterBegin(&test, "Get non-existent item from map"); Dqn_DSMap map = Dqn_DSMapInit(128); Dqn_DSMapEntry *entry = Dqn_DSMapGet(&map, 3 /*hash*/); - DQN_TEST_ASSERT(test, entry == nullptr); + DQN_TESTER_ASSERT(&test, entry == nullptr); Dqn_DSMapFree(&map); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Erase item from map"); + Dqn_TesterBegin(&test, "Erase item from map"); Dqn_DSMap map = Dqn_DSMapInit(128); Dqn_DSMapAddCopy(&map, 3 /*hash*/, 5 /*value*/); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %I64d", map.count); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %I64d", map.count); Dqn_DSMapErase(&map, 3 /*hash*/, Dqn_ZeroMem::No); - DQN_TEST_ASSERT_MSG(test, map.count == 0, "count: %I64d", map.count); + DQN_TESTER_ASSERTF(&test, map.count == 0, "count: %I64d", map.count); Dqn_DSMapFree(&map); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Erase non-existent item from map"); + Dqn_TesterBegin(&test, "Erase non-existent item from map"); Dqn_DSMap map = Dqn_DSMapInit(128); Dqn_DSMapErase(&map, 3 /*hash*/, Dqn_ZeroMem::No); - DQN_TEST_ASSERT_MSG(test, map.count == 0, "count: %I64d", map.count); + DQN_TESTER_ASSERTF(&test, map.count == 0, "count: %I64d", map.count); Dqn_DSMapFree(&map); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Test resize on maximum load"); + Dqn_TesterBegin(&test, "Test resize on maximum load"); const Dqn_isize INIT_SIZE = 4; Dqn_DSMap map = Dqn_DSMapInit(INIT_SIZE); Dqn_DSMapAddCopy(&map, 0 /*hash*/, 5 /*value*/); Dqn_DSMapAddCopy(&map, 1 /*hash*/, 5 /*value*/); - DQN_TEST_ASSERT_MSG(test, map.count == 2, "count: %I64d", map.count); + DQN_TESTER_ASSERTF(&test, map.count == 2, "count: %I64d", map.count); // This *should* cause a resize because 3/4 slots filled is 75% load Dqn_DSMapAddCopy(&map, 6 /*hash*/, 5 /*value*/); - DQN_TEST_ASSERT_MSG(test, map.count == 3, "count: %I64d", map.count); - DQN_TEST_ASSERT_MSG(test, map.size == INIT_SIZE * 2, "size: %I64d", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 3, "count: %I64d", map.count); + DQN_TESTER_ASSERTF(&test, map.size == INIT_SIZE * 2, "size: %I64d", map.size); // Check that the elements are rehashed where we expected them to be - DQN_TEST_ASSERT (test, map.slots[0].occupied == DQN_CAST(Dqn_u8)true); - DQN_TEST_ASSERT (test, map.slots[1].occupied == DQN_CAST(Dqn_u8)true); - DQN_TEST_ASSERT (test, map.slots[2].occupied == DQN_CAST(Dqn_u8)false); - DQN_TEST_ASSERT (test, map.slots[3].occupied == DQN_CAST(Dqn_u8)false); - DQN_TEST_ASSERT (test, map.slots[4].occupied == DQN_CAST(Dqn_u8)false); - DQN_TEST_ASSERT (test, map.slots[5].occupied == DQN_CAST(Dqn_u8)false); - DQN_TEST_ASSERT (test, map.slots[6].occupied == DQN_CAST(Dqn_u8)true); - DQN_TEST_ASSERT (test, map.slots[7].occupied == DQN_CAST(Dqn_u8)false); + DQN_TESTER_ASSERT(&test, map.slots[0].occupied == DQN_CAST(Dqn_u8)true); + DQN_TESTER_ASSERT(&test, map.slots[1].occupied == DQN_CAST(Dqn_u8)true); + DQN_TESTER_ASSERT(&test, map.slots[2].occupied == DQN_CAST(Dqn_u8)false); + DQN_TESTER_ASSERT(&test, map.slots[3].occupied == DQN_CAST(Dqn_u8)false); + DQN_TESTER_ASSERT(&test, map.slots[4].occupied == DQN_CAST(Dqn_u8)false); + DQN_TESTER_ASSERT(&test, map.slots[5].occupied == DQN_CAST(Dqn_u8)false); + DQN_TESTER_ASSERT(&test, map.slots[6].occupied == DQN_CAST(Dqn_u8)true); + DQN_TESTER_ASSERT(&test, map.slots[7].occupied == DQN_CAST(Dqn_u8)false); - DQN_TEST_ASSERT_MSG(test, map.slots[0].value == 5, "value: %d", map.slots[0].value); - DQN_TEST_ASSERT_MSG(test, map.slots[1].value == 5, "value: %d", map.slots[1].value); - DQN_TEST_ASSERT_MSG(test, map.slots[6].value == 5, "value: %d", map.slots[6].value); + DQN_TESTER_ASSERTF(&test, map.slots[0].value == 5, "value: %d", map.slots[0].value); + DQN_TESTER_ASSERTF(&test, map.slots[1].value == 5, "value: %d", map.slots[1].value); + DQN_TESTER_ASSERTF(&test, map.slots[6].value == 5, "value: %d", map.slots[6].value); Dqn_DSMapFree(&map); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); #endif // DQN_WITH_DSMAP return test; } -Dqn_Test Dqn_Test_Map() +Dqn_Tester Dqn_Test_Map() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_WITH_MAP) - DQN_TEST_GROUP(test, "Dqn_Map"); + DQN_TESTER_BEGIN_GROUP("Dqn_Map"); Dqn_Arena arena = {}; { - DQN_TEST(test, "Add r-value item to map"); + Dqn_TesterBegin(&test, "Add r-value item to map"); Dqn_Map map = Dqn_MapInitWithArena(&arena, 1); Dqn_MapEntry *entry = Dqn_MapAddCopy(&map, 3 /*hash*/, 5 /*value*/, Dqn_MapCollideRule::Overwrite); - DQN_TEST_ASSERT_MSG(test, map.size == 1, "size: %I64d", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, map.chain_count == 0, "chain_count: %zu", map.chain_count); - DQN_TEST_ASSERT_MSG(test, map.free_list == nullptr, "free_list: %p", map.free_list); - DQN_TEST_ASSERT_MSG(test, entry->hash == 3, "hash: %zu", entry->hash); - DQN_TEST_ASSERT_MSG(test, entry->value == 5, "value: %d", entry->value); - DQN_TEST_ASSERT_MSG(test, entry->next == nullptr, "next: %p", entry->next); + DQN_TESTER_ASSERTF(&test, map.size == 1, "size: %I64d", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, map.chain_count == 0, "chain_count: %zu", map.chain_count); + DQN_TESTER_ASSERTF(&test, map.free_list == nullptr, "free_list: %p", map.free_list); + DQN_TESTER_ASSERTF(&test, entry->hash == 3, "hash: %zu", entry->hash); + DQN_TESTER_ASSERTF(&test, entry->value == 5, "value: %d", entry->value); + DQN_TESTER_ASSERTF(&test, entry->next == nullptr, "next: %p", entry->next); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Add l-value item to map"); + Dqn_TesterBegin(&test, "Add l-value item to map"); Dqn_Map map = Dqn_MapInitWithArena(&arena, 1); int value = 5; Dqn_MapEntry *entry = Dqn_MapAdd(&map, 3 /*hash*/, value, Dqn_MapCollideRule::Overwrite); - DQN_TEST_ASSERT_MSG(test, map.size == 1, "size: %I64d", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, map.chain_count == 0, "chain_count: %zu", map.chain_count); - DQN_TEST_ASSERT_MSG(test, map.free_list == nullptr, "free_list: %p", map.free_list); - DQN_TEST_ASSERT_MSG(test, entry->hash == 3, "hash: %zu", entry->hash); - DQN_TEST_ASSERT_MSG(test, entry->value == 5, "value: %d", entry->value); - DQN_TEST_ASSERT_MSG(test, entry->next == nullptr, "next: %p", entry->next); + DQN_TESTER_ASSERTF(&test, map.size == 1, "size: %I64d", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, map.chain_count == 0, "chain_count: %zu", map.chain_count); + DQN_TESTER_ASSERTF(&test, map.free_list == nullptr, "free_list: %p", map.free_list); + DQN_TESTER_ASSERTF(&test, entry->hash == 3, "hash: %zu", entry->hash); + DQN_TESTER_ASSERTF(&test, entry->value == 5, "value: %d", entry->value); + DQN_TESTER_ASSERTF(&test, entry->next == nullptr, "next: %p", entry->next); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Add r-value item and overwrite on collision"); + Dqn_TesterBegin(&test, "Add r-value item and overwrite on collision"); Dqn_Map map = Dqn_MapInitWithArena(&arena, 1); Dqn_MapEntry *entry_a = Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite); Dqn_MapEntry *entry_b = Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Overwrite); - DQN_TEST_ASSERT_MSG(test, map.size == 1, "size: %zu", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, map.chain_count == 0, "chain_count: %zu", map.chain_count); - DQN_TEST_ASSERT_MSG(test, map.free_list == nullptr, "free_list: %p", map.free_list); - DQN_TEST_ASSERT_MSG(test, entry_a == entry_b, "Expected entry to be overwritten"); - DQN_TEST_ASSERT_MSG(test, entry_b->hash == 4, "hash: %zu", entry_b->hash); - DQN_TEST_ASSERT_MSG(test, entry_b->value == 6, "value: %d", entry_b->value); - DQN_TEST_ASSERT_MSG(test, entry_b->next == nullptr, "next: %p", entry_b->next); + DQN_TESTER_ASSERTF(&test, map.size == 1, "size: %zu", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, map.chain_count == 0, "chain_count: %zu", map.chain_count); + DQN_TESTER_ASSERTF(&test, map.free_list == nullptr, "free_list: %p", map.free_list); + DQN_TESTER_ASSERTF(&test, entry_a == entry_b, "Expected entry to be overwritten"); + DQN_TESTER_ASSERTF(&test, entry_b->hash == 4, "hash: %zu", entry_b->hash); + DQN_TESTER_ASSERTF(&test, entry_b->value == 6, "value: %d", entry_b->value); + DQN_TESTER_ASSERTF(&test, entry_b->next == nullptr, "next: %p", entry_b->next); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Add r-value item and fail on collision"); + Dqn_TesterBegin(&test, "Add r-value item and fail on collision"); Dqn_Map map = Dqn_MapInitWithArena(&arena, 1); Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite); Dqn_MapEntry *entry_b = Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Fail); - DQN_TEST_ASSERT_MSG(test, entry_b == nullptr, "Expected entry to be overwritten"); - DQN_TEST_ASSERT_MSG(test, map.size == 1, "size: %zu", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, map.chain_count == 0, "chain_count: %zu", map.chain_count); - DQN_TEST_ASSERT_MSG(test, map.free_list == nullptr, "free_list: %p", map.free_list); + DQN_TESTER_ASSERTF(&test, entry_b == nullptr, "Expected entry to be overwritten"); + DQN_TESTER_ASSERTF(&test, map.size == 1, "size: %zu", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, map.chain_count == 0, "chain_count: %zu", map.chain_count); + DQN_TESTER_ASSERTF(&test, map.free_list == nullptr, "free_list: %p", map.free_list); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Add r-value item and chain on collision"); + Dqn_TesterBegin(&test, "Add r-value item and chain on collision"); Dqn_Map map = Dqn_MapInitWithArena(&arena, 1); Dqn_MapEntry *entry_a = Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite); Dqn_MapEntry *entry_b = Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Chain); - DQN_TEST_ASSERT_MSG(test, map.size == 1, "size: %zu", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, map.chain_count == 1, "chain_count: %zu", map.chain_count); - DQN_TEST_ASSERT_MSG(test, map.free_list == nullptr, "free_list: %p", map.free_list); - DQN_TEST_ASSERT_MSG(test, entry_a != entry_b, "Expected colliding entry to be chained"); - DQN_TEST_ASSERT_MSG(test, entry_a->next == entry_b, "Expected chained entry to be next to our first map entry"); - DQN_TEST_ASSERT_MSG(test, entry_b->hash == 4, "hash: %zu", entry_b->hash); - DQN_TEST_ASSERT_MSG(test, entry_b->value == 6, "value: %d", entry_b->value); - DQN_TEST_ASSERT_MSG(test, entry_b->next == nullptr, "next: %p", entry_b->next); + DQN_TESTER_ASSERTF(&test, map.size == 1, "size: %zu", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, map.chain_count == 1, "chain_count: %zu", map.chain_count); + DQN_TESTER_ASSERTF(&test, map.free_list == nullptr, "free_list: %p", map.free_list); + DQN_TESTER_ASSERTF(&test, entry_a != entry_b, "Expected colliding entry to be chained"); + DQN_TESTER_ASSERTF(&test, entry_a->next == entry_b, "Expected chained entry to be next to our first map entry"); + DQN_TESTER_ASSERTF(&test, entry_b->hash == 4, "hash: %zu", entry_b->hash); + DQN_TESTER_ASSERTF(&test, entry_b->value == 6, "value: %d", entry_b->value); + DQN_TESTER_ASSERTF(&test, entry_b->next == nullptr, "next: %p", entry_b->next); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Add r-value item and get them back out again"); + Dqn_TesterBegin(&test, "Add r-value item and get them back out again"); Dqn_Map map = Dqn_MapInitWithArena(&arena, 1); Dqn_MapEntry *entry_a = Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite); Dqn_MapEntry *entry_b = Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Chain); Dqn_MapEntry *entry_a_copy = Dqn_MapGet(&map, 3 /*hash*/); Dqn_MapEntry *entry_b_copy = Dqn_MapGet(&map, 4 /*hash*/); - DQN_TEST_ASSERT_MSG(test, map.size == 1, "size: %zu", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, map.chain_count == 1, "chain_count: %zu", map.chain_count); - DQN_TEST_ASSERT_MSG(test, map.free_list == nullptr, "free_list: %p", map.free_list); - DQN_TEST_ASSERT(test, entry_a_copy == entry_a); - DQN_TEST_ASSERT(test, entry_b_copy == entry_b); + DQN_TESTER_ASSERTF(&test, map.size == 1, "size: %zu", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, map.chain_count == 1, "chain_count: %zu", map.chain_count); + DQN_TESTER_ASSERTF(&test, map.free_list == nullptr, "free_list: %p", map.free_list); + DQN_TESTER_ASSERT(&test, entry_a_copy == entry_a); + DQN_TESTER_ASSERT(&test, entry_b_copy == entry_b); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Add r-value item and erase it"); + Dqn_TesterBegin(&test, "Add r-value item and erase it"); Dqn_Map map = Dqn_MapInitWithArena(&arena, 1); Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite); Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Chain); Dqn_MapGet(&map, 3 /*hash*/); Dqn_MapErase(&map, 3 /*hash*/, Dqn_ZeroMem::No); - DQN_TEST_ASSERT_MSG(test, map.size == 1, "size: %zu", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, map.chain_count == 0, "chain_count: %zu", map.chain_count); - DQN_TEST_ASSERT_MSG(test, map.free_list != nullptr, "free_list: %p", map.free_list); + DQN_TESTER_ASSERTF(&test, map.size == 1, "size: %zu", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, map.chain_count == 0, "chain_count: %zu", map.chain_count); + DQN_TESTER_ASSERTF(&test, map.free_list != nullptr, "free_list: %p", map.free_list); - DQN_TEST_ASSERT_MSG(test, map.free_list->hash == 3, "Entry should not be zeroed out on erase"); - DQN_TEST_ASSERT_MSG(test, map.free_list->value == 5, "Entry should not be zeroed out on erase"); - DQN_TEST_ASSERT_MSG(test, map.free_list->next == nullptr, "This should be the first and only entry in the free list"); + DQN_TESTER_ASSERTF(&test, map.free_list->hash == 3, "Entry should not be zeroed out on erase"); + DQN_TESTER_ASSERTF(&test, map.free_list->value == 5, "Entry should not be zeroed out on erase"); + DQN_TESTER_ASSERTF(&test, map.free_list->next == nullptr, "This should be the first and only entry in the free list"); Dqn_MapEntry *entry = Dqn_MapGet(&map, 4 /*hash*/); - DQN_TEST_ASSERT_MSG(test, entry->hash == 4, "hash: %zu", entry->hash); - DQN_TEST_ASSERT_MSG(test, entry->value == 6, "value: %d", entry->value); - DQN_TEST_ASSERT_MSG(test, entry->next == nullptr, "next: %p", entry->next); + DQN_TESTER_ASSERTF(&test, entry->hash == 4, "hash: %zu", entry->hash); + DQN_TESTER_ASSERTF(&test, entry->value == 6, "value: %d", entry->value); + DQN_TESTER_ASSERTF(&test, entry->next == nullptr, "next: %p", entry->next); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Add r-value item and erase it, zeroing the memory out"); + Dqn_TesterBegin(&test, "Add r-value item and erase it, zeroing the memory out"); Dqn_Map map = Dqn_MapInitWithArena(&arena, 1); Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite); Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Chain); Dqn_MapGet(&map, 3 /*hash*/); Dqn_MapErase(&map, 3 /*hash*/, Dqn_ZeroMem::Yes); - DQN_TEST_ASSERT_MSG(test, map.size == 1, "size: %zu", map.size); - DQN_TEST_ASSERT_MSG(test, map.count == 1, "count: %zu", map.count); - DQN_TEST_ASSERT_MSG(test, map.chain_count == 0, "chain_count: %zu", map.chain_count); - DQN_TEST_ASSERT_MSG(test, map.free_list != nullptr, "free_list: %p", map.free_list); + DQN_TESTER_ASSERTF(&test, map.size == 1, "size: %zu", map.size); + DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %zu", map.count); + DQN_TESTER_ASSERTF(&test, map.chain_count == 0, "chain_count: %zu", map.chain_count); + DQN_TESTER_ASSERTF(&test, map.free_list != nullptr, "free_list: %p", map.free_list); - DQN_TEST_ASSERT_MSG(test, map.free_list->hash == 0, "Entry should be zeroed out on erase"); - DQN_TEST_ASSERT_MSG(test, map.free_list->value == 0, "Entry should be zeroed out on erase"); - DQN_TEST_ASSERT_MSG(test, map.free_list->next == nullptr, "This should be the first and only entry in the free list"); + DQN_TESTER_ASSERTF(&test, map.free_list->hash == 0, "Entry should be zeroed out on erase"); + DQN_TESTER_ASSERTF(&test, map.free_list->value == 0, "Entry should be zeroed out on erase"); + DQN_TESTER_ASSERTF(&test, map.free_list->next == nullptr, "This should be the first and only entry in the free list"); Dqn_MapEntry *entry = Dqn_MapGet(&map, 4 /*hash*/); - DQN_TEST_ASSERT_MSG(test, entry->hash == 4, "hash: %zu", entry->hash); - DQN_TEST_ASSERT_MSG(test, entry->value == 6, "value: %d", entry->value); - DQN_TEST_ASSERT_MSG(test, entry->next == nullptr, "next: %p", entry->next); + DQN_TESTER_ASSERTF(&test, entry->hash == 4, "hash: %zu", entry->hash); + DQN_TESTER_ASSERTF(&test, entry->value == 6, "value: %d", entry->value); + DQN_TESTER_ASSERTF(&test, entry->next == nullptr, "next: %p", entry->next); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } // TODO(dqn): Test free list is chained correctly // TODO(dqn): Test deleting 'b' from the list in the situation [map] - [a]->[b], we currently only test deleting a + DQN_TESTER_END_GROUP(&test); #endif // DQN_WITH_MAP return test; } -Dqn_Test Dqn_Test_Intrinsics() +Dqn_Tester Dqn_Test_Intrinsics() { - Dqn_Test test = {}; + Dqn_Tester test = {}; // TODO(dqn): We don't have meaningful tests here, but since // atomics/intrinsics are implemented using macros we ensure the macro was // written properly with these tests. - DQN_TEST_GROUP(test, "Dqn_Atomic"); + DQN_TESTER_BEGIN_GROUP("Dqn_Atomic"); { - DQN_TEST(test, "Dqn_AtomicAddU32"); + Dqn_TesterBegin(&test, "Dqn_AtomicAddU32"); Dqn_u32 val = 0; Dqn_AtomicAddU32(&val, 1); - DQN_TEST_ASSERT_MSG(test, val == 1, "val: %u", val); + DQN_TESTER_ASSERTF(&test, val == 1, "val: %u", val); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Dqn_AtomicAddU64"); + Dqn_TesterBegin(&test, "Dqn_AtomicAddU64"); Dqn_u64 val = 0; Dqn_AtomicAddU64(&val, 1); - DQN_TEST_ASSERT_MSG(test, val == 1, "val: %zu", val); + DQN_TESTER_ASSERTF(&test, val == 1, "val: %zu", val); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Dqn_AtomicSubU32"); + Dqn_TesterBegin(&test, "Dqn_AtomicSubU32"); Dqn_u32 val = 1; Dqn_AtomicSubU32(&val, 1); - DQN_TEST_ASSERT_MSG(test, val == 0, "val: %u", val); + DQN_TESTER_ASSERTF(&test, val == 0, "val: %u", val); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Dqn_AtomicSubU64"); + Dqn_TesterBegin(&test, "Dqn_AtomicSubU64"); Dqn_u64 val = 1; Dqn_AtomicSubU64(&val, 1); - DQN_TEST_ASSERT_MSG(test, val == 0, "val: %zu", val); + DQN_TESTER_ASSERTF(&test, val == 0, "val: %zu", val); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Dqn_AtomicSetValue32"); + Dqn_TesterBegin(&test, "Dqn_AtomicSetValue32"); long a = 0; long b = 111; Dqn_AtomicSetValue32(&a, b); - DQN_TEST_ASSERT_MSG(test, a == b, "a: %lu, b: %lu", a, b); + DQN_TESTER_ASSERTF(&test, a == b, "a: %lu, b: %lu", a, b); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Dqn_AtomicSetValue64"); + Dqn_TesterBegin(&test, "Dqn_AtomicSetValue64"); Dqn_i64 a = 0; Dqn_i64 b = 111; Dqn_AtomicSetValue64(&a, b); - DQN_TEST_ASSERT_MSG(test, a == b, "a: %I64i, b: %I64i", a, b); + DQN_TESTER_ASSERTF(&test, a == b, "a: %I64i, b: %I64i", a, b); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Dqn_CPUClockCycle"); + Dqn_TesterBegin(&test, "Dqn_CPUClockCycle"); Dqn_CPUClockCycle(); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Dqn_CompilerReadBarrierAndCPUReadFence"); + Dqn_TesterBegin(&test, "Dqn_CompilerReadBarrierAndCPUReadFence"); Dqn_CompilerReadBarrierAndCPUReadFence; + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Dqn_CompilerWriteBarrierAndCPUWriteFence"); + Dqn_TesterBegin(&test, "Dqn_CompilerWriteBarrierAndCPUWriteFence"); Dqn_CompilerWriteBarrierAndCPUWriteFence; + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); return test; } -Dqn_Test Dqn_Test_Rect() +Dqn_Tester Dqn_Test_Rect() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_WITH_MATH) - DQN_TEST_GROUP(test, "Dqn_Rect"); + DQN_TESTER_BEGIN_GROUP("Dqn_Rect"); // NOTE: Dqn_RectIntersection { { - DQN_TEST(test, "No intersection"); + Dqn_TesterBegin(&test, "No intersection"); Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2(0, 0), Dqn_V2(100, 100)); Dqn_Rect b = Dqn_RectInitFromPosAndSize(Dqn_V2(200, 0), Dqn_V2(200, 200)); Dqn_Rect ab = Dqn_RectIntersection(a, b); - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, ab.min.x == 0 && ab.min.y == 0 && ab.max.x == 0 && ab.max.y == 0, "ab = { min.x = %.2f, min.y = %.2f, max.x = %.2f. max.y = %.2f }", ab.min.x, ab.min.y, ab.max.x, ab.max.y); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "A's min intersects B"); + Dqn_TesterBegin(&test, "A's min intersects B"); Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2(50, 50), Dqn_V2(100, 100)); Dqn_Rect b = Dqn_RectInitFromPosAndSize(Dqn_V2( 0, 0), Dqn_V2(100, 100)); Dqn_Rect ab = Dqn_RectIntersection(a, b); - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, ab.min.x == 50 && ab.min.y == 50 && ab.max.x == 100 && ab.max.y == 100, "ab = { min.x = %.2f, min.y = %.2f, max.x = %.2f. max.y = %.2f }", ab.min.x, ab.min.y, ab.max.x, ab.max.y); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "B's min intersects A"); + Dqn_TesterBegin(&test, "B's min intersects A"); Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2( 0, 0), Dqn_V2(100, 100)); Dqn_Rect b = Dqn_RectInitFromPosAndSize(Dqn_V2(50, 50), Dqn_V2(100, 100)); Dqn_Rect ab = Dqn_RectIntersection(a, b); - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, ab.min.x == 50 && ab.min.y == 50 && ab.max.x == 100 && ab.max.y == 100, "ab = { min.x = %.2f, min.y = %.2f, max.x = %.2f. max.y = %.2f }", ab.min.x, ab.min.y, ab.max.x, ab.max.y); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "A's max intersects B"); + Dqn_TesterBegin(&test, "A's max intersects B"); Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2(-50, -50), Dqn_V2(100, 100)); Dqn_Rect b = Dqn_RectInitFromPosAndSize(Dqn_V2( 0, 0), Dqn_V2(100, 100)); Dqn_Rect ab = Dqn_RectIntersection(a, b); - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, ab.min.x == 0 && ab.min.y == 0 && ab.max.x == 50 && ab.max.y == 50, "ab = { min.x = %.2f, min.y = %.2f, max.x = %.2f. max.y = %.2f }", ab.min.x, ab.min.y, ab.max.x, ab.max.y); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "B's max intersects A"); + Dqn_TesterBegin(&test, "B's max intersects A"); Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2( 0, 0), Dqn_V2(100, 100)); Dqn_Rect b = Dqn_RectInitFromPosAndSize(Dqn_V2(-50, -50), Dqn_V2(100, 100)); Dqn_Rect ab = Dqn_RectIntersection(a, b); - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, ab.min.x == 0 && ab.min.y == 0 && ab.max.x == 50 && ab.max.y == 50, "ab = { min.x = %.2f, min.y = %.2f, max.x = %.2f. max.y = %.2f }", ab.min.x, ab.min.y, ab.max.x, ab.max.y); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "B contains A"); + Dqn_TesterBegin(&test, "B contains A"); Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2(25, 25), Dqn_V2( 25, 25)); Dqn_Rect b = Dqn_RectInitFromPosAndSize(Dqn_V2( 0, 0), Dqn_V2(100, 100)); Dqn_Rect ab = Dqn_RectIntersection(a, b); - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, ab.min.x == 25 && ab.min.y == 25 && ab.max.x == 50 && ab.max.y == 50, "ab = { min.x = %.2f, min.y = %.2f, max.x = %.2f. max.y = %.2f }", ab.min.x, ab.min.y, ab.max.x, ab.max.y); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "A contains B"); + Dqn_TesterBegin(&test, "A contains B"); Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2( 0, 0), Dqn_V2(100, 100)); Dqn_Rect b = Dqn_RectInitFromPosAndSize(Dqn_V2(25, 25), Dqn_V2( 25, 25)); Dqn_Rect ab = Dqn_RectIntersection(a, b); - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, ab.min.x == 25 && ab.min.y == 25 && ab.max.x == 50 && ab.max.y == 50, "ab = { min.x = %.2f, min.y = %.2f, max.x = %.2f. max.y = %.2f }", ab.min.x, ab.min.y, ab.max.x, ab.max.y); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "A equals B"); + Dqn_TesterBegin(&test, "A equals B"); Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2(0, 0), Dqn_V2(100, 100)); Dqn_Rect b = a; Dqn_Rect ab = Dqn_RectIntersection(a, b); - DQN_TEST_ASSERT_MSG(test, + DQN_TESTER_ASSERTF(&test, ab.min.x == 0 && ab.min.y == 0 && ab.max.x == 100 && ab.max.y == 100, "ab = { min.x = %.2f, min.y = %.2f, max.x = %.2f. max.y = %.2f }", ab.min.x, ab.min.y, ab.max.x, ab.max.y); + Dqn_TesterEnd(&test); } } + DQN_TESTER_END_GROUP(&test); #endif // DQN_WITH_MATH return test; } -Dqn_Test Dqn_Test_PerfCounter() +Dqn_Tester Dqn_Test_PerfCounter() { - Dqn_Test test = {}; - DQN_TEST_GROUP(test, "Dqn_PerfCounter"); + Dqn_Tester test = {}; + DQN_TESTER_BEGIN_GROUP("Dqn_PerfCounter"); { - DQN_TEST(test, "Dqn_PerfCounterNow"); + Dqn_TesterBegin(&test, "Dqn_PerfCounterNow"); Dqn_u64 result = Dqn_PerfCounterNow(); - DQN_TEST_ASSERT(test, result != 0); + DQN_TESTER_ASSERT(&test, result != 0); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Consecutive ticks are ordered"); + Dqn_TesterBegin(&test, "Consecutive ticks are ordered"); Dqn_u64 a = Dqn_PerfCounterNow(); Dqn_u64 b = Dqn_PerfCounterNow(); - DQN_TEST_ASSERT_MSG(test, b >= a, "a: %zu, b: %zu", a, b); + DQN_TESTER_ASSERTF(&test, b >= a, "a: %zu, b: %zu", a, b); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Ticks to time are a correct order of magnitude"); + Dqn_TesterBegin(&test, "Ticks to time are a correct order of magnitude"); Dqn_u64 a = Dqn_PerfCounterNow(); Dqn_u64 b = Dqn_PerfCounterNow(); @@ -970,376 +945,424 @@ Dqn_Test Dqn_Test_PerfCounter() Dqn_f64 ms = Dqn_PerfCounterMs(a, b); Dqn_f64 micro_s = Dqn_PerfCounterMicroS(a, b); Dqn_f64 ns = Dqn_PerfCounterNs(a, b); - DQN_TEST_ASSERT_MSG(test, s <= ms, "s: %f, ms: %f", s, ms); - DQN_TEST_ASSERT_MSG(test, ms <= micro_s, "ms: %f, micro_s: %f", ms, micro_s); - DQN_TEST_ASSERT_MSG(test, micro_s <= ns, "micro_s: %f, ns: %f", micro_s, ns); + DQN_TESTER_ASSERTF(&test, s <= ms, "s: %f, ms: %f", s, ms); + DQN_TESTER_ASSERTF(&test, ms <= micro_s, "ms: %f, micro_s: %f", ms, micro_s); + DQN_TESTER_ASSERTF(&test, micro_s <= ns, "micro_s: %f, ns: %f", micro_s, ns); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); return test; } -Dqn_Test Dqn_Test_OS() +Dqn_Tester Dqn_Test_OS() { - Dqn_Test test = {}; - DQN_TEST_GROUP(test, "Dqn_OS"); + Dqn_Tester test = {}; + DQN_TESTER_BEGIN_GROUP("Dqn_OS"); { - DQN_TEST(test, "Generate secure RNG bytes with nullptr"); + Dqn_TesterBegin(&test, "Generate secure RNG bytes with nullptr"); Dqn_b32 result = Dqn_OSSecureRNGBytes(nullptr, 1); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Generate secure RNG 32 bytes"); + Dqn_TesterBegin(&test, "Generate secure RNG 32 bytes"); char const ZERO[32] = {}; char buf[32] = {}; Dqn_b32 result = Dqn_OSSecureRNGBytes(buf, Dqn_ArrayCountI(buf)); - DQN_TEST_ASSERT(test, result); - DQN_TEST_ASSERT(test, DQN_MEMCMP(buf, ZERO, Dqn_ArrayCount(buf)) != 0); + DQN_TESTER_ASSERT(&test, result); + DQN_TESTER_ASSERT(&test, DQN_MEMCMP(buf, ZERO, Dqn_ArrayCount(buf)) != 0); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Generate secure RNG 0 bytes"); + Dqn_TesterBegin(&test, "Generate secure RNG 0 bytes"); char buf[32] = {}; buf[0] = 'Z'; Dqn_b32 result = Dqn_OSSecureRNGBytes(buf, 0); - DQN_TEST_ASSERT(test, result); - DQN_TEST_ASSERT(test, buf[0] == 'Z'); + DQN_TESTER_ASSERT(&test, result); + DQN_TESTER_ASSERT(&test, buf[0] == 'Z'); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Query executable directory"); + Dqn_TesterBegin(&test, "Query executable directory"); Dqn_Arena arena = {}; Dqn_String result = Dqn_OSExecutableDirectory(&arena); - DQN_TEST_ASSERT(test, Dqn_StringIsValid(result)); - DQN_TEST_ASSERT_MSG(test, Dqn_FileDirExists(result), "result(%zu): %.*s", result.size, DQN_STRING_FMT(result)); + DQN_TESTER_ASSERT(&test, Dqn_StringIsValid(result)); + DQN_TESTER_ASSERTF(&test, Dqn_FileDirExists(result), "result(%zu): %.*s", result.size, DQN_STRING_FMT(result)); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); return test; } -Dqn_Test Dqn_Test_Str() +Dqn_Tester Dqn_Test_Str() { - Dqn_Test test = {}; - DQN_TEST_GROUP(test, "Dqn_Str"); + Dqn_Tester test = {}; + DQN_TESTER_BEGIN_GROUP("Dqn_Str"); // --------------------------------------------------------------------------------------------- // NOTE: Dqn_CStringToI64 // --------------------------------------------------------------------------------------------- { - DQN_TEST(test, "To I64: Convert nullptr"); + Dqn_TesterBegin(&test, "To I64: Convert nullptr"); Dqn_i64 result = Dqn_CStringToI64(nullptr); - DQN_TEST_ASSERT(test, result == 0); + DQN_TESTER_ASSERT(&test, result == 0); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To I64: Convert empty string"); + Dqn_TesterBegin(&test, "To I64: Convert empty string"); Dqn_i64 result = Dqn_CStringToI64(""); - DQN_TEST_ASSERT(test, result == 0); + DQN_TESTER_ASSERT(&test, result == 0); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To I64: Convert \"1\""); + Dqn_TesterBegin(&test, "To I64: Convert \"1\""); Dqn_i64 result = Dqn_CStringToI64("1"); - DQN_TEST_ASSERT(test, result == 1); + DQN_TESTER_ASSERT(&test, result == 1); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To I64: Convert \"-0\""); + Dqn_TesterBegin(&test, "To I64: Convert \"-0\""); Dqn_i64 result = Dqn_CStringToI64("-0"); - DQN_TEST_ASSERT(test, result == 0); + DQN_TESTER_ASSERT(&test, result == 0); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To I64: Convert \"-1\""); + Dqn_TesterBegin(&test, "To I64: Convert \"-1\""); Dqn_i64 result = Dqn_CStringToI64("-1"); - DQN_TEST_ASSERT(test, result == -1); + DQN_TESTER_ASSERT(&test, result == -1); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To I64: Convert \"1.2\""); + Dqn_TesterBegin(&test, "To I64: Convert \"1.2\""); Dqn_i64 result = Dqn_CStringToI64("1.2"); - DQN_TEST_ASSERT(test, result == 1); + DQN_TESTER_ASSERT(&test, result == 1); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To I64: Convert \"1,234\""); + Dqn_TesterBegin(&test, "To I64: Convert \"1,234\""); Dqn_i64 result = Dqn_CStringToI64("1,234"); - DQN_TEST_ASSERT(test, result == 1234); + DQN_TESTER_ASSERT(&test, result == 1234); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To I64: Convert \"1,2\""); + Dqn_TesterBegin(&test, "To I64: Convert \"1,2\""); Dqn_i64 result = Dqn_CStringToI64("1,2"); - DQN_TEST_ASSERT(test, result == 12); + DQN_TESTER_ASSERT(&test, result == 12); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To I64: Convert \"12a3\""); + Dqn_TesterBegin(&test, "To I64: Convert \"12a3\""); Dqn_i64 result = Dqn_CStringToI64("12a3"); - DQN_TEST_ASSERT(test, result == 12); + DQN_TESTER_ASSERT(&test, result == 12); + Dqn_TesterEnd(&test); } // --------------------------------------------------------------------------------------------- // NOTE: Dqn_CStringToU64 // --------------------------------------------------------------------------------------------- { - DQN_TEST(test, "To U64: Convert nullptr"); + Dqn_TesterBegin(&test, "To U64: Convert nullptr"); Dqn_u64 result = Dqn_CStringToU64(nullptr); - DQN_TEST_ASSERT_MSG(test, result == 0, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To U64: Convert empty string"); + Dqn_TesterBegin(&test, "To U64: Convert empty string"); Dqn_u64 result = Dqn_CStringToU64(""); - DQN_TEST_ASSERT_MSG(test, result == 0, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To U64: Convert \"1\""); + Dqn_TesterBegin(&test, "To U64: Convert \"1\""); Dqn_u64 result = Dqn_CStringToU64("1"); - DQN_TEST_ASSERT_MSG(test, result == 1, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 1, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To U64: Convert \"-0\""); + Dqn_TesterBegin(&test, "To U64: Convert \"-0\""); Dqn_u64 result = Dqn_CStringToU64("-0"); - DQN_TEST_ASSERT_MSG(test, result == 0, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To U64: Convert \"-1\""); + Dqn_TesterBegin(&test, "To U64: Convert \"-1\""); Dqn_u64 result = Dqn_CStringToU64("-1"); - DQN_TEST_ASSERT_MSG(test, result == 0, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To U64: Convert \"1.2\""); + Dqn_TesterBegin(&test, "To U64: Convert \"1.2\""); Dqn_u64 result = Dqn_CStringToU64("1.2"); - DQN_TEST_ASSERT_MSG(test, result == 1, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 1, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To U64: Convert \"1,234\""); + Dqn_TesterBegin(&test, "To U64: Convert \"1,234\""); Dqn_u64 result = Dqn_CStringToU64("1,234"); - DQN_TEST_ASSERT_MSG(test, result == 1234, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 1234, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To U64: Convert \"1,2\""); + Dqn_TesterBegin(&test, "To U64: Convert \"1,2\""); Dqn_u64 result = Dqn_CStringToU64("1,2"); - DQN_TEST_ASSERT_MSG(test, result == 12, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 12, "result: %zu", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "To U64: Convert \"12a3\""); + Dqn_TesterBegin(&test, "To U64: Convert \"12a3\""); Dqn_u64 result = Dqn_CStringToU64("12a3"); - DQN_TEST_ASSERT_MSG(test, result == 12, "result: %zu", result); + DQN_TESTER_ASSERTF(&test, result == 12, "result: %zu", result); + Dqn_TesterEnd(&test); } // --------------------------------------------------------------------------------------------- // NOTE: Dqn_CStringFind // --------------------------------------------------------------------------------------------- { - DQN_TEST(test, "Find: String (char) is not in buffer"); + Dqn_TesterBegin(&test, "Find: String (char) is not in buffer"); char const buf[] = "836a35becd4e74b66a0d6844d51f1a63018c7ebc44cf7e109e8e4bba57eefb55"; char const find[] = "2"; char const *result = Dqn_CStringFind(buf, find, Dqn_CharCountI(buf), Dqn_CharCountI(find)); - DQN_TEST_ASSERT(test, result == nullptr); + DQN_TESTER_ASSERT(&test, result == nullptr); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Find: String (char) is in buffer"); + Dqn_TesterBegin(&test, "Find: String (char) is in buffer"); char const buf[] = "836a35becd4e74b66a0d6844d51f1a63018c7ebc44cf7e109e8e4bba57eefb55"; char const find[] = "6"; char const *result = Dqn_CStringFind(buf, find, Dqn_CharCountI(buf), Dqn_CharCountI(find)); - DQN_TEST_ASSERT(test, result != nullptr); - DQN_TEST_ASSERT(test, result[0] == '6' && result[1] == 'a'); + DQN_TESTER_ASSERT(&test, result != nullptr); + DQN_TESTER_ASSERT(&test, result[0] == '6' && result[1] == 'a'); + Dqn_TesterEnd(&test); } // --------------------------------------------------------------------------------------------- // NOTE: Dqn_CStringFileNameFromPath // --------------------------------------------------------------------------------------------- { - DQN_TEST(test, "File name from Windows path"); + Dqn_TesterBegin(&test, "File name from Windows path"); Dqn_isize file_name_size = 0; char const buf[] = "C:\\ABC\\test.exe"; char const *result = Dqn_CStringFileNameFromPath(buf, Dqn_CharCountI(buf), &file_name_size); - DQN_TEST_ASSERT_MSG(test, file_name_size == 8, "size: %I64d", file_name_size); - DQN_TEST_ASSERT_MSG(test, Dqn_StringInit(result, file_name_size) == DQN_STRING("test.exe"), "%.*s", (int)file_name_size, result); + DQN_TESTER_ASSERTF(&test, file_name_size == 8, "size: %I64d", file_name_size); + DQN_TESTER_ASSERTF(&test, Dqn_StringInit(result, file_name_size) == DQN_STRING("test.exe"), "%.*s", DQN_CAST(int)file_name_size, result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "File name from Linux path"); + Dqn_TesterBegin(&test, "File name from Linux path"); Dqn_isize file_name_size = 0; char const buf[] = "/ABC/test.exe"; char const *result = Dqn_CStringFileNameFromPath(buf, Dqn_CharCountI(buf), &file_name_size); - DQN_TEST_ASSERT_MSG(test, file_name_size == 8, "size: %I64d", file_name_size); - DQN_TEST_ASSERT_MSG(test, Dqn_StringInit(result, file_name_size) == DQN_STRING("test.exe"), "%.*s", (int)file_name_size, result); + DQN_TESTER_ASSERTF(&test, file_name_size == 8, "size: %I64d", file_name_size); + DQN_TESTER_ASSERTF(&test, Dqn_StringInit(result, file_name_size) == DQN_STRING("test.exe"), "%.*s", (int)file_name_size, result); + Dqn_TesterEnd(&test); } // --------------------------------------------------------------------------------------------- // NOTE: Dqn_CStringTrimPrefix // --------------------------------------------------------------------------------------------- { - DQN_TEST(test, "Trim prefix"); + Dqn_TesterBegin(&test, "Trim prefix"); char const prefix[] = "@123"; char const buf[] = "@123string"; Dqn_isize trimmed_size = 0; char const *result = Dqn_CStringTrimPrefix(buf, Dqn_CharCountI(buf), prefix, Dqn_CharCountI(prefix), &trimmed_size); - DQN_TEST_ASSERT_MSG(test, trimmed_size == 6, "size: %I64d", trimmed_size); - DQN_TEST_ASSERT_MSG(test, Dqn_StringInit(result, trimmed_size) == DQN_STRING("string"), "%.*s", (int)trimmed_size, result); + DQN_TESTER_ASSERTF(&test, trimmed_size == 6, "size: %I64d", trimmed_size); + DQN_TESTER_ASSERTF(&test, Dqn_StringInit(result, trimmed_size) == DQN_STRING("string"), "%.*s", (int)trimmed_size, result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Trim prefix, nullptr trimmed size"); + Dqn_TesterBegin(&test, "Trim prefix, nullptr trimmed size"); char const prefix[] = "@123"; char const buf[] = "@123string"; char const *result = Dqn_CStringTrimPrefix(buf, Dqn_CharCountI(buf), prefix, Dqn_CharCountI(prefix), nullptr); - DQN_TEST_ASSERT(test, result); + DQN_TESTER_ASSERT(&test, result); + Dqn_TesterEnd(&test); } // --------------------------------------------------------------------------------------------- // NOTE: Dqn_CStringIsAllDigits // --------------------------------------------------------------------------------------------- { - DQN_TEST(test, "Is all digits fails on non-digit string"); + Dqn_TesterBegin(&test, "Is all digits fails on non-digit string"); char const buf[] = "@123string"; Dqn_b32 result = Dqn_CStringIsAllDigits(buf, Dqn_CharCountI(buf)); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits fails on nullptr"); + Dqn_TesterBegin(&test, "Is all digits fails on nullptr"); Dqn_b32 result = Dqn_CStringIsAllDigits(nullptr, 0); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits fails on nullptr w/ size"); + Dqn_TesterBegin(&test, "Is all digits fails on nullptr w/ size"); Dqn_b32 result = Dqn_CStringIsAllDigits(nullptr, 1); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits fails on 0 size w/ string"); + Dqn_TesterBegin(&test, "Is all digits fails on 0 size w/ string"); char const buf[] = "@123string"; Dqn_b32 result = Dqn_CStringIsAllDigits(buf, 0); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits success"); + Dqn_TesterBegin(&test, "Is all digits success"); char const buf[] = "23"; Dqn_b32 result = Dqn_CStringIsAllDigits(buf, Dqn_CharCountI(buf)); - DQN_TEST_ASSERT(test, DQN_CAST(bool)result == true); + DQN_TESTER_ASSERT(&test, DQN_CAST(bool)result == true); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits fails on whitespace"); + Dqn_TesterBegin(&test, "Is all digits fails on whitespace"); char const buf[] = "23 "; Dqn_b32 result = Dqn_CStringIsAllDigits(buf, Dqn_CharCountI(buf)); - DQN_TEST_ASSERT(test, DQN_CAST(bool)result == false); + DQN_TESTER_ASSERT(&test, DQN_CAST(bool)result == false); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); return test; } -Dqn_Test Dqn_Test_String() +Dqn_Tester Dqn_Test_String() { - Dqn_Test test = {}; - DQN_TEST_GROUP(test, "Dqn_String"); + Dqn_Tester test = {}; + DQN_TESTER_BEGIN_GROUP("Dqn_String"); { - DQN_TEST(test, "Initialise with string literal w/ macro"); + Dqn_TesterBegin(&test, "Initialise with string literal w/ macro"); Dqn_String string = DQN_STRING("AB"); - DQN_TEST_ASSERT_MSG(test, string.size == 2, "size: %I64d", string.size); - DQN_TEST_ASSERT_MSG(test, string.cap == 2, "cap: %I64d", string.cap); - DQN_TEST_ASSERT_MSG(test, string.str[0] == 'A', "string[0]: %c", string.str[0]); - DQN_TEST_ASSERT_MSG(test, string.str[1] == 'B', "string[1]: %c", string.str[1]); + DQN_TESTER_ASSERTF(&test, string.size == 2, "size: %I64d", string.size); + DQN_TESTER_ASSERTF(&test, string.cap == 2, "cap: %I64d", string.cap); + DQN_TESTER_ASSERTF(&test, string.str[0] == 'A', "string[0]: %c", string.str[0]); + DQN_TESTER_ASSERTF(&test, string.str[1] == 'B', "string[1]: %c", string.str[1]); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Initialise with format string"); + Dqn_TesterBegin(&test, "Initialise with format string"); Dqn_Arena arena = {}; Dqn_String string = Dqn_StringFmt(&arena, "%s", "AB"); - DQN_TEST_ASSERT_MSG(test, string.size == 2, "size: %I64d", string.size); - DQN_TEST_ASSERT_MSG(test, string.cap == 2, "cap: %I64d", string.cap); - DQN_TEST_ASSERT_MSG(test, string.str[0] == 'A', "string[0]: %c", string.str[0]); - DQN_TEST_ASSERT_MSG(test, string.str[1] == 'B', "string[1]: %c", string.str[1]); - DQN_TEST_ASSERT_MSG(test, string.str[2] == 0, "string[2]: %c", string.str[2]); + DQN_TESTER_ASSERTF(&test, string.size == 2, "size: %I64d", string.size); + DQN_TESTER_ASSERTF(&test, string.cap == 2, "cap: %I64d", string.cap); + DQN_TESTER_ASSERTF(&test, string.str[0] == 'A', "string[0]: %c", string.str[0]); + DQN_TESTER_ASSERTF(&test, string.str[1] == 'B', "string[1]: %c", string.str[1]); + DQN_TESTER_ASSERTF(&test, string.str[2] == 0, "string[2]: %c", string.str[2]); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Copy string"); + Dqn_TesterBegin(&test, "Copy string"); Dqn_Arena arena = {}; Dqn_String string = DQN_STRING("AB"); Dqn_String copy = Dqn_StringCopy(string, &arena); - DQN_TEST_ASSERT_MSG(test, copy.size == 2, "size: %I64d", copy.size); - DQN_TEST_ASSERT_MSG(test, copy.cap == 2, "cap: %I64d", copy.cap); - DQN_TEST_ASSERT_MSG(test, copy.str[0] == 'A', "copy[0]: %c", copy.str[0]); - DQN_TEST_ASSERT_MSG(test, copy.str[1] == 'B', "copy[1]: %c", copy.str[1]); - DQN_TEST_ASSERT_MSG(test, copy.str[2] == 0, "copy[2]: %c", copy.str[2]); + DQN_TESTER_ASSERTF(&test, copy.size == 2, "size: %I64d", copy.size); + DQN_TESTER_ASSERTF(&test, copy.cap == 2, "cap: %I64d", copy.cap); + DQN_TESTER_ASSERTF(&test, copy.str[0] == 'A', "copy[0]: %c", copy.str[0]); + DQN_TESTER_ASSERTF(&test, copy.str[1] == 'B', "copy[1]: %c", copy.str[1]); + DQN_TESTER_ASSERTF(&test, copy.str[2] == 0, "copy[2]: %c", copy.str[2]); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Trim whitespace around string"); + Dqn_TesterBegin(&test, "Trim whitespace around string"); Dqn_String string = Dqn_StringTrimWhitespaceAround(DQN_STRING(" AB ")); - DQN_TEST_ASSERT_MSG(test, string.size == 2, "size: %I64d", string.size); - DQN_TEST_ASSERT_MSG(test, string.cap == 2, "cap: %I64d", string.cap); - DQN_TEST_ASSERT_MSG(test, string.str[0] == 'A', "string[0]: %c", string.str[0]); - DQN_TEST_ASSERT_MSG(test, string.str[1] == 'B', "string[1]: %c", string.str[1]); - DQN_TEST_ASSERT_MSG(test, string.str[2] == ' ', "string[1]: %c", string.str[1]); + DQN_TESTER_ASSERTF(&test, string.size == 2, "size: %I64d", string.size); + DQN_TESTER_ASSERTF(&test, string.cap == 2, "cap: %I64d", string.cap); + DQN_TESTER_ASSERTF(&test, string.str[0] == 'A', "string[0]: %c", string.str[0]); + DQN_TESTER_ASSERTF(&test, string.str[1] == 'B', "string[1]: %c", string.str[1]); + DQN_TESTER_ASSERTF(&test, string.str[2] == ' ', "string[1]: %c", string.str[1]); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Allocate string from arena"); + Dqn_TesterBegin(&test, "Allocate string from arena"); Dqn_Arena arena = {}; Dqn_String string = Dqn_StringAllocate(&arena, 2, Dqn_ZeroMem::No); - DQN_TEST_ASSERT_MSG(test, string.size == 0, "size: %I64d", string.size); - DQN_TEST_ASSERT_MSG(test, string.cap == 2, "cap: %I64d", string.cap); + DQN_TESTER_ASSERTF(&test, string.size == 0, "size: %I64d", string.size); + DQN_TESTER_ASSERTF(&test, string.cap == 2, "cap: %I64d", string.cap); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Append to allocated string"); + Dqn_TesterBegin(&test, "Append to allocated string"); Dqn_Arena arena = {}; Dqn_String string = Dqn_StringAllocate(&arena, 2, Dqn_ZeroMem::No); Dqn_StringAppendFmt(&string, "%c", 'A'); Dqn_StringAppendFmt(&string, "%c", 'B'); - DQN_TEST_ASSERT_MSG(test, string.size == 2, "size: %I64d", string.size); - DQN_TEST_ASSERT_MSG(test, string.cap == 2, "cap: %I64d", string.cap); - DQN_TEST_ASSERT_MSG(test, string.str[0] == 'A', "string[0]: %c", string.str[0]); - DQN_TEST_ASSERT_MSG(test, string.str[1] == 'B', "string[1]: %c", string.str[1]); - DQN_TEST_ASSERT_MSG(test, string.str[2] == 0, "string[2]: %c", string.str[2]); + DQN_TESTER_ASSERTF(&test, string.size == 2, "size: %I64d", string.size); + DQN_TESTER_ASSERTF(&test, string.cap == 2, "cap: %I64d", string.cap); + DQN_TESTER_ASSERTF(&test, string.str[0] == 'A', "string[0]: %c", string.str[0]); + DQN_TESTER_ASSERTF(&test, string.str[1] == 'B', "string[1]: %c", string.str[1]); + DQN_TESTER_ASSERTF(&test, string.str[2] == 0, "string[2]: %c", string.str[2]); + Dqn_TesterEnd(&test); } // --------------------------------------------------------------------------------------------- // NOTE: Dqn_CStringTrim[Prefix/Suffix] // --------------------------------------------------------------------------------------------- { - DQN_TEST(test, "Trim prefix with matching prefix"); + Dqn_TesterBegin(&test, "Trim prefix with matching prefix"); Dqn_String input = DQN_STRING("nft/abc"); Dqn_String result = Dqn_StringTrimPrefix(input, DQN_STRING("nft/")); - DQN_TEST_ASSERT_MSG(test, result == DQN_STRING("abc"), "%.*s", DQN_STRING_FMT(result)); + DQN_TESTER_ASSERTF(&test, result == DQN_STRING("abc"), "%.*s", DQN_STRING_FMT(result)); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Trim prefix with non matching prefix"); + Dqn_TesterBegin(&test, "Trim prefix with non matching prefix"); Dqn_String input = DQN_STRING("nft/abc"); Dqn_String result = Dqn_StringTrimPrefix(input, DQN_STRING(" ft/")); - DQN_TEST_ASSERT_MSG(test, result == input, "%.*s", DQN_STRING_FMT(result)); + DQN_TESTER_ASSERTF(&test, result == input, "%.*s", DQN_STRING_FMT(result)); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Trim suffix with matching suffix"); + Dqn_TesterBegin(&test, "Trim suffix with matching suffix"); Dqn_String input = DQN_STRING("nft/abc"); Dqn_String result = Dqn_StringTrimSuffix(input, DQN_STRING("abc")); - DQN_TEST_ASSERT_MSG(test, result == DQN_STRING("nft/"), "%.*s", DQN_STRING_FMT(result)); + DQN_TESTER_ASSERTF(&test, result == DQN_STRING("nft/"), "%.*s", DQN_STRING_FMT(result)); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Trim suffix with non matching suffix"); + Dqn_TesterBegin(&test, "Trim suffix with non matching suffix"); Dqn_String input = DQN_STRING("nft/abc"); Dqn_String result = Dqn_StringTrimSuffix(input, DQN_STRING("ab")); - DQN_TEST_ASSERT_MSG(test, result == input, "%.*s", DQN_STRING_FMT(result)); + DQN_TESTER_ASSERTF(&test, result == input, "%.*s", DQN_STRING_FMT(result)); + Dqn_TesterEnd(&test); } @@ -1347,91 +1370,102 @@ Dqn_Test Dqn_Test_String() // NOTE: Dqn_StringIsAllDigits // --------------------------------------------------------------------------------------------- { - DQN_TEST(test, "Is all digits fails on non-digit string"); + Dqn_TesterBegin(&test, "Is all digits fails on non-digit string"); Dqn_b32 result = Dqn_StringIsAllDigits(DQN_STRING("@123string")); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits fails on nullptr"); + Dqn_TesterBegin(&test, "Is all digits fails on nullptr"); Dqn_b32 result = Dqn_StringIsAllDigits(Dqn_StringInit(nullptr, 0)); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits fails on nullptr w/ size"); + Dqn_TesterBegin(&test, "Is all digits fails on nullptr w/ size"); Dqn_b32 result = Dqn_StringIsAllDigits(Dqn_StringInit(nullptr, 1)); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits fails on string w/ 0 size"); + Dqn_TesterBegin(&test, "Is all digits fails on string w/ 0 size"); char const buf[] = "@123string"; Dqn_b32 result = Dqn_StringIsAllDigits(Dqn_StringInit(buf, 0)); - DQN_TEST_ASSERT(test, result == false); + DQN_TESTER_ASSERT(&test, result == false); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits success"); + Dqn_TesterBegin(&test, "Is all digits success"); Dqn_b32 result = Dqn_StringIsAllDigits(DQN_STRING("23")); - DQN_TEST_ASSERT(test, DQN_CAST(bool)result == true); + DQN_TESTER_ASSERT(&test, DQN_CAST(bool)result == true); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Is all digits fails on whitespace"); + Dqn_TesterBegin(&test, "Is all digits fails on whitespace"); Dqn_b32 result = Dqn_StringIsAllDigits(DQN_STRING("23 ")); - DQN_TEST_ASSERT(test, DQN_CAST(bool)result == false); + DQN_TESTER_ASSERT(&test, DQN_CAST(bool)result == false); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); return test; } -Dqn_Test Dqn_Test_TicketMutex() +Dqn_Tester Dqn_Test_TicketMutex() { - Dqn_Test test = {}; - DQN_TEST_GROUP(test, "Dqn_TicketMutex"); + Dqn_Tester test = {}; + DQN_TESTER_BEGIN_GROUP("Dqn_TicketMutex"); { // TODO: We don't have a meaningful test but since atomics are // implemented with a macro this ensures that we test that they are // written correctly. - DQN_TEST(test, "Ticket mutex start and stop"); + Dqn_TesterBegin(&test, "Ticket mutex start and stop"); Dqn_TicketMutex mutex = {}; Dqn_TicketMutexBegin(&mutex); Dqn_TicketMutexEnd(&mutex); - DQN_TEST_ASSERT(test, mutex.ticket == mutex.serving); + DQN_TESTER_ASSERT(&test, mutex.ticket == mutex.serving); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Ticket mutex start and stop w/ advanced API"); + Dqn_TesterBegin(&test, "Ticket mutex start and stop w/ advanced API"); Dqn_TicketMutex mutex = {}; unsigned int ticket_a = Dqn_TicketMutexMakeTicket(&mutex); unsigned int ticket_b = Dqn_TicketMutexMakeTicket(&mutex); - DQN_TEST_ASSERT(test, DQN_CAST(bool)Dqn_TicketMutexCanLock(&mutex, ticket_b) == false); - DQN_TEST_ASSERT(test, DQN_CAST(bool)Dqn_TicketMutexCanLock(&mutex, ticket_a) == true); + DQN_TESTER_ASSERT(&test, DQN_CAST(bool)Dqn_TicketMutexCanLock(&mutex, ticket_b) == false); + DQN_TESTER_ASSERT(&test, DQN_CAST(bool)Dqn_TicketMutexCanLock(&mutex, ticket_a) == true); Dqn_TicketMutexBeginTicket(&mutex, ticket_a); Dqn_TicketMutexEnd(&mutex); Dqn_TicketMutexBeginTicket(&mutex, ticket_b); Dqn_TicketMutexEnd(&mutex); - DQN_TEST_ASSERT(test, mutex.ticket == mutex.serving); - DQN_TEST_ASSERT(test, mutex.ticket == ticket_b + 1); + DQN_TESTER_ASSERT(&test, mutex.ticket == mutex.serving); + DQN_TESTER_ASSERT(&test, mutex.ticket == ticket_b + 1); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); return test; } -Dqn_Test Dqn_Test_Win() +Dqn_Tester Dqn_Test_Win() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_OS_WIN32) - DQN_TEST_GROUP(test, "Dqn_Win"); + DQN_TESTER_BEGIN_GROUP("Dqn_Win"); { - DQN_TEST(test, "UTF8 to wide character size calculation"); + Dqn_TesterBegin(&test, "UTF8 to wide character size calculation"); int result = Dqn_WinUTF8ToWCharSizeRequired(DQN_STRING("String")); - DQN_TEST_ASSERT_MSG(test, result == 6, "Size returned: %d. This size should be including the null-terminator", result); + DQN_TESTER_ASSERTF(&test, result == 6, "Size returned: %d. This size should be including the null-terminator", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "UTF8 to wide character"); + Dqn_TesterBegin(&test, "UTF8 to wide character"); Dqn_Arena arena = {}; Dqn_String const INPUT = DQN_STRING("String"); int size_required = Dqn_WinUTF8ToWCharSizeRequired(INPUT); @@ -1443,20 +1477,22 @@ Dqn_Test Dqn_Test_Win() int size_returned = Dqn_WinUTF8ToWChar(INPUT, string, size_required + 1); wchar_t const EXPECTED[] = {L'S', L't', L'r', L'i', L'n', L'g', 0}; - DQN_TEST_ASSERT_MSG(test, size_required == size_returned, "string_size: %d, result: %d", size_required, size_returned); - DQN_TEST_ASSERT_MSG(test, size_returned == Dqn_ArrayCount(EXPECTED) - 1, "string_size: %d, expected: %zu", size_returned, sizeof(EXPECTED)); - DQN_TEST_ASSERT(test, DQN_MEMCMP(EXPECTED, string, sizeof(EXPECTED)) == 0); + DQN_TESTER_ASSERTF(&test, size_required == size_returned, "string_size: %d, result: %d", size_required, size_returned); + DQN_TESTER_ASSERTF(&test, size_returned == Dqn_ArrayCount(EXPECTED) - 1, "string_size: %d, expected: %zu", size_returned, sizeof(EXPECTED)); + DQN_TESTER_ASSERT(&test, DQN_MEMCMP(EXPECTED, string, sizeof(EXPECTED)) == 0); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Wide char to UTF8 size calculation"); + Dqn_TesterBegin(&test, "Wide char to UTF8 size calculation"); int result = Dqn_WinWCharToUTF8SizeRequired(DQN_STRINGW(L"String")); - DQN_TEST_ASSERT_MSG(test, result == 6, "Size returned: %d. This size should be including the null-terminator", result); + DQN_TESTER_ASSERTF(&test, result == 6, "Size returned: %d. This size should be including the null-terminator", result); + Dqn_TesterEnd(&test); } { - DQN_TEST(test, "Wide char to UTF8"); + Dqn_TesterBegin(&test, "Wide char to UTF8"); Dqn_Arena arena = {}; Dqn_StringW const INPUT = DQN_STRINGW(L"String"); int size_required = Dqn_WinWCharToUTF8SizeRequired(INPUT); @@ -1468,11 +1504,13 @@ Dqn_Test Dqn_Test_Win() int size_returned = Dqn_WinWCharToUTF8(INPUT, string, size_required + 1); char const EXPECTED[] = {'S', 't', 'r', 'i', 'n', 'g', 0}; - DQN_TEST_ASSERT_MSG(test, size_required == size_returned, "string_size: %d, result: %d", size_required, size_returned); - DQN_TEST_ASSERT_MSG(test, size_returned == Dqn_ArrayCount(EXPECTED) - 1, "string_size: %d, expected: %zu", size_returned, sizeof(EXPECTED)); - DQN_TEST_ASSERT(test, DQN_MEMCMP(EXPECTED, string, sizeof(EXPECTED)) == 0); + DQN_TESTER_ASSERTF(&test, size_required == size_returned, "string_size: %d, result: %d", size_required, size_returned); + DQN_TESTER_ASSERTF(&test, size_returned == Dqn_ArrayCount(EXPECTED) - 1, "string_size: %d, expected: %zu", size_returned, sizeof(EXPECTED)); + DQN_TESTER_ASSERT(&test, DQN_MEMCMP(EXPECTED, string, sizeof(EXPECTED)) == 0); Dqn_ArenaFree(&arena); + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); #endif // DQN_OS_WIN32 return test; @@ -1503,7 +1541,7 @@ Dqn_String const DQN_TESTS__HASH_STRING[] = #undef DQN_TESTS_HASH_X_ENTRY }; -void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) +void Dqn_Test__KeccakDispatch(Dqn_Tester *test, int hash_type, Dqn_String input) { #if defined(DQN_KECCAK_H) Dqn_ThreadScratch scratch = Dqn_ThreadGetScratch(); @@ -1516,7 +1554,7 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) Dqn_KeccakBytes28 hash = Dqn_SHA3_224StringToBytes28(input); Dqn_KeccakBytes28 expect; FIPS202_SHA3_224(DQN_CAST(u8 *)input.str, input.size, (u8 *)expect.data); - DQN_TEST_ASSERT_MSG((*test), + DQN_TESTER_ASSERTF(test, Dqn_KeccakBytes28Equals(&hash, &expect), "\ninput: %.*s" "\nhash: %.*s" @@ -1533,7 +1571,7 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) Dqn_KeccakBytes32 hash = Dqn_SHA3_256StringToBytes32(input); Dqn_KeccakBytes32 expect; FIPS202_SHA3_256(DQN_CAST(u8 *)input.str, input.size, (u8 *)expect.data); - DQN_TEST_ASSERT_MSG((*test), + DQN_TESTER_ASSERTF(test, Dqn_KeccakBytes32Equals(&hash, &expect), "\ninput: %.*s" "\nhash: %.*s" @@ -1550,7 +1588,7 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) Dqn_KeccakBytes48 hash = Dqn_SHA3_384StringToBytes48(input); Dqn_KeccakBytes48 expect; FIPS202_SHA3_384(DQN_CAST(u8 *)input.str, input.size, (u8 *)expect.data); - DQN_TEST_ASSERT_MSG((*test), + DQN_TESTER_ASSERTF(test, Dqn_KeccakBytes48Equals(&hash, &expect), "\ninput: %.*s" "\nhash: %.*s" @@ -1567,7 +1605,7 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) Dqn_KeccakBytes64 hash = Dqn_SHA3_512StringToBytes64(input); Dqn_KeccakBytes64 expect; FIPS202_SHA3_512(DQN_CAST(u8 *)input.str, input.size, (u8 *)expect.data); - DQN_TEST_ASSERT_MSG((*test), + DQN_TESTER_ASSERTF(test, Dqn_KeccakBytes64Equals(&hash, &expect), "\ninput: %.*s" "\nhash: %.*s" @@ -1584,7 +1622,7 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) Dqn_KeccakBytes28 hash = Dqn_Keccak224StringToBytes28(input); Dqn_KeccakBytes28 expect; Keccak(1152, 448, DQN_CAST(u8 *)input.str, input.size, 0x01, (u8 *)expect.data, sizeof(expect)); - DQN_TEST_ASSERT_MSG((*test), + DQN_TESTER_ASSERTF(test, Dqn_KeccakBytes28Equals(&hash, &expect), "\ninput: %.*s" "\nhash: %.*s" @@ -1601,7 +1639,7 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) Dqn_KeccakBytes32 hash = Dqn_Keccak256StringToBytes32(input); Dqn_KeccakBytes32 expect; Keccak(1088, 512, DQN_CAST(u8 *)input.str, input.size, 0x01, (u8 *)expect.data, sizeof(expect)); - DQN_TEST_ASSERT_MSG((*test), + DQN_TESTER_ASSERTF(test, Dqn_KeccakBytes32Equals(&hash, &expect), "\ninput: %.*s" "\nhash: %.*s" @@ -1618,7 +1656,7 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) Dqn_KeccakBytes48 hash = Dqn_Keccak384StringToBytes48(input); Dqn_KeccakBytes48 expect; Keccak(832, 768, DQN_CAST(u8 *)input.str, input.size, 0x01, (u8 *)expect.data, sizeof(expect)); - DQN_TEST_ASSERT_MSG((*test), + DQN_TESTER_ASSERTF(test, Dqn_KeccakBytes48Equals(&hash, &expect), "\ninput: %.*s" "\nhash: %.*s" @@ -1635,7 +1673,7 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) Dqn_KeccakBytes64 hash = Dqn_Keccak512StringToBytes64(input); Dqn_KeccakBytes64 expect; Keccak(576, 1024, DQN_CAST(u8 *)input.str, input.size, 0x01, (u8 *)expect.data, sizeof(expect)); - DQN_TEST_ASSERT_MSG((*test), + DQN_TESTER_ASSERTF(test, Dqn_KeccakBytes64Equals(&hash, &expect), "\ninput: %.*s" "\nhash: %.*s" @@ -1651,9 +1689,9 @@ void Dqn_Test__KeccakDispatch(Dqn_Test *test, int hash_type, Dqn_String input) #endif // DQN_KECCAK_H } -Dqn_Test Dqn_Test_Keccak() +Dqn_Tester Dqn_Test_Keccak() { - Dqn_Test test = {}; + Dqn_Tester test = {}; #if defined(DQN_KECCAK_H) Dqn_String const INPUTS[] = { DQN_STRING("abc"), @@ -1663,7 +1701,7 @@ Dqn_Test Dqn_Test_Keccak() "pqrstnopqrstu"), }; - DQN_TEST_GROUP(test, "Dqn_Keccak"); + DQN_TESTER_BEGIN_GROUP("Dqn_Keccak"); for (int hash_type = 0; hash_type < Hash_Count; hash_type++) { pcg32_random_t rng = {}; @@ -1671,11 +1709,12 @@ Dqn_Test Dqn_Test_Keccak() for (Dqn_String input : INPUTS) { - DQN_TEST(test, "%.*s - Input: %.*s", DQN_STRING_FMT(DQN_TESTS__HASH_STRING[hash_type]), DQN_MIN(input.size, 54), input.str); + Dqn_TesterBegin(&test, "%.*s - Input: %.*s", DQN_STRING_FMT(DQN_TESTS__HASH_STRING[hash_type]), DQN_CAST(int)DQN_MIN(input.size, 54), input.str); Dqn_Test__KeccakDispatch(&test, hash_type, input); + Dqn_TesterEnd(&test); } - DQN_TEST(test, "%.*s - Deterministic random inputs", DQN_STRING_FMT(DQN_TESTS__HASH_STRING[hash_type])); + Dqn_TesterBegin(&test, "%.*s - Deterministic random inputs", DQN_STRING_FMT(DQN_TESTS__HASH_STRING[hash_type])); for (int index = 0; index < 128; index++) { char src[4096] = {}; @@ -1687,14 +1726,16 @@ Dqn_Test Dqn_Test_Keccak() Dqn_String input = Dqn_StringInit(src, src_size); Dqn_Test__KeccakDispatch(&test, hash_type, input); } + Dqn_TesterEnd(&test); } + DQN_TESTER_END_GROUP(&test); #endif // DQN_KECCAK_H return test; } void Dqn_Test_RunSuite() { - Dqn_Test tests[] + Dqn_Tester tests[] { Dqn_Test_Array(), Dqn_Test_File(), @@ -1717,7 +1758,7 @@ void Dqn_Test_RunSuite() int total_tests = 0; int total_good_tests = 0; - for (Dqn_Test &test : tests) + for (Dqn_Tester &test : tests) { total_tests += test.num_tests_in_group; total_good_tests += test.num_tests_ok_in_group;