Dqn/dqn_tests.cpp

1770 lines
73 KiB
C++
Raw Normal View History

2021-07-01 12:02:39 +00:00
// -------------------------------------------------------------------------------------------------
// NOTE: Preprocessor Config
// -------------------------------------------------------------------------------------------------
/*
#define DQN_TEST_WITH_MAIN Define this to enable the main function and allow standalone compiling
and running of the file.
2021-07-01 12:02:39 +00:00
*/
#if defined(DQN_TEST_WITH_MAIN)
#define DQN_IMPLEMENTATION
#define DQN_WITH_CRT_ALLOCATOR // Dqn_CRTAllocator
#define DQN_WITH_DSMAP // Dqn_DSMap
#define DQN_WITH_FIXED_ARRAY // Dqn_FixedArray
#define DQN_WITH_FIXED_STRING // Dqn_FixedString
#define DQN_WITH_HEX // Dqn_Hex and friends ...
#define DQN_WITH_JSON_WRITER // Dqn_JsonWriter
#define DQN_WITH_MAP // Dqn_Map
#define DQN_WITH_MATH // Dqn_V2/3/4/Mat4 and friends ...
#define DQN_WITH_THREAD_CONTEXT // Dqn_ThreadContext and friends ...
#include "dqn.h"
#define DQN_KECCAK_IMPLEMENTATION
#include "dqn_keccak.h"
2021-07-01 12:02:39 +00:00
#endif
#include "dqn_tests_helpers.cpp"
2022-02-17 10:01:31 +00:00
#define DQN_TESTER_IMPLEMENTATION
#include "dqn_tester.h"
2019-08-24 01:39:12 +00:00
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_Array()
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
DQN_TESTER_BEGIN_GROUP("Dqn_Array");
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_ArrayInitWithMemory
2019-08-24 01:39:12 +00:00
{
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Fixed Memory: Test add single item and can't allocate more");
2021-07-22 09:59:27 +00:00
int memory[4] = {};
2021-09-24 12:29:34 +00:00
Dqn_Array<int> 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);
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
2021-09-24 12:29:34 +00:00
int *added_item = Dqn_ArrayAdd(&array, 5);
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Fixed Memory: Test add array of items");
2021-07-22 09:59:27 +00:00
int memory[4] = {};
int DATA[] = {1, 2, 3};
2021-09-24 12:29:34 +00:00
Dqn_Array<int> array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/);
Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA));
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Fixed Memory: Test clear and clear with memory zeroed");
2021-07-22 09:59:27 +00:00
int memory[4] = {};
int DATA[] = {1, 2, 3};
2021-09-24 12:29:34 +00:00
Dqn_Array<int> array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/);
Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA));
Dqn_ArrayClear(&array, Dqn_ZeroMem::No);
2022-02-17 10:01:31 +00:00
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]);
2021-07-22 09:59:27 +00:00
2021-09-24 12:29:34 +00:00
Dqn_ArrayClear(&array, Dqn_ZeroMem::Yes);
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Fixed Memory: Test erase stable and erase unstable");
2021-07-22 09:59:27 +00:00
int memory[4] = {};
int DATA[] = {1, 2, 3, 4};
2021-09-24 12:29:34 +00:00
Dqn_Array<int> array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/);
Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA));
Dqn_ArrayEraseUnstable(&array, 1);
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
2021-09-24 12:29:34 +00:00
Dqn_ArrayEraseStable(&array, 0);
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Fixed Memory: Test array pop and peek");
2021-07-22 09:59:27 +00:00
int memory[4] = {};
int DATA[] = {1, 2, 3};
2021-09-24 12:29:34 +00:00
Dqn_Array<int> array = Dqn_ArrayInitWithMemory(memory, Dqn_ArrayCount(memory), 0 /*size*/);
Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA));
Dqn_ArrayPop(&array, 2);
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
2021-09-24 12:29:34 +00:00
int *peek_item = Dqn_ArrayPeek(&array);
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
}
}
2021-07-01 12:02:39 +00:00
2021-07-22 09:59:27 +00:00
// NOTE: Dynamic Memory: Dqn_Array
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dynamic Memory: Reserve and check over commit reallocates");
2021-09-24 12:29:34 +00:00
Dqn_Arena arena = {};
2021-07-28 11:10:25 +00:00
Dqn_Array<int> array = {};
array.arena = &arena;
2021-09-24 12:29:34 +00:00
Dqn_ArrayReserve(&array, 4);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, array.size == 0, "array.size: %zu", array.size);
DQN_TESTER_ASSERTF(&test, array.max == 4, "array.max: %zu", array.max);
2021-07-28 11:10:25 +00:00
int DATA[] = {1, 2, 3, 4};
2021-09-24 12:29:34 +00:00
Dqn_ArrayAddArray(&array, DATA, Dqn_ArrayCount(DATA));
2022-02-17 10:01:31 +00:00
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);
2021-07-28 11:10:25 +00:00
2021-09-24 12:29:34 +00:00
int *added_item = Dqn_ArrayAdd(&array, 5);
2022-02-17 10:01:31 +00:00
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);
2021-07-28 11:10:25 +00:00
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
return test;
2021-07-22 09:59:27 +00:00
}
2019-08-24 01:39:12 +00:00
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_File()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
DQN_TESTER_BEGIN_GROUP("Dqn_File");
{
2021-09-24 12:29:34 +00:00
Dqn_Arena arena = {};
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
// NOTE: Write step
Dqn_String8 const SRC_FILE = DQN_STRING("dqn_test_file");
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Write file, read it, copy it, move it and delete it");
Dqn_b32 write_result = Dqn_FileWriteFile(SRC_FILE.data, SRC_FILE.size, "test", 4);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, write_result);
DQN_TESTER_ASSERT(&test, Dqn_FileExists(SRC_FILE));
// NOTE: Read step
2021-09-24 12:29:34 +00:00
Dqn_Arena arena = {};
Dqn_String8 read_file = Dqn_FileArenaReadToString(SRC_FILE.data, SRC_FILE.size, &arena);
DQN_TESTER_ASSERTF(&test, Dqn_String8IsValid(read_file), "Failed to load file");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, read_file.size == 4, "File read wrong amount of bytes");
DQN_TESTER_ASSERTF(&test, Dqn_String8Eq(read_file, DQN_STRING("test")), "read(%zu): %.*s", read_file.size, DQN_STRING_FMT(read_file));
// NOTE: Copy step
Dqn_String8 const COPY_FILE = DQN_STRING("dqn_test_file_copy");
2021-09-24 12:29:34 +00:00
Dqn_b32 copy_result = Dqn_FileCopy(SRC_FILE, COPY_FILE, true /*overwrite*/);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, copy_result);
DQN_TESTER_ASSERT(&test, Dqn_FileExists(COPY_FILE));
// NOTE: Move step
Dqn_String8 const MOVE_FILE = DQN_STRING("dqn_test_file_move");
2021-09-24 12:29:34 +00:00
Dqn_b32 move_result = Dqn_FileMove(COPY_FILE, MOVE_FILE, true /*overwrite*/);
2022-02-17 10:01:31 +00:00
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
2021-09-24 12:29:34 +00:00
Dqn_b32 delete_src_file = Dqn_FileDelete(SRC_FILE);
Dqn_b32 delete_moved_file = Dqn_FileDelete(MOVE_FILE);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, delete_src_file);
DQN_TESTER_ASSERT(&test, delete_moved_file);
// NOTE: Deleting non-existent file fails
2021-09-24 12:29:34 +00:00
Dqn_b32 delete_non_existent_src_file = Dqn_FileDelete(SRC_FILE);
Dqn_b32 delete_non_existent_moved_file = Dqn_FileDelete(MOVE_FILE);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, delete_non_existent_moved_file == false);
DQN_TESTER_ASSERT(&test, delete_non_existent_src_file == false);
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
return test;
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_FixedArray()
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_WITH_FIXED_ARRAY)
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_FixedArray");
// NOTE: Dqn_FixedArrayInit
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Initialise from raw array");
2021-07-22 09:59:27 +00:00
int raw_array[] = {1, 2};
auto array = Dqn_FixedArrayInit<int, 4>(raw_array, (int)Dqn_ArrayCount(raw_array));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, array.size == 2);
DQN_TESTER_ASSERT(&test, array[0] == 1);
DQN_TESTER_ASSERT(&test, array[1] == 2);
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
2021-07-01 12:02:39 +00:00
// NOTE: Dqn_FixedArrayEraseStable
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Erase stable 1 element from array");
2021-07-22 09:59:27 +00:00
int raw_array[] = {1, 2, 3};
auto array = Dqn_FixedArrayInit<int, 4>(raw_array, (int)Dqn_ArrayCount(raw_array));
Dqn_FixedArrayEraseStable(&array, 1);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, array.size == 2);
DQN_TESTER_ASSERT(&test, array[0] == 1);
DQN_TESTER_ASSERT(&test, array[1] == 3);
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
2019-08-24 01:39:12 +00:00
// NOTE: Dqn_FixedArrayEraseUnstable
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Erase unstable 1 element from array");
2021-07-22 09:59:27 +00:00
int raw_array[] = {1, 2, 3};
auto array = Dqn_FixedArrayInit<int, 4>(raw_array, (int)Dqn_ArrayCount(raw_array));
Dqn_FixedArrayEraseUnstable(&array, 0);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, array.size == 2);
DQN_TESTER_ASSERT(&test, array[0] == 3);
DQN_TESTER_ASSERT(&test, array[1] == 2);
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
2019-08-24 03:38:58 +00:00
// NOTE: Dqn_FixedArrayAdd
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add 1 element to array");
2021-07-22 09:59:27 +00:00
int const ITEM = 2;
int raw_array[] = {1};
auto array = Dqn_FixedArrayInit<int, 4>(raw_array, (int)Dqn_ArrayCount(raw_array));
Dqn_FixedArrayAdd(&array, ITEM);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, array.size == 2);
DQN_TESTER_ASSERT(&test, array[0] == 1);
DQN_TESTER_ASSERT(&test, array[1] == ITEM);
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
// NOTE: Dqn_FixedArrayClear
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Clear array");
2021-07-22 09:59:27 +00:00
int raw_array[] = {1};
auto array = Dqn_FixedArrayInit<int, 4>(raw_array, (int)Dqn_ArrayCount(raw_array));
Dqn_FixedArrayClear(&array);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, array.size == 0);
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_WITH_FIXED_ARRAY
return test;
2021-07-22 09:59:27 +00:00
}
2021-07-01 12:02:39 +00:00
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_FixedString()
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_WITH_FIXED_STRING)
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_FixedString");
2019-08-24 03:38:58 +00:00
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_FixedStringAppend
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Append too much fails");
2021-07-22 09:59:27 +00:00
Dqn_FixedString<4> str = {};
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, Dqn_FixedStringAppend(&str, "abcd") == false, "We need space for the null-terminator");
Dqn_TesterEnd(&test);
2019-08-24 01:39:12 +00:00
}
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_FixedStringAppendFmt
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Append format string too much fails");
2021-07-22 09:59:27 +00:00
Dqn_FixedString<4> str = {};
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, Dqn_FixedStringAppendFmt(&str, "abcd") == false, "We need space for the null-terminator");
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_WITH_FIXED_STRING
return test;
2021-07-22 09:59:27 +00:00
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_Hex()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_WITH_HEX)
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_Hex");
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert 0x123");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0x123"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0x123, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert 0xFFFF");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0xFFFF"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0xFFFF, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert FFFF");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("FFFF"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0xFFFF, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert abCD");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("abCD"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0xabCD, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert 0xabCD");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0xabCD"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0xabCD, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert 0x");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0x"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0x0, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert 0X");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("0X"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0x0, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert 3");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("3"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 3, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert f");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("f"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0xf, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert g");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("g"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Convert -0x3");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_HexStringToU64(DQN_STRING("-0x3"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_WITH_HEX
return test;
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_M4()
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_WITH_MATH)
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_M4");
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Simple translate and scale matrix");
2021-09-24 12:29:34 +00:00
Dqn_M4 translate = Dqn_M4TranslateF(1, 2, 3);
Dqn_M4 scale = Dqn_M4ScaleF(2, 2, 2);
Dqn_M4 result = Dqn_M4Mul(translate, scale);
2021-07-22 09:59:27 +00:00
const Dqn_M4 EXPECT = {{
{2, 0, 0, 0},
{0, 2, 0, 0},
{0, 0, 2, 0},
{1, 2, 3, 1},
}};
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
memcmp(result.columns, EXPECT.columns, sizeof(EXPECT)) == 0,
"\nresult =\n%s\nexpected =\n%s",
Dqn_M4ColumnMajorString(result).data,
Dqn_M4ColumnMajorString(EXPECT).data);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_WITH_MATH
return test;
2021-07-22 09:59:27 +00:00
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_DSMap()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_WITH_DSMAP)
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_DSMap");
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add r-value item to map");
2021-09-24 12:29:34 +00:00
Dqn_DSMap<int> map = Dqn_DSMapInit<int>(128);
Dqn_DSMapEntry<int> *entry = Dqn_DSMapAddCopy(&map, 3 /*hash*/, 5 /*value*/);
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add l-value item to map");
2021-09-24 12:29:34 +00:00
Dqn_DSMap<int> map = Dqn_DSMapInit<int>(128);
int value = 5;
2021-09-24 12:29:34 +00:00
Dqn_DSMapEntry<int> *entry = Dqn_DSMapAdd(&map, 3 /*hash*/, value);
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Get item from map");
2021-09-24 12:29:34 +00:00
Dqn_DSMap<int> map = Dqn_DSMapInit<int>(128);
Dqn_DSMapEntry<int> *entry = Dqn_DSMapAddCopy(&map, 3 /*hash*/, 5 /*value*/);
Dqn_DSMapEntry<int> *get_entry = Dqn_DSMapGet(&map, 3 /*hash*/);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, get_entry == entry, "get_entry: %p, entry: %p", get_entry, entry);
Dqn_DSMapFree(&map, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Get non-existent item from map");
2021-09-24 12:29:34 +00:00
Dqn_DSMap<int> map = Dqn_DSMapInit<int>(128);
Dqn_DSMapEntry<int> *entry = Dqn_DSMapGet(&map, 3 /*hash*/);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, entry == nullptr);
Dqn_DSMapFree(&map, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Erase item from map");
2021-09-24 12:29:34 +00:00
Dqn_DSMap<int> map = Dqn_DSMapInit<int>(128);
Dqn_DSMapAddCopy(&map, 3 /*hash*/, 5 /*value*/);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, map.count == 1, "count: %I64d", map.count);
2021-09-24 12:29:34 +00:00
Dqn_DSMapErase(&map, 3 /*hash*/, Dqn_ZeroMem::No);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, map.count == 0, "count: %I64d", map.count);
Dqn_DSMapFree(&map, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Erase non-existent item from map");
2021-09-24 12:29:34 +00:00
Dqn_DSMap<int> map = Dqn_DSMapInit<int>(128);
Dqn_DSMapErase(&map, 3 /*hash*/, Dqn_ZeroMem::No);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, map.count == 0, "count: %I64d", map.count);
Dqn_DSMapFree(&map, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Test resize on maximum load");
const Dqn_isize INIT_SIZE = 4;
2021-09-24 12:29:34 +00:00
Dqn_DSMap<int> map = Dqn_DSMapInit<int>(INIT_SIZE);
Dqn_DSMapAddCopy(&map, 0 /*hash*/, 5 /*value*/);
Dqn_DSMapAddCopy(&map, 1 /*hash*/, 5 /*value*/);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, map.count == 2, "count: %I64d", map.count);
// This *should* cause a resize because 3/4 slots filled is 75% load
2021-09-24 12:29:34 +00:00
Dqn_DSMapAddCopy(&map, 6 /*hash*/, 5 /*value*/);
2022-02-17 10:01:31 +00:00
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
2022-02-17 10:01:31 +00:00
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_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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_WITH_DSMAP
return test;
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_Map()
2021-07-28 11:10:25 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_WITH_MAP)
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_Map");
2021-09-24 12:29:34 +00:00
Dqn_Arena arena = {};
2021-07-28 11:10:25 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add r-value item to map");
2021-09-24 12:29:34 +00:00
Dqn_Map<int> map = Dqn_MapInitWithArena<int>(&arena, 1);
Dqn_MapEntry<int> *entry = Dqn_MapAddCopy(&map, 3 /*hash*/, 5 /*value*/, Dqn_MapCollideRule::Overwrite);
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add l-value item to map");
2021-09-24 12:29:34 +00:00
Dqn_Map<int> map = Dqn_MapInitWithArena<int>(&arena, 1);
2021-07-28 11:10:25 +00:00
int value = 5;
2021-09-24 12:29:34 +00:00
Dqn_MapEntry<int> *entry = Dqn_MapAdd(&map, 3 /*hash*/, value, Dqn_MapCollideRule::Overwrite);
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add r-value item and overwrite on collision");
2021-09-24 12:29:34 +00:00
Dqn_Map<int> map = Dqn_MapInitWithArena<int>(&arena, 1);
Dqn_MapEntry<int> *entry_a = Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite);
Dqn_MapEntry<int> *entry_b = Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Overwrite);
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add r-value item and fail on collision");
2021-09-24 12:29:34 +00:00
Dqn_Map<int> map = Dqn_MapInitWithArena<int>(&arena, 1);
Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite);
Dqn_MapEntry<int> *entry_b = Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Fail);
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add r-value item and chain on collision");
2021-09-24 12:29:34 +00:00
Dqn_Map<int> map = Dqn_MapInitWithArena<int>(&arena, 1);
Dqn_MapEntry<int> *entry_a = Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite);
Dqn_MapEntry<int> *entry_b = Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Chain);
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add r-value item and get them back out again");
2021-09-24 12:29:34 +00:00
Dqn_Map<int> map = Dqn_MapInitWithArena<int>(&arena, 1);
Dqn_MapEntry<int> *entry_a = Dqn_MapAddCopy(&map, 3 /*hash*/, 5, Dqn_MapCollideRule::Overwrite);
Dqn_MapEntry<int> *entry_b = Dqn_MapAddCopy(&map, 4 /*hash*/, 6, Dqn_MapCollideRule::Chain);
2021-07-28 11:10:25 +00:00
2021-09-24 12:29:34 +00:00
Dqn_MapEntry<int> *entry_a_copy = Dqn_MapGet(&map, 3 /*hash*/);
Dqn_MapEntry<int> *entry_b_copy = Dqn_MapGet(&map, 4 /*hash*/);
2022-02-17 10:01:31 +00:00
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, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add r-value item and erase it");
2021-09-24 12:29:34 +00:00
Dqn_Map<int> map = Dqn_MapInitWithArena<int>(&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*/);
2021-07-28 11:10:25 +00:00
2021-09-24 12:29:34 +00:00
Dqn_MapErase(&map, 3 /*hash*/, Dqn_ZeroMem::No);
2022-02-17 10:01:31 +00:00
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);
2021-07-28 11:10:25 +00:00
2022-02-17 10:01:31 +00:00
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");
2021-07-28 11:10:25 +00:00
2021-09-24 12:29:34 +00:00
Dqn_MapEntry<int> *entry = Dqn_MapGet(&map, 4 /*hash*/);
2022-02-17 10:01:31 +00:00
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);
2021-07-28 11:10:25 +00:00
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Add r-value item and erase it, zeroing the memory out");
2021-09-24 12:29:34 +00:00
Dqn_Map<int> map = Dqn_MapInitWithArena<int>(&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*/);
2021-07-28 11:10:25 +00:00
2021-09-24 12:29:34 +00:00
Dqn_MapErase(&map, 3 /*hash*/, Dqn_ZeroMem::Yes);
2022-02-17 10:01:31 +00:00
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);
2021-07-28 11:10:25 +00:00
2022-02-17 10:01:31 +00:00
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");
2021-07-28 11:10:25 +00:00
2021-09-24 12:29:34 +00:00
Dqn_MapEntry<int> *entry = Dqn_MapGet(&map, 4 /*hash*/);
2022-02-17 10:01:31 +00:00
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);
2021-07-28 11:10:25 +00:00
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
// 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
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_WITH_MAP
return test;
2021-07-28 11:10:25 +00:00
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_Intrinsics()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
2021-07-28 11:10:25 +00:00
// 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.
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_Atomic");
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_AtomicAddU32");
Dqn_u32 val = 0;
Dqn_AtomicAddU32(&val, 1);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, val == 1, "val: %u", val);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_AtomicAddU64");
Dqn_u64 val = 0;
Dqn_AtomicAddU64(&val, 1);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, val == 1, "val: %zu", val);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_AtomicSubU32");
Dqn_u32 val = 1;
Dqn_AtomicSubU32(&val, 1);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, val == 0, "val: %u", val);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_AtomicSubU64");
Dqn_u64 val = 1;
Dqn_AtomicSubU64(&val, 1);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, val == 0, "val: %zu", val);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_AtomicSetValue32");
long a = 0;
long b = 111;
Dqn_AtomicSetValue32(&a, b);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, a == b, "a: %lu, b: %lu", a, b);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_AtomicSetValue64");
Dqn_i64 a = 0;
Dqn_i64 b = 111;
Dqn_AtomicSetValue64(&a, b);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, a == b, "a: %I64i, b: %I64i", a, b);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_CPUClockCycle");
Dqn_CPUClockCycle();
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_CompilerReadBarrierAndCPUReadFence");
Dqn_CompilerReadBarrierAndCPUReadFence;
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_CompilerWriteBarrierAndCPUWriteFence");
Dqn_CompilerWriteBarrierAndCPUWriteFence;
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
return test;
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_Rect()
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_WITH_MATH)
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_Rect");
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_RectIntersection
2019-08-24 01:39:12 +00:00
{
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "No intersection");
2021-09-24 12:29:34 +00:00
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);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
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);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2019-08-24 01:39:12 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "A's min intersects B");
2021-09-24 12:29:34 +00:00
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);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
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);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2019-08-24 01:39:12 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "B's min intersects A");
2021-09-24 12:29:34 +00:00
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);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
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);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2019-08-24 01:39:12 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "A's max intersects B");
2021-09-24 12:29:34 +00:00
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);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
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);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2019-08-24 01:39:12 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "B's max intersects A");
2021-09-24 12:29:34 +00:00
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);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
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);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2019-08-24 01:39:12 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "B contains A");
2021-09-24 12:29:34 +00:00
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);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
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);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "A contains B");
2021-09-24 12:29:34 +00:00
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);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
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);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "A equals B");
2021-09-24 12:29:34 +00:00
Dqn_Rect a = Dqn_RectInitFromPosAndSize(Dqn_V2(0, 0), Dqn_V2(100, 100));
2021-07-22 09:59:27 +00:00
Dqn_Rect b = a;
2021-09-24 12:29:34 +00:00
Dqn_Rect ab = Dqn_RectIntersection(a, b);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test,
2021-07-22 09:59:27 +00:00
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);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_WITH_MATH
return test;
2021-07-22 09:59:27 +00:00
}
2019-08-24 01:39:12 +00:00
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_PerfCounter()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
DQN_TESTER_BEGIN_GROUP("Dqn_PerfCounter");
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Dqn_PerfCounterNow");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_PerfCounterNow();
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result != 0);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Consecutive ticks are ordered");
2021-09-24 12:29:34 +00:00
Dqn_u64 a = Dqn_PerfCounterNow();
Dqn_u64 b = Dqn_PerfCounterNow();
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, b >= a, "a: %zu, b: %zu", a, b);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Ticks to time are a correct order of magnitude");
2021-09-24 12:29:34 +00:00
Dqn_u64 a = Dqn_PerfCounterNow();
Dqn_u64 b = Dqn_PerfCounterNow();
2021-09-24 12:29:34 +00:00
Dqn_f64 s = Dqn_PerfCounterS(a, b);
Dqn_f64 ms = Dqn_PerfCounterMs(a, b);
Dqn_f64 micro_s = Dqn_PerfCounterMicroS(a, b);
Dqn_f64 ns = Dqn_PerfCounterNs(a, b);
2022-02-17 10:01:31 +00:00
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);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
return test;
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_OS()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
DQN_TESTER_BEGIN_GROUP("Dqn_OS");
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Generate secure RNG bytes with nullptr");
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_OSSecureRNGBytes(nullptr, 1);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Generate secure RNG 32 bytes");
char const ZERO[32] = {};
char buf[32] = {};
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_OSSecureRNGBytes(buf, Dqn_ArrayCountI(buf));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result);
DQN_TESTER_ASSERT(&test, DQN_MEMCMP(buf, ZERO, Dqn_ArrayCount(buf)) != 0);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Generate secure RNG 0 bytes");
char buf[32] = {};
buf[0] = 'Z';
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_OSSecureRNGBytes(buf, 0);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result);
DQN_TESTER_ASSERT(&test, buf[0] == 'Z');
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Query executable directory");
2021-09-24 12:29:34 +00:00
Dqn_Arena arena = {};
Dqn_String8 result = Dqn_OSEXEDir(&arena);
DQN_TESTER_ASSERT(&test, Dqn_String8IsValid(result));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, Dqn_FileDirExists(result), "result(%zu): %.*s", result.size, DQN_STRING_FMT(result));
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
return test;
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_Str()
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
DQN_TESTER_BEGIN_GROUP("Dqn_Str");
2019-08-24 01:39:12 +00:00
// ---------------------------------------------------------------------------------------------
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_CStringToI64
2019-08-24 01:39:12 +00:00
// ---------------------------------------------------------------------------------------------
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert nullptr");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64(nullptr);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == 0);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert empty string");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64("");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == 0);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert \"1\"");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64("1");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == 1);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert \"-0\"");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64("-0");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == 0);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert \"-1\"");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64("-1");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == -1);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert \"1.2\"");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64("1.2");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == 1);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert \"1,234\"");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64("1,234");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == 1234);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert \"1,2\"");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64("1,2");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == 12);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To I64: Convert \"12a3\"");
2021-09-24 12:29:34 +00:00
Dqn_i64 result = Dqn_CStringToI64("12a3");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == 12);
Dqn_TesterEnd(&test);
2019-08-24 01:39:12 +00:00
}
// ---------------------------------------------------------------------------------------------
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_CStringToU64
2019-08-24 01:39:12 +00:00
// ---------------------------------------------------------------------------------------------
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert nullptr");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64(nullptr);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert empty string");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64("");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert \"1\"");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64("1");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 1, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert \"-0\"");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64("-0");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert \"-1\"");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64("-1");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 0, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert \"1.2\"");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64("1.2");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 1, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert \"1,234\"");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64("1,234");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 1234, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert \"1,2\"");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64("1,2");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 12, "result: %zu", result);
Dqn_TesterEnd(&test);
}
2019-08-24 01:39:12 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "To U64: Convert \"12a3\"");
2021-09-24 12:29:34 +00:00
Dqn_u64 result = Dqn_CStringToU64("12a3");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, result == 12, "result: %zu", result);
Dqn_TesterEnd(&test);
2019-08-24 01:39:12 +00:00
}
// ---------------------------------------------------------------------------------------------
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_CStringFind
// ---------------------------------------------------------------------------------------------
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Find: String (char) is not in buffer");
char const buf[] = "836a35becd4e74b66a0d6844d51f1a63018c7ebc44cf7e109e8e4bba57eefb55";
char const find[] = "2";
2021-09-24 12:29:34 +00:00
char const *result = Dqn_CStringFind(buf, find, Dqn_CharCountI(buf), Dqn_CharCountI(find));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == nullptr);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Find: String (char) is in buffer");
char const buf[] = "836a35becd4e74b66a0d6844d51f1a63018c7ebc44cf7e109e8e4bba57eefb55";
char const find[] = "6";
2021-09-24 12:29:34 +00:00
char const *result = Dqn_CStringFind(buf, find, Dqn_CharCountI(buf), Dqn_CharCountI(find));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result != nullptr);
DQN_TESTER_ASSERT(&test, result[0] == '6' && result[1] == 'a');
Dqn_TesterEnd(&test);
}
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_CStringFileNameFromPath
// ---------------------------------------------------------------------------------------------
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "File name from Windows path");
Dqn_isize file_name_size = 0;
char const buf[] = "C:\\ABC\\test.exe";
2021-09-24 12:29:34 +00:00
char const *result = Dqn_CStringFileNameFromPath(buf, Dqn_CharCountI(buf), &file_name_size);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, file_name_size == 8, "size: %I64d", file_name_size);
DQN_TESTER_ASSERTF(&test, Dqn_String8Eq(Dqn_String8Init(result, file_name_size), DQN_STRING("test.exe")), "%.*s", DQN_CAST(int)file_name_size, result);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "File name from Linux path");
Dqn_isize file_name_size = 0;
char const buf[] = "/ABC/test.exe";
2021-09-24 12:29:34 +00:00
char const *result = Dqn_CStringFileNameFromPath(buf, Dqn_CharCountI(buf), &file_name_size);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, file_name_size == 8, "size: %I64d", file_name_size);
DQN_TESTER_ASSERTF(&test, Dqn_String8Eq(Dqn_String8Init(result, file_name_size), DQN_STRING("test.exe")), "%.*s", (int)file_name_size, result);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_CStringTrimPrefix
// ---------------------------------------------------------------------------------------------
{
2022-02-17 10:01:31 +00:00
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);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, trimmed_size == 6, "size: %I64d", trimmed_size);
DQN_TESTER_ASSERTF(&test, Dqn_String8Eq(Dqn_String8Init(result, trimmed_size), DQN_STRING("string")), "%.*s", (int)trimmed_size, result);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Trim prefix, nullptr trimmed size");
char const prefix[] = "@123";
char const buf[] = "@123string";
2021-09-24 12:29:34 +00:00
char const *result = Dqn_CStringTrimPrefix(buf, Dqn_CharCountI(buf), prefix, Dqn_CharCountI(prefix), nullptr);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result);
Dqn_TesterEnd(&test);
}
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_CStringIsAllDigits
// ---------------------------------------------------------------------------------------------
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on non-digit string");
char const buf[] = "@123string";
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_CStringIsAllDigits(buf, Dqn_CharCountI(buf));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on nullptr");
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_CStringIsAllDigits(nullptr, 0);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on nullptr w/ size");
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_CStringIsAllDigits(nullptr, 1);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on 0 size w/ string");
char const buf[] = "@123string";
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_CStringIsAllDigits(buf, 0);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits success");
char const buf[] = "23";
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_CStringIsAllDigits(buf, Dqn_CharCountI(buf));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, DQN_CAST(bool)result == true);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on whitespace");
char const buf[] = "23 ";
2021-09-24 12:29:34 +00:00
Dqn_b32 result = Dqn_CStringIsAllDigits(buf, Dqn_CharCountI(buf));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, DQN_CAST(bool)result == false);
Dqn_TesterEnd(&test);
2021-07-01 12:02:39 +00:00
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
return test;
2021-07-22 09:59:27 +00:00
}
2021-07-01 12:02:39 +00:00
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_String()
2021-07-28 11:10:25 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
DQN_TESTER_BEGIN_GROUP("Dqn_String8");
2021-07-28 11:10:25 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Initialise with string literal w/ macro");
Dqn_String8 string = DQN_STRING("AB");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, string.size == 2, "size: %I64d", string.size);
DQN_TESTER_ASSERTF(&test, string.data[0] == 'A', "string[0]: %c", string.data[0]);
DQN_TESTER_ASSERTF(&test, string.data[1] == 'B', "string[1]: %c", string.data[1]);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Initialise with format string");
Dqn_Arena arena = {};
Dqn_String8 string = Dqn_String8Fmt(&arena, "%s", "AB");
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, string.size == 2, "size: %I64d", string.size);
DQN_TESTER_ASSERTF(&test, string.data[0] == 'A', "string[0]: %c", string.data[0]);
DQN_TESTER_ASSERTF(&test, string.data[1] == 'B', "string[1]: %c", string.data[1]);
DQN_TESTER_ASSERTF(&test, string.data[2] == 0, "string[2]: %c", string.data[2]);
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Copy string");
2021-09-24 12:29:34 +00:00
Dqn_Arena arena = {};
Dqn_String8 string = DQN_STRING("AB");
Dqn_String8 copy = Dqn_String8Copy(&arena, string);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, copy.size == 2, "size: %I64d", copy.size);
DQN_TESTER_ASSERTF(&test, copy.data[0] == 'A', "copy[0]: %c", copy.data[0]);
DQN_TESTER_ASSERTF(&test, copy.data[1] == 'B', "copy[1]: %c", copy.data[1]);
DQN_TESTER_ASSERTF(&test, copy.data[2] == 0, "copy[2]: %c", copy.data[2]);
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Trim whitespace around string");
Dqn_String8 string = Dqn_String8TrimWhitespaceAround(DQN_STRING(" AB "));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(&test, string.size == 2, "size: %I64d", string.size);
DQN_TESTER_ASSERTF(&test, string.data[0] == 'A', "string[0]: %c", string.data[0]);
DQN_TESTER_ASSERTF(&test, string.data[1] == 'B', "string[1]: %c", string.data[1]);
DQN_TESTER_ASSERTF(&test, string.data[2] == ' ', "string[1]: %c", string.data[1]);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Allocate string from arena");
Dqn_Arena arena = {};
Dqn_String8 string = Dqn_String8Allocate(&arena, 2, Dqn_ZeroMem::No);
DQN_TESTER_ASSERTF(&test, string.size == 2, "size: %I64d", string.size);
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
2021-07-28 11:10:25 +00:00
}
2021-09-24 12:29:34 +00:00
// NOTE: Dqn_CStringTrim[Prefix/Suffix]
// ---------------------------------------------------------------------------------------------
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Trim prefix with matching prefix");
Dqn_String8 input = DQN_STRING("nft/abc");
Dqn_String8 result = Dqn_String8TrimPrefix(input, DQN_STRING("nft/"));
DQN_TESTER_ASSERTF(&test, Dqn_String8Eq(result, DQN_STRING("abc")), "%.*s", DQN_STRING_FMT(result));
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Trim prefix with non matching prefix");
Dqn_String8 input = DQN_STRING("nft/abc");
Dqn_String8 result = Dqn_String8TrimPrefix(input, DQN_STRING(" ft/"));
DQN_TESTER_ASSERTF(&test, Dqn_String8Eq(result, input), "%.*s", DQN_STRING_FMT(result));
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Trim suffix with matching suffix");
Dqn_String8 input = DQN_STRING("nft/abc");
Dqn_String8 result = Dqn_String8TrimSuffix(input, DQN_STRING("abc"));
DQN_TESTER_ASSERTF(&test, Dqn_String8Eq(result, DQN_STRING("nft/")), "%.*s", DQN_STRING_FMT(result));
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Trim suffix with non matching suffix");
Dqn_String8 input = DQN_STRING("nft/abc");
Dqn_String8 result = Dqn_String8TrimSuffix(input, DQN_STRING("ab"));
DQN_TESTER_ASSERTF(&test, Dqn_String8Eq(result, input), "%.*s", DQN_STRING_FMT(result));
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
// ---------------------------------------------------------------------------------------------
// NOTE: Dqn_String8IsAllDigits
// ---------------------------------------------------------------------------------------------
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on non-digit string");
Dqn_b32 result = Dqn_String8IsAllDigits(DQN_STRING("@123string"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on nullptr");
Dqn_b32 result = Dqn_String8IsAllDigits(Dqn_String8Init(nullptr, 0));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on nullptr w/ size");
Dqn_b32 result = Dqn_String8IsAllDigits(Dqn_String8Init(nullptr, 1));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on string w/ 0 size");
char const buf[] = "@123string";
Dqn_b32 result = Dqn_String8IsAllDigits(Dqn_String8Init(buf, 0));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, result == false);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits success");
Dqn_b32 result = Dqn_String8IsAllDigits(DQN_STRING("23"));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, DQN_CAST(bool)result == true);
Dqn_TesterEnd(&test);
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Is all digits fails on whitespace");
Dqn_b32 result = Dqn_String8IsAllDigits(DQN_STRING("23 "));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, DQN_CAST(bool)result == false);
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
return test;
2021-07-28 11:10:25 +00:00
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_TicketMutex()
2021-07-22 09:59:27 +00:00
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
DQN_TESTER_BEGIN_GROUP("Dqn_TicketMutex");
2021-07-22 09:59:27 +00:00
{
// 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.
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Ticket mutex start and stop");
2021-07-22 09:59:27 +00:00
Dqn_TicketMutex mutex = {};
2021-09-24 12:29:34 +00:00
Dqn_TicketMutexBegin(&mutex);
Dqn_TicketMutexEnd(&mutex);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, mutex.ticket == mutex.serving);
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
{
2022-02-17 10:01:31 +00:00
Dqn_TesterBegin(&test, "Ticket mutex start and stop w/ advanced API");
2021-07-22 09:59:27 +00:00
Dqn_TicketMutex mutex = {};
2021-09-24 12:29:34 +00:00
unsigned int ticket_a = Dqn_TicketMutexMakeTicket(&mutex);
unsigned int ticket_b = Dqn_TicketMutexMakeTicket(&mutex);
2022-02-17 10:01:31 +00:00
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);
2021-07-22 09:59:27 +00:00
2021-09-24 12:29:34 +00:00
Dqn_TicketMutexBeginTicket(&mutex, ticket_a);
Dqn_TicketMutexEnd(&mutex);
Dqn_TicketMutexBeginTicket(&mutex, ticket_b);
Dqn_TicketMutexEnd(&mutex);
2021-07-22 09:59:27 +00:00
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, mutex.ticket == mutex.serving);
DQN_TESTER_ASSERT(&test, mutex.ticket == ticket_b + 1);
Dqn_TesterEnd(&test);
2021-07-22 09:59:27 +00:00
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
return test;
2021-07-22 09:59:27 +00:00
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_Win()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_OS_WIN32)
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_Win");
{
Dqn_TesterBegin(&test, "String8 to String16 size required");
int result = Dqn_WinString8ToCString16(DQN_STRING("a"), nullptr, 0);
DQN_TESTER_ASSERTF(&test, result == 2, "Size returned: %d. This size should include the null-terminator", result);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
Dqn_TesterBegin(&test, "String16 to String8 size required");
int result = Dqn_WinString16ToCString8(DQN_STRINGW(L"a"), nullptr, 0);
DQN_TESTER_ASSERTF(&test, result == 2, "Size returned: %d. This size should include the null-terminator", result);
Dqn_TesterEnd(&test);
}
{
Dqn_TesterBegin(&test, "String8 to String16 size required");
int result = Dqn_WinString8ToCString16(DQN_STRING("String"), nullptr, 0);
DQN_TESTER_ASSERTF(&test, result == 7, "Size returned: %d. This size should include the null-terminator", result);
Dqn_TesterEnd(&test);
}
{
Dqn_TesterBegin(&test, "String16 to String8 size required");
int result = Dqn_WinString16ToCString8(DQN_STRINGW(L"String"), nullptr, 0);
DQN_TESTER_ASSERTF(&test, result == 7, "Size returned: %d. This size should include the null-terminator", result);
Dqn_TesterEnd(&test);
}
{
Dqn_TesterBegin(&test, "String8 to String16");
Dqn_Arena arena = {};
Dqn_String8 const INPUT = DQN_STRING("String");
int size_required = Dqn_WinString8ToCString16(INPUT, nullptr, 0);
wchar_t *string = Dqn_ArenaNewArray(&arena, wchar_t, size_required, Dqn_ZeroMem::No);
// Fill the string with error sentinels, which ensures the string is zero terminated
DQN_MEMSET(string, 'Z', size_required);
int size_returned = Dqn_WinString8ToCString16(INPUT, string, size_required);
wchar_t const EXPECTED[] = {L'S', L't', L'r', L'i', L'n', L'g', 0};
2022-02-17 10:01:31 +00:00
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), "string_size: %d, expected: %zu", size_returned, Dqn_ArrayCount(EXPECTED));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, DQN_MEMCMP(EXPECTED, string, sizeof(EXPECTED)) == 0);
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
{
Dqn_TesterBegin(&test, "String16 to String8: No null-terminate");
Dqn_Arena arena = {};
Dqn_String16 INPUT = DQN_STRINGW(L"String");
int size_required = Dqn_WinString16ToCString8(INPUT, nullptr, 0);
char *string = Dqn_ArenaNewArray(&arena, char, size_required, Dqn_ZeroMem::No);
// Fill the string with error sentinels, which ensures the string is zero terminated
DQN_MEMSET(string, 'Z', size_required);
int size_returned = Dqn_WinString16ToCString8(INPUT, string, size_required);
char const EXPECTED[] = {'S', 't', 'r', 'i', 'n', 'g', 0};
2022-02-17 10:01:31 +00:00
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), "string_size: %d, expected: %zu", size_returned, Dqn_ArrayCount(EXPECTED));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERT(&test, DQN_MEMCMP(EXPECTED, string, sizeof(EXPECTED)) == 0);
Dqn_ArenaFree(&arena, false /*clear_mem*/);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_OS_WIN32
return test;
}
#define DQN_TESTS_HASH_X_MACRO \
DQN_TESTS_HASH_X_ENTRY(SHA3_224, "SHA3-224") \
DQN_TESTS_HASH_X_ENTRY(SHA3_256, "SHA3-256") \
DQN_TESTS_HASH_X_ENTRY(SHA3_384, "SHA3-384") \
DQN_TESTS_HASH_X_ENTRY(SHA3_512, "SHA3-512") \
DQN_TESTS_HASH_X_ENTRY(Keccak_224, "Keccak-224") \
DQN_TESTS_HASH_X_ENTRY(Keccak_256, "Keccak-256") \
DQN_TESTS_HASH_X_ENTRY(Keccak_384, "Keccak-384") \
DQN_TESTS_HASH_X_ENTRY(Keccak_512, "Keccak-512") \
DQN_TESTS_HASH_X_ENTRY(Count, "Keccak-512")
enum Dqn_Tests__HashType
{
#define DQN_TESTS_HASH_X_ENTRY(enum_val, string) Hash_##enum_val,
DQN_TESTS_HASH_X_MACRO
#undef DQN_TESTS_HASH_X_ENTRY
};
Dqn_String8 const DQN_TESTS__HASH_STRING[] =
{
#define DQN_TESTS_HASH_X_ENTRY(enum_val, string) DQN_STRING(string),
DQN_TESTS_HASH_X_MACRO
#undef DQN_TESTS_HASH_X_ENTRY
};
void Dqn_Test__KeccakDispatch(Dqn_Tester *test, int hash_type, Dqn_String8 input)
{
#if defined(DQN_KECCAK_H)
2021-09-24 12:29:34 +00:00
Dqn_ThreadScratch scratch = Dqn_ThreadGetScratch();
Dqn_String8 input_hex = Dqn_HexBytesToHexStringArena(input.data, input.size, scratch.arena);
switch(hash_type)
{
case Hash_SHA3_224:
{
Dqn_KeccakBytes28 hash = Dqn_SHA3_224StringToBytes28(input);
Dqn_KeccakBytes28 expect;
FIPS202_SHA3_224(DQN_CAST(u8 *)input.data, input.size, (u8 *)expect.data);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(test,
Dqn_KeccakBytes28Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s"
,
DQN_STRING_FMT(input_hex),
DQN_KECCAK_STRING56_FMT(Dqn_KeccakBytes28ToHex(&hash).data),
DQN_KECCAK_STRING56_FMT(Dqn_KeccakBytes28ToHex(&expect).data));
}
break;
case Hash_SHA3_256:
{
Dqn_KeccakBytes32 hash = Dqn_SHA3_256StringToBytes32(input);
Dqn_KeccakBytes32 expect;
FIPS202_SHA3_256(DQN_CAST(u8 *)input.data, input.size, (u8 *)expect.data);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(test,
Dqn_KeccakBytes32Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s"
,
DQN_STRING_FMT(input_hex),
DQN_KECCAK_STRING64_FMT(Dqn_KeccakBytes32ToHex(&hash).data),
DQN_KECCAK_STRING64_FMT(Dqn_KeccakBytes32ToHex(&expect).data));
}
break;
case Hash_SHA3_384:
{
Dqn_KeccakBytes48 hash = Dqn_SHA3_384StringToBytes48(input);
Dqn_KeccakBytes48 expect;
FIPS202_SHA3_384(DQN_CAST(u8 *)input.data, input.size, (u8 *)expect.data);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(test,
Dqn_KeccakBytes48Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s"
,
DQN_STRING_FMT(input_hex),
DQN_KECCAK_STRING96_FMT(Dqn_KeccakBytes48ToHex(&hash).data),
DQN_KECCAK_STRING96_FMT(Dqn_KeccakBytes48ToHex(&expect).data));
}
break;
case Hash_SHA3_512:
{
Dqn_KeccakBytes64 hash = Dqn_SHA3_512StringToBytes64(input);
Dqn_KeccakBytes64 expect;
FIPS202_SHA3_512(DQN_CAST(u8 *)input.data, input.size, (u8 *)expect.data);
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(test,
Dqn_KeccakBytes64Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s"
,
DQN_STRING_FMT(input_hex),
DQN_KECCAK_STRING128_FMT(Dqn_KeccakBytes64ToHex(&hash).data),
DQN_KECCAK_STRING128_FMT(Dqn_KeccakBytes64ToHex(&expect).data));
}
break;
case Hash_Keccak_224:
{
Dqn_KeccakBytes28 hash = Dqn_Keccak224StringToBytes28(input);
Dqn_KeccakBytes28 expect;
Keccak(1152, 448, DQN_CAST(u8 *)input.data, input.size, 0x01, (u8 *)expect.data, sizeof(expect));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(test,
Dqn_KeccakBytes28Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s"
,
DQN_STRING_FMT(input_hex),
DQN_KECCAK_STRING56_FMT(Dqn_KeccakBytes28ToHex(&hash).data),
DQN_KECCAK_STRING56_FMT(Dqn_KeccakBytes28ToHex(&expect).data));
}
break;
case Hash_Keccak_256:
{
Dqn_KeccakBytes32 hash = Dqn_Keccak256StringToBytes32(input);
Dqn_KeccakBytes32 expect;
Keccak(1088, 512, DQN_CAST(u8 *)input.data, input.size, 0x01, (u8 *)expect.data, sizeof(expect));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(test,
Dqn_KeccakBytes32Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s"
,
DQN_STRING_FMT(input_hex),
DQN_KECCAK_STRING64_FMT(Dqn_KeccakBytes32ToHex(&hash).data),
DQN_KECCAK_STRING64_FMT(Dqn_KeccakBytes32ToHex(&expect).data));
}
break;
case Hash_Keccak_384:
{
Dqn_KeccakBytes48 hash = Dqn_Keccak384StringToBytes48(input);
Dqn_KeccakBytes48 expect;
Keccak(832, 768, DQN_CAST(u8 *)input.data, input.size, 0x01, (u8 *)expect.data, sizeof(expect));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(test,
Dqn_KeccakBytes48Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s"
,
DQN_STRING_FMT(input_hex),
DQN_KECCAK_STRING96_FMT(Dqn_KeccakBytes48ToHex(&hash).data),
DQN_KECCAK_STRING96_FMT(Dqn_KeccakBytes48ToHex(&expect).data));
}
break;
case Hash_Keccak_512:
{
Dqn_KeccakBytes64 hash = Dqn_Keccak512StringToBytes64(input);
Dqn_KeccakBytes64 expect;
Keccak(576, 1024, DQN_CAST(u8 *)input.data, input.size, 0x01, (u8 *)expect.data, sizeof(expect));
2022-02-17 10:01:31 +00:00
DQN_TESTER_ASSERTF(test,
Dqn_KeccakBytes64Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s"
,
DQN_STRING_FMT(input_hex),
DQN_KECCAK_STRING128_FMT(Dqn_KeccakBytes64ToHex(&hash).data),
DQN_KECCAK_STRING128_FMT(Dqn_KeccakBytes64ToHex(&expect).data));
}
break;
}
#endif // DQN_KECCAK_H
}
2022-02-17 10:01:31 +00:00
Dqn_Tester Dqn_Test_Keccak()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester test = {};
#if defined(DQN_KECCAK_H)
Dqn_String8 const INPUTS[] = {
DQN_STRING("abc"),
DQN_STRING(""),
DQN_STRING("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"),
DQN_STRING("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmno"
"pqrstnopqrstu"),
};
2022-02-17 10:01:31 +00:00
DQN_TESTER_BEGIN_GROUP("Dqn_Keccak");
for (int hash_type = 0; hash_type < Hash_Count; hash_type++)
{
pcg32_random_t rng = {};
pcg32_srandom_r(&rng, 0xd48e'be21'2af8'733d, 0x3f89'3bd2'd6b0'4eef);
for (Dqn_String8 input : INPUTS)
{
Dqn_TesterBegin(&test, "%.*s - Input: %.*s", DQN_STRING_FMT(DQN_TESTS__HASH_STRING[hash_type]), DQN_CAST(int)DQN_MIN(input.size, 54), input.data);
Dqn_Test__KeccakDispatch(&test, hash_type, input);
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
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] = {};
Dqn_u32 src_size = pcg32_boundedrand_r(&rng, sizeof(src));
for (int src_index = 0; src_index < src_size; src_index++)
src[src_index] = pcg32_boundedrand_r(&rng, 255);
Dqn_String8 input = Dqn_String8Init(src, src_size);
Dqn_Test__KeccakDispatch(&test, hash_type, input);
}
2022-02-17 10:01:31 +00:00
Dqn_TesterEnd(&test);
}
2022-02-17 10:01:31 +00:00
DQN_TESTER_END_GROUP(&test);
#endif // DQN_KECCAK_H
return test;
}
2021-07-22 09:59:27 +00:00
void Dqn_Test_RunSuite()
{
2022-02-17 10:01:31 +00:00
Dqn_Tester tests[]
{
Dqn_Test_Array(),
Dqn_Test_File(),
Dqn_Test_FixedArray(),
Dqn_Test_FixedString(),
Dqn_Test_Hex(),
Dqn_Test_Intrinsics(),
Dqn_Test_M4(),
Dqn_Test_DSMap(),
Dqn_Test_Map(),
Dqn_Test_Rect(),
Dqn_Test_PerfCounter(),
Dqn_Test_OS(),
Dqn_Test_Keccak(),
Dqn_Test_Str(),
Dqn_Test_String(),
Dqn_Test_TicketMutex(),
Dqn_Test_Win(),
};
int total_tests = 0;
int total_good_tests = 0;
2022-02-17 10:01:31 +00:00
for (Dqn_Tester &test : tests)
{
total_tests += test.num_tests_in_group;
total_good_tests += test.num_tests_ok_in_group;
}
fprintf(stdout, "Summary: %d/%d tests succeeded\n", total_good_tests, total_tests);
2019-08-24 01:39:12 +00:00
}
2021-07-01 12:02:39 +00:00
#if defined(DQN_TEST_WITH_MAIN)
int main(int argc, char *argv[])
2019-08-24 01:39:12 +00:00
{
(void)argv; (void)argc;
2021-07-22 09:59:27 +00:00
Dqn_Test_RunSuite();
2019-08-24 01:39:12 +00:00
return 0;
}
2021-07-01 12:02:39 +00:00
#endif
2019-08-24 01:39:12 +00:00