doylet/DN
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup base layer

Browse Source
This commit is contained in:
doylet
2025-10-19 22:31:56 +11:00
parent fd7a543e34
commit fff3fe1988
50 changed files with 5056 additions and 4848 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Extra/dn_async.cpp
+3 -3
View File
@@ -6,8 +6,8 @@
static DN_I32 DN_ASYNC_ThreadEntryPoint_(DN_OSThread *thread)
{
DN_OS_ThreadSetName(DN_Str8_FromIStr8(&thread->name));
DN_ASYNCCore *async = DN_CAST(DN_ASYNCCore *) thread->user_context;
DN_OS_ThreadSetName(DN_Str8FromPtr(thread->name.data, thread->name.size));
DN_ASYNCCore *async = DN_Cast(DN_ASYNCCore *) thread->user_context;
DN_Ring *ring = &async->ring;
for (;;) {
DN_OS_SemaphoreWait(&async->worker_sem, UINT32_MAX);
@@ -51,7 +51,7 @@ DN_API void DN_ASYNC_Init(DN_ASYNCCore *async, char *base, DN_USize base_size, D
async->threads = threads;
for (DN_ForIndexU(index, async->thread_count)) {
DN_OSThread *thread = async->threads + index;
DN_IStr8_AppendF(&thread->name, "ASYNC W%zu", index);
DN_FmtAppend(thread->name.data, &thread->name.size, DN_ArrayCountU(thread->name.data), "ASYNC W%zu", index);
DN_OS_ThreadInit(thread, DN_ASYNC_ThreadEntryPoint_, async);
}
}
Source/Extra/dn_bin_pack.cpp
+14 -14
View File
@@ -6,11 +6,11 @@ DN_API void DN_BinPack_U64(DN_BinPack *pack, DN_BinPackMode mode, DN_U64 *item)
if (mode == DN_BinPackMode_Serialise) {
DN_U64 it = *item;
do {
DN_U8 write_value = DN_CAST(DN_U8)(it & VALUE_MASK);
DN_U8 write_value = DN_Cast(DN_U8)(it & VALUE_MASK);
it >>= 7;
if (it)
write_value |= CONTINUE_BIT;
DN_Str8Builder_AppendBytesCopy(&pack->writer, &write_value, sizeof(write_value));
DN_Str8BuilderAppendBytesCopy(&pack->writer, &write_value, sizeof(write_value));
} while (it);
} else {
*item = 0;
@@ -18,7 +18,7 @@ DN_API void DN_BinPack_U64(DN_BinPack *pack, DN_BinPackMode mode, DN_U64 *item)
for (DN_U8 src = CONTINUE_BIT; (src & CONTINUE_BIT) && bits_read < 64; bits_read += 7) {
src = pack->read.data[pack->read_index++];
DN_U8 masked_src = src & VALUE_MASK;
*item |= (DN_CAST(DN_U64) masked_src << bits_read);
*item |= (DN_Cast(DN_U64) masked_src << bits_read);
}
}
}
@@ -109,10 +109,10 @@ DN_API void DN_BinPack_Str8FromArena(DN_BinPack *pack, DN_Arena *arena, DN_BinPa
{
DN_BinPack_VarInt_(pack, mode, &string->size, sizeof(string->size));
if (mode == DN_BinPackMode_Serialise) {
DN_Str8Builder_AppendBytesCopy(&pack->writer, string->data, string->size);
DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->size);
} else {
DN_Str8 src = DN_Str8_Slice(pack->read, pack->read_index, string->size);
*string = DN_Str8_FromStr8(arena, src);
DN_Str8 src = DN_Str8Slice(pack->read, pack->read_index, string->size);
*string = DN_Str8FromStr8Arena(arena, src);
pack->read_index += src.size;
}
}
@@ -121,17 +121,17 @@ DN_API void DN_BinPack_Str8FromPool(DN_BinPack *pack, DN_Pool *pool, DN_BinPackM
{
DN_BinPack_VarInt_(pack, mode, &string->size, sizeof(string->size));
if (mode == DN_BinPackMode_Serialise) {
DN_Str8Builder_AppendBytesCopy(&pack->writer, string->data, string->size);
DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->size);
} else {
DN_Str8 src = DN_Str8_Slice(pack->read, pack->read_index, string->size);
*string = DN_Pool_AllocStr8Copy(pool, src);
DN_Str8 src = DN_Str8Slice(pack->read, pack->read_index, string->size);
*string = DN_Str8FromStr8Pool(pool, src);
pack->read_index += src.size;
}
}
DN_API void DN_BinPack_BytesFromArena(DN_BinPack *pack, DN_Arena *arena, DN_BinPackMode mode, void **ptr, DN_USize *size)
{
DN_Str8 string = DN_Str8_Init(*ptr, *size);
DN_Str8 string = DN_Str8FromPtr(*ptr, *size);
DN_BinPack_Str8FromArena(pack, arena, mode, &string);
*ptr = string.data;
*size = string.size;
@@ -139,7 +139,7 @@ DN_API void DN_BinPack_BytesFromArena(DN_BinPack *pack, DN_Arena *arena, DN_BinP
DN_API void DN_BinPack_BytesFromPool(DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, void **ptr, DN_USize *size)
{
DN_Str8 string = DN_Str8_Init(*ptr, *size);
DN_Str8 string = DN_Str8FromPtr(*ptr, *size);
DN_BinPack_Str8FromPool(pack, pool, mode, &string);
*ptr = string.data;
*size = string.size;
@@ -149,9 +149,9 @@ DN_API void DN_BinPack_CArray(DN_BinPack *pack, DN_BinPackMode mode, void *ptr,
{
DN_BinPack_VarInt_(pack, mode, &size, sizeof(size));
if (mode == DN_BinPackMode_Serialise) {
DN_Str8Builder_AppendBytesCopy(&pack->writer, ptr, size);
DN_Str8BuilderAppendBytesCopy(&pack->writer, ptr, size);
} else {
DN_Str8 src = DN_Str8_Slice(pack->read, pack->read_index, size);
DN_Str8 src = DN_Str8Slice(pack->read, pack->read_index, size);
DN_Assert(src.size == size);
DN_Memcpy(ptr, src.data, DN_Min(src.size, size));
pack->read_index += src.size;
@@ -160,6 +160,6 @@ DN_API void DN_BinPack_CArray(DN_BinPack *pack, DN_BinPackMode mode, void *ptr,
DN_API DN_Str8 DN_BinPack_Build(DN_BinPack const *pack, DN_Arena *arena)
{
DN_Str8 result = DN_Str8Builder_Build(&pack->writer, arena);
DN_Str8 result = DN_Str8BuilderBuild(&pack->writer, arena);
return result;
}
Source/Extra/dn_cgen.cpp
+263 -274
View File
File diff suppressed because it is too large Load Diff
Source/Extra/dn_cgen.h
+2 -2
View File
@@ -180,10 +180,10 @@ enum DN_CGenEmit
DN_CGenEmit_Implementation = 1 << 1,
};
#define DN_CGen_MDToDNStr8(str8) DN_Str8_Init((str8).str, (str8).size)
#define DN_CGen_MDToDNStr8(str8) DN_Str8FromPtr((str8).str, (str8).size)
#define DN_CGen_DNToMDStr8(str8) \
{ \
DN_CAST(MD_u8 *) \
DN_Cast(MD_u8 *) \
(str8).data, \
(str8).size \
}
Source/Extra/dn_csv.cpp
+13 -13
View File
@@ -17,7 +17,7 @@ static bool DN_CSV_TokeniserValid(DN_CSVTokeniser *tokeniser)
static bool DN_CSV_TokeniserNextRow(DN_CSVTokeniser *tokeniser)
{
bool result = false;
if (DN_CSV_TokeniserValid(tokeniser) && DN_Str8_HasData(tokeniser->string)) {
if (DN_CSV_TokeniserValid(tokeniser) && DN_Str8HasData(tokeniser->string)) {
// NOTE: First time querying row iterator is nil, let tokeniser advance
if (tokeniser->it) {
// NOTE: Only advance the tokeniser if we're at the end of the line and
@@ -39,7 +39,7 @@ static DN_Str8 DN_CSV_TokeniserNextField(DN_CSVTokeniser *tokeniser)
if (!DN_CSV_TokeniserValid(tokeniser))
return result;
if (!DN_Str8_HasData(tokeniser->string)) {
if (!DN_Str8HasData(tokeniser->string)) {
tokeniser->bad = true;
return result;
}
@@ -111,8 +111,8 @@ static DN_Str8 DN_CSV_TokeniserNextField(DN_CSVTokeniser *tokeniser)
tokeniser->it++;
// NOTE: Generate the record
result.data = DN_CAST(char *) begin;
result.size = DN_CAST(int)(end - begin);
result.data = DN_Cast(char *) begin;
result.size = DN_Cast(int)(end - begin);
return result;
}
@@ -146,7 +146,7 @@ static int DN_CSV_TokeniserNextN(DN_CSVTokeniser *tokeniser, DN_Str8 *fields, in
int result = 0;
for (; result < fields_size; result++) {
fields[result] = column_iterator ? DN_CSV_TokeniserNextColumn(tokeniser) : DN_CSV_TokeniserNextField(tokeniser);
if (!DN_CSV_TokeniserValid(tokeniser) || !DN_Str8_HasData(fields[result]))
if (!DN_CSV_TokeniserValid(tokeniser) || !DN_Str8HasData(fields[result]))
break;
}
@@ -177,11 +177,11 @@ static void DN_CSV_PackU64(DN_CSVPack *pack, DN_CSVSerialise serialise, DN_U64 *
{
if (serialise == DN_CSVSerialise_Read) {
DN_Str8 csv_value = DN_CSV_TokeniserNextColumn(&pack->read_tokeniser);
DN_Str8ToU64Result to_u64 = DN_Str8_ToU64(csv_value, 0);
DN_Str8ToU64Result to_u64 = DN_Str8ToU64(csv_value, 0);
DN_Assert(to_u64.success);
*value = to_u64.value;
} else {
DN_Str8Builder_AppendF(&pack->write_builder, "%s%" PRIu64, pack->write_column++ ? "," : "", *value);
DN_Str8BuilderAppendF(&pack->write_builder, "%s%" PRIu64, pack->write_column++ ? "," : "", *value);
}
}
@@ -189,11 +189,11 @@ static void DN_CSV_PackI64(DN_CSVPack *pack, DN_CSVSerialise serialise, DN_I64 *
{
if (serialise == DN_CSVSerialise_Read) {
DN_Str8 csv_value = DN_CSV_TokeniserNextColumn(&pack->read_tokeniser);
DN_Str8ToI64Result to_i64 = DN_Str8_ToI64(csv_value, 0);
DN_Str8ToI64Result to_i64 = DN_Str8ToI64(csv_value, 0);
DN_Assert(to_i64.success);
*value = to_i64.value;
} else {
DN_Str8Builder_AppendF(&pack->write_builder, "%s%" PRIu64, pack->write_column++ ? "," : "", *value);
DN_Str8BuilderAppendF(&pack->write_builder, "%s%" PRIu64, pack->write_column++ ? "," : "", *value);
}
}
@@ -250,9 +250,9 @@ static void DN_CSV_PackStr8(DN_CSVPack *pack, DN_CSVSerialise serialise, DN_Str8
{
if (serialise == DN_CSVSerialise_Read) {
DN_Str8 csv_value = DN_CSV_TokeniserNextColumn(&pack->read_tokeniser);
*str8 = DN_Str8_FromStr8(arena, csv_value);
*str8 = DN_Str8FromStr8(arena, csv_value);
} else {
DN_Str8Builder_AppendF(&pack->write_builder, "%s%.*s", pack->write_column++ ? "," : "", DN_STR_FMT(*str8));
DN_Str8BuilderAppendF(&pack->write_builder, "%s%.*s", pack->write_column++ ? "," : "", DN_Str8PrintFmt(*str8));
}
}
@@ -263,7 +263,7 @@ static void DN_CSV_PackBuffer(DN_CSVPack *pack, DN_CSVSerialise serialise, void
*size = DN_Min(*size, csv_value.size);
DN_Memcpy(dest, csv_value.data, *size);
} else {
DN_Str8Builder_AppendF(&pack->write_builder, "%s%.*s", pack->write_column++ ? "," : "", DN_CAST(int)(*size), dest);
DN_Str8BuilderAppendF(&pack->write_builder, "%s%.*s", pack->write_column++ ? "," : "", DN_Cast(int)(*size), dest);
}
}
@@ -281,7 +281,7 @@ static bool DN_CSV_PackNewLine(DN_CSVPack *pack, DN_CSVSerialise serialise)
result = DN_CSV_TokeniserNextRow(&pack->read_tokeniser);
} else {
pack->write_column = 0;
result = DN_Str8Builder_AppendRef(&pack->write_builder, DN_STR8("\n"));
result = DN_Str8BuilderAppendRef(&pack->write_builder, DN_Str8Lit("\n"));
}
return result;
}
Source/Extra/dn_hash.cpp
+2 -2
View File
@@ -21,7 +21,7 @@
// Default values recommended by: http://isthe.com/chongo/tech/comp/fnv/
DN_API uint32_t DN_FNV1A32_Iterate(void const *bytes, DN_USize size, uint32_t hash)
{
auto buffer = DN_CAST(uint8_t const *)bytes;
auto buffer = DN_Cast(uint8_t const *)bytes;
for (DN_USize i = 0; i < size; i++)
hash = (buffer[i] ^ hash) * 16777619 /*FNV Prime*/;
return hash;
@@ -35,7 +35,7 @@ DN_API uint32_t DN_FNV1A32_Hash(void const *bytes, DN_USize size)
DN_API uint64_t DN_FNV1A64_Iterate(void const *bytes, DN_USize size, uint64_t hash)
{
auto buffer = DN_CAST(uint8_t const *)bytes;
auto buffer = DN_Cast(uint8_t const *)bytes;
for (DN_USize i = 0; i < size; i++)
hash = (buffer[i] ^ hash) * 1099511628211 /*FNV Prime*/;
return hash;
Source/Extra/dn_hash.h
+1 -1
View File
@@ -40,6 +40,6 @@ DN_API uint64_t DN_FNV1A64_Iterate (void const *bytes, DN_USize si
DN_API uint32_t DN_MurmurHash3_x86U32 (void const *key, int len, uint32_t seed);
DN_API DN_MurmurHash3 DN_MurmurHash3_x64U128 (void const *key, int len, uint32_t seed);
#define DN_MurmurHash3_x64U128AsU64(key, len, seed) (DN_MurmurHash3_x64U128(key, len, seed).e[0])
#define DN_MurmurHash3_x64U128AsU32(key, len, seed) (DN_CAST(uint32_t)DN_MurmurHash3_x64U128(key, len, seed).e[0])
#define DN_MurmurHash3_x64U128AsU32(key, len, seed) (DN_Cast(uint32_t)DN_MurmurHash3_x64U128(key, len, seed).e[0])
#endif // !defined(DN_HASH_H)
Source/Extra/dn_helpers.cpp
+12 -141
View File
@@ -106,7 +106,7 @@ DN_API DN_JSONBuilder DN_JSONBuilder_Init(DN_Arena *arena, int spaces_per_indent
DN_API DN_Str8 DN_JSONBuilder_Build(DN_JSONBuilder const *builder, DN_Arena *arena)
{
DN_Str8 result = DN_Str8Builder_Build(&builder->string_builder, arena);
DN_Str8 result = DN_Str8BuilderBuild(&builder->string_builder, arena);
return result;
}
@@ -142,18 +142,18 @@ DN_API void DN_JSONBuilder_KeyValue(DN_JSONBuilder *builder, DN_Str8 key, DN_Str
int spaces = builder->indent_level * spaces_per_indent;
if (key.size)
DN_Str8Builder_AppendF(&builder->string_builder,
DN_Str8BuilderAppendF(&builder->string_builder,
"%.*s%*c\"%.*s\": %.*s",
prefix_size,
prefix,
spaces,
' ',
DN_STR_FMT(key),
DN_STR_FMT(value));
DN_Str8PrintFmt(key),
DN_Str8PrintFmt(value));
else if (spaces == 0)
DN_Str8Builder_AppendF(&builder->string_builder, "%.*s%.*s", prefix_size, prefix, DN_STR_FMT(value));
DN_Str8BuilderAppendF(&builder->string_builder, "%.*s%.*s", prefix_size, prefix, DN_Str8PrintFmt(value));
else
DN_Str8Builder_AppendF(&builder->string_builder, "%.*s%*c%.*s", prefix_size, prefix, spaces, ' ', DN_STR_FMT(value));
DN_Str8BuilderAppendF(&builder->string_builder, "%.*s%*c%.*s", prefix_size, prefix, spaces, ' ', DN_Str8PrintFmt(value));
if (item == DN_JSONBuilderItem_OpenContainer)
builder->indent_level++;
@@ -164,7 +164,7 @@ DN_API void DN_JSONBuilder_KeyValue(DN_JSONBuilder *builder, DN_Str8 key, DN_Str
DN_API void DN_JSONBuilder_KeyValueFV(DN_JSONBuilder *builder, DN_Str8 key, char const *value_fmt, va_list args)
{
DN_OSTLSTMem tmem = DN_OS_TLSTMem(builder->string_builder.arena);
DN_Str8 value = DN_Str8_FromFV(tmem.arena, value_fmt, args);
DN_Str8 value = DN_Str8FromFmtVArena(tmem.arena, value_fmt, args);
DN_JSONBuilder_KeyValue(builder, key, value);
}
@@ -178,22 +178,22 @@ DN_API void DN_JSONBuilder_KeyValueF(DN_JSONBuilder *builder, DN_Str8 key, char
DN_API void DN_JSONBuilder_ObjectBeginNamed(DN_JSONBuilder *builder, DN_Str8 name)
{
DN_JSONBuilder_KeyValue(builder, name, DN_STR8("{"));
DN_JSONBuilder_KeyValue(builder, name, DN_Str8Lit("{"));
}
DN_API void DN_JSONBuilder_ObjectEnd(DN_JSONBuilder *builder)
{
DN_JSONBuilder_KeyValue(builder, DN_STR8(""), DN_STR8("}"));
DN_JSONBuilder_KeyValue(builder, DN_Str8Lit(""), DN_Str8Lit("}"));
}
DN_API void DN_JSONBuilder_ArrayBeginNamed(DN_JSONBuilder *builder, DN_Str8 name)
{
DN_JSONBuilder_KeyValue(builder, name, DN_STR8("["));
DN_JSONBuilder_KeyValue(builder, name, DN_Str8Lit("["));
}
DN_API void DN_JSONBuilder_ArrayEnd(DN_JSONBuilder *builder)
{
DN_JSONBuilder_KeyValue(builder, DN_STR8(""), DN_STR8("]"));
DN_JSONBuilder_KeyValue(builder, DN_Str8Lit(""), DN_Str8Lit("]"));
}
DN_API void DN_JSONBuilder_Str8Named(DN_JSONBuilder *builder, DN_Str8 key, DN_Str8 value)
@@ -239,136 +239,7 @@ DN_API void DN_JSONBuilder_F64Named(DN_JSONBuilder *builder, DN_Str8 key, double
DN_API void DN_JSONBuilder_BoolNamed(DN_JSONBuilder *builder, DN_Str8 key, bool value)
{
DN_Str8 value_string = value ? DN_STR8("true") : DN_STR8("false");
DN_Str8 value_string = value ? DN_Str8Lit("true") : DN_Str8Lit("false");
DN_JSONBuilder_KeyValueF(builder, key, "%.*s", value_string.size, value_string.data);
}
#endif // !defined(DN_NO_JSON_BUILDER)
// NOTE: DN_JobQueue ///////////////////////////////////////////////////////////////////////////////
DN_API DN_JobQueueSPMC DN_OS_JobQueueSPMCInit()
{
DN_JobQueueSPMC result = {};
result.thread_wait_for_job_semaphore = DN_OS_SemaphoreInit(0 /*initial_count*/);
result.wait_for_completion_semaphore = DN_OS_SemaphoreInit(0 /*initial_count*/);
result.complete_queue_write_semaphore = DN_OS_SemaphoreInit(DN_ArrayCountU(result.complete_queue));
result.mutex = DN_OS_MutexInit();
return result;
}
DN_API bool DN_OS_JobQueueSPMCCanAdd(DN_JobQueueSPMC const *queue, uint32_t count)
{
uint32_t read_index = queue->read_index;
uint32_t write_index = queue->write_index;
uint32_t size = write_index - read_index;
bool result = (size + count) <= DN_ArrayCountU(queue->jobs);
return result;
}
DN_API bool DN_OS_JobQueueSPMCAddArray(DN_JobQueueSPMC *queue, DN_Job *jobs, uint32_t count)
{
if (!queue)
return false;
uint32_t const pot_mask = DN_ArrayCountU(queue->jobs) - 1;
uint32_t read_index = queue->read_index;
uint32_t write_index = queue->write_index;
uint32_t size = write_index - read_index;
if ((size + count) > DN_ArrayCountU(queue->jobs))
return false;
for (size_t offset = 0; offset < count; offset++) {
uint32_t wrapped_write_index = (write_index + offset) & pot_mask;
queue->jobs[wrapped_write_index] = jobs[offset];
}
DN_OS_MutexLock(&queue->mutex);
queue->write_index += count;
DN_OS_SemaphoreIncrement(&queue->thread_wait_for_job_semaphore, count);
DN_OS_MutexUnlock(&queue->mutex);
return true;
}
DN_API bool DN_OS_JobQueueSPMCAdd(DN_JobQueueSPMC *queue, DN_Job job)
{
bool result = DN_OS_JobQueueSPMCAddArray(queue, &job, 1);
return result;
}
DN_API int32_t DN_OS_JobQueueSPMCThread(DN_OSThread *thread)
{
DN_JobQueueSPMC *queue = DN_CAST(DN_JobQueueSPMC *) thread->user_context;
uint32_t const pot_mask = DN_ArrayCountU(queue->jobs) - 1;
static_assert(DN_ArrayCountU(queue->jobs) == DN_ArrayCountU(queue->complete_queue), "PoT mask is used to mask access to both arrays");
for (;;) {
DN_OS_SemaphoreWait(&queue->thread_wait_for_job_semaphore, DN_OS_SEMAPHORE_INFINITE_TIMEOUT);
if (queue->quit)
break;
DN_Assert(queue->read_index != queue->write_index);
DN_OS_MutexLock(&queue->mutex);
uint32_t wrapped_read_index = queue->read_index & pot_mask;
DN_Job job = queue->jobs[wrapped_read_index];
queue->read_index += 1;
DN_OS_MutexUnlock(&queue->mutex);
job.elapsed_tsc -= DN_CPUGetTSC();
job.func(thread, job.user_context);
job.elapsed_tsc += DN_CPUGetTSC();
if (job.add_to_completion_queue) {
DN_OS_SemaphoreWait(&queue->complete_queue_write_semaphore, DN_OS_SEMAPHORE_INFINITE_TIMEOUT);
DN_OS_MutexLock(&queue->mutex);
queue->complete_queue[(queue->complete_write_index++ & pot_mask)] = job;
DN_OS_MutexUnlock(&queue->mutex);
DN_OS_SemaphoreIncrement(&queue->complete_queue_write_semaphore, 1);
}
// NOTE: Update finish counter
DN_OS_MutexLock(&queue->mutex);
queue->finish_index += 1;
// NOTE: If all jobs are finished and we have another thread who is
// blocked via `WaitForCompletion` for this job queue, we will go
// release the semaphore to wake them all up.
bool all_jobs_finished = queue->finish_index == queue->write_index;
if (all_jobs_finished && queue->threads_waiting_for_completion) {
DN_OS_SemaphoreIncrement(&queue->wait_for_completion_semaphore,
queue->threads_waiting_for_completion);
queue->threads_waiting_for_completion = 0;
}
DN_OS_MutexUnlock(&queue->mutex);
}
return queue->quit_exit_code;
}
DN_API void DN_OS_JobQueueSPMCWaitForCompletion(DN_JobQueueSPMC *queue)
{
DN_OS_MutexLock(&queue->mutex);
if (queue->finish_index == queue->write_index) {
DN_OS_MutexUnlock(&queue->mutex);
return;
}
queue->threads_waiting_for_completion++;
DN_OS_MutexUnlock(&queue->mutex);
DN_OS_SemaphoreWait(&queue->wait_for_completion_semaphore, DN_OS_SEMAPHORE_INFINITE_TIMEOUT);
}
DN_API DN_USize DN_OS_JobQueueSPMCGetFinishedJobs(DN_JobQueueSPMC *queue, DN_Job *jobs, DN_USize jobs_size)
{
DN_USize result = 0;
if (!queue || !jobs || jobs_size <= 0)
return result;
uint32_t const pot_mask = DN_ArrayCountU(queue->jobs) - 1;
DN_OS_MutexLock(&queue->mutex);
while (queue->complete_read_index < queue->complete_write_index && result < jobs_size)
jobs[result++] = queue->complete_queue[(queue->complete_read_index++ & pot_mask)];
DN_OS_MutexUnlock(&queue->mutex);
return result;
}
Source/Extra/dn_helpers.h
+13 -65
View File
@@ -95,42 +95,6 @@ struct DN_BinarySearchResult
template <typename T>
using DN_QSortLessThanProc = bool(T const &a, T const &b, void *user_context);
// NOTE: Misc //////////////////////////////////////////////////////////////////////////////////////
// NOTE: DN_JobQueue ///////////////////////////////////////////////////////////////////////////////
typedef void(DN_JobQueueFunc)(DN_OSThread *thread, void *user_context);
struct DN_Job
{
DN_JobQueueFunc *func; // The function to invoke for the job
void *user_context; // Pointer user can set to use in their `job_func`
uint64_t elapsed_tsc;
uint16_t user_tag; // Arbitrary value the user can set to identiy the type of `user_context` this job has
bool add_to_completion_queue; // When true, on job completion, job must be dequeued from the completion queue via `GetFinishedJobs`
};
#if !defined(DN_JOB_QUEUE_SPMC_SIZE)
#define DN_JOB_QUEUE_SPMC_SIZE 128
#endif
struct DN_JobQueueSPMC
{
DN_OSMutex mutex;
DN_OSSemaphore thread_wait_for_job_semaphore;
DN_OSSemaphore wait_for_completion_semaphore;
DN_U32 threads_waiting_for_completion;
DN_Job jobs[DN_JOB_QUEUE_SPMC_SIZE];
DN_B32 quit;
DN_U32 quit_exit_code;
DN_U32 volatile read_index;
DN_U32 volatile finish_index;
DN_U32 volatile write_index;
DN_OSSemaphore complete_queue_write_semaphore;
DN_Job complete_queue[DN_JOB_QUEUE_SPMC_SIZE];
DN_U32 volatile complete_read_index;
DN_U32 volatile complete_write_index;
};
// NOTE: DN_PCG32 //////////////////////////////////////////////////////////////////////////////////
DN_API DN_PCG32 DN_PCG32_Init (uint64_t seed);
DN_API uint32_t DN_PCG32_Next (DN_PCG32 *rng);
@@ -173,41 +137,25 @@ DN_API void DN_JSONBuilder_I64Named (DN_JSONBuilde
DN_API void DN_JSONBuilder_F64Named (DN_JSONBuilder *builder, DN_Str8 key, double value, int decimal_places);
DN_API void DN_JSONBuilder_BoolNamed (DN_JSONBuilder *builder, DN_Str8 key, bool value);
#define DN_JSONBuilder_ObjectBegin(builder) DN_JSONBuilder_ObjectBeginNamed(builder, DN_STR8(""))
#define DN_JSONBuilder_ArrayBegin(builder) DN_JSONBuilder_ArrayBeginNamed(builder, DN_STR8(""))
#define DN_JSONBuilder_Str8(builder, value) DN_JSONBuilder_Str8Named(builder, DN_STR8(""), value)
#define DN_JSONBuilder_Literal(builder, value) DN_JSONBuilder_LiteralNamed(builder, DN_STR8(""), value)
#define DN_JSONBuilder_U64(builder, value) DN_JSONBuilder_U64Named(builder, DN_STR8(""), value)
#define DN_JSONBuilder_I64(builder, value) DN_JSONBuilder_I64Named(builder, DN_STR8(""), value)
#define DN_JSONBuilder_F64(builder, value) DN_JSONBuilder_F64Named(builder, DN_STR8(""), value)
#define DN_JSONBuilder_Bool(builder, value) DN_JSONBuilder_BoolNamed(builder, DN_STR8(""), value)
#define DN_JSONBuilder_ObjectBegin(builder) DN_JSONBuilder_ObjectBeginNamed(builder, DN_Str8Lit(""))
#define DN_JSONBuilder_ArrayBegin(builder) DN_JSONBuilder_ArrayBeginNamed(builder, DN_Str8Lit(""))
#define DN_JSONBuilder_Str8(builder, value) DN_JSONBuilder_Str8Named(builder, DN_Str8Lit(""), value)
#define DN_JSONBuilder_Literal(builder, value) DN_JSONBuilder_LiteralNamed(builder, DN_Str8Lit(""), value)
#define DN_JSONBuilder_U64(builder, value) DN_JSONBuilder_U64Named(builder, DN_Str8Lit(""), value)
#define DN_JSONBuilder_I64(builder, value) DN_JSONBuilder_I64Named(builder, DN_Str8Lit(""), value)
#define DN_JSONBuilder_F64(builder, value) DN_JSONBuilder_F64Named(builder, DN_Str8Lit(""), value)
#define DN_JSONBuilder_Bool(builder, value) DN_JSONBuilder_BoolNamed(builder, DN_Str8Lit(""), value)
#endif // !defined(DN_NO_JSON_BUILDER)
// NOTE: DN_BinarySearch ///////////////////////////////////////////////////////////////////////////
// NOTE: DN_BinarySearch
template <typename T> bool DN_BinarySearch_DefaultLessThan(T const &lhs, T const &rhs);
template <typename T> DN_BinarySearchResult DN_BinarySearch (T const *array,
DN_USize array_size,
T const &find,
DN_BinarySearchType type = DN_BinarySearchType_Match,
DN_BinarySearchLessThanProc<T> less_than = DN_BinarySearch_DefaultLessThan);
template <typename T> DN_BinarySearchResult DN_BinarySearch (T const *array, DN_USize array_size, T const &find, DN_BinarySearchType type = DN_BinarySearchType_Match, DN_BinarySearchLessThanProc<T> less_than = DN_BinarySearch_DefaultLessThan);
// NOTE: DN_QSort //////////////////////////////////////////////////////////////////////////////////
// NOTE: DN_QSort
template <typename T> bool DN_QSort_DefaultLessThan(T const &lhs, T const &rhs, void *user_context);
template <typename T> void DN_QSort (T *array,
DN_USize array_size,
void *user_context,
DN_QSortLessThanProc<T> less_than = DN_QSort_DefaultLessThan);
template <typename T> void DN_QSort (T *array, DN_USize array_size, void *user_context, DN_QSortLessThanProc<T> less_than = DN_QSort_DefaultLessThan);
// NOTE: DN_JobQueue ///////////////////////////////////////////////////////////////////////////////
DN_API DN_JobQueueSPMC DN_OS_JobQueueSPMCInit ();
DN_API bool DN_OS_JobQueueSPMCCanAdd (DN_JobQueueSPMC const *queue, uint32_t count);
DN_API bool DN_OS_JobQueueSPMCAddArray (DN_JobQueueSPMC *queue, DN_Job *jobs, uint32_t count);
DN_API bool DN_OS_JobQueueSPMCAdd (DN_JobQueueSPMC *queue, DN_Job job);
DN_API void DN_OS_JobQueueSPMCWaitForCompletion (DN_JobQueueSPMC *queue);
DN_API int32_t DN_OS_JobQueueSPMCThread (DN_OSThread *thread);
DN_API DN_USize DN_OS_JobQueueSPMCGetFinishedJobs (DN_JobQueueSPMC *queue, DN_Job *jobs, DN_USize jobs_size);
// NOTE: DN_BinarySearch ///////////////////////////////////////////////////////////////////////////
// NOTE: DN_BinarySearch
template <typename T>
bool DN_BinarySearch_DefaultLessThan(T const &lhs, T const &rhs)
{
Source/Extra/dn_json.cpp
+27 -27
View File
@@ -7,8 +7,8 @@ void *DN_JSON_ArenaAllocFunc(void *user_data, size_t count)
if (!user_data)
return result;
DN_Arena *arena = DN_CAST(DN_Arena*)user_data;
result = DN_Arena_Alloc(arena, count, alignof(json_value_s), DN_ZeroMem_No);
DN_Arena *arena = DN_Cast(DN_Arena*)user_data;
result = DN_ArenaAlloc(arena, count, alignof(json_value_s), DN_ZMem_No);
return result;
}
@@ -30,9 +30,9 @@ char const *DN_JSON_TypeEnumCString(json_type_e type, size_t *size)
bool DN_JSON_String8Cmp(json_string_s const *lhs, DN_Str8 key)
{
bool result = false;
if (lhs && DN_Str8_HasData(key)) {
DN_Str8 lhs_string = DN_Str8_Init(lhs->string, lhs->string_size);
result = DN_Str8_Eq(lhs_string, key);
if (lhs && key.size) {
DN_Str8 lhs_string = DN_Str8FromPtr(lhs->string, lhs->string_size);
result = DN_Str8Eq(lhs_string, key);
}
return result;
}
@@ -42,7 +42,7 @@ DN_JSONIt DN_JSON_LoadFileToIt(DN_Arena *arena, DN_Str8 json)
{
json_parse_result_s parse_result = {};
json_value_ex_s *ex_value =
DN_CAST(json_value_ex_s *) json_parse_ex(json.data,
DN_Cast(json_value_ex_s *) json_parse_ex(json.data,
json.size,
json_parse_flags_allow_location_information,
DN_JSON_ArenaAllocFunc,
@@ -124,13 +124,13 @@ json_value_s *DN_JSON_ItPushCurrValue(DN_JSONIt *it)
return result;
if (curr->type == DN_JSON_ItEntryTypeObjElement) {
json_object_element_s *element = DN_CAST(json_object_element_s *) curr->value;
json_object_element_s *element = DN_Cast(json_object_element_s *) curr->value;
result = element->value;
} else if (curr->type == DN_JSON_ItEntryTypeArrayElement) {
json_array_element_s *element = DN_CAST(json_array_element_s *) curr->value;
json_array_element_s *element = DN_Cast(json_array_element_s *) curr->value;
result = element->value;
} else {
result = DN_CAST(json_value_s *) curr->value;
result = DN_Cast(json_value_s *) curr->value;
}
if (result->type == json_type_array) {
@@ -155,18 +155,18 @@ bool DN_JSON_ItNext(DN_JSONIt *it)
json_object_element_s *obj_element = nullptr;
json_array_element_s *array_element = nullptr;
if (curr->type == DN_JSON_ItEntryTypeObj) {
auto *obj = DN_CAST(json_object_s *) curr->value;
auto *obj = DN_Cast(json_object_s *) curr->value;
obj_element = obj->start;
} else if (curr->type == DN_JSON_ItEntryTypeObjElement) {
auto *element = DN_CAST(json_object_element_s *) curr->value;
auto *element = DN_Cast(json_object_element_s *) curr->value;
obj_element = element->next;
DN_JSON_ItPop(it);
} else if (curr->type == DN_JSON_ItEntryTypeArray) {
auto *value = DN_CAST(json_value_s *) curr->value;
auto *value = DN_Cast(json_value_s *) curr->value;
auto *array = json_value_as_array(value);
array_element = array->start;
} else if (curr->type == DN_JSON_ItEntryTypeArrayElement) {
auto *element = DN_CAST(json_array_element_s *) curr->value;
auto *element = DN_Cast(json_array_element_s *) curr->value;
array_element = element->next;
DN_JSON_ItPop(it);
} else {
@@ -201,17 +201,17 @@ json_value_s *DN_JSON_ItCurrValue(DN_JSONIt *it)
return result;
if (curr->type == DN_JSON_ItEntryTypeObjElement) {
auto *element = DN_CAST(json_object_element_s *)curr->value;
auto *element = DN_Cast(json_object_element_s *)curr->value;
result = element->value;
} else if (curr->type == DN_JSON_ItEntryTypeArrayElement) {
auto *element = DN_CAST(json_array_element_s *)curr->value;
auto *element = DN_Cast(json_array_element_s *)curr->value;
result = element->value;
} else if (curr->type == DN_JSON_ItEntryTypeString ||
curr->type == DN_JSON_ItEntryTypeNumber ||
curr->type == DN_JSON_ItEntryTypeObj ||
curr->type == DN_JSON_ItEntryTypeArray)
{
result = DN_CAST(json_value_s *)curr->value;
result = DN_Cast(json_value_s *)curr->value;
}
return result;
@@ -221,7 +221,7 @@ json_object_element_s *DN_JSON_ItCurrObjElement(DN_JSONIt *it)
{
DN_JSONItEntry *curr = DN_JSON_ItCurr(it);
auto *result = (curr && curr->type == DN_JSON_ItEntryTypeObjElement)
? DN_CAST(json_object_element_s *) curr->value
? DN_Cast(json_object_element_s *) curr->value
: nullptr;
return result;
}
@@ -291,7 +291,7 @@ DN_Str8 DN_JSON_ItKey(DN_JSONIt *it)
json_object_element_s *curr = DN_JSON_ItCurrObjElement(it);
DN_Str8 result = {};
if (curr) {
result.data = DN_CAST(char *)curr->name->string;
result.data = DN_Cast(char *)curr->name->string;
result.size = curr->name->string_size;
}
return result;
@@ -364,7 +364,7 @@ DN_Str8 DN_JSON_ItValueToString(DN_JSONIt *it)
{
DN_Str8 result = {};
if (json_string_s *curr = DN_JSON_ItValueIsString(it))
result = DN_Str8_Init(curr->string, curr->string_size);
result = DN_Str8FromPtr(curr->string, curr->string_size);
return result;
}
@@ -372,7 +372,7 @@ int64_t DN_JSON_ItValueToI64(DN_JSONIt *it)
{
int64_t result = {};
if (json_number_s *curr = DN_JSON_ItValueIsNumber(it))
result = DN_Str8_ToI64(DN_Str8_Init(curr->number, curr->number_size), 0 /*separator*/).value;
result = DN_I64FromStr8(DN_Str8FromPtr(curr->number, curr->number_size), 0 /*separator*/).value;
return result;
}
@@ -380,7 +380,7 @@ uint64_t DN_JSON_ItValueToU64(DN_JSONIt *it)
{
uint64_t result = {};
if (json_number_s *curr = DN_JSON_ItValueIsNumber(it))
result = DN_Str8_ToU64(DN_Str8_Init(curr->number, curr->number_size), 0 /*separator*/).value;
result = DN_U64FromStr8(DN_Str8FromPtr(curr->number, curr->number_size), 0 /*separator*/).value;
return result;
}
@@ -402,27 +402,27 @@ void DN_JSON_ItErrorUnknownKeyValue_(DN_JSONIt *it, DN_CallSite call_site)
return;
size_t value_type_size = 0;
char const *value_type = DN_JSON_TypeEnumCString(DN_CAST(json_type_e)curr->value->type, &value_type_size);
char const *value_type = DN_JSON_TypeEnumCString(DN_Cast(json_type_e)curr->value->type, &value_type_size);
json_string_s const *key = curr->name;
if (it->flags & json_parse_flags_allow_location_information) {
json_string_ex_s const *info = DN_CAST(json_string_ex_s const *)key;
json_string_ex_s const *info = DN_Cast(json_string_ex_s const *)key;
DN_LOG_EmitFromType(DN_LOG_MakeU32LogTypeParam(DN_LOGType_Warning),
call_site,
"Unknown key-value pair in object [loc=%zu:%zu, key=%.*s, value=%.*s]",
info->line_no,
info->row_no,
DN_CAST(int) key->string_size,
DN_Cast(int) key->string_size,
key->string,
DN_CAST(int) value_type_size,
DN_Cast(int) value_type_size,
value_type);
} else {
DN_LOG_EmitFromType(DN_LOG_MakeU32LogTypeParam(DN_LOGType_Warning),
call_site,
"Unknown key-value pair in object [key=%.*s, value=%.*s]",
DN_CAST(int) key->string_size,
DN_Cast(int) key->string_size,
key->string,
DN_CAST(int) value_type_size,
DN_Cast(int) value_type_size,
value_type);
}
}
Source/Extra/dn_math.cpp
+4 -5
View File
@@ -1200,15 +1200,14 @@ DN_API DN_Str8x256 DN_M4_ColumnMajorString(DN_M4 mat)
for (int row = 0; row < 4; row++) {
for (int it = 0; it < 4; it++) {
if (it == 0)
DN_IStr8_AppendF(&result, "|");
DN_IStr8_AppendF(&result, "%.5f", mat.columns[it][row]);
DN_FmtAppend(result.data, &result.size, sizeof(result.data), "|");
DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%.5f", mat.columns[it][row]);
if (it != 3)
DN_IStr8_AppendF(&result, ", ");
DN_FmtAppend(result.data, &result.size, sizeof(result.data), ", ");
else
DN_IStr8_AppendF(&result, "|\n");
DN_FmtAppend(result.data, &result.size, sizeof(result.data), "|\n");
}
}
return result;
}
Source/Extra/dn_net2_curl.cpp
+60 -60
View File
@@ -24,24 +24,24 @@ static DN_NET2Response DN_NET2_WaitForAnyResponse(DN_NET2Core *net, DN_Arena *ar
// NOTE: Fill in the result
DN_NET2ResponseInternal const *response = &request->response;
result.request = {DN_CAST(DN_U64) request};
result.request = {DN_Cast(DN_U64) request};
result.success = response->status != DN_NET2RequestStatus_Error;
result.ws_type = response->ws_type;
result.http_status = response->http_status;
result.body = DN_Str8Builder_Build(&response->body, arena);
result.body = DN_Str8BuilderBuild(&response->body, arena);
if (response->error.size)
result.error = DN_Str8_FromStr8(arena, response->error);
result.error = DN_Str8FromStr8Arena(arena, response->error);
// NOTE: Deallocate the memory used in the request
DN_Arena_PopTo(&request->arena, request->start_response_arena_pos);
request->response.body = DN_Str8Builder_FromArena(&request->arena);
DN_ArenaPopTo(&request->arena, request->start_response_arena_pos);
request->response.body = DN_Str8BuilderFromArena(&request->arena);
// NOTE: For websocket requests, notify the NET thread we've read data from it and it can go
// back to polling the socket for more data
if (request->type == DN_NET2RequestType_WS && request->response.status != DN_NET2RequestStatus_Error) {
DN_NET2RingEvent event = {};
event.type = DN_NET2RingEventType_ReceivedWSReceipt;
event.request = {DN_CAST(DN_U64)request};
event.request = {DN_Cast(DN_U64)request};
for (DN_OS_MutexScope(&net->ring_mutex))
DN_Ring_WriteStruct(&net->ring, &event);
curl_multi_wakeup(net->curlm);
@@ -55,7 +55,7 @@ static DN_NET2Response DN_NET2_WaitForResponse(DN_NET2Core *net, DN_NET2Request
{
DN_NET2Response result = {};
if (request.handle != 0) {
DN_NET2RequestInternal *request_ptr = DN_CAST(DN_NET2RequestInternal *) request.handle;
DN_NET2RequestInternal *request_ptr = DN_Cast(DN_NET2RequestInternal *) request.handle;
DN_OSSemaphoreWaitResult wait = DN_OS_SemaphoreWait(&request_ptr->completion_sem, timeout_ms);
if (wait == DN_OSSemaphoreWaitResult_Success) {
// NOTE: Fill in the result
@@ -64,19 +64,19 @@ static DN_NET2Response DN_NET2_WaitForResponse(DN_NET2Core *net, DN_NET2Request
result.success = response->status != DN_NET2RequestStatus_Error;
result.ws_type = response->ws_type;
result.http_status = response->http_status;
result.body = DN_Str8Builder_Build(&response->body, arena);
result.body = DN_Str8BuilderBuild(&response->body, arena);
if (response->error.size)
result.error = DN_Str8_FromStr8(arena, response->error);
result.error = DN_Str8FromStr8Arena(arena, response->error);
// NOTE: Deallocate the memory used in the request
DN_Arena_PopTo(&request_ptr->arena, request_ptr->start_response_arena_pos);
request_ptr->response.body = DN_Str8Builder_FromArena(&request_ptr->arena);
DN_ArenaPopTo(&request_ptr->arena, request_ptr->start_response_arena_pos);
request_ptr->response.body = DN_Str8BuilderFromArena(&request_ptr->arena);
// NOTE: Decrement the global completion tracking semaphore (this is so that if you waited on
// the net object's semaphore, you don't get a phantom wakeup because this function already
// consumed it).
DN_OSSemaphoreWaitResult net_wait_result = DN_OS_SemaphoreWait(&net->completion_sem, 0 /*timeout_ms*/);
DN_AssertF(net_wait_result == DN_OSSemaphoreWaitResult_Success, "Wait result was: %zu", DN_CAST(DN_USize)net_wait_result);
DN_AssertF(net_wait_result == DN_OSSemaphoreWaitResult_Success, "Wait result was: %zu", DN_Cast(DN_USize)net_wait_result);
// NOTE: Remove the request from the done list
for (DN_OS_MutexScope(&net->free_or_done_mutex)) {
@@ -119,18 +119,18 @@ static void DN_NET2_DeinitRequest(DN_NET2Core *net, DN_NET2Request *request)
static DN_USize DN_NET2_HTTPCallback_(char *payload, DN_USize size, DN_USize count, void *user_data)
{
auto *request = DN_CAST(DN_NET2RequestInternal *) user_data;
auto *request = DN_Cast(DN_NET2RequestInternal *) user_data;
DN_USize result = 0;
DN_USize payload_size = size * count;
if (DN_Str8Builder_AppendBytesCopy(&request->response.body, payload, payload_size))
if (DN_Str8BuilderAppendBytesCopy(&request->response.body, payload, payload_size))
result = payload_size;
return result;
}
static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
{
DN_NET2Core *net = DN_CAST(DN_NET2Core *) thread->user_context;
DN_OS_ThreadSetName(DN_Str8_Init(net->curl_thread.name.data, net->curl_thread.name.size));
DN_NET2Core *net = DN_Cast(DN_NET2Core *) thread->user_context;
DN_OS_ThreadSetName(DN_Str8FromPtr(net->curl_thread.name.data, net->curl_thread.name.size));
for (;;) {
DN_OSTLSTMem tmem = DN_OS_TLSPushTMem(nullptr);
@@ -146,7 +146,7 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
case DN_NET2RingEventType_Nil: dequeue_ring = false; break;
case DN_NET2RingEventType_DoHTTP: {
DN_NET2RequestInternal *request = DN_CAST(DN_NET2RequestInternal *)event.request.handle;
DN_NET2RequestInternal *request = DN_Cast(DN_NET2RequestInternal *)event.request.handle;
DN_Assert(request->response.status != DN_NET2RequestStatus_Error);
switch (request->type) {
case DN_NET2RequestType_Nil: {
@@ -156,7 +156,7 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
case DN_NET2RequestType_HTTP: {
DN_Assert(request->response.status == DN_NET2RequestStatus_Nil);
DN_NET2CurlConn *conn = DN_CAST(DN_NET2CurlConn *) request->context;
DN_NET2CurlConn *conn = DN_Cast(DN_NET2CurlConn *) request->context;
CURLMcode multi_add = curl_multi_add_handle(net->curlm, conn->curl);
DN_Assert(multi_add == CURLM_OK);
DN_Assert(request->next == nullptr);
@@ -172,7 +172,7 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
DN_Assert(request->next == nullptr);
DN_Assert(request->prev == nullptr);
if (request->response.status == DN_NET2RequestStatus_Nil) {
DN_NET2CurlConn *conn = DN_CAST(DN_NET2CurlConn *) request->context;
DN_NET2CurlConn *conn = DN_Cast(DN_NET2CurlConn *) request->context;
CURLMcode multi_add = curl_multi_add_handle(net->curlm, conn->curl);
DN_Assert(multi_add == CURLM_OK);
DN_DLList_Append(net->http_list, request); // Open the WS connection
@@ -187,7 +187,7 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
DN_Str8 payload = {};
for (DN_OS_MutexScope(&net->ring_mutex)) {
DN_Assert(DN_Ring_HasData(&net->ring, event.send_ws_payload_size));
payload = DN_Str8_Alloc(tmem.arena, event.send_ws_payload_size, DN_ZeroMem_No);
payload = DN_Str8FromArena(tmem.arena, event.send_ws_payload_size, DN_ZMem_No);
DN_Ring_Read(&net->ring, payload.data, payload.size);
}
@@ -201,11 +201,11 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
case DN_NET2WSType_Pong: curlws_flag = CURLWS_PONG; break;
}
DN_NET2RequestInternal *request = DN_CAST(DN_NET2RequestInternal *) event.request.handle;
DN_NET2RequestInternal *request = DN_Cast(DN_NET2RequestInternal *) event.request.handle;
DN_Assert(request->type == DN_NET2RequestType_WS);
DN_Assert(request->response.status == DN_NET2RequestStatus_HTTPReceived || request->response.status == DN_NET2RequestStatus_WSReceived);
DN_NET2CurlConn *conn = DN_CAST(DN_NET2CurlConn *) request->context;
DN_NET2CurlConn *conn = DN_Cast(DN_NET2CurlConn *) request->context;
DN_USize sent = 0;
CURLcode send_result = curl_ws_send(conn->curl, payload.data, payload.size, &sent, 0, curlws_flag);
DN_AssertF(send_result == CURLE_OK, "Failed to send: %s", curl_easy_strerror(send_result));
@@ -213,7 +213,7 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
} break;
case DN_NET2RingEventType_ReceivedWSReceipt: {
DN_NET2RequestInternal *request = DN_CAST(DN_NET2RequestInternal *) event.request.handle;
DN_NET2RequestInternal *request = DN_Cast(DN_NET2RequestInternal *) event.request.handle;
DN_Assert(request->type == DN_NET2RequestType_WS);
DN_Assert(request->response.status == DN_NET2RequestStatus_WSReceived ||
request->response.status == DN_NET2RequestStatus_HTTPReceived);
@@ -224,13 +224,13 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
case DN_NET2RingEventType_DeinitRequest: {
if (event.request.handle != 0) {
DN_NET2RequestInternal *request = DN_CAST(DN_NET2RequestInternal *) event.request.handle;
DN_NET2RequestInternal *request = DN_Cast(DN_NET2RequestInternal *) event.request.handle;
request->response = {};
DN_Arena_Clear(&request->arena);
DN_ArenaClear(&request->arena);
DN_OS_SemaphoreDeinit(&request->completion_sem);
DN_NET2CurlConn *conn = DN_CAST(DN_NET2CurlConn *) request->context;
DN_NET2CurlConn *conn = DN_Cast(DN_NET2CurlConn *) request->context;
curl_multi_remove_handle(net->curlm, conn->curl);
curl_easy_reset(conn->curl);
curl_slist_free_all(conn->curl_slist);
@@ -255,10 +255,10 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
if (msg) {
// NOTE: Get request handle
DN_NET2RequestInternal *request = nullptr;
curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, DN_CAST(void **) & request);
curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, DN_Cast(void **) & request);
DN_Assert(request);
DN_NET2CurlConn *conn = DN_CAST(DN_NET2CurlConn *)request->context;
DN_NET2CurlConn *conn = DN_Cast(DN_NET2CurlConn *)request->context;
DN_Assert(conn->curl == msg->easy_handle);
if (msg->data.result == CURLE_OK) {
@@ -267,14 +267,14 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
if (get_result == CURLE_OK) {
request->response.status = DN_NET2RequestStatus_HTTPReceived;
} else {
request->response.error = DN_Str8_FromF(&request->arena, "Failed to get HTTP response status (CURL %d): %s", msg->data.result, curl_easy_strerror(get_result));
request->response.error = DN_Str8FromFmtArena(&request->arena, "Failed to get HTTP response status (CURL %d): %s", msg->data.result, curl_easy_strerror(get_result));
request->response.status = DN_NET2RequestStatus_Error;
}
} else {
request->response.status = DN_NET2RequestStatus_Error;
request->response.error = DN_Str8_FromF(&request->arena,
request->response.error = DN_Str8FromFmtArena(&request->arena,
"Net request to '%.*s' failed (CURL %d): %s",
DN_STR_FMT(request->url),
DN_Str8PrintFmt(request->url),
msg->data.result,
curl_easy_strerror(msg->data.result));
}
@@ -309,7 +309,7 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
const curl_ws_frame *meta = nullptr;
size_t bytes_read_this_frame = {};
DN_NET2CurlConn *conn = DN_CAST(DN_NET2CurlConn *) request->context;
DN_NET2CurlConn *conn = DN_Cast(DN_NET2CurlConn *) request->context;
for (;;) {
// NOTE: Determine WS payload size received
DN_USize bytes_read = 0;
@@ -318,10 +318,10 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
break;
// NOTE: Allocate and read
DN_Str8 buffer = DN_Str8_Alloc(&request->arena, meta->bytesleft, DN_ZeroMem_No);
DN_Str8 buffer = DN_Str8FromArena(&request->arena, meta->bytesleft, DN_ZMem_No);
receive_result = curl_ws_recv(conn->curl, buffer.data, buffer.size, &buffer.size, &meta);
bytes_read_this_frame += buffer.size;
DN_Str8Builder_AppendRef(&request->response.body, buffer);
DN_Str8BuilderAppendRef(&request->response.body, buffer);
if (meta->flags & CURLWS_TEXT)
request->response.ws_type = DN_NET2WSType_Text;
@@ -364,9 +364,9 @@ static int32_t DN_NET2_ThreadEntryPoint_(DN_OSThread *thread)
request->response.status = DN_NET2RequestStatus_WSReceived;
if (receive_result != CURLE_OK) {
request->response.status = DN_NET2RequestStatus_Error;
request->response.error = DN_Str8_FromF(&request->arena,
request->response.error = DN_Str8FromFmtArena(&request->arena,
"Websocket failed to receive data for '%.*s' (CURL %d): %s",
DN_STR_FMT(request->url),
DN_Str8PrintFmt(request->url),
receive_result,
curl_easy_strerror(receive_result));
}
@@ -385,25 +385,25 @@ static void DN_NET2_Init(DN_NET2Core *net, char *ring_base, DN_USize ring_size,
{
net->base = base;
net->base_size = base_size;
net->arena = DN_Arena_FromBuffer(net->base, net->base_size, DN_ArenaFlags_Nil);
net->arena = DN_ArenaFromBuffer(net->base, net->base_size, DN_ArenaFlags_Nil);
net->ring.base = ring_base;
net->ring.size = ring_size;
net->ring_mutex = DN_OS_MutexInit();
net->completion_sem = DN_OS_SemaphoreInit(0);
net->free_or_done_mutex = DN_OS_MutexInit();
net->curlm = DN_CAST(CURLM *)curl_multi_init();
net->curlm = DN_Cast(CURLM *)curl_multi_init();
DN_DLList_InitArena(net->free_list, DN_NET2RequestInternal, &net->arena);
DN_DLList_InitArena(net->http_list, DN_NET2RequestInternal, &net->arena);
DN_DLList_InitArena(net->ws_list, DN_NET2RequestInternal, &net->arena);
DN_DLList_InitArena(net->done_list, DN_NET2RequestInternal, &net->arena);
DN_IStr8_AppendF(&net->curl_thread.name, "NET (CURL)");
DN_FmtAppend(net->curl_thread.name.data, &net->curl_thread.name.size, sizeof(net->curl_thread.name.data), "NET (CURL)");
DN_OS_ThreadInit(&net->curl_thread, DN_NET2_ThreadEntryPoint_, net);
}
static void DN_NET2_SetupCurlRequest_(DN_NET2RequestInternal *request)
{
DN_NET2CurlConn *conn = DN_CAST(DN_NET2CurlConn *) request->context;
DN_NET2CurlConn *conn = DN_Cast(DN_NET2CurlConn *) request->context;
CURL *curl = conn->curl;
curl_easy_setopt(curl, CURLOPT_PRIVATE, request);
@@ -430,13 +430,13 @@ static void DN_NET2_SetupCurlRequest_(DN_NET2RequestInternal *request)
} break;
case DN_NET2RequestType_HTTP: {
request->method = DN_Str8_TrimWhitespaceAround(request->method);
DN_Str8 const GET = DN_STR8("GET");
DN_Str8 const POST = DN_STR8("POST");
request->method = DN_Str8TrimWhitespaceAround(request->method);
DN_Str8 const GET = DN_Str8Lit("GET");
DN_Str8 const POST = DN_Str8Lit("POST");
if (DN_Str8_EqInsensitive(request->method, GET)) {
if (DN_Str8EqInsensitive(request->method, GET)) {
curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
} else if (DN_Str8_EqInsensitive(request->method, POST)) {
} else if (DN_Str8EqInsensitive(request->method, POST)) {
curl_easy_setopt(curl, CURLOPT_POST, 1);
if (request->args.payload.size > DN_Gigabytes(2))
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, request->args.payload.size);
@@ -451,7 +451,7 @@ static void DN_NET2_SetupCurlRequest_(DN_NET2RequestInternal *request)
// NOTE: Handle basic auth
if (request->args.flags & DN_NET2DoHTTPFlags_BasicAuth) {
if (DN_Str8_HasData(request->args.username) && DN_Str8_HasData(request->args.password)) {
if (request->args.username.size && request->args.password.size) {
DN_Assert(request->args.username.data[request->args.username.size] == 0);
DN_Assert(request->args.password.data[request->args.password.size] == 0);
curl_easy_setopt(curl, CURLOPT_USERNAME, request->args.username.data);
@@ -470,42 +470,42 @@ static DN_NET2Request DN_NET2_DoRequest_(DN_NET2Core *net, DN_Str8 url, DN_Str8
DN_DLList_Dequeue(net->free_list, request);
if (!request) {
request = DN_Arena_New(&net->arena, DN_NET2RequestInternal, DN_ZeroMem_Yes);
request = DN_ArenaNew(&net->arena, DN_NET2RequestInternal, DN_ZMem_Yes);
DN_NET2CurlConn *conn = new (request->context) DN_NET2CurlConn;
conn->curl = DN_CAST(CURL *)curl_easy_init();
conn->curl = DN_Cast(CURL *)curl_easy_init();
}
// NOTE: Setup request
DN_NET2Request result = {};
if (request) {
result.handle = DN_CAST(DN_U64) request;
result.handle = DN_Cast(DN_U64) request;
if (!request->arena.curr)
request->arena = DN_Arena_FromVMem(DN_Megabytes(1), DN_Kilobytes(1), DN_ArenaFlags_Nil);
request->arena = DN_ArenaFromVMem(DN_Megabytes(1), DN_Kilobytes(1), DN_ArenaFlags_Nil);
request->type = type;
request->gen = DN_Max(request->gen + 1, 1);
request->url = DN_Str8_FromStr8(&request->arena, url);
request->method = DN_Str8_FromStr8(&request->arena, method);
request->url = DN_Str8FromStr8Arena(&request->arena, url);
request->method = DN_Str8FromStr8Arena(&request->arena, method);
if (args) {
request->args.flags = args->flags;
request->args.username = DN_Str8_FromStr8(&request->arena, args->username);
request->args.password = DN_Str8_FromStr8(&request->arena, args->password);
request->args.username = DN_Str8FromStr8Arena(&request->arena, args->username);
request->args.password = DN_Str8FromStr8Arena(&request->arena, args->password);
if (type == DN_NET2RequestType_HTTP)
request->args.payload = DN_Str8_FromStr8(&request->arena, args->payload);
request->args.payload = DN_Str8FromStr8Arena(&request->arena, args->payload);
request->args.headers = DN_Arena_NewArray(&request->arena, DN_Str8, args->headers_size, DN_ZeroMem_No);
request->args.headers = DN_ArenaNewArray(&request->arena, DN_Str8, args->headers_size, DN_ZMem_No);
DN_Assert(request->args.headers);
if (request->args.headers) {
for (DN_ForItSize(it, DN_Str8, args->headers, args->headers_size))
request->args.headers[it.index] = DN_Str8_FromStr8(&request->arena, *it.data);
request->args.headers[it.index] = DN_Str8FromStr8Arena(&request->arena, *it.data);
request->args.headers_size = args->headers_size;
}
}
request->response.body = DN_Str8Builder_FromArena(&request->arena);
request->response.body = DN_Str8BuilderFromArena(&request->arena);
request->completion_sem = DN_OS_SemaphoreInit(0);
request->start_response_arena_pos = DN_Arena_Pos(&request->arena);
request->start_response_arena_pos = DN_ArenaPos(&request->arena);
DN_NET2_SetupCurlRequest_(request);
@@ -530,7 +530,7 @@ static DN_NET2Request DN_NET2_DoHTTP(DN_NET2Core *net, DN_Str8 url, DN_Str8 meth
static DN_NET2Request DN_NET2_OpenWS(DN_NET2Core *net, DN_Str8 url, DN_NET2DoHTTPArgs const *args)
{
DN_NET2Request result = DN_NET2_DoRequest_(net, url, DN_STR8(""), args, DN_NET2RequestType_WS);
DN_NET2Request result = DN_NET2_DoRequest_(net, url, DN_Str8Lit(""), args, DN_NET2RequestType_WS);
return result;
}
Source/Extra/dn_tests.cpp
+235 -216
View File
@@ -303,6 +303,41 @@ static DN_UTCore DN_Tests_Base()
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_XSAVE) == DN_RefImplCPUReport::XSAVE());
#endif
}
for (DN_UT_Test(&result, "Age")) {
// NOTE: Seconds and milliseconds
{
DN_Str8x128 str8 = DN_AgeStr8FromMsU64(1001, DN_AgeUnit_Sec | DN_AgeUnit_Ms);
DN_Str8 expect = DN_Str8Lit("1s 1ms");
DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.size, expect.data, expect.size), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect));
}
// NOTE: Fractional seconds
{
DN_Str8x128 str8 = DN_AgeStr8FromMsU64(1001, DN_AgeUnit_FractionalSec);
DN_Str8 expect = DN_Str8Lit("1.001s");
DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.size, expect.data, expect.size), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect));
}
}
for (DN_UT_Test(&result, "String")) {
{
DN_Str8x32 str8 = DN_Str8x32FromU64(123456, ' ');
DN_Str8 expect = DN_Str8Lit("123 456");
DN_UT_AssertF(&result, DN_Str8Eq(DN_Str8FromStruct(&str8), expect), "buf_str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect));
}
}
for (DN_UT_Test(&result, "Misc")) {
{
char buf[8] = {};
DN_USize buf_size = 0;
DN_FmtAppendResult buf_str8 = DN_FmtAppendTruncate(buf, &buf_size, sizeof(buf), DN_Str8Lit("..."), "This string is longer than %d characters", DN_Cast(int)(sizeof(buf) - 1));
DN_Str8 expect = DN_Str8Lit("This..."); // 7 characters long, 1 byte reserved for null-terminator
DN_UT_Assert(&result, buf_str8.truncated);
DN_UT_AssertF(&result, DN_Str8Eq(buf_str8.str8, expect), "buf_str8=%.*s, expect=%.*s", DN_Str8PrintFmt(buf_str8.str8), DN_Str8PrintFmt(expect));
}
}
}
#endif // defined(DN_PLATFORM_WIN32) && defined(DN_COMPILER_MSVC)
return result;
@@ -316,27 +351,27 @@ static DN_UTCore DN_Tests_Arena()
for (DN_UT_Test(&result, "Reused memory is zeroed out")) {
uint8_t alignment = 1;
DN_USize alloc_size = DN_Kilobytes(128);
DN_Arena arena = DN_Arena_FromVMem(0, 0, DN_ArenaFlags_Nil);
DN_Arena arena = DN_ArenaFromVMem(0, 0, DN_ArenaFlags_Nil);
DN_DEFER
{
DN_Arena_Deinit(&arena);
DN_ArenaDeinit(&arena);
};
// NOTE: Allocate 128 kilobytes, fill it with garbage, then reset the arena
uintptr_t first_ptr_address = 0;
{
DN_ArenaTempMem temp_mem = DN_Arena_TempMemBegin(&arena);
void *ptr = DN_Arena_Alloc(&arena, alloc_size, alignment, DN_ZeroMem_Yes);
first_ptr_address = DN_CAST(uintptr_t) ptr;
DN_ArenaTempMem temp_mem = DN_ArenaTempMemBegin(&arena);
void *ptr = DN_ArenaAlloc(&arena, alloc_size, alignment, DN_ZMem_Yes);
first_ptr_address = DN_Cast(uintptr_t) ptr;
DN_Memset(ptr, 'z', alloc_size);
DN_Arena_TempMemEnd(temp_mem);
DN_ArenaTempMemEnd(temp_mem);
}
// NOTE: Reallocate 128 kilobytes
char *ptr = DN_CAST(char *) DN_Arena_Alloc(&arena, alloc_size, alignment, DN_ZeroMem_Yes);
char *ptr = DN_Cast(char *) DN_ArenaAlloc(&arena, alloc_size, alignment, DN_ZMem_Yes);
// NOTE: Double check we got the same pointer
DN_UT_Assert(&result, first_ptr_address == DN_CAST(uintptr_t) ptr);
DN_UT_Assert(&result, first_ptr_address == DN_Cast(uintptr_t) ptr);
// NOTE: Check that the bytes are set to 0
for (DN_USize i = 0; i < alloc_size; i++)
@@ -345,56 +380,56 @@ static DN_UTCore DN_Tests_Arena()
for (DN_UT_Test(&result, "Test arena grows naturally, 1mb + 4mb")) {
// NOTE: Allocate 1mb, then 4mb, this should force the arena to grow
DN_Arena arena = DN_Arena_FromVMem(DN_Megabytes(2), DN_Megabytes(2), DN_ArenaFlags_Nil);
DN_Arena arena = DN_ArenaFromVMem(DN_Megabytes(2), DN_Megabytes(2), DN_ArenaFlags_Nil);
DN_DEFER
{
DN_Arena_Deinit(&arena);
DN_ArenaDeinit(&arena);
};
char *ptr_1mb = DN_Arena_NewArray(&arena, char, DN_Megabytes(1), DN_ZeroMem_Yes);
char *ptr_4mb = DN_Arena_NewArray(&arena, char, DN_Megabytes(4), DN_ZeroMem_Yes);
char *ptr_1mb = DN_ArenaNewArray(&arena, char, DN_Megabytes(1), DN_ZMem_Yes);
char *ptr_4mb = DN_ArenaNewArray(&arena, char, DN_Megabytes(4), DN_ZMem_Yes);
DN_UT_Assert(&result, ptr_1mb);
DN_UT_Assert(&result, ptr_4mb);
DN_ArenaBlock const *block_4mb_begin = arena.curr;
char const *block_4mb_end = DN_CAST(char *) block_4mb_begin + block_4mb_begin->reserve;
char const *block_4mb_end = DN_Cast(char *) block_4mb_begin + block_4mb_begin->reserve;
DN_ArenaBlock const *block_1mb_begin = block_4mb_begin->prev;
DN_UT_AssertF(&result, block_1mb_begin, "New block should have been allocated");
char const *block_1mb_end = DN_CAST(char *) block_1mb_begin + block_1mb_begin->reserve;
char const *block_1mb_end = DN_Cast(char *) block_1mb_begin + block_1mb_begin->reserve;
DN_UT_AssertF(&result, block_1mb_begin != block_4mb_begin, "New block should have been allocated and linked");
DN_UT_AssertF(&result, ptr_1mb >= DN_CAST(char *) block_1mb_begin && ptr_1mb <= block_1mb_end, "Pointer was not allocated from correct memory block");
DN_UT_AssertF(&result, ptr_4mb >= DN_CAST(char *) block_4mb_begin && ptr_4mb <= block_4mb_end, "Pointer was not allocated from correct memory block");
DN_UT_AssertF(&result, ptr_1mb >= DN_Cast(char *) block_1mb_begin && ptr_1mb <= block_1mb_end, "Pointer was not allocated from correct memory block");
DN_UT_AssertF(&result, ptr_4mb >= DN_Cast(char *) block_4mb_begin && ptr_4mb <= block_4mb_end, "Pointer was not allocated from correct memory block");
}
for (DN_UT_Test(&result, "Test arena grows naturally, 1mb, temp memory 4mb")) {
DN_Arena arena = DN_Arena_FromVMem(DN_Megabytes(2), DN_Megabytes(2), DN_ArenaFlags_Nil);
DN_Arena arena = DN_ArenaFromVMem(DN_Megabytes(2), DN_Megabytes(2), DN_ArenaFlags_Nil);
DN_DEFER
{
DN_Arena_Deinit(&arena);
DN_ArenaDeinit(&arena);
};
// NOTE: Allocate 1mb, then 4mb, this should force the arena to grow
char *ptr_1mb = DN_CAST(char *) DN_Arena_Alloc(&arena, DN_Megabytes(1), 1 /*align*/, DN_ZeroMem_Yes);
char *ptr_1mb = DN_Cast(char *) DN_ArenaAlloc(&arena, DN_Megabytes(1), 1 /*align*/, DN_ZMem_Yes);
DN_UT_Assert(&result, ptr_1mb);
DN_ArenaTempMem temp_memory = DN_Arena_TempMemBegin(&arena);
DN_ArenaTempMem temp_memory = DN_ArenaTempMemBegin(&arena);
{
char *ptr_4mb = DN_Arena_NewArray(&arena, char, DN_Megabytes(4), DN_ZeroMem_Yes);
char *ptr_4mb = DN_ArenaNewArray(&arena, char, DN_Megabytes(4), DN_ZMem_Yes);
DN_UT_Assert(&result, ptr_4mb);
DN_ArenaBlock const *block_4mb_begin = arena.curr;
char const *block_4mb_end = DN_CAST(char *) block_4mb_begin + block_4mb_begin->reserve;
char const *block_4mb_end = DN_Cast(char *) block_4mb_begin + block_4mb_begin->reserve;
DN_ArenaBlock const *block_1mb_begin = block_4mb_begin->prev;
char const *block_1mb_end = DN_CAST(char *) block_1mb_begin + block_1mb_begin->reserve;
char const *block_1mb_end = DN_Cast(char *) block_1mb_begin + block_1mb_begin->reserve;
DN_UT_AssertF(&result, block_1mb_begin != block_4mb_begin, "New block should have been allocated and linked");
DN_UT_AssertF(&result, ptr_1mb >= DN_CAST(char *) block_1mb_begin && ptr_1mb <= block_1mb_end, "Pointer was not allocated from correct memory block");
DN_UT_AssertF(&result, ptr_4mb >= DN_CAST(char *) block_4mb_begin && ptr_4mb <= block_4mb_end, "Pointer was not allocated from correct memory block");
DN_UT_AssertF(&result, ptr_1mb >= DN_Cast(char *) block_1mb_begin && ptr_1mb <= block_1mb_end, "Pointer was not allocated from correct memory block");
DN_UT_AssertF(&result, ptr_4mb >= DN_Cast(char *) block_4mb_begin && ptr_4mb <= block_4mb_end, "Pointer was not allocated from correct memory block");
}
DN_Arena_TempMemEnd(temp_memory);
DN_ArenaTempMemEnd(temp_memory);
DN_UT_Assert(&result, arena.curr->prev == nullptr);
DN_UT_AssertF(&result,
arena.curr->reserve >= DN_Megabytes(1),
@@ -414,79 +449,80 @@ static DN_UTCore DN_Tests_Bin()
DN_UT_LogF(&test, "DN_Bin\n");
{
for (DN_UT_Test(&test, "Convert 0x123")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("0x123"));
uint64_t result = DN_U64FromHexStr8Unsafe(DN_Str8Lit("0x123"));
DN_UT_AssertF(&test, result == 0x123, "result: %" PRIu64, result);
}
for (DN_UT_Test(&test, "Convert 0xFFFF")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("0xFFFF"));
uint64_t result = DN_U64FromHexStr8Unsafe(DN_Str8Lit("0xFFFF"));
DN_UT_AssertF(&test, result == 0xFFFF, "result: %" PRIu64, result);
}
for (DN_UT_Test(&test, "Convert FFFF")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("FFFF"));
uint64_t result = DN_U64FromHexStr8Unsafe(DN_Str8Lit("FFFF"));
DN_UT_AssertF(&test, result == 0xFFFF, "result: %" PRIu64, result);
}
for (DN_UT_Test(&test, "Convert abCD")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("abCD"));
uint64_t result = DN_U64FromHexStr8Unsafe(DN_Str8Lit("abCD"));
DN_UT_AssertF(&test, result == 0xabCD, "result: %" PRIu64, result);
}
for (DN_UT_Test(&test, "Convert 0xabCD")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("0xabCD"));
uint64_t result = DN_U64FromHexStr8Unsafe(DN_Str8Lit("0xabCD"));
DN_UT_AssertF(&test, result == 0xabCD, "result: %" PRIu64, result);
}
for (DN_UT_Test(&test, "Convert 0x")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("0x"));
uint64_t result = DN_U64FromHexStr8Unsafe(DN_Str8Lit("0x"));
DN_UT_AssertF(&test, result == 0x0, "result: %" PRIu64, result);
}
for (DN_UT_Test(&test, "Convert 0X")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("0X"));
uint64_t result = DN_U64FromHexStr8Unsafe(DN_Str8Lit("0X"));
DN_UT_AssertF(&test, result == 0x0, "result: %" PRIu64, result);
}
for (DN_UT_Test(&test, "Convert 3")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("3"));
uint64_t result = DN_U64FromHexStr8Unsafe(DN_Str8Lit("3"));
DN_UT_AssertF(&test, result == 3, "result: %" PRIu64, result);
}
for (DN_UT_Test(&test, "Convert f")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("f"));
DN_UT_AssertF(&test, result == 0xf, "result: %" PRIu64, result);
DN_U64FromResult result = DN_U64FromHexStr8(DN_Str8Lit("f"));
DN_UT_Assert(&test, result.success);
DN_UT_Assert(&test, result.value == 0xf);
}
for (DN_UT_Test(&test, "Convert g")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("g"));
DN_UT_AssertF(&test, result == 0, "result: %" PRIu64, result);
DN_U64FromResult result = DN_U64FromHexStr8(DN_Str8Lit("g"));
DN_UT_Assert(&test, !result.success);
}
for (DN_UT_Test(&test, "Convert -0x3")) {
uint64_t result = DN_CVT_U64FromHex(DN_STR8("-0x3"));
DN_UT_AssertF(&test, result == 0, "result: %" PRIu64, result);
DN_U64FromResult result = DN_U64FromHexStr8(DN_Str8Lit("-0x3"));
DN_UT_Assert(&test, !result.success);
}
uint32_t number = 0xd095f6;
for (DN_UT_Test(&test, "Convert %x to string", number)) {
DN_Str8 number_hex = DN_CVT_HexFromBytes(tmem.arena, &number, sizeof(number));
DN_UT_AssertF(&test, DN_Str8_Eq(number_hex, DN_STR8("f695d000")), "number_hex=%.*s", DN_STR_FMT(number_hex));
DN_Str8 number_hex = DN_HexFromBytesPtrArena(&number, sizeof(number), tmem.arena);
DN_UT_AssertF(&test, DN_Str8Eq(number_hex, DN_Str8Lit("f695d000")), "number_hex=%.*s", DN_Str8PrintFmt(number_hex));
}
number = 0xf6ed00;
for (DN_UT_Test(&test, "Convert %x to string", number)) {
DN_Str8 number_hex = DN_CVT_HexFromBytes(tmem.arena, &number, sizeof(number));
DN_UT_AssertF(&test, DN_Str8_Eq(number_hex, DN_STR8("00edf600")), "number_hex=%.*s", DN_STR_FMT(number_hex));
DN_Str8 number_hex = DN_HexFromBytesPtrArena(&number, sizeof(number), tmem.arena);
DN_UT_AssertF(&test, DN_Str8Eq(number_hex, DN_Str8Lit("00edf600")), "number_hex=%.*s", DN_Str8PrintFmt(number_hex));
}
DN_Str8 hex = DN_STR8("0xf6ed00");
for (DN_UT_Test(&test, "Convert %.*s to bytes", DN_STR_FMT(hex))) {
DN_Str8 bytes = DN_CVT_BytesFromHex(tmem.arena, hex);
DN_Str8 hex = DN_Str8Lit("0xf6ed00");
for (DN_UT_Test(&test, "Convert %.*s to bytes", DN_Str8PrintFmt(hex))) {
DN_Str8 bytes = DN_BytesFromHexStr8Arena(hex, tmem.arena);
DN_UT_AssertF(&test,
DN_Str8_Eq(bytes, DN_STR8("\xf6\xed\x00")),
DN_Str8Eq(bytes, DN_Str8Lit("\xf6\xed\x00")),
"number_hex=%.*s",
DN_STR_FMT(DN_CVT_HexFromBytes(tmem.arena, bytes.data, bytes.size)));
DN_Str8PrintFmt(DN_HexFromBytesPtrArena(bytes.data, bytes.size, tmem.arena)));
}
}
return test;
@@ -808,16 +844,16 @@ static DN_UTCore DN_Tests_BaseContainers()
{
DN_OSTLSTMem tmem = DN_OS_TLSTMem(nullptr);
{
DN_Arena arena = DN_Arena_FromVMem(0, 0, DN_ArenaFlags_Nil);
DN_Arena arena = DN_ArenaFromVMem(0, 0, DN_ArenaFlags_Nil);
uint32_t const MAP_SIZE = 64;
DN_DSMap<uint64_t> map = DN_DSMap_Init<uint64_t>(&arena, MAP_SIZE, DN_DSMapFlags_Nil);
DN_DEFER
{
DN_DSMap_Deinit(&map, DN_ZeroMem_Yes);
DN_DSMap_Deinit(&map, DN_ZMem_Yes);
};
for (DN_UT_Test(&result, "Find non-existent value")) {
DN_DSMapResult<uint64_t> find = DN_DSMap_FindKeyStr8(&map, DN_STR8("Foo"));
DN_DSMapResult<uint64_t> find = DN_DSMap_FindKeyStr8(&map, DN_Str8Lit("Foo"));
DN_UT_Assert(&result, !find.found);
DN_UT_Assert(&result, map.size == MAP_SIZE);
DN_UT_Assert(&result, map.initial_size == MAP_SIZE);
@@ -856,20 +892,20 @@ static DN_UTCore DN_Tests_BaseContainers()
for (int result_type = 0; result_type < DSMapTestType_Count; result_type++) {
DN_Str8 prefix = {};
switch (result_type) {
case DSMapTestType_Set: prefix = DN_STR8("Set"); break;
case DSMapTestType_MakeSlot: prefix = DN_STR8("Make slot"); break;
case DSMapTestType_Set: prefix = DN_Str8Lit("Set"); break;
case DSMapTestType_MakeSlot: prefix = DN_Str8Lit("Make slot"); break;
}
DN_ArenaTempMemScope temp_mem_scope = DN_ArenaTempMemScope(tmem.arena);
DN_Arena arena = DN_Arena_FromVMem(0, 0, DN_ArenaFlags_Nil);
DN_Arena arena = DN_ArenaFromVMem(0, 0, DN_ArenaFlags_Nil);
uint32_t const MAP_SIZE = 64;
DN_DSMap<uint64_t> map = DN_DSMap_Init<uint64_t>(&arena, MAP_SIZE, DN_DSMapFlags_Nil);
DN_DEFER
{
DN_DSMap_Deinit(&map, DN_ZeroMem_Yes);
DN_DSMap_Deinit(&map, DN_ZMem_Yes);
};
for (DN_UT_Test(&result, "%.*s: Test growing", DN_STR_FMT(prefix))) {
for (DN_UT_Test(&result, "%.*s: Test growing", DN_Str8PrintFmt(prefix))) {
uint64_t map_start_size = map.size;
uint64_t value = 0;
uint64_t grow_threshold = map_start_size * 3 / 4;
@@ -904,13 +940,13 @@ static DN_UTCore DN_Tests_BaseContainers()
}
}
for (DN_UT_Test(&result, "%.*s: Check the sentinel is present", DN_STR_FMT(prefix))) {
for (DN_UT_Test(&result, "%.*s: Check the sentinel is present", DN_Str8PrintFmt(prefix))) {
DN_DSMapSlot<uint64_t> NIL_SLOT = {};
DN_DSMapSlot<uint64_t> sentinel = map.slots[DN_DS_MAP_SENTINEL_SLOT];
DN_UT_Assert(&result, DN_Memcmp(&sentinel, &NIL_SLOT, sizeof(NIL_SLOT)) == 0);
}
for (DN_UT_Test(&result, "%.*s: Recheck all the hash tables values after growing", DN_STR_FMT(prefix))) {
for (DN_UT_Test(&result, "%.*s: Recheck all the hash tables values after growing", DN_Str8PrintFmt(prefix))) {
for (uint64_t index = 1 /*Sentinel*/; index < map.occupied; index++) {
DN_DSMapSlot<uint64_t> const *slot = map.slots + index;
@@ -930,7 +966,7 @@ static DN_UTCore DN_Tests_BaseContainers()
}
}
for (DN_UT_Test(&result, "%.*s: Test shrinking", DN_STR_FMT(prefix))) {
for (DN_UT_Test(&result, "%.*s: Test shrinking", DN_Str8PrintFmt(prefix))) {
uint64_t start_map_size = map.size;
uint64_t start_map_occupied = map.occupied;
uint64_t value = 0;
@@ -1008,7 +1044,7 @@ static DN_UTCore DN_Tests_BaseContainers()
array.max = DN_ArrayCountU(array_buffer);
for (DN_UT_Test(&result, "Make item")) {
int *item = DN_IArray_Make(&array, DN_ZeroMem_Yes);
int *item = DN_IArray_Make(&array, DN_ZMem_Yes);
DN_UT_Assert(&result, item && array.size == 1);
}
}
@@ -1307,8 +1343,8 @@ static DN_UTCore DN_Tests_BaseContainers()
// NOTE: Verify that the items returned from the data array are
// contiguous in memory.
UnalignedObject *make_item_a = DN_VArray_MakeArray(&array, 1, DN_ZeroMem_Yes);
UnalignedObject *make_item_b = DN_VArray_MakeArray(&array, 1, DN_ZeroMem_Yes);
UnalignedObject *make_item_a = DN_VArray_MakeArray(&array, 1, DN_ZMem_Yes);
UnalignedObject *make_item_b = DN_VArray_MakeArray(&array, 1, DN_ZMem_Yes);
DN_Memset(make_item_a->data, 'a', sizeof(make_item_a->data));
DN_Memset(make_item_b->data, 'b', sizeof(make_item_b->data));
DN_UT_Assert(&result, (uintptr_t)make_item_b == (uintptr_t)(make_item_a + 1));
@@ -1387,7 +1423,7 @@ static DN_UTCore DN_Tests_Intrinsics()
for (DN_UT_Test(&result, "DN_AtomicSetValue64")) {
int64_t a = 0;
int64_t b = 111;
DN_AtomicSetValue64(DN_CAST(uint64_t *) & a, b);
DN_AtomicSetValue64(DN_Cast(uint64_t *) & a, b);
DN_UT_AssertF(&result, a == b, "a: %" PRId64 ", b: %" PRId64, a, b);
}
@@ -1603,7 +1639,7 @@ enum DN_Tests__HashType
DN_Str8 const DN_UT_HASH_STRING_[] =
{
#define DN_UT_HASH_X_ENTRY(enum_val, string) DN_STR8(string),
#define DN_UT_HASH_X_ENTRY(enum_val, string) DN_Str8Lit(string),
DN_UT_HASH_X_MACRO
#undef DN_UT_HASH_X_ENTRY
};
@@ -1617,13 +1653,13 @@ void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
case Hash_SHA3_224: {
DN_KCBytes28 hash = DN_KC_SHA3_224Str8(input);
DN_KCBytes28 expect;
DN_RefImpl_FIPS202_SHA3_224_(DN_CAST(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_RefImpl_FIPS202_SHA3_224_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_UT_AssertF(test,
DN_KC_Bytes28Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_STR_FMT(input_hex),
DN_Str8PrintFmt(input_hex),
DN_KC_STRING56_FMT(DN_KC_Bytes28ToHex(&hash).data),
DN_KC_STRING56_FMT(DN_KC_Bytes28ToHex(&expect).data));
} break;
@@ -1631,13 +1667,13 @@ void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
case Hash_SHA3_256: {
DN_KCBytes32 hash = DN_KC_SHA3_256Str8(input);
DN_KCBytes32 expect;
DN_RefImpl_FIPS202_SHA3_256_(DN_CAST(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_RefImpl_FIPS202_SHA3_256_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_UT_AssertF(test,
DN_KC_Bytes32Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_STR_FMT(input_hex),
DN_Str8PrintFmt(input_hex),
DN_KC_STRING64_FMT(DN_KC_Bytes32ToHex(&hash).data),
DN_KC_STRING64_FMT(DN_KC_Bytes32ToHex(&expect).data));
} break;
@@ -1645,13 +1681,13 @@ void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
case Hash_SHA3_384: {
DN_KCBytes48 hash = DN_KC_SHA3_384Str8(input);
DN_KCBytes48 expect;
DN_RefImpl_FIPS202_SHA3_384_(DN_CAST(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_RefImpl_FIPS202_SHA3_384_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_UT_AssertF(test,
DN_KC_Bytes48Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_STR_FMT(input_hex),
DN_Str8PrintFmt(input_hex),
DN_KC_STRING96_FMT(DN_KC_Bytes48ToHex(&hash).data),
DN_KC_STRING96_FMT(DN_KC_Bytes48ToHex(&expect).data));
} break;
@@ -1659,13 +1695,13 @@ void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
case Hash_SHA3_512: {
DN_KCBytes64 hash = DN_KC_SHA3_512Str8(input);
DN_KCBytes64 expect;
DN_RefImpl_FIPS202_SHA3_512_(DN_CAST(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_RefImpl_FIPS202_SHA3_512_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_UT_AssertF(test,
DN_KC_Bytes64Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_STR_FMT(input_hex),
DN_Str8PrintFmt(input_hex),
DN_KC_STRING128_FMT(DN_KC_Bytes64ToHex(&hash).data),
DN_KC_STRING128_FMT(DN_KC_Bytes64ToHex(&expect).data));
} break;
@@ -1673,13 +1709,13 @@ void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
case Hash_Keccak_224: {
DN_KCBytes28 hash = DN_KC_Keccak224Str8(input);
DN_KCBytes28 expect;
DN_RefImpl_Keccak_(1152, 448, DN_CAST(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_RefImpl_Keccak_(1152, 448, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_UT_AssertF(test,
DN_KC_Bytes28Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_STR_FMT(input_hex),
DN_Str8PrintFmt(input_hex),
DN_KC_STRING56_FMT(DN_KC_Bytes28ToHex(&hash).data),
DN_KC_STRING56_FMT(DN_KC_Bytes28ToHex(&expect).data));
} break;
@@ -1687,13 +1723,13 @@ void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
case Hash_Keccak_256: {
DN_KCBytes32 hash = DN_KC_Keccak256Str8(input);
DN_KCBytes32 expect;
DN_RefImpl_Keccak_(1088, 512, DN_CAST(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_RefImpl_Keccak_(1088, 512, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_UT_AssertF(test,
DN_KC_Bytes32Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_STR_FMT(input_hex),
DN_Str8PrintFmt(input_hex),
DN_KC_STRING64_FMT(DN_KC_Bytes32ToHex(&hash).data),
DN_KC_STRING64_FMT(DN_KC_Bytes32ToHex(&expect).data));
} break;
@@ -1701,13 +1737,13 @@ void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
case Hash_Keccak_384: {
DN_KCBytes48 hash = DN_KC_Keccak384Str8(input);
DN_KCBytes48 expect;
DN_RefImpl_Keccak_(832, 768, DN_CAST(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_RefImpl_Keccak_(832, 768, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_UT_AssertF(test,
DN_KC_Bytes48Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_STR_FMT(input_hex),
DN_Str8PrintFmt(input_hex),
DN_KC_STRING96_FMT(DN_KC_Bytes48ToHex(&hash).data),
DN_KC_STRING96_FMT(DN_KC_Bytes48ToHex(&expect).data));
} break;
@@ -1715,13 +1751,13 @@ void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
case Hash_Keccak_512: {
DN_KCBytes64 hash = DN_KC_Keccak512Str8(input);
DN_KCBytes64 expect;
DN_RefImpl_Keccak_(576, 1024, DN_CAST(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_RefImpl_Keccak_(576, 1024, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_UT_AssertF(test,
DN_KC_Bytes64Equals(&hash, &expect),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_STR_FMT(input_hex),
DN_Str8PrintFmt(input_hex),
DN_KC_STRING128_FMT(DN_KC_Bytes64ToHex(&hash).data),
DN_KC_STRING128_FMT(DN_KC_Bytes64ToHex(&expect).data));
} break;
@@ -1732,10 +1768,10 @@ DN_UTCore DN_Tests_Keccak()
{
DN_UTCore test = DN_UT_Init();
DN_Str8 const INPUTS[] = {
DN_STR8("abc"),
DN_STR8(""),
DN_STR8("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"),
DN_STR8("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmno"
DN_Str8Lit("abc"),
DN_Str8Lit(""),
DN_Str8Lit("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"),
DN_Str8Lit("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmno"
"pqrstnopqrstu"),
};
@@ -1744,20 +1780,20 @@ DN_UTCore DN_Tests_Keccak()
for (int hash_type = 0; hash_type < Hash_Count; hash_type++) {
DN_PCG32 rng = DN_PCG32_Init(0xd48e'be21'2af8'733d);
for (DN_Str8 input : INPUTS) {
DN_UT_BeginF(&test, "%.*s - Input: %.*s", DN_STR_FMT(DN_UT_HASH_STRING_[hash_type]), DN_CAST(int) DN_Min(input.size, 54), input.data);
DN_UT_BeginF(&test, "%.*s - Input: %.*s", DN_Str8PrintFmt(DN_UT_HASH_STRING_[hash_type]), DN_Cast(int) DN_Min(input.size, 54), input.data);
DN_Tests_KeccakDispatch_(&test, hash_type, input);
DN_UT_End(&test);
}
DN_UT_BeginF(&test, "%.*s - Deterministic random inputs", DN_STR_FMT(DN_UT_HASH_STRING_[hash_type]));
DN_UT_BeginF(&test, "%.*s - Deterministic random inputs", DN_Str8PrintFmt(DN_UT_HASH_STRING_[hash_type]));
for (DN_USize index = 0; index < 128; index++) {
char src[4096] = {};
uint32_t src_size = DN_PCG32_Range(&rng, 0, sizeof(src));
for (DN_USize src_index = 0; src_index < src_size; src_index++)
src[src_index] = DN_CAST(char) DN_PCG32_Range(&rng, 0, 255);
src[src_index] = DN_Cast(char) DN_PCG32_Range(&rng, 0, 255);
DN_Str8 input = DN_Str8_Init(src, src_size);
DN_Str8 input = DN_Str8FromPtr(src, src_size);
DN_Tests_KeccakDispatch_(&test, hash_type, input);
}
DN_UT_End(&test);
@@ -1813,8 +1849,8 @@ static DN_UTCore DN_Tests_OS()
for (DN_UT_Test(&result, "Query executable directory")) {
DN_OSTLSTMem tmem = DN_OS_TLSTMem(nullptr);
DN_Str8 os_result = DN_OS_EXEDir(tmem.arena);
DN_UT_Assert(&result, DN_Str8_HasData(os_result));
DN_UT_AssertF(&result, DN_OS_PathIsDir(os_result), "result(%zu): %.*s", os_result.size, DN_STR_FMT(os_result));
DN_UT_Assert(&result, os_result.size);
DN_UT_AssertF(&result, DN_OS_PathIsDir(os_result), "result(%zu): %.*s", os_result.size, DN_Str8PrintFmt(os_result));
}
for (DN_UT_Test(&result, "DN_OS_PerfCounterNow")) {
@@ -1844,37 +1880,37 @@ static DN_UTCore DN_Tests_OS()
DN_UT_LogF(&result, "\nDN_OS Filesystem\n");
{
for (DN_UT_Test(&result, "Make directory recursive \"abcd/efgh\"")) {
DN_UT_AssertF(&result, DN_OS_PathMakeDir(DN_STR8("abcd/efgh")), "Failed to make directory");
DN_UT_AssertF(&result, DN_OS_PathIsDir(DN_STR8("abcd")), "Directory was not made");
DN_UT_AssertF(&result, DN_OS_PathIsDir(DN_STR8("abcd/efgh")), "Subdirectory was not made");
DN_UT_AssertF(&result, DN_OS_PathIsFile(DN_STR8("abcd")) == false, "This function should only return true for files");
DN_UT_AssertF(&result, DN_OS_PathIsFile(DN_STR8("abcd/efgh")) == false, "This function should only return true for files");
DN_UT_AssertF(&result, DN_OS_PathDelete(DN_STR8("abcd/efgh")), "Failed to delete directory");
DN_UT_AssertF(&result, DN_OS_PathDelete(DN_STR8("abcd")), "Failed to cleanup directory");
DN_UT_AssertF(&result, DN_OS_PathMakeDir(DN_Str8Lit("abcd/efgh")), "Failed to make directory");
DN_UT_AssertF(&result, DN_OS_PathIsDir(DN_Str8Lit("abcd")), "Directory was not made");
DN_UT_AssertF(&result, DN_OS_PathIsDir(DN_Str8Lit("abcd/efgh")), "Subdirectory was not made");
DN_UT_AssertF(&result, DN_OS_PathIsFile(DN_Str8Lit("abcd")) == false, "This function should only return true for files");
DN_UT_AssertF(&result, DN_OS_PathIsFile(DN_Str8Lit("abcd/efgh")) == false, "This function should only return true for files");
DN_UT_AssertF(&result, DN_OS_PathDelete(DN_Str8Lit("abcd/efgh")), "Failed to delete directory");
DN_UT_AssertF(&result, DN_OS_PathDelete(DN_Str8Lit("abcd")), "Failed to cleanup directory");
}
for (DN_UT_Test(&result, "File write, read, copy, move and delete")) {
// NOTE: Write step
DN_Str8 const SRC_FILE = DN_STR8("dn_result_file");
DN_B32 write_result = DN_OS_FileWriteAll(SRC_FILE, DN_STR8("1234"), nullptr);
DN_Str8 const SRC_FILE = DN_Str8Lit("dn_result_file");
DN_B32 write_result = DN_OS_FileWriteAll(SRC_FILE, DN_Str8Lit("1234"), nullptr);
DN_UT_Assert(&result, write_result);
DN_UT_Assert(&result, DN_OS_PathIsFile(SRC_FILE));
// NOTE: Read step
DN_OSTLSTMem tmem = DN_OS_TLSTMem(nullptr);
DN_Str8 read_file = DN_OS_FileReadAllArena(tmem.arena, SRC_FILE, nullptr);
DN_UT_AssertF(&result, DN_Str8_HasData(read_file), "Failed to load file");
DN_UT_AssertF(&result, read_file.size, "Failed to load file");
DN_UT_AssertF(&result, read_file.size == 4, "File read wrong amount of bytes (%zu)", read_file.size);
DN_UT_AssertF(&result, DN_Str8_Eq(read_file, DN_STR8("1234")), "Read %zu bytes instead of the expected 4: '%.*s'", read_file.size, DN_STR_FMT(read_file));
DN_UT_AssertF(&result, DN_Str8Eq(read_file, DN_Str8Lit("1234")), "Read %zu bytes instead of the expected 4: '%.*s'", read_file.size, DN_Str8PrintFmt(read_file));
// NOTE: Copy step
DN_Str8 const COPY_FILE = DN_STR8("dn_result_file_copy");
DN_Str8 const COPY_FILE = DN_Str8Lit("dn_result_file_copy");
DN_B32 copy_result = DN_OS_FileCopy(SRC_FILE, COPY_FILE, true /*overwrite*/, nullptr);
DN_UT_Assert(&result, copy_result);
DN_UT_Assert(&result, DN_OS_PathIsFile(COPY_FILE));
// NOTE: Move step
DN_Str8 const MOVE_FILE = DN_STR8("dn_result_file_move");
DN_Str8 const MOVE_FILE = DN_Str8Lit("dn_result_file_move");
DN_B32 move_result = DN_OS_FileMove(COPY_FILE, MOVE_FILE, true /*overwrite*/, nullptr);
DN_UT_Assert(&result, move_result);
DN_UT_Assert(&result, DN_OS_PathIsFile(MOVE_FILE));
@@ -2079,7 +2115,7 @@ static DN_UTCore DN_Tests_Str8()
DN_UT_LogF(&result, "DN_Str8\n");
{
for (DN_UT_Test(&result, "Initialise with string literal w/ macro")) {
DN_Str8 string = DN_STR8("AB");
DN_Str8 string = DN_Str8Lit("AB");
DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size);
DN_UT_AssertF(&result, string.data[0] == 'A', "string[0]: %c", string.data[0]);
DN_UT_AssertF(&result, string.data[1] == 'B', "string[1]: %c", string.data[1]);
@@ -2087,7 +2123,7 @@ static DN_UTCore DN_Tests_Str8()
for (DN_UT_Test(&result, "Initialise with format string")) {
DN_OSTLSTMem tmem = DN_OS_TLSTMem(nullptr);
DN_Str8 string = DN_Str8_FromF(tmem.arena, "%s", "AB");
DN_Str8 string = DN_Str8FromFmtArena(tmem.arena, "%s", "AB");
DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size);
DN_UT_AssertF(&result, string.data[0] == 'A', "string[0]: %c", string.data[0]);
DN_UT_AssertF(&result, string.data[1] == 'B', "string[1]: %c", string.data[1]);
@@ -2096,8 +2132,8 @@ static DN_UTCore DN_Tests_Str8()
for (DN_UT_Test(&result, "Copy string")) {
DN_OSTLSTMem tmem = DN_OS_TLSTMem(nullptr);
DN_Str8 string = DN_STR8("AB");
DN_Str8 copy = DN_Str8_FromStr8(tmem.arena, string);
DN_Str8 string = DN_Str8Lit("AB");
DN_Str8 copy = DN_Str8FromStr8Arena(tmem.arena, string);
DN_UT_AssertF(&result, copy.size == 2, "size: %zu", copy.size);
DN_UT_AssertF(&result, copy.data[0] == 'A', "copy[0]: %c", copy.data[0]);
DN_UT_AssertF(&result, copy.data[1] == 'B', "copy[1]: %c", copy.data[1]);
@@ -2105,226 +2141,209 @@ static DN_UTCore DN_Tests_Str8()
}
for (DN_UT_Test(&result, "Trim whitespace around string")) {
DN_Str8 string = DN_Str8_TrimWhitespaceAround(DN_STR8(" AB "));
DN_UT_AssertF(&result, DN_Str8_Eq(string, DN_STR8("AB")), "[string=%.*s]", DN_STR_FMT(string));
DN_Str8 string = DN_Str8TrimWhitespaceAround(DN_Str8Lit(" AB "));
DN_UT_AssertF(&result, DN_Str8Eq(string, DN_Str8Lit("AB")), "[string=%.*s]", DN_Str8PrintFmt(string));
}
for (DN_UT_Test(&result, "Allocate string from arena")) {
DN_OSTLSTMem tmem = DN_OS_TLSTMem(nullptr);
DN_Str8 string = DN_Str8_Alloc(tmem.arena, 2, DN_ZeroMem_No);
DN_Str8 string = DN_Str8FromArena(tmem.arena, 2, DN_ZMem_No);
DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size);
}
// NOTE: TrimPrefix/Suffix /////////////////////////////////////////////////////////////////////
for (DN_UT_Test(&result, "Trim prefix with matching prefix")) {
DN_Str8 input = DN_STR8("nft/abc");
DN_Str8 str_result = DN_Str8_TrimPrefix(input, DN_STR8("nft/"));
DN_UT_AssertF(&result, DN_Str8_Eq(str_result, DN_STR8("abc")), "%.*s", DN_STR_FMT(str_result));
DN_Str8 input = DN_Str8Lit("nft/abc");
DN_Str8 str_result = DN_Str8TrimPrefix(input, DN_Str8Lit("nft/"));
DN_UT_AssertF(&result, DN_Str8Eq(str_result, DN_Str8Lit("abc")), "%.*s", DN_Str8PrintFmt(str_result));
}
for (DN_UT_Test(&result, "Trim prefix with non matching prefix")) {
DN_Str8 input = DN_STR8("nft/abc");
DN_Str8 str_result = DN_Str8_TrimPrefix(input, DN_STR8(" ft/"));
DN_UT_AssertF(&result, DN_Str8_Eq(str_result, input), "%.*s", DN_STR_FMT(str_result));
DN_Str8 input = DN_Str8Lit("nft/abc");
DN_Str8 str_result = DN_Str8TrimPrefix(input, DN_Str8Lit(" ft/"));
DN_UT_AssertF(&result, DN_Str8Eq(str_result, input), "%.*s", DN_Str8PrintFmt(str_result));
}
for (DN_UT_Test(&result, "Trim suffix with matching suffix")) {
DN_Str8 input = DN_STR8("nft/abc");
DN_Str8 str_result = DN_Str8_TrimSuffix(input, DN_STR8("abc"));
DN_UT_AssertF(&result, DN_Str8_Eq(str_result, DN_STR8("nft/")), "%.*s", DN_STR_FMT(str_result));
DN_Str8 input = DN_Str8Lit("nft/abc");
DN_Str8 str_result = DN_Str8TrimSuffix(input, DN_Str8Lit("abc"));
DN_UT_AssertF(&result, DN_Str8Eq(str_result, DN_Str8Lit("nft/")), "%.*s", DN_Str8PrintFmt(str_result));
}
for (DN_UT_Test(&result, "Trim suffix with non matching suffix")) {
DN_Str8 input = DN_STR8("nft/abc");
DN_Str8 str_result = DN_Str8_TrimSuffix(input, DN_STR8("ab"));
DN_UT_AssertF(&result, DN_Str8_Eq(str_result, input), "%.*s", DN_STR_FMT(str_result));
DN_Str8 input = DN_Str8Lit("nft/abc");
DN_Str8 str_result = DN_Str8TrimSuffix(input, DN_Str8Lit("ab"));
DN_UT_AssertF(&result, DN_Str8Eq(str_result, input), "%.*s", DN_Str8PrintFmt(str_result));
}
// NOTE: DN_Str8_IsAllDigits //////////////////////////////////////////////////////////////
// NOTE: DN_Str8IsAllDigits //////////////////////////////////////////////////////////////
for (DN_UT_Test(&result, "Is all digits fails on non-digit string")) {
DN_B32 str_result = DN_Str8_IsAll(DN_STR8("@123string"), DN_Str8IsAll_Digits);
DN_B32 str_result = DN_Str8IsAll(DN_Str8Lit("@123string"), DN_Str8IsAllType_Digits);
DN_UT_Assert(&result, str_result == false);
}
for (DN_UT_Test(&result, "Is all digits fails on nullptr")) {
DN_B32 str_result = DN_Str8_IsAll(DN_Str8_Init(nullptr, 0), DN_Str8IsAll_Digits);
DN_UT_Assert(&result, str_result == false);
}
for (DN_UT_Test(&result, "Is all digits fails on nullptr w/ size")) {
DN_B32 str_result = DN_Str8_IsAll(DN_Str8_Init(nullptr, 1), DN_Str8IsAll_Digits);
DN_B32 str_result = DN_Str8IsAll(DN_Str8FromPtr(nullptr, 0), DN_Str8IsAllType_Digits);
DN_UT_Assert(&result, str_result == false);
}
for (DN_UT_Test(&result, "Is all digits fails on string w/ 0 size")) {
char const buf[] = "@123string";
DN_B32 str_result = DN_Str8_IsAll(DN_Str8_Init(buf, 0), DN_Str8IsAll_Digits);
DN_B32 str_result = DN_Str8IsAll(DN_Str8FromPtr(buf, 0), DN_Str8IsAllType_Digits);
DN_UT_Assert(&result, !str_result);
}
for (DN_UT_Test(&result, "Is all digits success")) {
DN_B32 str_result = DN_Str8_IsAll(DN_STR8("23"), DN_Str8IsAll_Digits);
DN_UT_Assert(&result, DN_CAST(bool) str_result == true);
DN_B32 str_result = DN_Str8IsAll(DN_Str8Lit("23"), DN_Str8IsAllType_Digits);
DN_UT_Assert(&result, DN_Cast(bool) str_result == true);
}
for (DN_UT_Test(&result, "Is all digits fails on whitespace")) {
DN_B32 str_result = DN_Str8_IsAll(DN_STR8("23 "), DN_Str8IsAll_Digits);
DN_UT_Assert(&result, DN_CAST(bool) str_result == false);
DN_B32 str_result = DN_Str8IsAll(DN_Str8Lit("23 "), DN_Str8IsAllType_Digits);
DN_UT_Assert(&result, DN_Cast(bool) str_result == false);
}
// NOTE: DN_Str8_BSplit ///////////////////////////////////////////////////////////////////
// NOTE: DN_Str8BSplit ///////////////////////////////////////////////////////////////////
{
{
char const *TEST_FMT = "Binary split \"%.*s\" with \"%.*s\"";
DN_Str8 delimiter = DN_STR8("/");
DN_Str8 input = DN_STR8("abcdef");
for (DN_UT_Test(&result, TEST_FMT, DN_STR_FMT(input), DN_STR_FMT(delimiter))) {
DN_Str8BSplitResult split = DN_Str8_BSplit(input, delimiter);
DN_UT_AssertF(&result, DN_Str8_Eq(split.lhs, DN_STR8("abcdef")), "[lhs=%.*s]", DN_STR_FMT(split.lhs));
DN_UT_AssertF(&result, DN_Str8_Eq(split.rhs, DN_STR8("")), "[rhs=%.*s]", DN_STR_FMT(split.rhs));
DN_Str8 delimiter = DN_Str8Lit("/");
DN_Str8 input = DN_Str8Lit("abcdef");
for (DN_UT_Test(&result, TEST_FMT, DN_Str8PrintFmt(input), DN_Str8PrintFmt(delimiter))) {
DN_Str8BSplitResult split = DN_Str8BSplit(input, delimiter);
DN_UT_AssertF(&result, DN_Str8Eq(split.lhs, DN_Str8Lit("abcdef")), "[lhs=%.*s]", DN_Str8PrintFmt(split.lhs));
DN_UT_AssertF(&result, DN_Str8Eq(split.rhs, DN_Str8Lit("")), "[rhs=%.*s]", DN_Str8PrintFmt(split.rhs));
}
input = DN_STR8("abc/def");
for (DN_UT_Test(&result, TEST_FMT, DN_STR_FMT(input), DN_STR_FMT(delimiter))) {
DN_Str8BSplitResult split = DN_Str8_BSplit(input, delimiter);
DN_UT_AssertF(&result, DN_Str8_Eq(split.lhs, DN_STR8("abc")), "[lhs=%.*s]", DN_STR_FMT(split.lhs));
DN_UT_AssertF(&result, DN_Str8_Eq(split.rhs, DN_STR8("def")), "[rhs=%.*s]", DN_STR_FMT(split.rhs));
input = DN_Str8Lit("abc/def");
for (DN_UT_Test(&result, TEST_FMT, DN_Str8PrintFmt(input), DN_Str8PrintFmt(delimiter))) {
DN_Str8BSplitResult split = DN_Str8BSplit(input, delimiter);
DN_UT_AssertF(&result, DN_Str8Eq(split.lhs, DN_Str8Lit("abc")), "[lhs=%.*s]", DN_Str8PrintFmt(split.lhs));
DN_UT_AssertF(&result, DN_Str8Eq(split.rhs, DN_Str8Lit("def")), "[rhs=%.*s]", DN_Str8PrintFmt(split.rhs));
}
input = DN_STR8("/abcdef");
for (DN_UT_Test(&result, TEST_FMT, DN_STR_FMT(input), DN_STR_FMT(delimiter))) {
DN_Str8BSplitResult split = DN_Str8_BSplit(input, delimiter);
DN_UT_AssertF(&result, DN_Str8_Eq(split.lhs, DN_STR8("")), "[lhs=%.*s]", DN_STR_FMT(split.lhs));
DN_UT_AssertF(&result, DN_Str8_Eq(split.rhs, DN_STR8("abcdef")), "[rhs=%.*s]", DN_STR_FMT(split.rhs));
input = DN_Str8Lit("/abcdef");
for (DN_UT_Test(&result, TEST_FMT, DN_Str8PrintFmt(input), DN_Str8PrintFmt(delimiter))) {
DN_Str8BSplitResult split = DN_Str8BSplit(input, delimiter);
DN_UT_AssertF(&result, DN_Str8Eq(split.lhs, DN_Str8Lit("")), "[lhs=%.*s]", DN_Str8PrintFmt(split.lhs));
DN_UT_AssertF(&result, DN_Str8Eq(split.rhs, DN_Str8Lit("abcdef")), "[rhs=%.*s]", DN_Str8PrintFmt(split.rhs));
}
}
{
DN_Str8 delimiter = DN_STR8("-=-");
DN_Str8 input = DN_STR8("123-=-456");
for (DN_UT_Test(&result, "Binary split \"%.*s\" with \"%.*s\"", DN_STR_FMT(input), DN_STR_FMT(delimiter))) {
DN_Str8BSplitResult split = DN_Str8_BSplit(input, delimiter);
DN_UT_AssertF(&result, DN_Str8_Eq(split.lhs, DN_STR8("123")), "[lhs=%.*s]", DN_STR_FMT(split.lhs));
DN_UT_AssertF(&result, DN_Str8_Eq(split.rhs, DN_STR8("456")), "[rhs=%.*s]", DN_STR_FMT(split.rhs));
DN_Str8 delimiter = DN_Str8Lit("-=-");
DN_Str8 input = DN_Str8Lit("123-=-456");
for (DN_UT_Test(&result, "Binary split \"%.*s\" with \"%.*s\"", DN_Str8PrintFmt(input), DN_Str8PrintFmt(delimiter))) {
DN_Str8BSplitResult split = DN_Str8BSplit(input, delimiter);
DN_UT_AssertF(&result, DN_Str8Eq(split.lhs, DN_Str8Lit("123")), "[lhs=%.*s]", DN_Str8PrintFmt(split.lhs));
DN_UT_AssertF(&result, DN_Str8Eq(split.rhs, DN_Str8Lit("456")), "[rhs=%.*s]", DN_Str8PrintFmt(split.rhs));
}
}
}
// NOTE: DN_Str8_ToI64 /////////////////////////////////////////////////////////////////////////
for (DN_UT_Test(&result, "To I64: Convert null string")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_Str8_Init(nullptr, 5), 0);
DN_UT_Assert(&result, str_result.success);
DN_UT_Assert(&result, str_result.value == 0);
}
// NOTE: DN_I64FromStr8
for (DN_UT_Test(&result, "To I64: Convert empty string")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_STR8(""), 0);
DN_I64FromResult str_result = DN_I64FromStr8(DN_Str8Lit(""), 0);
DN_UT_Assert(&result, str_result.success);
DN_UT_Assert(&result, str_result.value == 0);
}
for (DN_UT_Test(&result, "To I64: Convert \"1\"")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_STR8("1"), 0);
DN_I64FromResult str_result = DN_I64FromStr8(DN_Str8Lit("1"), 0);
DN_UT_Assert(&result, str_result.success);
DN_UT_Assert(&result, str_result.value == 1);
}
for (DN_UT_Test(&result, "To I64: Convert \"-0\"")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_STR8("-0"), 0);
DN_I64FromResult str_result = DN_I64FromStr8(DN_Str8Lit("-0"), 0);
DN_UT_Assert(&result, str_result.success);
DN_UT_Assert(&result, str_result.value == 0);
}
for (DN_UT_Test(&result, "To I64: Convert \"-1\"")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_STR8("-1"), 0);
DN_I64FromResult str_result = DN_I64FromStr8(DN_Str8Lit("-1"), 0);
DN_UT_Assert(&result, str_result.success);
DN_UT_Assert(&result, str_result.value == -1);
}
for (DN_UT_Test(&result, "To I64: Convert \"1.2\"")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_STR8("1.2"), 0);
DN_I64FromResult str_result = DN_I64FromStr8(DN_Str8Lit("1.2"), 0);
DN_UT_Assert(&result, !str_result.success);
DN_UT_Assert(&result, str_result.value == 1);
}
for (DN_UT_Test(&result, "To I64: Convert \"1,234\"")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_STR8("1,234"), ',');
DN_I64FromResult str_result = DN_I64FromStr8(DN_Str8Lit("1,234"), ',');
DN_UT_Assert(&result, str_result.success);
DN_UT_Assert(&result, str_result.value == 1234);
}
for (DN_UT_Test(&result, "To I64: Convert \"1,2\"")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_STR8("1,2"), ',');
DN_I64FromResult str_result = DN_I64FromStr8(DN_Str8Lit("1,2"), ',');
DN_UT_Assert(&result, str_result.success);
DN_UT_Assert(&result, str_result.value == 12);
}
for (DN_UT_Test(&result, "To I64: Convert \"12a3\"")) {
DN_Str8ToI64Result str_result = DN_Str8_ToI64(DN_STR8("12a3"), 0);
DN_I64FromResult str_result = DN_I64FromStr8(DN_Str8Lit("12a3"), 0);
DN_UT_Assert(&result, !str_result.success);
DN_UT_Assert(&result, str_result.value == 12);
}
// NOTE: DN_Str8_ToU64 /////////////////////////////////////////////////////////////////////////
for (DN_UT_Test(&result, "To U64: Convert nullptr")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_Str8_Init(nullptr, 5), 0);
DN_UT_Assert(&result, str_result.success);
DN_UT_AssertF(&result, str_result.value == 0, "result: %" PRIu64, str_result.value);
}
// NOTE: DN_U64FromStr8
for (DN_UT_Test(&result, "To U64: Convert empty string")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_STR8(""), 0);
DN_U64FromResult str_result = DN_U64FromStr8(DN_Str8Lit(""), 0);
DN_UT_Assert(&result, str_result.success);
DN_UT_AssertF(&result, str_result.value == 0, "result: %" PRIu64, str_result.value);
}
for (DN_UT_Test(&result, "To U64: Convert \"1\"")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_STR8("1"), 0);
DN_U64FromResult str_result = DN_U64FromStr8(DN_Str8Lit("1"), 0);
DN_UT_Assert(&result, str_result.success);
DN_UT_AssertF(&result, str_result.value == 1, "result: %" PRIu64, str_result.value);
}
for (DN_UT_Test(&result, "To U64: Convert \"-0\"")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_STR8("-0"), 0);
DN_U64FromResult str_result = DN_U64FromStr8(DN_Str8Lit("-0"), 0);
DN_UT_Assert(&result, !str_result.success);
DN_UT_AssertF(&result, str_result.value == 0, "result: %" PRIu64, str_result.value);
}
for (DN_UT_Test(&result, "To U64: Convert \"-1\"")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_STR8("-1"), 0);
DN_U64FromResult str_result = DN_U64FromStr8(DN_Str8Lit("-1"), 0);
DN_UT_Assert(&result, !str_result.success);
DN_UT_AssertF(&result, str_result.value == 0, "result: %" PRIu64, str_result.value);
}
for (DN_UT_Test(&result, "To U64: Convert \"1.2\"")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_STR8("1.2"), 0);
DN_U64FromResult str_result = DN_U64FromStr8(DN_Str8Lit("1.2"), 0);
DN_UT_Assert(&result, !str_result.success);
DN_UT_AssertF(&result, str_result.value == 1, "result: %" PRIu64, str_result.value);
}
for (DN_UT_Test(&result, "To U64: Convert \"1,234\"")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_STR8("1,234"), ',');
DN_U64FromResult str_result = DN_U64FromStr8(DN_Str8Lit("1,234"), ',');
DN_UT_Assert(&result, str_result.success);
DN_UT_AssertF(&result, str_result.value == 1234, "result: %" PRIu64, str_result.value);
}
for (DN_UT_Test(&result, "To U64: Convert \"1,2\"")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_STR8("1,2"), ',');
DN_U64FromResult str_result = DN_U64FromStr8(DN_Str8Lit("1,2"), ',');
DN_UT_Assert(&result, str_result.success);
DN_UT_AssertF(&result, str_result.value == 12, "result: %" PRIu64, str_result.value);
}
for (DN_UT_Test(&result, "To U64: Convert \"12a3\"")) {
DN_Str8ToU64Result str_result = DN_Str8_ToU64(DN_STR8("12a3"), 0);
DN_U64FromResult str_result = DN_U64FromStr8(DN_Str8Lit("12a3"), 0);
DN_UT_Assert(&result, !str_result.success);
DN_UT_AssertF(&result, str_result.value == 12, "result: %" PRIu64, str_result.value);
}
// NOTE: DN_Str8_Find /////////////////////////////////////////////////////////////////////
// NOTE: DN_Str8Find
for (DN_UT_Test(&result, "Find: String (char) is not in buffer")) {
DN_Str8 buf = DN_STR8("836a35becd4e74b66a0d6844d51f1a63018c7ebc44cf7e109e8e4bba57eefb55");
DN_Str8 find = DN_STR8("2");
DN_Str8FindResult str_result = DN_Str8_FindStr8(buf, find, DN_Str8EqCase_Sensitive);
DN_Str8 buf = DN_Str8Lit("836a35becd4e74b66a0d6844d51f1a63018c7ebc44cf7e109e8e4bba57eefb55");
DN_Str8 find = DN_Str8Lit("2");
DN_Str8FindResult str_result = DN_Str8FindStr8(buf, find, DN_Str8EqCase_Sensitive);
DN_UT_Assert(&result, !str_result.found);
DN_UT_Assert(&result, str_result.index == 0);
DN_UT_Assert(&result, str_result.match.data == nullptr);
@@ -2332,33 +2351,33 @@ static DN_UTCore DN_Tests_Str8()
}
for (DN_UT_Test(&result, "Find: String (char) is in buffer")) {
DN_Str8 buf = DN_STR8("836a35becd4e74b66a0d6844d51f1a63018c7ebc44cf7e109e8e4bba57eefb55");
DN_Str8 find = DN_STR8("6");
DN_Str8FindResult str_result = DN_Str8_FindStr8(buf, find, DN_Str8EqCase_Sensitive);
DN_Str8 buf = DN_Str8Lit("836a35becd4e74b66a0d6844d51f1a63018c7ebc44cf7e109e8e4bba57eefb55");
DN_Str8 find = DN_Str8Lit("6");
DN_Str8FindResult str_result = DN_Str8FindStr8(buf, find, DN_Str8EqCase_Sensitive);
DN_UT_Assert(&result, str_result.found);
DN_UT_Assert(&result, str_result.index == 2);
DN_UT_Assert(&result, str_result.match.data[0] == '6');
}
// NOTE: DN_Str8_FileNameFromPath //////////////////////////////////////////////////////////////
// NOTE: DN_Str8FileNameFromPath
for (DN_UT_Test(&result, "File name from Windows path")) {
DN_Str8 buf = DN_STR8("C:\\ABC\\str_result.exe");
DN_Str8 str_result = DN_Str8_FileNameFromPath(buf);
DN_UT_AssertF(&result, str_result == DN_STR8("str_result.exe"), "%.*s", DN_STR_FMT(str_result));
DN_Str8 buf = DN_Str8Lit("C:\\ABC\\str_result.exe");
DN_Str8 str_result = DN_Str8FileNameFromPath(buf);
DN_UT_AssertF(&result, DN_Str8Eq(str_result, DN_Str8Lit("str_result.exe")), "%.*s", DN_Str8PrintFmt(str_result));
}
for (DN_UT_Test(&result, "File name from Linux path")) {
DN_Str8 buf = DN_STR8("/ABC/str_result.exe");
DN_Str8 str_result = DN_Str8_FileNameFromPath(buf);
DN_UT_AssertF(&result, str_result == DN_STR8("str_result.exe"), "%.*s", DN_STR_FMT(str_result));
DN_Str8 buf = DN_Str8Lit("/ABC/str_result.exe");
DN_Str8 str_result = DN_Str8FileNameFromPath(buf);
DN_UT_AssertF(&result, DN_Str8Eq(str_result, DN_Str8Lit("str_result.exe")), "%.*s", DN_Str8PrintFmt(str_result));
}
// NOTE: DN_Str8_TrimPrefix ////////////////////////////////////////////////////////////////////
// NOTE: DN_Str8TrimPrefix
for (DN_UT_Test(&result, "Trim prefix")) {
DN_Str8 prefix = DN_STR8("@123");
DN_Str8 buf = DN_STR8("@123string");
DN_Str8 str_result = DN_Str8_TrimPrefix(buf, prefix, DN_Str8EqCase_Sensitive);
DN_UT_Assert(&result, str_result == DN_STR8("string"));
DN_Str8 prefix = DN_Str8Lit("@123");
DN_Str8 buf = DN_Str8Lit("@123string");
DN_Str8 str_result = DN_Str8TrimPrefix(buf, prefix, DN_Str8EqCase_Sensitive);
DN_UT_Assert(&result, DN_Str8Eq(str_result, DN_Str8Lit("string")));
}
}
return result;
@@ -2383,8 +2402,8 @@ static DN_UTCore DN_Tests_TicketMutex()
DN_TicketMutex mutex = {};
unsigned int ticket_a = DN_TicketMutex_MakeTicket(&mutex);
unsigned int ticket_b = DN_TicketMutex_MakeTicket(&mutex);
DN_UT_Assert(&result, DN_CAST(bool) DN_TicketMutex_CanLock(&mutex, ticket_b) == false);
DN_UT_Assert(&result, DN_CAST(bool) DN_TicketMutex_CanLock(&mutex, ticket_a) == true);
DN_UT_Assert(&result, DN_Cast(bool) DN_TicketMutex_CanLock(&mutex, ticket_b) == false);
DN_UT_Assert(&result, DN_Cast(bool) DN_TicketMutex_CanLock(&mutex, ticket_a) == true);
DN_TicketMutex_BeginTicket(&mutex, ticket_a);
DN_TicketMutex_End(&mutex);
@@ -2405,22 +2424,22 @@ static DN_UTCore DN_Tests_Win()
DN_UT_LogF(&result, "OS Win32\n");
{
DN_OSTLSTMem tmem = DN_OS_TLSTMem(nullptr);
DN_Str8 input8 = DN_STR8("String");
DN_Str8 input8 = DN_Str8Lit("String");
DN_Str16 input16 = DN_Str16{(wchar_t *)(L"String"), sizeof(L"String") / sizeof(L"String"[0]) - 1};
for (DN_UT_Test(&result, "Str8 to Str16")) {
DN_Str16 str_result = DN_W32_Str8ToStr16(tmem.arena, input8);
DN_UT_Assert(&result, str_result == input16);
DN_UT_Assert(&result, DN_Str16Eq(str_result, input16));
}
for (DN_UT_Test(&result, "Str16 to Str8")) {
DN_Str8 str_result = DN_W32_Str16ToStr8(tmem.arena, input16);
DN_UT_Assert(&result, str_result == input8);
DN_UT_Assert(&result, DN_Str8Eq(str_result, input8));
}
for (DN_UT_Test(&result, "Str16 to Str8: Null terminates string")) {
int size_required = DN_W32_Str16ToStr8Buffer(input16, nullptr, 0);
char *string = DN_Arena_NewArray(tmem.arena, char, size_required + 1, DN_ZeroMem_No);
char *string = DN_ArenaNewArray(tmem.arena, char, size_required + 1, DN_ZMem_No);
// Fill the string with error sentinels
DN_Memset(string, 'Z', size_required + 1);
@@ -2438,8 +2457,8 @@ static DN_UTCore DN_Tests_Win()
int size_returned = DN_W32_Str16ToStr8Buffer(input16, nullptr, 0);
char const EXPECTED[] = {'S', 't', 'r', 'i', 'n', 'g', 0};
DN_UT_AssertF(&result, DN_CAST(int) string8.size == size_returned, "string_size: %d, result: %d", DN_CAST(int) string8.size, size_returned);
DN_UT_AssertF(&result, DN_CAST(int) string8.size == DN_ArrayCountU(EXPECTED) - 1, "string_size: %d, expected: %zu", DN_CAST(int) string8.size, DN_ArrayCountU(EXPECTED) - 1);
DN_UT_AssertF(&result, DN_Cast(int) string8.size == size_returned, "string_size: %d, result: %d", DN_Cast(int) string8.size, size_returned);
DN_UT_AssertF(&result, DN_Cast(int) string8.size == DN_ArrayCountU(EXPECTED) - 1, "string_size: %d, expected: %zu", DN_Cast(int) string8.size, DN_ArrayCountU(EXPECTED) - 1);
DN_UT_Assert(&result, DN_Memcmp(EXPECTED, string8.data, sizeof(EXPECTED)) == 0);
}
}
Source/Extra/dn_type_info.cpp
+1 -1
View File
@@ -25,7 +25,7 @@ DN_TypeGetField DN_Type_GetField(DN_TypeInfo const *type_info, DN_Str8 name)
if (type_field->name == name) {
result.success = true;
result.index = index;
result.field = DN_CAST(DN_TypeField *)type_field;
result.field = DN_Cast(DN_TypeField *)type_field;
break;
}
}