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

Fix unit tests w/ updates

Browse Source
This commit is contained in:
doylet 2026-03-27 20:13:16 +11:00
parent f9b6dfecf8
commit d6f4b9ab55
3 changed files with 253 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
Source/Base/dn_base.cpp
View File

@ -1851,6 +1851,49 @@ DN_API DN_U64 DN_U64FromHexStr8Unsafe(DN_Str8 hex)
return result;
}
DN_API DN_U64 DN_U64FromU8x32HiBEUnsafe(DN_U8x32 const *val)
{
DN_U64 result_be = 0; // Last 8 bytes of 32-byte slot (big-endian)
DN_Memcpy(&result_be, val->data + sizeof(val->data) - sizeof(result_be), sizeof(result_be));
DN_U64 result = DN_ByteSwap64(result_be);
return result;
}
DN_API DN_U64 DN_U64FromU8x32HiBE(DN_U8x32 const *val)
{
DN_U64 result = {};
if (val) {
// NOTE: Check that the high bits are not set
DN_U8x32 zero_mask = {};
bool high_bits_set = DN_Memcmp(val->data, zero_mask.data, sizeof(zero_mask.data) - sizeof(result)) != 0;
DN_Assert(!high_bits_set);
result = DN_U64FromU8x32HiBEUnsafe(val);
}
return result;
}
DN_API DN_USize DN_USizeFromU8x32HiBEUnsafe(DN_U8x32 const *val)
{
DN_USize result_be = 0;
DN_Memcpy(&result_be, val->data + sizeof(val->data) - sizeof(result_be), sizeof(result_be));
DN_USize result = DN_ByteSwapUSize(result_be);
return result;
}
DN_API DN_USize DN_USizeFromU8x32HiBE(DN_U8x32 const *val)
{
DN_USize result = {};
if (val) {
// NOTE: Check that the high bits are not set
DN_U8x32 mask = {};
DN_Memset(mask.data, 1, sizeof(mask.data) - sizeof(result));
bool high_bits_set = DN_Memcmp(val->data, mask.data, 24) != 0;
DN_Assert(!high_bits_set);
result = DN_USizeFromU8x32HiBEUnsafe(val);
}
return result;
}
DN_API void DN_ByteSwapU64Ptr(DN_U8 *dest, DN_U64 src)
{
dest[0] = DN_Cast(DN_U8)((src >> 56) & 0xFF);
@ -2190,6 +2233,40 @@ DN_API DN_Str8x256 DN_Str8x256FromFmtV(DN_FMT_ATTRIB char const *fmt, va_list ar
return result;
}
DN_API DN_Str8x512 DN_Str8x512FromFmt(DN_FMT_ATTRIB char const *fmt, ...)
{
va_list args;
va_start(args, fmt);
DN_Str8x512 result = {};
DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args);
va_end(args);
return result;
}
DN_API DN_Str8x512 DN_Str8x512FromFmtV(DN_FMT_ATTRIB char const *fmt, va_list args)
{
DN_Str8x512 result = {};
DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args);
return result;
}
DN_API DN_Str8x1024 DN_Str8x1024FromFmt(DN_FMT_ATTRIB char const *fmt, ...)
{
va_list args;
va_start(args, fmt);
DN_Str8x1024 result = {};
DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args);
va_end(args);
return result;
}
DN_API DN_Str8x1024 DN_Str8x1024FromFmtV(DN_FMT_ATTRIB char const *fmt, va_list args)
{
DN_Str8x1024 result = {};
DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args);
return result;
}
DN_API void DN_Str8x16AppendFmt(DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, ...)
{
va_list args;
@ -2255,6 +2332,32 @@ DN_API void DN_Str8x256AppendFmtV(DN_Str8x256 *str, DN_FMT_ATTRIB char const *fm
DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args);
}
DN_API void DN_Str8x512AppendFmt(DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt, ...)
{
va_list args;
va_start(args, fmt);
DN_Str8x512AppendFmtV(str, fmt, args);
va_end(args);
}
DN_API void DN_Str8x512AppendFmtV(DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt, va_list args)
{
DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args);
}
DN_API void DN_Str8x1024AppendFmt(DN_Str8x1024 *str, DN_FMT_ATTRIB char const *fmt, ...)
{
va_list args;
va_start(args, fmt);
DN_Str8x1024AppendFmtV(str, fmt, args);
va_end(args);
}
DN_API void DN_Str8x1024AppendFmtV(DN_Str8x1024 *str, DN_FMT_ATTRIB char const *fmt, va_list args)
{
DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args);
}
DN_API DN_Str8x32 DN_Str8x32FromU64(DN_U64 val, char separator)
{
DN_Str8x32 result = {};
@ -3414,22 +3517,17 @@ DN_API DN_NibbleFromU8Result DN_NibbleFromU8(DN_U8 u8)
return result;
}
DN_API DN_USize DN_BytesFromHexPtr(void const *hex, DN_USize hex_count, void *bytes, DN_USize bytes_count)
DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count)
{
DN_USize result = 0;
DN_U8 const *hex_u8 = DN_Cast(DN_U8 const *) hex;
if (hex_count >= 2 && hex_u8[0] == '0' && (hex_u8[1] == 'x' || hex_u8[1] == 'X')) {
hex_u8 += 2;
hex_count -= 2;
}
if (hex_count > (bytes_count * 2))
DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(hex);
DN_USize result = 0;
if (hex_trimmed.size > (dest_count * 2))
return result;
DN_U8 *ptr = DN_Cast(DN_U8 *)bytes;
for (DN_USize index = 0; index < hex_count; index += 2) {
DN_U8 nibble0 = DN_U8FromHexNibble(hex_u8[index + 0]);
DN_U8 nibble1 = DN_U8FromHexNibble(hex_u8[index + 1]);
DN_U8 *ptr = DN_Cast(DN_U8 *) dest;
for (DN_USize index = 0; index < hex_trimmed.size; index += 2) {
DN_U8 nibble0 = DN_U8FromHexNibble(hex_trimmed.data[index + 0]);
DN_U8 nibble1 = DN_U8FromHexNibble(hex_trimmed.data[index + 1]);
if (nibble0 == 0xFF || nibble1 == 0xFF)
return result;
*ptr++ = nibble0 << 4 | nibble1 << 0;
@ -3438,42 +3536,45 @@ DN_API DN_USize DN_BytesFromHexPtr(void const *hex, DN_USize hex_count, void *by
return result;
}
DN_API DN_Str8 DN_BytesFromHexPtrArena(void const *hex, DN_USize hex_size, DN_Arena *arena)
{
DN_Assert(hex_size % 2 == 0);
DN_Str8 result = {};
result.data = DN_ArenaNewArray(arena, char, hex_size / 2, DN_ZMem_No);
if (result.data)
result.size = DN_BytesFromHexPtr(hex, hex_size, result.data, hex_size / 2);
return result;
}
DN_API DN_USize DN_BytesFromHexStr8(DN_Str8 hex, void *dest, DN_USize dest_count)
{
DN_USize result = DN_BytesFromHexPtr(hex.data, hex.size, dest, dest_count);
return result;
}
DN_API DN_Str8 DN_BytesFromHexStr8Arena(DN_Str8 hex, DN_Arena *arena)
DN_API DN_Str8 DN_BytesFromHexArena(DN_Str8 hex, DN_Arena *arena)
{
DN_Str8 result = DN_BytesFromHexPtrArena(hex.data, hex.size, arena);
return result;
}
DN_API DN_U8x16 DN_BytesFromHex32Ptr(void const *hex, DN_USize hex_count)
DN_API DN_USize DN_BytesFromHexPtr(char const *hex, DN_USize hex_count, void *dest, DN_USize dest_count)
{
DN_U8x16 result = {};
DN_Assert(hex_count / 2 == sizeof result.data);
DN_USize bytes_written = DN_BytesFromHexPtr(hex, hex_count, result.data, sizeof result);
DN_USize result = DN_BytesFromHex(DN_Str8FromPtr(hex, hex_count), dest, dest_count);
return result;
}
DN_API DN_Str8 DN_BytesFromHexPtrArena(char const *hex, DN_USize hex_count, DN_Arena *arena)
{
DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count));
DN_Assert(hex_trimmed.size % 2 == 0);
DN_Str8 result = {};
result.data = DN_ArenaNewArray(arena, char, hex_trimmed.size / 2, DN_ZMem_No);
if (result.data)
result.size = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.size / 2);
return result;
}
DN_API DN_U8x16 DN_BytesFromHex32Ptr(char const *hex, DN_USize hex_count)
{
DN_U8x16 result = {};
DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count));
DN_Assert(hex_trimmed.size / 2 == sizeof result.data);
DN_USize bytes_written = DN_BytesFromHex(hex_trimmed, result.data, sizeof result.data);
DN_Assert(bytes_written == sizeof result.data);
return result;
}
DN_API DN_U8x32 DN_BytesFromHex64Ptr(void const *hex, DN_USize hex_count)
DN_API DN_U8x32 DN_BytesFromHex64Ptr(char const *hex, DN_USize hex_count)
{
DN_U8x32 result = {};
DN_Assert(hex_count / 2 == sizeof result.data);
DN_USize bytes_written = DN_BytesFromHexPtr(hex, hex_count, result.data, sizeof result);
DN_U8x32 result = {};
DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count));
DN_Assert(hex_trimmed.size / 2 == sizeof result.data);
DN_USize bytes_written = DN_BytesFromHex(hex_trimmed, result.data, sizeof result.data);
DN_Assert(bytes_written == sizeof result.data);
return result;
}

