1954 lines
104 KiB
C
1954 lines
104 KiB
C
#if !defined(INTC_TESTS_H)
|
|
#define INTC_TESTS_H
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// NOTE: Overview
|
|
// -----------------------------------------------------------------------------
|
|
// calccrypto's uint128/256 C++ tests converted into tests compatible with
|
|
// intc.h variations. This file compiles down and exposes a couple of functions
|
|
// that allow you to run the unit tests for "intc.h"
|
|
//
|
|
// This file can be compiled standalone by defining the macro
|
|
// INTC_TESTS_WITH_MAIN.
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
// NOTE: Configuration
|
|
// -----------------------------------------------------------------------------
|
|
// #define INTC_TESTS_IMPLEMENTATION
|
|
// Define this in one and only one C++ file to enable the implementation
|
|
// code of the header file.
|
|
//
|
|
// #define INTC_TESTS_WITH_MAIN
|
|
// Define this macro to enable a main entry point function such that this
|
|
// file can be compiled standalone into a runnable executable.
|
|
//
|
|
// #define INTC_TESTS_NO_COLORS
|
|
// Define this macro to disable colors from the output of the unit tests.
|
|
|
|
#if defined(INTC_TESTS_WITH_MAIN)
|
|
#if !defined(INTC_TESTS_IMPLEMENTATION)
|
|
#define INTC_TESTS_IMPLEMENTATION
|
|
#endif
|
|
|
|
#define INTC_IMPLEMENTATION
|
|
#include <intc.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// NOTE: Data Structures
|
|
// -----------------------------------------------------------------------------
|
|
struct intc_test_state
|
|
{
|
|
int test_count;
|
|
int fail_count;
|
|
};
|
|
|
|
struct intc_test_case
|
|
{
|
|
char const *name;
|
|
int name_size;
|
|
bool failed;
|
|
};
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// NOTE: Functions
|
|
// -----------------------------------------------------------------------------
|
|
// Run the unit tests for intc_u128/u256 integer types.
|
|
struct intc_test_state intc_u128_unit_tests();
|
|
|
|
#if !defined(INTC_NO_U256)
|
|
struct intc_test_state intc_u256_unit_tests();
|
|
#endif
|
|
|
|
// Helper function that runs both tests and pretty prints the summary of the tests
|
|
void intc_unit_tests();
|
|
|
|
// Helper function to print out test state
|
|
void intc_test_state_print(char const *label, struct intc_test_state const *state);
|
|
#endif // INTC_TESTS_H
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// NOTE: Test Data Declarations
|
|
// -----------------------------------------------------------------------------
|
|
#if defined(INTC_TESTS_IMPLEMENTATION)
|
|
struct intc_base_to_string {
|
|
int base;
|
|
char const *expect;
|
|
} const INTC_TESTS_STRING_BASE_TESTS[] = {
|
|
{2, "10000100000101011000010101101100"},
|
|
{3, "12201102210121112101"},
|
|
{4, "2010011120111230"},
|
|
{5, "14014244043144"},
|
|
{6, "1003520344444"},
|
|
{7, "105625466632"},
|
|
{8, "20405302554"},
|
|
{9, "5642717471"},
|
|
{10, "2216002924"},
|
|
{11, "a3796a883"},
|
|
{12, "51a175124"},
|
|
{13, "294145645"},
|
|
{14, "170445352"},
|
|
{15, "ce82d6d4"},
|
|
{16, "8415856c"},
|
|
{17, "56dc4e33"},
|
|
{18, "3b2db13a"},
|
|
{19, "291i3b4g"},
|
|
{20, "1eca0764"},
|
|
{21, "14hc96jg"},
|
|
{22, "jblga9e"},
|
|
{23, "em6i5a5"},
|
|
{24, "be75374"},
|
|
{25, "91mo4go"},
|
|
{26, "74d74li"},
|
|
{27, "5jblgea"},
|
|
{28, "4gl7i9g"},
|
|
{29, "3l13lor"},
|
|
{30, "315o5e4"},
|
|
{31, "2fcfub9"},
|
|
{32, "221b1bc"},
|
|
{33, "1nkji2p"},
|
|
{34, "1eq93ik"},
|
|
{35, "176p6y9"},
|
|
{36, "10ncmss"}
|
|
};
|
|
|
|
intc_u64 const INTC_TESTS_MAX_UNSIGNED_VALUES[] = {
|
|
(intc_u8)-1,
|
|
(intc_u16)-1,
|
|
(intc_u32)-1,
|
|
(intc_u64)-1,
|
|
};
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// NOTE: Testing Macros
|
|
// -----------------------------------------------------------------------------
|
|
#define INTC_TESTS_ASSERT_MSG(expr, fmt, ...) \
|
|
do \
|
|
{ \
|
|
if (!(expr)) \
|
|
{ \
|
|
test_case_.failed = true; \
|
|
char const *file = intc_strip_path_to_file(__FILE__); \
|
|
printf(" +--Test failed at %s:%d, expression was: %s\n", file, __LINE__, #expr); \
|
|
printf(" V\n"); \
|
|
printf(" |--"); \
|
|
printf(fmt, __VA_ARGS__); \
|
|
fputc('\n', stdout); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define INTC_TESTS_ASSERT(expr) \
|
|
do \
|
|
{ \
|
|
if (!(expr)) \
|
|
{ \
|
|
test_case_.failed = true; \
|
|
char const *file = intc_strip_path_to_file(__FILE__); \
|
|
printf(" +--Test failed at %s:%d, expression was: %s\n", file, __LINE__, #expr); \
|
|
printf(" V\n"); \
|
|
} \
|
|
} while (0)
|
|
|
|
#if defined(INTC_TESTS_NO_COLORS)
|
|
#define INTC_TESTS_COLOR_RED
|
|
#define INTC_TESTS_COLOR_GREEN
|
|
#define INTC_TESTS_COLOR_MAGENTA
|
|
#define INTC_TESTS_COLOR_RESET
|
|
#else
|
|
#define INTC_TESTS_COLOR_RED "\x1b[31m"
|
|
#define INTC_TESTS_COLOR_GREEN "\x1b[32m"
|
|
#define INTC_TESTS_COLOR_MAGENTA "\x1b[35m"
|
|
#define INTC_TESTS_COLOR_RESET "\x1b[0m"
|
|
#endif
|
|
|
|
#define INTC_TESTS_BEGIN(test_name) \
|
|
struct intc_test_case test_case_ = INTC_ZERO_INIT; \
|
|
test_case_.name = test_name; \
|
|
test_case_.name_size = sizeof(test_name) - 1; \
|
|
test_case_.failed = false; \
|
|
result.test_count++
|
|
|
|
#define INTC_TESTS_END \
|
|
fprintf(stdout, " %s", test_case_.name); \
|
|
for (int index = 0; index < (64 - test_case_.name_size); index++) \
|
|
{ \
|
|
if (index) \
|
|
fputc('.', stdout); \
|
|
else \
|
|
fputc(' ', stdout); \
|
|
} \
|
|
\
|
|
fputc(' ', stdout); \
|
|
if (test_case_.failed) \
|
|
{ \
|
|
fprintf(stdout, INTC_TESTS_COLOR_RED "FAILED" INTC_TESTS_COLOR_RESET); \
|
|
result.fail_count++; \
|
|
} \
|
|
else \
|
|
fprintf(stdout, INTC_TESTS_COLOR_GREEN "OK" INTC_TESTS_COLOR_RESET); \
|
|
fputc('\n', stdout);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// NOTE: Implementation
|
|
// -----------------------------------------------------------------------------
|
|
static char *intc_strip_path_to_file(char const *file)
|
|
{
|
|
int size = (int)strlen(file);
|
|
char *result = (char *)file;
|
|
for (int i = size - 1; i >= 0; i--)
|
|
{
|
|
if (file[i] == '\\' || file[i] == '/')
|
|
{
|
|
result = result + i + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
struct intc_test_state intc_u128_unit_tests(void)
|
|
{
|
|
struct intc_test_state result = INTC_ZERO_INIT;
|
|
printf(INTC_TESTS_COLOR_MAGENTA "intc_u128 unit tests" INTC_TESTS_COLOR_RESET);
|
|
printf("\n accessors.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Accessor.bits");
|
|
struct intc_u128 value = INTC_U64_TO_U128(1);
|
|
for(int i = 0; i < 127; i++){
|
|
INTC_TESTS_ASSERT(intc_u128_clz(value) == i + 1); // before shift
|
|
value = intc_u128_lshift(value, 1);
|
|
}
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_clz(INTC_U128_ZERO) == 0);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Accessor.data");
|
|
struct intc_u128 const value = INTC_U128(0x0123456789abcdefULL, 0xfedcba9876543210ULL);
|
|
INTC_TESTS_ASSERT(value.hi == 0xfedcba9876543210ULL);
|
|
INTC_TESTS_ASSERT(value.lo == 0x0123456789abcdefULL);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n add.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.add");
|
|
struct intc_u128 const low = INTC_U128(1, 0);
|
|
struct intc_u128 const high = INTC_U128(0, 1);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(low, low), INTC_U64_TO_U128(2)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(low, high), INTC_U128(1, 1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(high, high), INTC_U128(0, 2)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.add");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
|
|
struct intc_u128 const val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(INTC_U64_TO_U128(t) , val), INTC_U128(0xf0f0f0f0f0f0f0f1ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(INTC_U64_TO_U128(f) , val), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(INTC_U64_TO_U128(u8) , val), INTC_U128(0xf0f0f0f0f0f0f19aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(INTC_U64_TO_U128(u16), val), INTC_U128(0xf0f0f0f0f0f19b9aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(INTC_U64_TO_U128(u32), val), INTC_U128(0xf0f0f0f19b9b9b9aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(INTC_U64_TO_U128(u64), val), INTC_U128(0x9b9b9b9b9b9b9b9aULL, 0xf0f0f0f0f0f0f0f1ULL)));
|
|
|
|
INTC_TESTS_ASSERT(u8 += intc_u128_as_u8(val) == (intc_u8)0x9aULL);
|
|
INTC_TESTS_ASSERT(u16 += intc_u128_as_u16(val) == (intc_u16)0x9b9aULL);
|
|
INTC_TESTS_ASSERT(u32 += intc_u128_as_u32(val) == (intc_u32)0x9b9b9b9aULL);
|
|
INTC_TESTS_ASSERT(u64 += intc_u128_as_u64(val) == (intc_u64)0x9b9b9b9b9b9b9b9aULL);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n and.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitWise.and");
|
|
struct intc_u128 t = INTC_U64_TO_U128((bool)true);
|
|
struct intc_u128 f = INTC_U64_TO_U128((bool)false);
|
|
struct intc_u128 u8 = INTC_U64_TO_U128((intc_u8)0xaaULL);
|
|
struct intc_u128 u16 = INTC_U64_TO_U128((intc_u16)0xaaaaULL);
|
|
struct intc_u128 u32 = INTC_U64_TO_U128((intc_u32)0xaaaaaaaaULL);
|
|
struct intc_u128 u64 = INTC_U64_TO_U128((intc_u64)0xaaaaaaaaaaaaaaaaULL);
|
|
|
|
struct intc_u128 const val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(t , val), INTC_U64_TO_U128(0)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(f , val), INTC_U64_TO_U128(0)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(u8 , val), INTC_U64_TO_U128(0xa0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(u16, val), INTC_U64_TO_U128(0xa0a0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(u32, val), INTC_U64_TO_U128(0xa0a0a0a0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(u64, val), INTC_U64_TO_U128(0xa0a0a0a0a0a0a0a0ULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.and");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 const val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(INTC_U64_TO_U128(t) , val), INTC_U64_TO_U128(0x0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(INTC_U64_TO_U128(f) , val), INTC_U64_TO_U128(0x0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(INTC_U64_TO_U128(u8) , val), INTC_U64_TO_U128(0xa0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(INTC_U64_TO_U128(u16), val), INTC_U64_TO_U128(0xa0a0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(INTC_U64_TO_U128(u32), val), INTC_U64_TO_U128(0xa0a0a0a0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(INTC_U64_TO_U128(u64), val), INTC_U64_TO_U128(0xa0a0a0a0a0a0a0a0ULL)));
|
|
|
|
INTC_TESTS_ASSERT((bool)(t &= intc_u128_as_bool(val)) == true);
|
|
INTC_TESTS_ASSERT((bool)(f &= intc_u128_as_bool(val)) == false);
|
|
INTC_TESTS_ASSERT((u8 &= intc_u128_as_u8(val)) == (intc_u8)0xa0ULL);
|
|
INTC_TESTS_ASSERT((u16 &= intc_u128_as_u16(val)) == (intc_u16)0xa0a0ULL);
|
|
INTC_TESTS_ASSERT((u32 &= intc_u128_as_u32(val)) == (intc_u32)0xa0a0a0a0ULL);
|
|
INTC_TESTS_ASSERT((u64 &= intc_u128_as_u64(val)) == (intc_u64)0xa0a0a0a0a0a0a0a0ULL);
|
|
|
|
// zero
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_and(INTC_U128_ZERO, val), INTC_U128_ZERO));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n assignment.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Assignment.all");
|
|
const struct intc_u128 t_1 = INTC_U64_TO_U128(true);
|
|
const struct intc_u128 f_1 = INTC_U64_TO_U128(false);
|
|
const struct intc_u128 u8_1 = INTC_U64_TO_U128(0x01);
|
|
const struct intc_u128 u16_1 = INTC_U64_TO_U128(0x0123);
|
|
const struct intc_u128 u32_1 = INTC_U64_TO_U128(0x01234567);
|
|
const struct intc_u128 u64_1 = INTC_U64_TO_U128(0x0123456789abcdef);
|
|
|
|
struct intc_u128 t_2 = INTC_U128_ZERO;
|
|
struct intc_u128 f_2 = INTC_U128_ZERO;
|
|
struct intc_u128 u8_2 = INTC_U128_ZERO;
|
|
struct intc_u128 u16_2 = INTC_U128_ZERO;
|
|
struct intc_u128 u32_2 = INTC_U128_ZERO;
|
|
struct intc_u128 u64_2 = INTC_U128_ZERO;
|
|
|
|
t_2 = t_1;
|
|
f_2 = f_1;
|
|
u8_2 = u8_1;
|
|
u16_2 = u16_1;
|
|
u32_2 = u32_1;
|
|
u64_2 = u64_1;
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(t_1, t_2));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(f_1, f_2));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(u8_1, u8_2));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(u16_1, u16_2));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(u32_1, u32_2));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(u64_1, u64_2));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n constructor.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Constructor.standard");
|
|
struct intc_u128 value = INTC_U64_TO_U128(0x0123456789abcdefULL);
|
|
const struct intc_u128 original = value;
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U128_ZERO, INTC_U128_ZERO));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(value, original));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(value, INTC_U64_TO_U128(0x0123456789abcdefULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Constructor.one");
|
|
intc_u64 a = INTC_U64_TO_U128(true).hi;
|
|
intc_u64 b = INTC_U64_TO_U128(true).lo;
|
|
intc_u64 c = INTC_U64_TO_U128(false).hi;
|
|
intc_u64 d = INTC_U64_TO_U128(false).lo;
|
|
|
|
intc_u64 e = INTC_U64_TO_U128((intc_u8)0x01ULL).hi;
|
|
intc_u64 f = INTC_U64_TO_U128((intc_u16)0x0123ULL).hi;
|
|
intc_u64 g = INTC_U64_TO_U128((intc_u32)0x01234567ULL).hi;
|
|
intc_u64 h = INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL).hi;
|
|
|
|
intc_u64 i = INTC_U64_TO_U128((intc_u8)0x01ULL).lo;
|
|
intc_u64 j = INTC_U64_TO_U128((intc_u16)0x0123ULL).lo;
|
|
intc_u64 k = INTC_U64_TO_U128((intc_u32)0x01234567ULL).lo;
|
|
intc_u64 l = INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL).lo;
|
|
|
|
INTC_TESTS_ASSERT(a == (intc_u64)false);
|
|
INTC_TESTS_ASSERT(b == (intc_u64)true);
|
|
INTC_TESTS_ASSERT(c == (intc_u64)false);
|
|
INTC_TESTS_ASSERT(d == (intc_u64)false);
|
|
|
|
INTC_TESTS_ASSERT(e == 0ULL);
|
|
INTC_TESTS_ASSERT(f == 0ULL);
|
|
INTC_TESTS_ASSERT(g == 0ULL);
|
|
INTC_TESTS_ASSERT(h == 0ULL);
|
|
|
|
INTC_TESTS_ASSERT(i == (intc_u8)0x01ULL);
|
|
INTC_TESTS_ASSERT(j == (intc_u16)0x0123ULL);
|
|
INTC_TESTS_ASSERT(k == (intc_u32)0x01234567ULL);
|
|
INTC_TESTS_ASSERT(l == (intc_u64)0x0123456789abcdefULL);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Constructor.two");
|
|
for (int hi = 0; hi < 2; hi++)
|
|
{
|
|
for (int lo = 0; lo < 2; lo++)
|
|
{
|
|
struct intc_u128 const val = INTC_U128((intc_u64)lo, (intc_u64)hi);
|
|
INTC_TESTS_ASSERT(val.hi == (intc_u64)hi);
|
|
INTC_TESTS_ASSERT(val.lo == (intc_u64)lo);
|
|
}
|
|
}
|
|
|
|
intc_u64 a = INTC_U128((intc_u8)0x01ULL, (intc_u8)0x01ULL).hi;
|
|
intc_u64 b = INTC_U128((intc_u16)0x0123ULL, (intc_u16)0x0123ULL).hi;
|
|
intc_u64 c = INTC_U128((intc_u32)0x01234567ULL, (intc_u32)0x01234567ULL).hi;
|
|
intc_u64 d = INTC_U128((intc_u64)0x0123456789abcdefULL, (intc_u64)0x0123456789abcdefULL).hi;
|
|
|
|
intc_u64 e = INTC_U128((intc_u8)0x01ULL, (intc_u8)0x01ULL).lo;
|
|
intc_u64 f = INTC_U128((intc_u16)0x0123ULL, (intc_u16)0x0123ULL).lo;
|
|
intc_u64 g = INTC_U128((intc_u32)0x01234567ULL, (intc_u32)0x01234567ULL).lo;
|
|
intc_u64 h = INTC_U128((intc_u64)0x0123456789abcdefULL, (intc_u64)0x0123456789abcdefULL).lo;
|
|
|
|
INTC_TESTS_ASSERT(a == (intc_u8)0x01ULL);
|
|
INTC_TESTS_ASSERT(b == (intc_u16)0x0123ULL);
|
|
INTC_TESTS_ASSERT(c == (intc_u32)0x01234567ULL);
|
|
INTC_TESTS_ASSERT(d == (intc_u64)0x0123456789abcdefULL);
|
|
|
|
INTC_TESTS_ASSERT(e == (intc_u8)0x01ULL);
|
|
INTC_TESTS_ASSERT(f == (intc_u16)0x0123ULL);
|
|
INTC_TESTS_ASSERT(g == (intc_u32)0x01234567ULL);
|
|
INTC_TESTS_ASSERT(h == (intc_u64)0x0123456789abcdefULL);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n div.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.divide");
|
|
struct intc_u128 const big_val = INTC_U64_TO_U128(0xfedbca9876543210ULL);
|
|
struct intc_u128 const small_val = INTC_U64_TO_U128(0xffffULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(small_val, small_val), INTC_U64_TO_U128(1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(small_val, big_val), INTC_U64_TO_U128(0)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(big_val, big_val), INTC_U64_TO_U128(1)));
|
|
|
|
// TODO(dqn): How do we want to do this ...
|
|
// EXPECT_THROW(uint128_t(1) / uint128_t(0), std::domain_error);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.divide");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
|
|
struct intc_u128 const val = INTC_U64_TO_U128(0x7bULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(INTC_U64_TO_U128(t) , val), INTC_U64_TO_U128(false)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(INTC_U64_TO_U128(f) , val), INTC_U64_TO_U128(false)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(INTC_U64_TO_U128(u8), val), INTC_U64_TO_U128(0x1ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(INTC_U64_TO_U128(u16), val), INTC_U64_TO_U128(0x163ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(INTC_U64_TO_U128(u32), val), INTC_U64_TO_U128(0x163356bULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(INTC_U64_TO_U128(u64), val), INTC_U64_TO_U128(0x163356b88ac0de0ULL)));
|
|
|
|
INTC_TESTS_ASSERT((intc_u8)(u8 /= intc_u128_as_u8(val)) == (intc_u8)0x1ULL);
|
|
INTC_TESTS_ASSERT((intc_u16)(u16 /= intc_u128_as_u16(val)) == (intc_u16)0x163ULL);
|
|
INTC_TESTS_ASSERT((intc_u32)(u32 /= intc_u128_as_u32(val)) == (intc_u32)0x163356bULL);
|
|
INTC_TESTS_ASSERT((intc_u64)(u64 /= intc_u128_as_u64(val)) == (intc_u64)0x163356b88ac0de0ULL);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n equals.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.equals");
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U128(0xdeadbeefULL), INTC_U64_TO_U128(0xdeadbeefULL)));
|
|
INTC_TESTS_ASSERT(!intc_u128_eq(INTC_U64_TO_U128(0xdeadbeefULL), INTC_U64_TO_U128(0xfee1baadULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n fix.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.increment");
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add_u64(INTC_U128_ZERO, 1), INTC_U64_TO_U128(1)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.decrement");
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub_u64(INTC_U128_ZERO, 1), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n functions.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Function.data");
|
|
// make sure all of the test strings create the ASCII version of the string
|
|
struct intc_u128 const original = INTC_U64_TO_U128(2216002924);
|
|
for (int test_index = 0; test_index < (int)(sizeof(INTC_TESTS_STRING_BASE_TESTS)/sizeof(INTC_TESTS_STRING_BASE_TESTS[0])); test_index++)
|
|
{
|
|
struct intc_base_to_string const *test_entry = INTC_TESTS_STRING_BASE_TESTS + test_index;
|
|
struct intc_u128_string output = intc_u128_str(original, test_entry->base, 0 /*separate_every_n_chars*/, ' ' /*separate_ch*/);
|
|
INTC_TESTS_ASSERT_MSG(strcmp(output.data, test_entry->expect) == 0,
|
|
"output: %s\n"
|
|
"expect: %s\n",
|
|
output.data,
|
|
test_entry->expect);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n gt.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.greater_than");
|
|
struct intc_u128 const big = INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
|
struct intc_u128 const small = INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_gt(small, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_gt(small, big) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_gt(big, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_gt(big, big) == false);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.greater_than");
|
|
for (int index = 0;
|
|
index < (int)(sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES)/sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES[0]));
|
|
index++)
|
|
{
|
|
struct intc_u128 const small = INTC_U128_ZERO;
|
|
struct intc_u128 const big = INTC_U64_TO_U128(INTC_TESTS_MAX_UNSIGNED_VALUES[index]);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_gt(small, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_gt(small, big) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_gt(big, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_gt(big, big) == false);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n gte.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.greater_than_or_equals");
|
|
struct intc_u128 const big = INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
|
struct intc_u128 const small = INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_gt_eq(small, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_gt_eq(small, big) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_gt_eq(big, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_gt_eq(big, big) == true);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.greater_than_or_equals");
|
|
for (int index = 0;
|
|
index < (int)(sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES)/sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES[0]));
|
|
index++)
|
|
{
|
|
struct intc_u128 const small = INTC_U128_ZERO;
|
|
struct intc_u128 const big = INTC_U64_TO_U128(INTC_TESTS_MAX_UNSIGNED_VALUES[index]);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_gt_eq(small, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_gt_eq(small, big) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_gt_eq(big, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_gt_eq(big, big) == true);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n invert.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitWise.invert");
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_negate(INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL)), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_negate(INTC_U128(0x0000000000000000ULL, 0xffffffffffffffffULL)), INTC_U128(0xffffffffffffffffULL, 0x0000000000000000ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_negate(INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL)), INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n leftshift.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitShift.left");
|
|
// operator<<
|
|
struct intc_u128 val = INTC_U64_TO_U128(0x1);
|
|
intc_u64 exp_val = 1;
|
|
for(int i = 0; i < 64; i++){
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_lshift(val, i), INTC_U64_TO_U128(exp_val << i)));
|
|
}
|
|
|
|
struct intc_u128 zero = INTC_U128_ZERO;
|
|
for (int i = 0; i < 64; i++)
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_lshift(zero, i), INTC_U128_ZERO));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.shift_left");
|
|
intc_u8 u8 = 0xffULL;
|
|
intc_u16 u16 = 0xffffULL;
|
|
intc_u32 u32 = 0xffffffff;
|
|
intc_u64 u64 = 0xffffffffffffffff;
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_lshift(INTC_U64_TO_U128(u8), 7), INTC_U64_TO_U128(0x7f80ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_lshift(INTC_U64_TO_U128(u16), 15), INTC_U64_TO_U128(0x7fff8000ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_lshift(INTC_U64_TO_U128(u32), 31), INTC_U64_TO_U128(0x7fffffff80000000ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_lshift(INTC_U64_TO_U128(u64), 63), INTC_U128(0x8000000000000000ULL, 0x7fffffffffffffffULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n lt.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.less_than");
|
|
struct intc_u128 const big = INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
|
struct intc_u128 const small = INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_lt(small, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_lt(small, big) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_lt(big, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_lt(big, big) == false);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.less_than");
|
|
for (int index = 0;
|
|
index < (int)(sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES)/sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES[0]));
|
|
index++)
|
|
{
|
|
struct intc_u128 const small = INTC_U128_ZERO;
|
|
struct intc_u128 const big = INTC_U64_TO_U128(INTC_TESTS_MAX_UNSIGNED_VALUES[index]);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_lt(small, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_lt(small, big) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_lt(big, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_lt(big, big) == false);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n lte.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.less_than_or_equals");
|
|
struct intc_u128 const big = INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
|
struct intc_u128 const small = INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_lt_eq(small, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_lt_eq(small, big) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_lt_eq(big, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_lt_eq(big, big) == true);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.less_than_or_equals");
|
|
for (int index = 0;
|
|
index < (int)(sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES)/sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES[0]));
|
|
index++)
|
|
{
|
|
struct intc_u128 const small = INTC_U128_ZERO;
|
|
struct intc_u128 const big = INTC_U64_TO_U128(INTC_TESTS_MAX_UNSIGNED_VALUES[index]);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_lt_eq(small, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_lt_eq(small, big) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_lt_eq(big, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_lt_eq(big, big) == true);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n mod.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.modulo");
|
|
// has remainder
|
|
struct intc_u128 const val = INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
|
struct intc_u128 const val_mod = INTC_U64_TO_U128(0xfedcba9876543210ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(val, val_mod), INTC_U64_TO_U128(0x7f598f328cc265bfULL)));
|
|
|
|
// no remainder
|
|
struct intc_u128 const val_0 = INTC_U128(0, 0xfedcba9876543210);
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(val_0, val_mod), INTC_U128_ZERO));
|
|
|
|
// TODO(dqn): Add a way to catch divide by 0 assert nicely? Maybe?
|
|
// mod 0
|
|
// EXPECT_THROW(uint128_t(1) % uint128_t(0), std::domain_error);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.modulo");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 const val = INTC_U64_TO_U128(0xd03ULL); // prime
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(INTC_U64_TO_U128(t), val), INTC_U64_TO_U128(true)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(INTC_U64_TO_U128(f), val), INTC_U64_TO_U128(false)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(INTC_U64_TO_U128(u8), val), INTC_U64_TO_U128((intc_u8) 0xaaULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(INTC_U64_TO_U128(u16), val), INTC_U64_TO_U128((intc_u16)0x183ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(INTC_U64_TO_U128(u32), val), INTC_U64_TO_U128((intc_u32)0x249ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(INTC_U64_TO_U128(u64), val), INTC_U64_TO_U128((intc_u64)0xc7fULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n mult.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.multiply");
|
|
struct intc_u128 const val = INTC_U64_TO_U128(0xfedbca9876543210ULL);
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(val, val), INTC_U128(0x010e6cd7a44a4100ULL, 0xfdb8e2bacbfe7cefULL)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(val, INTC_U128_ZERO), INTC_U128_ZERO));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(INTC_U128_ZERO, val), INTC_U128_ZERO));
|
|
|
|
struct intc_u128 const one = INTC_U64_TO_U128(1);
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(val, one), val));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(one, val), val));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.multiply");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 const val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(INTC_U64_TO_U128(t), val), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(INTC_U64_TO_U128(f), val), INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(INTC_U64_TO_U128(u8), val), INTC_U128(0xffffffffffffff60ULL, 0xffffffffffffffffULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(INTC_U64_TO_U128(u16), val), INTC_U128(0xffffffffffff5f60ULL, 0xffffffffffffffffULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(INTC_U64_TO_U128(u32), val), INTC_U128(0xffffffff5f5f5f60ULL, 0xffffffffffffffffULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(INTC_U64_TO_U128(u64), val), INTC_U128(0x5f5f5f5f5f5f5f60ULL, 0xffffffffffffffffULL)));
|
|
|
|
INTC_TESTS_ASSERT((intc_u8)(u8 * intc_u128_as_u8(val)) == (intc_u8)0x60ULL);
|
|
INTC_TESTS_ASSERT((intc_u16)(u16 * intc_u128_as_u16(val)) == (intc_u16)0x5f60ULL);
|
|
INTC_TESTS_ASSERT((intc_u32)(u32 * intc_u128_as_u32(val)) == (intc_u32)0x5f5f5f60ULL);
|
|
INTC_TESTS_ASSERT((intc_u64)(u64 * intc_u128_as_u64(val)) == (intc_u64)0x5f5f5f5f5f5f5f60ULL);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n notequals.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.not_equals");
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(0xdeadbeefULL), INTC_U64_TO_U128(0xdeadbeefULL)) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(0xdeadbeefULL), INTC_U64_TO_U128(0xfee1baadULL)) == true);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.not_equals");
|
|
bool const t = true;
|
|
bool const f = false;
|
|
intc_u8 const u8 = 0xaaULL;
|
|
intc_u16 const u16 = 0xaaaaULL;
|
|
intc_u32 const u32 = 0xaaaaaaaaULL;
|
|
intc_u64 const u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(t) , INTC_U64_TO_U128(f)) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(f) , INTC_U64_TO_U128(t)) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(u8) , INTC_U64_TO_U128(u64)) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(u16), INTC_U64_TO_U128(u32)) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(u32), INTC_U64_TO_U128(u16)) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(u64), INTC_U64_TO_U128(u8)) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(t) , INTC_U64_TO_U128(t)) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(f) , INTC_U64_TO_U128(f)) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(u8) , INTC_U64_TO_U128(u8)) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(u16), INTC_U64_TO_U128(u16)) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(u32), INTC_U64_TO_U128(u32)) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_neq(INTC_U64_TO_U128(u64), INTC_U64_TO_U128(u64)) == false);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n or.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitWise.or");
|
|
struct intc_u128 const t = INTC_U64_TO_U128((bool) true);
|
|
struct intc_u128 const f = INTC_U64_TO_U128((bool) false);
|
|
struct intc_u128 const u8 = INTC_U64_TO_U128((intc_u8) 0xaaULL);
|
|
struct intc_u128 const u16 = INTC_U64_TO_U128((intc_u16) 0xaaaaULL);
|
|
struct intc_u128 const u32 = INTC_U64_TO_U128((intc_u32) 0xaaaaaaaaULL);
|
|
struct intc_u128 const u64 = INTC_U64_TO_U128((intc_u64) 0xaaaaaaaaaaaaaaaaULL);
|
|
struct intc_u128 const val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(t , val), INTC_U128(0xf0f0f0f0f0f0f0f1ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(f , val), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(u8 , val), INTC_U128(0xf0f0f0f0f0f0f0faULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(u16, val), INTC_U128(0xf0f0f0f0f0f0fafaULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(u32, val), INTC_U128(0xf0f0f0f0fafafafaULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(u64, val), INTC_U128(0xfafafafafafafafaULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(INTC_U128_ZERO, val), val));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.or");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaa;
|
|
intc_u16 u16 = 0xaaaa;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 const val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(INTC_U64_TO_U128(t) , val), INTC_U128(0xf0f0f0f0f0f0f0f1ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(INTC_U64_TO_U128(f) , val), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(INTC_U64_TO_U128(u8) , val), INTC_U128(0xf0f0f0f0f0f0f0faULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(INTC_U64_TO_U128(u16), val), INTC_U128(0xf0f0f0f0f0f0fafaULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(INTC_U64_TO_U128(u32), val), INTC_U128(0xf0f0f0f0fafafafaULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_or(INTC_U64_TO_U128(u64), val), INTC_U128(0xfafafafafafafafaULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n rightshift.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitShift.right");
|
|
// operator>>
|
|
struct intc_u128 val = INTC_U64_TO_U128(0xffffffffffffffffULL);
|
|
intc_u64 exp = 0xffffffffffffffffULL;
|
|
|
|
for(int i = 0; i < 64; i++){
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(val, i), INTC_U64_TO_U128(exp >> i)));
|
|
}
|
|
|
|
struct intc_u128 zero = INTC_U128_ZERO;
|
|
for (int i = 0; i < 64; i++)
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(zero, i), INTC_U128_ZERO));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.shift_left");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xffULL;
|
|
intc_u16 u16 = 0xffffULL;
|
|
intc_u32 u32 = 0xffffffffULL;
|
|
intc_u64 u64 = 0xffffffffffffffffULL;
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(t) , 0), INTC_U64_TO_U128(1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(f) , 0), INTC_U128_ZERO));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u8), 0), INTC_U64_TO_U128(u8)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u16), 0), INTC_U64_TO_U128(u16)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u32), 0), INTC_U64_TO_U128(u32)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u64), 0), INTC_U64_TO_U128(u64)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(t), 1), INTC_U64_TO_U128((intc_u64)t >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(f), 1), INTC_U64_TO_U128((intc_u64)f >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u8), 1), INTC_U64_TO_U128((intc_u64)u8 >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u16), 1), INTC_U64_TO_U128((intc_u64)u16 >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u32), 1), INTC_U64_TO_U128((intc_u64)u32 >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u64), 1), INTC_U64_TO_U128((intc_u64)u64 >> 1)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u8), 7), INTC_U64_TO_U128(1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u16), 15), INTC_U64_TO_U128(1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u32), 31), INTC_U64_TO_U128(1)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_rshift(INTC_U64_TO_U128(u64), 63), INTC_U64_TO_U128(1)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n sub.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.subtract");
|
|
struct intc_u128 const big = INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
|
struct intc_u128 const small = INTC_U128(0x0000000000000001ULL, 0x0000000000000000ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(small, small), INTC_U128_ZERO));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(small, big), INTC_U128(0x0000000000000002ULL, 0x0000000000000000ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(big , small), INTC_U128(0xfffffffffffffffeULL, 0xffffffffffffffffULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(big , big), INTC_U128_ZERO));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.subtract");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(INTC_U64_TO_U128(t) , val), INTC_U128(0x0f0f0f0f0f0f0f11ULL, 0x0f0f0f0f0f0f0f0fULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(INTC_U64_TO_U128(f) , val), INTC_U128(0x0f0f0f0f0f0f0f10ULL, 0x0f0f0f0f0f0f0f0fULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(INTC_U64_TO_U128(u8) , val), INTC_U128(0x0f0f0f0f0f0f0fbaULL, 0x0f0f0f0f0f0f0f0fULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(INTC_U64_TO_U128(u16), val), INTC_U128(0x0f0f0f0f0f0fb9baULL, 0x0f0f0f0f0f0f0f0fULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(INTC_U64_TO_U128(u32), val), INTC_U128(0x0f0f0f0fb9b9b9baULL, 0x0f0f0f0f0f0f0f0fULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_sub(INTC_U64_TO_U128(u64), val), INTC_U128(0xb9b9b9b9b9b9b9baULL, 0x0f0f0f0f0f0f0f0fULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n typecast.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Typecast.all");
|
|
struct intc_u128 const val = INTC_U128(0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
|
INTC_TESTS_ASSERT(intc_u128_as_bool(INTC_U64_TO_U128(true)) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_as_bool(INTC_U64_TO_U128(false)) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_as_u8(val) == (intc_u8)0xaaULL);
|
|
INTC_TESTS_ASSERT(intc_u128_as_u16(val) == (intc_u16)0xaaaaULL);
|
|
INTC_TESTS_ASSERT(intc_u128_as_u32(val) == (intc_u32)0xaaaaaaaaULL);
|
|
INTC_TESTS_ASSERT(intc_u128_as_u64(val) == (intc_u64)0xaaaaaaaaaaaaaaaaULL);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n xor.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitWise.xor");
|
|
struct intc_u128 t = INTC_U64_TO_U128((bool) true);
|
|
struct intc_u128 f = INTC_U64_TO_U128((bool) false);
|
|
struct intc_u128 u8 = INTC_U64_TO_U128((intc_u8) 0xaaULL);
|
|
struct intc_u128 u16 = INTC_U64_TO_U128((intc_u16) 0xaaaaULL);
|
|
struct intc_u128 u32 = INTC_U64_TO_U128((intc_u32) 0xaaaaaaaaULL);
|
|
struct intc_u128 u64 = INTC_U64_TO_U128((intc_u64) 0xaaaaaaaaaaaaaaaa);
|
|
struct intc_u128 const val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(t , val), INTC_U128(0xf0f0f0f0f0f0f0f1ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(f , val), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(u8 , val), INTC_U128(0xf0f0f0f0f0f0f05aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(u16, val), INTC_U128(0xf0f0f0f0f0f05a5aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(u32, val), INTC_U128(0xf0f0f0f05a5a5a5aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(u64, val), INTC_U128(0x5a5a5a5a5a5a5a5aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
|
|
// zero
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(INTC_U128_ZERO, val), val));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.xor");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 const val = INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(INTC_U64_TO_U128(t ), val), INTC_U128(0xf0f0f0f0f0f0f0f1ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(INTC_U64_TO_U128(f ), val), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(INTC_U64_TO_U128(u8 ), val), INTC_U128(0xf0f0f0f0f0f0f05aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(INTC_U64_TO_U128(u16), val), INTC_U128(0xf0f0f0f0f0f05a5aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(INTC_U64_TO_U128(u32), val), INTC_U128(0xf0f0f0f05a5a5a5aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_xor(INTC_U64_TO_U128(u64), val), INTC_U128(0x5a5a5a5a5a5a5a5aULL, 0xf0f0f0f0f0f0f0f0ULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
fputc('\n', stdout);
|
|
return result;
|
|
}
|
|
|
|
#if !defined(INTC_NO_U256)
|
|
struct intc_test_state intc_u256_unit_tests(void)
|
|
{
|
|
struct intc_test_state result = INTC_ZERO_INIT;
|
|
printf(INTC_TESTS_COLOR_MAGENTA "intc_u256 unit tests" INTC_TESTS_COLOR_RESET);
|
|
printf("\n accessors.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Accessor.bits");
|
|
struct intc_u256 value = INTC_U64_TO_U256(1);
|
|
for (int i = 0; i < 127; i++)
|
|
{
|
|
INTC_TESTS_ASSERT(intc_u256_clz(value) == (i + 1));
|
|
value = intc_u256_lshift(value, 1);
|
|
}
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_clz(INTC_U256_ZERO) == 0);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Accessor.data");
|
|
const struct intc_u256 value = INTC_U256(INTC_U128(0x0123456789abcdefULL, 0xfedcba9876543210ULL), INTC_U128(0x0123456789abcdefULL, 0xfedcba9876543210ULL));
|
|
INTC_TESTS_ASSERT_MSG(value.hi.hi == 0xfedcba9876543210ULL, "hi.hi: %llx\n", value.hi.hi);
|
|
INTC_TESTS_ASSERT_MSG(value.hi.lo == 0x0123456789abcdefULL, "hi.lo: %llx\n", value.hi.lo);
|
|
INTC_TESTS_ASSERT_MSG(value.lo.hi == 0xfedcba9876543210ULL, "lo.hi: %llx\n", value.lo.hi);
|
|
INTC_TESTS_ASSERT_MSG(value.lo.lo == 0x0123456789abcdefULL, "lo.lo: %llx\n", value.lo.lo);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n add.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.add");
|
|
struct intc_u256 low = INTC_U256(1, 0);
|
|
struct intc_u256 high = INTC_U256(0, 1);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add(low, low), INTC_U64_TO_U256(2)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add(low, high), INTC_U256(1, 1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add(high, high), INTC_U256(0, 2)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.add");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 u128 = INTC_U128(0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
|
struct intc_u256 val = INTC_U256(INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add_u64(val, t ), INTC_U256(INTC_U128(0xf0f0f0f0f0f0f0f1ULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add_u64(val, f ), INTC_U256(INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add_u64(val, u8 ), INTC_U256(INTC_U128(0xf0f0f0f0f0f0f19aULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add_u64(val, u16), INTC_U256(INTC_U128(0xf0f0f0f0f0f19b9aULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add_u64(val, u32), INTC_U256(INTC_U128(0xf0f0f0f19b9b9b9aULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add_u64(val, u64), INTC_U256(INTC_U128(0x9b9b9b9b9b9b9b9aULL, 0xf0f0f0f0f0f0f0f1ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_add(val, INTC_U128_TO_U256(u128)), INTC_U256(INTC_U128(0x9b9b9b9b9b9b9b9aULL, 0x9b9b9b9b9b9b9b9bULL), INTC_U128(0xf0f0f0f0f0f0f0f1ULL, 0xf0f0f0f0f0f0f0f0ULL))));
|
|
|
|
INTC_TESTS_ASSERT((bool) (t + intc_u256_as_bool(val)) == true);
|
|
INTC_TESTS_ASSERT((bool) (f + intc_u256_as_bool(val)) == true);
|
|
INTC_TESTS_ASSERT((intc_u8) (u8 + intc_u256_as_u8 (val)) == (intc_u8) 0x9aULL);
|
|
INTC_TESTS_ASSERT((intc_u16)(u16 + intc_u256_as_u16 (val)) == (intc_u16)0x9b9aULL);
|
|
INTC_TESTS_ASSERT((intc_u32)(u32 + intc_u256_as_u32 (val)) == (intc_u32)0x9b9b9b9aULL);
|
|
INTC_TESTS_ASSERT((intc_u64)(u64 + intc_u256_as_u64 (val)) == (intc_u64)0x9b9b9b9b9b9b9b9aULL);
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_add(u128, intc_u256_as_u128(val)), INTC_U128(0x9b9b9b9b9b9b9b9aULL, 0x9b9b9b9b9b9b9b9bULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n and.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Bitwise.and");
|
|
const struct intc_u256 t = INTC_U64_TO_U256((bool) true);
|
|
const struct intc_u256 f = INTC_U64_TO_U256((bool) false);
|
|
const struct intc_u256 u8 = INTC_U64_TO_U256((intc_u8) 0xaaULL);
|
|
const struct intc_u256 u16 = INTC_U64_TO_U256((intc_u16) 0xaaaaULL);
|
|
const struct intc_u256 u32 = INTC_U64_TO_U256((intc_u32) 0xaaaaaaaaULL);
|
|
const struct intc_u256 u64 = INTC_U64_TO_U256((intc_u64) 0xaaaaaaaaaaaaaaaaULL);
|
|
const struct intc_u256 val = INTC_U128_TO_U256(INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(t, val), INTC_U64_TO_U256(0)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(f, val), INTC_U64_TO_U256(0)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(u8, val), INTC_U64_TO_U256(0xa0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(u16, val), INTC_U64_TO_U256(0xa0a0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(u32, val), INTC_U64_TO_U256(0xa0a0a0a0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(u64, val), INTC_U64_TO_U256(0xa0a0a0a0a0a0a0a0ULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.and");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
const struct intc_u256 val = INTC_U256(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(INTC_U64_TO_U256(t ), val), INTC_U64_TO_U256(0)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(INTC_U64_TO_U256(f ), val), INTC_U64_TO_U256(0)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(INTC_U64_TO_U256(u8 ), val), INTC_U64_TO_U256(0xa0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(INTC_U64_TO_U256(u16), val), INTC_U64_TO_U256(0xa0a0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(INTC_U64_TO_U256(u32), val), INTC_U64_TO_U256(0xa0a0a0a0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(INTC_U64_TO_U256(u64), val), INTC_U64_TO_U256(0xa0a0a0a0a0a0a0a0ULL)));
|
|
|
|
// TODO: Why is this test result different from calccrypto and intc?
|
|
//
|
|
// true &= (0xF0F0F0 ...) == true?
|
|
//
|
|
// Original test line was
|
|
//
|
|
// EXPECT_EQ(t &= val, false);
|
|
//
|
|
INTC_TESTS_ASSERT((bool) (t &= intc_u256_as_bool(val)) == true);
|
|
|
|
INTC_TESTS_ASSERT((bool) (f &= intc_u256_as_bool(val)) == false);
|
|
INTC_TESTS_ASSERT((intc_u8) (u8 &= intc_u256_as_u8 (val)) == (intc_u8) 0xa0ULL);
|
|
INTC_TESTS_ASSERT((intc_u16)(u16 &= intc_u256_as_u16 (val)) == (intc_u16)0xa0a0ULL);
|
|
INTC_TESTS_ASSERT((intc_u32)(u32 &= intc_u256_as_u32 (val)) == (intc_u32)0xa0a0a0a0ULL);
|
|
INTC_TESTS_ASSERT((intc_u64)(u64 &= intc_u256_as_u64 (val)) == (intc_u64)0xa0a0a0a0a0a0a0a0ULL);
|
|
|
|
// zero
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_and(INTC_U256_ZERO, val), INTC_U256_ZERO));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n assignment.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Assignment.all");
|
|
const struct intc_u256 t_1 = INTC_U64_TO_U256(true);
|
|
const struct intc_u256 f_1 = INTC_U64_TO_U256(false);
|
|
const struct intc_u256 u8_1 = INTC_U64_TO_U256(0x01);
|
|
const struct intc_u256 u16_1 = INTC_U64_TO_U256(0x0123);
|
|
const struct intc_u256 u32_1 = INTC_U64_TO_U256(0x01234567);
|
|
const struct intc_u256 u64_1 = INTC_U64_TO_U256(0x0123456789abcdef);
|
|
|
|
struct intc_u256 t_2 = INTC_U64_TO_U256(0);
|
|
struct intc_u256 f_2 = INTC_U64_TO_U256(0);
|
|
struct intc_u256 u8_2 = INTC_U64_TO_U256(0);
|
|
struct intc_u256 u16_2 = INTC_U64_TO_U256(0);
|
|
struct intc_u256 u32_2 = INTC_U64_TO_U256(0);
|
|
struct intc_u256 u64_2 = INTC_U64_TO_U256(0);
|
|
|
|
t_2 = t_1;
|
|
f_2 = f_1;
|
|
u8_2 = u8_1;
|
|
u16_2 = u16_1;
|
|
u32_2 = u32_1;
|
|
u64_2 = u64_1;
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(t_1, t_2));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(f_1, f_2));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(u8_1, u8_2));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(u16_1, u16_2));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(u32_1, u32_2));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(u64_1, u64_2));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n constructor.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Constructor.standard");
|
|
struct intc_u256 value = INTC_U64_TO_U256(0x0123456789abcdefULL);
|
|
const struct intc_u256 original = value;
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(value, original));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(value, INTC_U64_TO_U256(0x0123456789abcdefULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Constructor.dataing");
|
|
struct intc_u256 val;
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", -1 /*size*/, &val));
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, INTC_U256_MAX),
|
|
"val: %s\n"
|
|
"expect: %s\n",
|
|
intc_u256_readable_hex_str(val).data,
|
|
intc_u256_readable_hex_str(INTC_U256_MAX).data);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", -1 /*size*/, &val));
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, INTC_U256_MAX),
|
|
"val: %s\n"
|
|
"expect: %s\n",
|
|
intc_u256_readable_hex_str(val).data,
|
|
intc_u256_readable_hex_str(INTC_U256_MAX).data);
|
|
|
|
<<<<<<< HEAD
|
|
INTC_TESTS_ASSERT(intc_u256_init_cstring("0x0", -1 /*size*/, &val));
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, INTC_U256_ZERO), "val: %s\n", intc_u256_readable_hex_str(val).data);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_cstring("0x0", -1 /*size*/, &val));
|
|
=======
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring("0x0", -1 /*size*/, &val));
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, INTC_U256_ZERO), "val: %s\n", intc_u256_readable_hex_str(val).data);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring("0x0", -1 /*size*/, &val));
|
|
>>>>>>> f769dd0 (intc: Add number -> u128/256 constructor)
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, INTC_U256_ZERO), "val: %s\n", intc_u256_readable_hex_str(val).data);
|
|
|
|
struct intc_u256 expect = INTC_U64_TO_U256(0x0123456789abcdefULL);
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring("0x0123456789abcdef", -1 /*size*/, &val));
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, expect),
|
|
"val: %s\n"
|
|
"expect: %s\n",
|
|
intc_u256_readable_hex_str(val).data,
|
|
intc_u256_readable_hex_str(expect).data);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Constructor.base_string");
|
|
struct intc_u256 val;
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring_base("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", -1 /*size*/, 16 /*base*/, &val));
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, INTC_U256_MAX),
|
|
"val: %s\n"
|
|
"expect: %s\n",
|
|
intc_u256_readable_hex_str(val).data,
|
|
intc_u256_readable_hex_str(INTC_U256_MAX).data);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring_base("115792089237316195423570985008687907853269984665640564039457584007913129639935", -1 /*size*/, 10 /*base*/, &val));
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, INTC_U256_MAX),
|
|
"val: %s\n"
|
|
"expect: %s\n",
|
|
intc_u256_readable_hex_str(val).data,
|
|
intc_u256_readable_hex_str(INTC_U256_MAX).data);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring_base("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", -1 /*size*/, 2 /*base*/, &val));
|
|
INTC_TESTS_ASSERT_MSG(intc_u256_eq(val, INTC_U256_MAX),
|
|
"val: %s\n"
|
|
"expect: %s\n",
|
|
intc_u256_readable_hex_str(val).data,
|
|
intc_u256_readable_hex_str(INTC_U256_MAX).data);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring_base("0", -1 /*size*/, 10 /*base*/, &val));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(val, INTC_U256_ZERO));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring_base("0x0123456789abcdef", -1 /*size*/, 16 /*base*/, &val));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(val, INTC_U64_TO_U256(0x0123456789abcdefULL)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring_base("755", -1 /*size*/, 8 /*base*/, &val));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(val, INTC_U64_TO_U256(0x01ed)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_init_hex_cstring_base("31415926", -1 /*size*/, 10 /*base*/, &val));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(val, INTC_U64_TO_U256(0x01df5e76ULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Constructor.one");
|
|
INTC_TESTS_ASSERT(intc_u128_as_bool(INTC_U64_TO_U256(true).hi) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_as_bool(INTC_U64_TO_U256(true).lo) == true);
|
|
INTC_TESTS_ASSERT(intc_u128_as_bool(INTC_U64_TO_U256(false).hi) == false);
|
|
INTC_TESTS_ASSERT(intc_u128_as_bool(INTC_U64_TO_U256(false).lo) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U256((intc_u8)0x01ULL).hi, INTC_U64_TO_U128(0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U256((intc_u16)0x0123ULL).hi, INTC_U64_TO_U128(0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U256((intc_u32)0x01234567ULL).hi, INTC_U64_TO_U128(0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U256((intc_u64)0x0123456789abcdefULL).hi, INTC_U64_TO_U128(0ULL)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U256((intc_u8)0x01ULL).lo, INTC_U64_TO_U128((intc_u8)0x01ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U256((intc_u16)0x0123ULL).lo, INTC_U64_TO_U128((intc_u16)0x0123ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U256((intc_u32)0x01234567ULL).lo, INTC_U64_TO_U128((intc_u32)0x01234567ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U64_TO_U256((intc_u64)0x0123456789abcdefULL).lo, INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Constructor.two");
|
|
for (int hi = 0; hi < 2; hi++)
|
|
{
|
|
for (int lo = 0; lo < 2; lo++)
|
|
{
|
|
struct intc_u256 const val = INTC_U256(INTC_U64_TO_U128((intc_u64)lo), INTC_U64_TO_U128((intc_u64)hi));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(val.hi, INTC_U64_TO_U128((intc_u64)hi)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(val.lo, INTC_U64_TO_U128((intc_u64)lo)));
|
|
}
|
|
}
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U256(INTC_U64_TO_U128((intc_u8) 0x01ULL), INTC_U64_TO_U128((intc_u8)0x01ULL)).hi, INTC_U64_TO_U128((intc_u8)0x01ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U256(INTC_U64_TO_U128((intc_u16)0x0123ULL), INTC_U64_TO_U128((intc_u16)0x0123ULL)).hi, INTC_U64_TO_U128((intc_u16)0x0123ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U256(INTC_U64_TO_U128((intc_u32)0x01234567ULL), INTC_U64_TO_U128((intc_u32)0x01234567ULL)).hi, INTC_U64_TO_U128((intc_u32)0x01234567ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U256(INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL), INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL)).hi, INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U256(INTC_U64_TO_U128((intc_u8) 0x01ULL), INTC_U64_TO_U128((intc_u8) 0x01ULL)).lo, INTC_U64_TO_U128((intc_u8)0x01ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U256(INTC_U64_TO_U128((intc_u16)0x0123ULL), INTC_U64_TO_U128((intc_u16)0x0123ULL)).lo, INTC_U64_TO_U128((intc_u16)0x0123ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U256(INTC_U64_TO_U128((intc_u32)0x01234567ULL), INTC_U64_TO_U128((intc_u32)0x01234567ULL)).lo, INTC_U64_TO_U128((intc_u32)0x01234567ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(INTC_U256(INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL), INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL)).lo, INTC_U64_TO_U128((intc_u64)0x0123456789abcdefULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n div.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.divide");
|
|
const struct intc_u256 big = INTC_U64_TO_U256(0xfedbca9876543210ULL);
|
|
const struct intc_u256 small = INTC_U64_TO_U256(0xffffULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(small, small), INTC_U64_TO_U256(1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(small, big), INTC_U64_TO_U256(0)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(big, big), INTC_U64_TO_U256(1)));
|
|
|
|
// TODO(dqn): Add a way to catch divide by 0 assert nicely? Maybe?
|
|
// INTC_TESTS_ASSERT(intc_u256_div(INTC_U64_TO_U256(1), INTC_U64_TO_U256(0)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.divide");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 u128 = INTC_U128(0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
|
struct intc_u256 val = INTC_U64_TO_U256(0x7bULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(INTC_U64_TO_U256(t), val), INTC_U64_TO_U256(false)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(INTC_U64_TO_U256(f), val), INTC_U64_TO_U256(false)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(INTC_U64_TO_U256(u8), val), INTC_U64_TO_U256(0x1ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(INTC_U64_TO_U256(u16), val), INTC_U64_TO_U256(0x163ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(INTC_U64_TO_U256(u32), val), INTC_U64_TO_U256(0x163356bULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_div(INTC_U64_TO_U256(u64), val), INTC_U64_TO_U256(0x163356b88ac0de0ULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_div(u128, intc_u256_as_u128(val)), INTC_U128(0x163356b88ac0de01ULL, 0x163356b88ac0de0ULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n equals.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.equals");
|
|
INTC_TESTS_ASSERT(intc_u256_eq(INTC_U64_TO_U256(0xdeadbeefULL), INTC_U64_TO_U256(0xdeadbeefULL)));
|
|
INTC_TESTS_ASSERT(!intc_u256_eq(INTC_U64_TO_U256(0xdeadbeefULL), INTC_U64_TO_U256(0xfee1baadULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n fix.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.increment");
|
|
struct intc_u256 value = INTC_U256_ZERO;
|
|
value = intc_u256_add_u64(value, 1);
|
|
INTC_TESTS_ASSERT(intc_u256_eq(value, INTC_U64_TO_U256(1)));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.decrement");
|
|
struct intc_u256 value = INTC_U256_ZERO;
|
|
value = intc_u256_sub_u64(value, 1);
|
|
INTC_TESTS_ASSERT(intc_u256_eq(value, INTC_U256(INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL))));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n functions.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Function.data");
|
|
// make sure all of the test strings create the ASCII version of the string
|
|
struct intc_u256 const original = INTC_U64_TO_U256(2216002924);
|
|
for (int test_index = 0; test_index < (int)(sizeof(INTC_TESTS_STRING_BASE_TESTS)/sizeof(INTC_TESTS_STRING_BASE_TESTS[0])); test_index++)
|
|
{
|
|
struct intc_base_to_string const *test_entry = INTC_TESTS_STRING_BASE_TESTS + test_index;
|
|
struct intc_u256_string output = intc_u256_str(original, test_entry->base, 0 /*separate_every_n_chars*/, ' ' /*separate_ch*/);
|
|
INTC_TESTS_ASSERT_MSG(strcmp(output.data, test_entry->expect) == 0,
|
|
"output: %s\n"
|
|
"expect: %s\n",
|
|
output.data,
|
|
test_entry->expect);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n gt.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.greater_than");
|
|
struct intc_u256 const big = INTC_U256(INTC_U64_TO_U128(0xffffffffffffffffULL), INTC_U64_TO_U128(0xffffffffffffffffULL));
|
|
struct intc_u256 const small = INTC_U256(INTC_U64_TO_U128(0x0000000000000000ULL), INTC_U64_TO_U128(0x0000000000000000ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_gt(small, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_gt(small, big) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_gt(big, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_gt(big, big) == false);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.greater_than");
|
|
for (int index = 0;
|
|
index < (int)(sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES)/sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES[0]));
|
|
index++)
|
|
{
|
|
struct intc_u256 const small = INTC_U256_ZERO;
|
|
struct intc_u256 const big = INTC_U64_TO_U256(INTC_TESTS_MAX_UNSIGNED_VALUES[index]);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_gt(small, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_gt(small, big) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_gt(big, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_gt(big, big) == false);
|
|
}
|
|
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n gte.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.greater_than_or_equals");
|
|
struct intc_u256 const big = INTC_U256(INTC_U64_TO_U128(0xffffffffffffffffULL), INTC_U64_TO_U128(0xffffffffffffffffULL));
|
|
struct intc_u256 const small = INTC_U256(INTC_U64_TO_U128(0x0000000000000000ULL), INTC_U64_TO_U128(0x0000000000000000ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_gt_eq(small, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_gt_eq(small, big) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_gt_eq(big, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_gt_eq(big, big) == true);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.greater_than_or_equals");
|
|
for (int index = 0;
|
|
index < (int)(sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES)/sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES[0]));
|
|
index++)
|
|
{
|
|
struct intc_u256 const small = INTC_U256_ZERO;
|
|
struct intc_u256 const big = INTC_U64_TO_U256(INTC_TESTS_MAX_UNSIGNED_VALUES[index]);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_gt_eq(small, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_gt_eq(small, big) == false);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_gt_eq(big, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_gt_eq(big, big) == true);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n invert.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitWise.invert");
|
|
for (int hi_hi = 0; hi_hi < 2; hi_hi++)
|
|
{
|
|
for (int hi_lo = 0; hi_lo < 2; hi_lo++)
|
|
{
|
|
for (int lo_hi = 0; lo_hi < 2; lo_hi++)
|
|
{
|
|
for (int lo_lo = 0; lo_lo < 2; lo_lo++)
|
|
{
|
|
struct intc_u256 const val =
|
|
intc_u256_negate(INTC_U256(
|
|
INTC_U128(lo_lo ? 0xffffffffffffffffULL : 0x0000000000000000ULL, lo_hi ? 0xffffffffffffffffULL : 0x0000000000000000ULL),
|
|
INTC_U128(hi_lo ? 0xffffffffffffffffULL : 0x0000000000000000ULL, hi_hi ? 0xffffffffffffffffULL : 0x0000000000000000ULL)));
|
|
|
|
INTC_TESTS_ASSERT(val.hi.hi == (intc_u64)hi_hi ? 0x0000000000000000ULL : 0xffffffffffffffffULL);
|
|
INTC_TESTS_ASSERT(val.hi.lo == (intc_u64)hi_lo ? 0x0000000000000000ULL : 0xffffffffffffffffULL);
|
|
INTC_TESTS_ASSERT(val.lo.hi == (intc_u64)lo_hi ? 0x0000000000000000ULL : 0xffffffffffffffffULL);
|
|
INTC_TESTS_ASSERT(val.lo.lo == (intc_u64)lo_lo ? 0x0000000000000000ULL : 0xffffffffffffffffULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n leftshift.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitShift.left");
|
|
// operator<<
|
|
struct intc_u256 val = INTC_U64_TO_U256(0x1);
|
|
intc_u64 exp_val = 1;
|
|
for(int i = 0; i < 64; i++){
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_lshift(val, i), INTC_U64_TO_U256(exp_val << i)));
|
|
}
|
|
|
|
struct intc_u256 zero = INTC_U256_ZERO;
|
|
for (int i = 0; i < 64; i++)
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_lshift(zero, i), INTC_U256_ZERO));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.shift_left");
|
|
intc_u8 u8 = 0xffULL;
|
|
intc_u16 u16 = 0xffffULL;
|
|
intc_u32 u32 = 0xffffffffULL;
|
|
intc_u64 u64 = 0xffffffffffffffffULL;
|
|
struct intc_u128 const u128 = INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_lshift(INTC_U64_TO_U256(u8), 7), INTC_U64_TO_U256(0x7f80ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_lshift(INTC_U64_TO_U256(u16), 15), INTC_U64_TO_U256(0x7fff8000ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_lshift(INTC_U64_TO_U256(u32), 31), INTC_U64_TO_U256(0x7fffffff80000000ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_lshift(INTC_U64_TO_U256(u64), 63), INTC_U256(INTC_U128(0x8000000000000000ULL, 0x7fffffffffffffffULL), INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_lshift(INTC_U128_TO_U256(u128), 127), INTC_U256(INTC_U128(0x0, 0x8000000000000000ULL), INTC_U128(0xffffffffffffffffULL, 0x7fffffffffffffffULL))));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n lt.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.less_than");
|
|
struct intc_u256 const big = INTC_U256(INTC_U64_TO_U128(0xffffffffffffffffULL), INTC_U64_TO_U128(0xffffffffffffffffULL));
|
|
struct intc_u256 const small = INTC_U256(INTC_U64_TO_U128(0x0000000000000000ULL), INTC_U64_TO_U128(0x0000000000000000ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_lt(small, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_lt(small, big) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_lt(big, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_lt(big, big) == false);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.less_than");
|
|
for (int index = 0;
|
|
index < (int)(sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES)/sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES[0]));
|
|
index++)
|
|
{
|
|
struct intc_u256 const small = INTC_U256_ZERO;
|
|
struct intc_u256 const big = INTC_U64_TO_U256(INTC_TESTS_MAX_UNSIGNED_VALUES[index]);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_lt(small, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_lt(small, big) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_lt(big, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_lt(big, big) == false);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n lte.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.less_than_or_equals");
|
|
struct intc_u256 const big = INTC_U256(INTC_U64_TO_U128(0xffffffffffffffffULL), INTC_U64_TO_U128(0xffffffffffffffffULL));
|
|
struct intc_u256 const small = INTC_U256(INTC_U64_TO_U128(0x0000000000000000ULL), INTC_U64_TO_U128(0x0000000000000000ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_lt_eq(small, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_lt_eq(small, big) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_lt_eq(big, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_lt_eq(big, big) == true);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.less_than_or_equals");
|
|
for (int index = 0;
|
|
index < (int)(sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES)/sizeof(INTC_TESTS_MAX_UNSIGNED_VALUES[0]));
|
|
index++)
|
|
{
|
|
struct intc_u256 const small = INTC_U256_ZERO;
|
|
struct intc_u256 const big = INTC_U64_TO_U256(INTC_TESTS_MAX_UNSIGNED_VALUES[index]);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_lt_eq(small, small) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_lt_eq(small, big) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_lt_eq(big, small) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_lt_eq(big, big) == true);
|
|
}
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n mod.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.modulo");
|
|
// has remainder
|
|
struct intc_u256 const val = INTC_U256(INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL));
|
|
struct intc_u256 const val_mod = INTC_U64_TO_U256(0xfedcba9876543210ULL);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mod(val, val_mod), INTC_U64_TO_U256(0x63794f9d55c8d29f)));
|
|
|
|
// no remainder
|
|
struct intc_u256 const val_0 = INTC_U256(INTC_U128(0, 0), INTC_U128(0, 0xfedcba9876543210));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mod(val_0, val_mod), INTC_U256_ZERO));
|
|
|
|
// TODO(dqn): Add a way to catch divide by 0 assert nicely? Maybe?
|
|
// mod 0
|
|
// EXPECT_THROW(uint256_t(1) % uint256_t(0), std::domain_error);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.modulo");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 const u128 = INTC_U128(0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
|
struct intc_u256 const val = INTC_U64_TO_U256(0xd03ULL); // prime
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mod(INTC_U64_TO_U256(t), val), INTC_U64_TO_U256(true)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mod(INTC_U64_TO_U256(f), val), INTC_U64_TO_U256(false)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mod(INTC_U64_TO_U256(u8), val), INTC_U64_TO_U256((intc_u8) 0xaaULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mod(INTC_U64_TO_U256(u16), val), INTC_U64_TO_U256((intc_u16)0x183ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mod(INTC_U64_TO_U256(u32), val), INTC_U64_TO_U256((intc_u32)0x249ULL)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mod(INTC_U64_TO_U256(u64), val), INTC_U64_TO_U256((intc_u64)0xc7fULL)));
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mod(u128, intc_u256_as_u128(val)), INTC_U64_TO_U128(0x9fbULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n mult.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.multiply");
|
|
struct intc_u256 const val = INTC_U64_TO_U256(0xfedbca9876543210ULL);
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(val, val), INTC_U256(INTC_U128(0x010e6cd7a44a4100ULL, 0xfdb8e2bacbfe7cefULL), INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL))));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(val, INTC_U256_ZERO), INTC_U256_ZERO));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(INTC_U256_ZERO, val), INTC_U256_ZERO));
|
|
|
|
struct intc_u256 const one = INTC_U64_TO_U256(1);
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(val, one), val));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(one, val), val));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.multiply");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 const u128 = INTC_U128(0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
|
struct intc_u256 const val = INTC_U256(INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(INTC_U64_TO_U256(t), val), INTC_U256(INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(INTC_U64_TO_U256(f), val), INTC_U256(INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL), INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(INTC_U64_TO_U256(u8), val), INTC_U256(INTC_U128(0xffffffffffffff60ULL, 0xffffffffffffffffULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(INTC_U64_TO_U256(u16), val), INTC_U256(INTC_U128(0xffffffffffff5f60ULL, 0xffffffffffffffffULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(INTC_U64_TO_U256(u32), val), INTC_U256(INTC_U128(0xffffffff5f5f5f60ULL, 0xffffffffffffffffULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(INTC_U64_TO_U256(u64), val), INTC_U256(INTC_U128(0x5f5f5f5f5f5f5f60ULL, 0xffffffffffffffffULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_mul(INTC_U128_TO_U256(u128), val), INTC_U256(INTC_U128(0x5f5f5f5f5f5f5f60ULL, 0x5f5f5f5f5f5f5f5fULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL))));
|
|
|
|
INTC_TESTS_ASSERT((intc_u8)(u8 * intc_u256_as_u8(val)) == (intc_u8)0x60ULL);
|
|
INTC_TESTS_ASSERT((intc_u16)(u16 * intc_u256_as_u16(val)) == (intc_u16)0x5f60ULL);
|
|
INTC_TESTS_ASSERT((intc_u32)(u32 * intc_u256_as_u32(val)) == (intc_u32)0x5f5f5f60ULL);
|
|
INTC_TESTS_ASSERT((intc_u64)(u64 * intc_u256_as_u64(val)) == (intc_u64)0x5f5f5f5f5f5f5f60ULL);
|
|
INTC_TESTS_ASSERT(intc_u128_eq(intc_u128_mul(u128, intc_u256_as_u128(val)), INTC_U128(0x5f5f5f5f5f5f5f60ULL, 0x5f5f5f5f5f5f5f5fULL)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n notequals.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Comparison.not_equals");
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(0xdeadbeefULL), INTC_U64_TO_U256(0xdeadbeefULL)) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(0xdeadbeefULL), INTC_U64_TO_U256(0xfee1baadULL)) == true);
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.not_equals");
|
|
bool const t = true;
|
|
bool const f = false;
|
|
intc_u8 const u8 = 0xaaULL;
|
|
intc_u16 const u16 = 0xaaaaULL;
|
|
intc_u32 const u32 = 0xaaaaaaaaULL;
|
|
intc_u64 const u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(t) , INTC_U64_TO_U256(f)) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(f) , INTC_U64_TO_U256(t)) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(u8) , INTC_U64_TO_U256(u64)) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(u16), INTC_U64_TO_U256(u32)) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(u32), INTC_U64_TO_U256(u16)) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(u64), INTC_U64_TO_U256(u8)) == true);
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(t) , INTC_U64_TO_U256(t)) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(f) , INTC_U64_TO_U256(f)) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(u8) , INTC_U64_TO_U256(u8)) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(u16), INTC_U64_TO_U256(u16)) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(u32), INTC_U64_TO_U256(u32)) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_neq(INTC_U64_TO_U256(u64), INTC_U64_TO_U256(u64)) == false);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n or.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitWise.or");
|
|
struct intc_u256 const t = INTC_U64_TO_U256((bool) true);
|
|
struct intc_u256 const f = INTC_U64_TO_U256((bool) false);
|
|
struct intc_u256 const u8 = INTC_U64_TO_U256((intc_u8) 0xaaULL);
|
|
struct intc_u256 const u16 = INTC_U64_TO_U256((intc_u16) 0xaaaaULL);
|
|
struct intc_u256 const u32 = INTC_U64_TO_U256((intc_u32) 0xaaaaaaaaULL);
|
|
struct intc_u256 const u64 = INTC_U64_TO_U256((intc_u64) 0xaaaaaaaaaaaaaaaaULL);
|
|
struct intc_u256 const val = INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(t , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f1ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(f , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(u8 , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0faULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(u16, val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0fafaULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(u32, val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0fafafafaULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(u64, val), INTC_U256(INTC_U64_TO_U128(0xfafafafafafafafaULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
|
|
// zero
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(INTC_U256_ZERO, val), val));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.or");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaa;
|
|
intc_u16 u16 = 0xaaaa;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u256 const val = INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(INTC_U64_TO_U256(t) , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f1ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(INTC_U64_TO_U256(f) , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(INTC_U64_TO_U256(u8) , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0faULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(INTC_U64_TO_U256(u16), val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0fafaULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(INTC_U64_TO_U256(u32), val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0fafafafaULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_or(INTC_U64_TO_U256(u64), val), INTC_U256(INTC_U64_TO_U128(0xfafafafafafafafaULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n rightshift.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitShift.right");
|
|
// operator>>
|
|
struct intc_u256 val = INTC_U64_TO_U256(0xffffffffffffffffULL);
|
|
intc_u64 exp = 0xffffffffffffffffULL;
|
|
|
|
for(int i = 0; i < 64; i++){
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(val, i), INTC_U64_TO_U256(exp >> i)));
|
|
}
|
|
|
|
struct intc_u256 zero = INTC_U256_ZERO;
|
|
for (int i = 0; i < 64; i++)
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(zero, i), INTC_U256_ZERO));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.shift_left");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xffULL;
|
|
intc_u16 u16 = 0xffffULL;
|
|
intc_u32 u32 = 0xffffffffULL;
|
|
intc_u64 u64 = 0xffffffffffffffffULL;
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(t) , 0), INTC_U64_TO_U256(1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(f) , 0), INTC_U256_ZERO));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u8), 0), INTC_U64_TO_U256(u8)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u16), 0), INTC_U64_TO_U256(u16)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u32), 0), INTC_U64_TO_U256(u32)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u64), 0), INTC_U64_TO_U256(u64)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(t), 1), INTC_U64_TO_U256((intc_u64)t >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(f), 1), INTC_U64_TO_U256((intc_u64)f >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u8), 1), INTC_U64_TO_U256((intc_u64)u8 >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u16), 1), INTC_U64_TO_U256((intc_u64)u16 >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u32), 1), INTC_U64_TO_U256((intc_u64)u32 >> 1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u64), 1), INTC_U64_TO_U256(u64 >> 1)));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u8), 7), INTC_U64_TO_U256(1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u16), 15), INTC_U64_TO_U256(1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u32), 31), INTC_U64_TO_U256(1)));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_rshift(INTC_U64_TO_U256(u64), 63), INTC_U64_TO_U256(1)));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n sub.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Arithmetic.subtract");
|
|
struct intc_u256 const big = INTC_U256(INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL));
|
|
struct intc_u256 const small = INTC_U256(INTC_U64_TO_U128(0x0000000000000001ULL), INTC_U64_TO_U128(0x0000000000000000ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(small, small), INTC_U256_ZERO));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(small, big), INTC_U256(INTC_U128(0x0000000000000002ULL, 0x0000000000000000ULL), INTC_U128(0x0000000000000000ULL, 0x0000000000000000ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(big , small), INTC_U256(INTC_U128(0xfffffffffffffffeULL, 0xffffffffffffffffULL), INTC_U128(0xffffffffffffffffULL, 0xffffffffffffffffULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(big , big), INTC_U256_ZERO));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.subtract");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u128 u128 = INTC_U128(0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
|
struct intc_u256 val = INTC_U256(INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL), INTC_U128(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(INTC_U64_TO_U256(t) , val), INTC_U256(INTC_U128(0x0f0f0f0f0f0f0f11ULL, 0x0f0f0f0f0f0f0f0fULL), INTC_U128(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(INTC_U64_TO_U256(f) , val), INTC_U256(INTC_U128(0x0f0f0f0f0f0f0f10ULL, 0x0f0f0f0f0f0f0f0fULL), INTC_U128(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(INTC_U64_TO_U256(u8) , val), INTC_U256(INTC_U128(0x0f0f0f0f0f0f0fbaULL, 0x0f0f0f0f0f0f0f0fULL), INTC_U128(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(INTC_U64_TO_U256(u16), val), INTC_U256(INTC_U128(0x0f0f0f0f0f0fb9baULL, 0x0f0f0f0f0f0f0f0fULL), INTC_U128(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(INTC_U64_TO_U256(u32), val), INTC_U256(INTC_U128(0x0f0f0f0fb9b9b9baULL, 0x0f0f0f0f0f0f0f0fULL), INTC_U128(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(INTC_U64_TO_U256(u64), val), INTC_U256(INTC_U128(0xb9b9b9b9b9b9b9baULL, 0x0f0f0f0f0f0f0f0fULL), INTC_U128(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_sub(INTC_U128_TO_U256(u128), val), INTC_U256(INTC_U128(0xb9b9b9b9b9b9b9baULL, 0xb9b9b9b9b9b9b9b9ULL), INTC_U128(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL))));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n typecast.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("Typecast.all");
|
|
struct intc_u256 const val = INTC_U256(INTC_U64_TO_U128(0xaaaaaaaaaaaaaaaaULL), INTC_U64_TO_U128(0xaaaaaaaaaaaaaaaaULL));
|
|
INTC_TESTS_ASSERT(intc_u256_as_bool(INTC_U64_TO_U256(true)) == true);
|
|
INTC_TESTS_ASSERT(intc_u256_as_bool(INTC_U64_TO_U256(false)) == false);
|
|
INTC_TESTS_ASSERT(intc_u256_as_u8(val) == (intc_u8)0xaaULL);
|
|
INTC_TESTS_ASSERT(intc_u256_as_u16(val) == (intc_u16)0xaaaaULL);
|
|
INTC_TESTS_ASSERT(intc_u256_as_u32(val) == (intc_u32)0xaaaaaaaaULL);
|
|
INTC_TESTS_ASSERT(intc_u256_as_u64(val) == (intc_u64)0xaaaaaaaaaaaaaaaaULL);
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
printf("\n xor.cpp\n");
|
|
{
|
|
{
|
|
INTC_TESTS_BEGIN("BitWise.xor");
|
|
struct intc_u256 t = INTC_U64_TO_U256((bool) true);
|
|
struct intc_u256 f = INTC_U64_TO_U256((bool) false);
|
|
struct intc_u256 u8 = INTC_U64_TO_U256((intc_u8) 0xaaULL);
|
|
struct intc_u256 u16 = INTC_U64_TO_U256((intc_u16) 0xaaaaULL);
|
|
struct intc_u256 u32 = INTC_U64_TO_U256((intc_u32) 0xaaaaaaaaULL);
|
|
struct intc_u256 u64 = INTC_U64_TO_U256((intc_u64) 0xaaaaaaaaaaaaaaaa);
|
|
struct intc_u256 const val = INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(t , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f1ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(f , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(u8 , val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f05aULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(u16, val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f05a5aULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(u32, val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f05a5a5a5aULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(u64, val), INTC_U256(INTC_U64_TO_U128(0x5a5a5a5a5a5a5a5aULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
|
|
// zero
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(INTC_U256_ZERO, val), val));
|
|
INTC_TESTS_END;
|
|
}
|
|
|
|
{
|
|
INTC_TESTS_BEGIN("External.xor");
|
|
bool t = true;
|
|
bool f = false;
|
|
intc_u8 u8 = 0xaaULL;
|
|
intc_u16 u16 = 0xaaaaULL;
|
|
intc_u32 u32 = 0xaaaaaaaaULL;
|
|
intc_u64 u64 = 0xaaaaaaaaaaaaaaaaULL;
|
|
struct intc_u256 const val = INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL));
|
|
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(INTC_U64_TO_U256(t ), val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f1ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(INTC_U64_TO_U256(f ), val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(INTC_U64_TO_U256(u8 ), val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f0f05aULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(INTC_U64_TO_U256(u16), val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f0f0f05a5aULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(INTC_U64_TO_U256(u32), val), INTC_U256(INTC_U64_TO_U128(0xf0f0f0f05a5a5a5aULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_ASSERT(intc_u256_eq(intc_u256_xor(INTC_U64_TO_U256(u64), val), INTC_U256(INTC_U64_TO_U128(0x5a5a5a5a5a5a5a5aULL), INTC_U64_TO_U128(0xf0f0f0f0f0f0f0f0ULL))));
|
|
INTC_TESTS_END;
|
|
}
|
|
}
|
|
|
|
fputc('\n', stdout);
|
|
return result;
|
|
}
|
|
#endif // !defined(INTC_NO_U256)
|
|
|
|
void intc_test_state_print(char const *label, struct intc_test_state const *state)
|
|
{
|
|
printf(INTC_TESTS_COLOR_MAGENTA "%s" INTC_TESTS_COLOR_RESET " -- %d/%d tests passsed", label, state->test_count - state->fail_count, state->test_count);
|
|
if (state->fail_count)
|
|
printf(INTC_TESTS_COLOR_RED " (%d tests failed)" INTC_TESTS_COLOR_RESET, state->fail_count);
|
|
fputc('\n', stdout);
|
|
}
|
|
|
|
void intc_unit_tests(void)
|
|
{
|
|
struct intc_test_state u128_state = intc_u128_unit_tests();
|
|
#if !defined(INTC_NO_U256)
|
|
struct intc_test_state u256_state = intc_u256_unit_tests();
|
|
#endif
|
|
|
|
intc_test_state_print("intc_u128_unit_tests", &u128_state);
|
|
|
|
#if !defined(INTC_NO_U256)
|
|
intc_test_state_print("intc_u256_unit_tests", &u256_state);
|
|
#endif
|
|
}
|
|
|
|
#if defined(INTC_TESTS_WITH_MAIN)
|
|
int main(void)
|
|
{
|
|
intc_unit_tests();
|
|
return 0;
|
|
}
|
|
#endif
|
|
#endif // INTC_TESTS_IMPLEMENTATION
|