66
Source/Base/dn_base.h
View File

@ -420,11 +420,13 @@ struct DN_Str8Slice
DN_USize count;
};
struct DN_Str8x16 { char data[16]; DN_USize size; };
struct DN_Str8x32 { char data[32]; DN_USize size; };
struct DN_Str8x64 { char data[64]; DN_USize size; };
struct DN_Str8x128 { char data[128]; DN_USize size; };
struct DN_Str8x256 { char data[256]; DN_USize size; };
struct DN_Str8x16 { char data[16]; DN_USize size; };
struct DN_Str8x32 { char data[32]; DN_USize size; };
struct DN_Str8x64 { char data[64]; DN_USize size; };
struct DN_Str8x128 { char data[128]; DN_USize size; };
struct DN_Str8x256 { char data[256]; DN_USize size; };
struct DN_Str8x512 { char data[512]; DN_USize size; };
struct DN_Str8x1024 { char data[1024]; DN_USize size; };
struct DN_Str16 // A pointer and length style string that holds slices to UTF16 bytes.
{
@ -1353,16 +1355,27 @@ DN_API DN_U64 DN_AlignUpPowerOfTwoU64
DN_API DN_U32 DN_AlignUpPowerOfTwoU32 (DN_U32 val);
DN_API void DN_ByteSwapU64Ptr (DN_U8* dest, DN_U64 src);
#define DN_ByteSwap64(u64) ( \
(((((DN_U64)(u64)) >> 56) & 0xFF) << 0) | \
(((((DN_U64)(u64)) >> 48) & 0xFF) << 8) | \
(((((DN_U64)(u64)) >> 40) & 0xFF) << 16) | \
(((((DN_U64)(u64)) >> 32) & 0xFF) << 24) | \
(((((DN_U64)(u64)) >> 24) & 0xFF) << 32) | \
(((((DN_U64)(u64)) >> 16) & 0xFF) << 40) | \
(((((DN_U64)(u64)) >> 8) & 0xFF) << 48) | \
(((((DN_U64)(u64)) >> 0) & 0xFF) << 56) \
#define DN_ByteSwap64(val) ( \
(((((DN_U64)(val)) >> 56) & 0xFF) << 0) | \
(((((DN_U64)(val)) >> 48) & 0xFF) << 8) | \
(((((DN_U64)(val)) >> 40) & 0xFF) << 16) | \
(((((DN_U64)(val)) >> 32) & 0xFF) << 24) | \
(((((DN_U64)(val)) >> 24) & 0xFF) << 32) | \
(((((DN_U64)(val)) >> 16) & 0xFF) << 40) | \
(((((DN_U64)(val)) >> 8) & 0xFF) << 48) | \
(((((DN_U64)(val)) >> 0) & 0xFF) << 56) \
)
#define DN_ByteSwap32(val) ( \
(((((DN_U32)(val)) >> 24) & 0xFF) << 0) | \
(((((DN_U32)(val)) >> 16) & 0xFF) << 8) | \
(((((DN_U32)(val)) >> 8) & 0xFF) << 16) | \
(((((DN_U32)(val)) >> 0) & 0xFF) << 24) \
)
#if defined(DN_64_BIT)
#define DN_ByteSwapUSize(val) DN_ByteSwap64(val)
#else
#define DN_ByteSwapUSize(val) DN_ByteSwap32(val)
#endif
DN_API DN_CPUIDResult DN_CPUID (DN_CPUIDArgs args);
@ -1544,6 +1557,10 @@ DN_API DN_U64FromResult DN_U64FromHexPtr
DN_API DN_U64 DN_U64FromHexPtrUnsafe (void const *hex, DN_USize hex_count);
DN_API DN_U64FromResult DN_U64FromHexStr8 (DN_Str8 hex);
DN_API DN_U64 DN_U64FromHexStr8Unsafe (DN_Str8 hex);
DN_API DN_U64 DN_U64FromU8x32HiBEUnsafe (DN_U8x32 const *val); // Get U64 stored in big-endian at the high bytes [24:32)
DN_API DN_U64 DN_U64FromU8x32HiBE (DN_U8x32 const *val); // Checks [0:24) bytes aren't set before getting the U64
DN_API DN_USize DN_USizeFromU8x32HiBEUnsafe (DN_U8x32 const *val); // Get USize stored in big-endian at the high bytes [32 - sizeof USize:32)
DN_API DN_USize DN_USizeFromU8x32HiBE (DN_U8x32 const *val); // Checks [0:sizeof USize) bytes aren't set before getting the U64
DN_API DN_I64FromResult DN_I64FromStr8 (DN_Str8 string, char separator);
DN_API DN_I64FromResult DN_I64FromPtr (void const *data, DN_USize size, char separator);
DN_API DN_I64 DN_I64FromPtrUnsafe (void const *data, DN_USize size, char separator);
@ -1563,6 +1580,7 @@ DN_API DN_USize DN_CStr16Size
#define DN_Str8PrintFmt(string) (int)((string).size), (string).data
#define DN_Str8FromPtr(data, size) DN_Literal(DN_Str8){(char *)(data), (DN_USize)(size)}
#define DN_Str8FromStruct(ptr) DN_Str8FromPtr((ptr)->data, (ptr)->size)
#define DN_Str8FromLitArray(c_array) DN_Str8FromPtr(c_array, DN_ArrayCountU(c_array))
DN_API DN_Str8 DN_Str8AllocArena (DN_Arena *arena, DN_USize size, DN_ZMem z_mem);
DN_API DN_Str8 DN_Str8AllocPool (DN_Pool *pool, DN_USize size);
DN_API DN_Str8 DN_Str8FromCStr8 (char const *src);
@ -1584,6 +1602,10 @@ DN_API DN_Str8x128 DN_Str8x128FromFmt
DN_API DN_Str8x256 DN_Str8x256FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API DN_Str8x256 DN_Str8x256FromFmt (DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_Str8x256 DN_Str8x256FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API DN_Str8x512 DN_Str8x512FromFmt (DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_Str8x512 DN_Str8x512FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API DN_Str8x1024 DN_Str8x1024FromFmt (DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_Str8x1024 DN_Str8x1024FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API void DN_Str8x16AppendFmt (DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, ...);
DN_API void DN_Str8x16AppendFmtV (DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API void DN_Str8x32AppendFmt (DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, ...);
@ -1594,6 +1616,10 @@ DN_API void DN_Str8x128AppendFmt
DN_API void DN_Str8x128AppendFmtV (DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API void DN_Str8x256AppendFmt (DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt, ...);
DN_API void DN_Str8x256AppendFmtV (DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API void DN_Str8x512AppendFmt (DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt, ...);
DN_API void DN_Str8x512AppendFmtV (DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API void DN_Str8x1024AppendFmt (DN_Str8x1024 *str, DN_FMT_ATTRIB char const *fmt, ...);
DN_API void DN_Str8x1024AppendFmtV (DN_Str8x1024 *str, DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API DN_Str8x32 DN_Str8x32FromU64 (DN_U64 val, char separator);
DN_API bool DN_Str8IsAll (DN_Str8 string, DN_Str8IsAllType is_all);
DN_API char * DN_Str8End (DN_Str8 string);
@ -1690,12 +1716,12 @@ DN_API bool DN_UTF8DecodeIterate
DN_API DN_U8 DN_U8FromHexNibble (char hex);
DN_API DN_NibbleFromU8Result DN_NibbleFromU8 (DN_U8 u8);
DN_API DN_USize DN_BytesFromHexPtr (void const *hex, DN_USize hex_count, void *dest, DN_USize dest_count);
DN_API DN_Str8 DN_BytesFromHexPtrArena (void const *hex, DN_USize hex_count, DN_Arena *arena);
DN_API DN_USize DN_BytesFromHexStr8 (DN_Str8 hex, void *dest, DN_USize dest_count);
DN_API DN_Str8 DN_BytesFromHexStr8Arena (DN_Str8 hex, DN_Arena *arena);
DN_API DN_U8x16 DN_BytesFromHex32Ptr (void const *hex, DN_USize hex_count);
DN_API DN_U8x32 DN_BytesFromHex64Ptr (void const *hex, DN_USize hex_count);
DN_API DN_USize DN_BytesFromHex (DN_Str8 hex, void *dest, DN_USize dest_count);
DN_API DN_Str8 DN_BytesFromHexArena (DN_Str8 hex, DN_Arena *arena);
DN_API DN_USize DN_BytesFromHexPtr (char const *hex, DN_USize hex_count, void *dest, DN_USize dest_count);
DN_API DN_Str8 DN_BytesFromHexPtrArena (char const *hex, DN_USize hex_count, DN_Arena *arena);
DN_API DN_U8x16 DN_BytesFromHex32Ptr (char const *hex, DN_USize hex_count);
DN_API DN_U8x32 DN_BytesFromHex64Ptr (char const *hex, DN_USize hex_count);
DN_API DN_HexU64Str8 DN_HexFromU64 (DN_U64 value, DN_HexFromU64Type type);
DN_API DN_USize DN_HexFromBytesPtr (void const *bytes, DN_USize bytes_count, void *hex, DN_USize hex_count);

112
Source/Extra/dn_tests.cpp
View File

@ -514,7 +514,7 @@ static DN_UTCore DN_Tests_Bin()
DN_Str8 hex = DN_Str8Lit("0xf6ed00");
for (DN_UT_Test(&test, "Convert %.*s to bytes", DN_Str8PrintFmt(hex))) {
DN_Str8 bytes = DN_BytesFromHexStr8Arena(hex, scratch.arena);
DN_Str8 bytes = DN_BytesFromHexArena(hex, scratch.arena);
DN_UT_AssertF(&test,
DN_Str8Eq(bytes, DN_Str8Lit("\xf6\xed\x00")),
"number_hex=%.*s",
@ -1567,8 +1567,8 @@ void DN_RefImpl_Keccak_(int r, int c, const uint8_t *in, uint64_t inLen, uint8_t
DN_MSVC_WARNING_POP
DN_GCC_WARNING_POP
#define DN_KC_IMPLEMENTATION
#include "../Standalone/dn_keccak.h"
#define DN_SHA3_IMPLEMENTATION
#include "../Standalone/dn_sha3.h"
#define DN_UT_HASH_X_MACRO \
DN_UT_HASH_X_ENTRY(SHA3_224, "SHA3-224") \
@ -1598,120 +1598,144 @@ DN_Str8 const DN_UT_HASH_STRING_[] =
void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
{
DN_TCScratch scratch = DN_TCScratchBegin(nullptr, 0);
DN_TCScratch scratch = DN_TCScratchBegin(nullptr, 0);
DN_Str8 input_hex = DN_HexFromBytesPtrArena(input.data, input.size, scratch.arena);
switch (hash_type) {
case Hash_SHA3_224: {
DN_KCBytes28 hash = DN_KC_SHA3_224Str8(input);
DN_KCBytes28 expect;
DN_SHA3U8x28 hash = DN_SHA3Hash224b(input.data, input.size);
DN_SHA3U8x28 expect;
DN_RefImpl_FIPS202_SHA3_224_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_Str8 hash_hex = DN_HexFromBytesPtrArena(hash.data, DN_ArrayCountU(hash.data), scratch.arena);
DN_Str8 expect_hex = DN_HexFromBytesPtrArena(expect.data, DN_ArrayCountU(expect.data), scratch.arena);
DN_UT_AssertF(test,
DN_KC_Bytes28Equals(&hash, &expect),
DN_MemEq(hash.data, sizeof(hash.data), expect.data, sizeof(expect.data)),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_Str8PrintFmt(input_hex),
DN_KC_STRING56_FMT(DN_KC_Bytes28ToHex(&hash).data),
DN_KC_STRING56_FMT(DN_KC_Bytes28ToHex(&expect).data));
DN_Str8PrintFmt(hash_hex),
DN_Str8PrintFmt(expect_hex));
} break;
case Hash_SHA3_256: {
DN_KCBytes32 hash = DN_KC_SHA3_256Str8(input);
DN_KCBytes32 expect;
DN_SHA3U8x32 hash = DN_SHA3Hash256b(input.data, input.size);
DN_SHA3U8x32 expect;
DN_RefImpl_FIPS202_SHA3_256_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_Str8 hash_hex = DN_HexFromBytesPtrArena(hash.data, DN_ArrayCountU(hash.data), scratch.arena);
DN_Str8 expect_hex = DN_HexFromBytesPtrArena(expect.data, DN_ArrayCountU(expect.data), scratch.arena);
DN_UT_AssertF(test,
DN_KC_Bytes32Equals(&hash, &expect),
DN_MemEq(hash.data, sizeof(hash.data), expect.data, sizeof(expect.data)),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_Str8PrintFmt(input_hex),
DN_KC_STRING64_FMT(DN_KC_Bytes32ToHex(&hash).data),
DN_KC_STRING64_FMT(DN_KC_Bytes32ToHex(&expect).data));
DN_Str8PrintFmt(hash_hex),
DN_Str8PrintFmt(expect_hex));
} break;
case Hash_SHA3_384: {
DN_KCBytes48 hash = DN_KC_SHA3_384Str8(input);
DN_KCBytes48 expect;
DN_SHA3U8x48 hash = DN_SHA3Hash384b(input.data, input.size);
DN_SHA3U8x48 expect;
DN_RefImpl_FIPS202_SHA3_384_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_Str8 hash_hex = DN_HexFromBytesPtrArena(hash.data, DN_ArrayCountU(hash.data), scratch.arena);
DN_Str8 expect_hex = DN_HexFromBytesPtrArena(expect.data, DN_ArrayCountU(expect.data), scratch.arena);
DN_UT_AssertF(test,
DN_KC_Bytes48Equals(&hash, &expect),
DN_MemEq(hash.data, sizeof(hash.data), expect.data, sizeof(expect.data)),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_Str8PrintFmt(input_hex),
DN_KC_STRING96_FMT(DN_KC_Bytes48ToHex(&hash).data),
DN_KC_STRING96_FMT(DN_KC_Bytes48ToHex(&expect).data));
DN_Str8PrintFmt(hash_hex),
DN_Str8PrintFmt(expect_hex));
} break;
case Hash_SHA3_512: {
DN_KCBytes64 hash = DN_KC_SHA3_512Str8(input);
DN_KCBytes64 expect;
DN_SHA3U8x64 hash = DN_SHA3Hash512b(input.data, input.size);
DN_SHA3U8x64 expect;
DN_RefImpl_FIPS202_SHA3_512_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data);
DN_Str8 hash_hex = DN_HexFromBytesPtrArena(hash.data, DN_ArrayCountU(hash.data), scratch.arena);
DN_Str8 expect_hex = DN_HexFromBytesPtrArena(expect.data, DN_ArrayCountU(expect.data), scratch.arena);
DN_UT_AssertF(test,
DN_KC_Bytes64Equals(&hash, &expect),
DN_MemEq(hash.data, sizeof(hash.data), expect.data, sizeof(expect.data)),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_Str8PrintFmt(input_hex),
DN_KC_STRING128_FMT(DN_KC_Bytes64ToHex(&hash).data),
DN_KC_STRING128_FMT(DN_KC_Bytes64ToHex(&expect).data));
DN_Str8PrintFmt(hash_hex),
DN_Str8PrintFmt(expect_hex));
} break;
case Hash_Keccak_224: {
DN_KCBytes28 hash = DN_KC_Keccak224Str8(input);
DN_KCBytes28 expect;
DN_SHA3U8x28 hash = DN_KeccakHash224b(input.data, input.size);
DN_SHA3U8x28 expect;
DN_RefImpl_Keccak_(1152, 448, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_Str8 hash_hex = DN_HexFromBytesPtrArena(hash.data, DN_ArrayCountU(hash.data), scratch.arena);
DN_Str8 expect_hex = DN_HexFromBytesPtrArena(expect.data, DN_ArrayCountU(expect.data), scratch.arena);
DN_UT_AssertF(test,
DN_KC_Bytes28Equals(&hash, &expect),
DN_MemEq(hash.data, sizeof(hash.data), expect.data, sizeof(expect.data)),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_Str8PrintFmt(input_hex),
DN_KC_STRING56_FMT(DN_KC_Bytes28ToHex(&hash).data),
DN_KC_STRING56_FMT(DN_KC_Bytes28ToHex(&expect).data));
DN_Str8PrintFmt(hash_hex),
DN_Str8PrintFmt(expect_hex));
} break;
case Hash_Keccak_256: {
DN_KCBytes32 hash = DN_KC_Keccak256Str8(input);
DN_KCBytes32 expect;
DN_SHA3U8x32 hash = DN_KeccakHash256b(input.data, input.size);
DN_SHA3U8x32 expect;
DN_RefImpl_Keccak_(1088, 512, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_Str8 hash_hex = DN_HexFromBytesPtrArena(hash.data, DN_ArrayCountU(hash.data), scratch.arena);
DN_Str8 expect_hex = DN_HexFromBytesPtrArena(expect.data, DN_ArrayCountU(expect.data), scratch.arena);
DN_UT_AssertF(test,
DN_KC_Bytes32Equals(&hash, &expect),
DN_MemEq(hash.data, sizeof(hash.data), expect.data, sizeof(expect.data)),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_Str8PrintFmt(input_hex),
DN_KC_STRING64_FMT(DN_KC_Bytes32ToHex(&hash).data),
DN_KC_STRING64_FMT(DN_KC_Bytes32ToHex(&expect).data));
DN_Str8PrintFmt(hash_hex),
DN_Str8PrintFmt(expect_hex));
} break;
case Hash_Keccak_384: {
DN_KCBytes48 hash = DN_KC_Keccak384Str8(input);
DN_KCBytes48 expect;
DN_SHA3U8x48 hash = DN_KeccakHash384b(input.data, input.size);
DN_SHA3U8x48 expect;
DN_RefImpl_Keccak_(832, 768, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_Str8 hash_hex = DN_HexFromBytesPtrArena(hash.data, DN_ArrayCountU(hash.data), scratch.arena);
DN_Str8 expect_hex = DN_HexFromBytesPtrArena(expect.data, DN_ArrayCountU(expect.data), scratch.arena);
DN_UT_AssertF(test,
DN_KC_Bytes48Equals(&hash, &expect),
DN_MemEq(hash.data, sizeof(hash.data), expect.data, sizeof(expect.data)),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_Str8PrintFmt(input_hex),
DN_KC_STRING96_FMT(DN_KC_Bytes48ToHex(&hash).data),
DN_KC_STRING96_FMT(DN_KC_Bytes48ToHex(&expect).data));
DN_Str8PrintFmt(hash_hex),
DN_Str8PrintFmt(expect_hex));
} break;
case Hash_Keccak_512: {
DN_KCBytes64 hash = DN_KC_Keccak512Str8(input);
DN_KCBytes64 expect;
DN_SHA3U8x64 hash = DN_KeccakHash512b(input.data, input.size);
DN_SHA3U8x64 expect;
DN_RefImpl_Keccak_(576, 1024, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect));
DN_Str8 hash_hex = DN_HexFromBytesPtrArena(hash.data, DN_ArrayCountU(hash.data), scratch.arena);
DN_Str8 expect_hex = DN_HexFromBytesPtrArena(expect.data, DN_ArrayCountU(expect.data), scratch.arena);
DN_UT_AssertF(test,
DN_KC_Bytes64Equals(&hash, &expect),
DN_MemEq(hash.data, sizeof(hash.data), expect.data, sizeof(expect.data)),
"\ninput: %.*s"
"\nhash: %.*s"
"\nexpect: %.*s",
DN_Str8PrintFmt(input_hex),
DN_KC_STRING128_FMT(DN_KC_Bytes64ToHex(&hash).data),
DN_KC_STRING128_FMT(DN_KC_Bytes64ToHex(&expect).data));
DN_Str8PrintFmt(hash_hex),
DN_Str8PrintFmt(expect_hex));
} break;
}
DN_TCScratchEnd(&scratch);