blankhex/bhlib
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add benchmarks, change project structure

Browse Source
This commit is contained in:
Mikhail Romanko
2025-10-12 10:20:09 +03:00
parent b1870bd709
commit 364d3a32ec
45 changed files with 323 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

484
test/tests/TestAlgo.c Normal file
View File

@@ -0,0 +1,484 @@
#include <BH/Algo.h>
#include <BH/Unit.h>
#include <string.h>
#include <stdlib.h>
static int DBG_IntEqual(const void *lhs,
const void *rhs)
{
return *(const int*)lhs - *(const int*)rhs;
}
static int DBG_VerifyPartition(size_t index,
int pivot,
int *array,
size_t size)
{
size_t i;
for (i = 0; i < index; i++)
if (array[i] >= pivot)
return -1;
for (i = index; i < size; i++)
if (array[i] < pivot)
return -1;
return 0;
}
static int DBG_VerifyHeap(int *array,
size_t size)
{
size_t i, left, right;
for (i = 0; i < size; i++)
{
left = i * 2 + 1;
right = i * 2 + 2;
if (left < size && array[i] < array[left])
return -1;
if (right < size && array[i] < array[right])
return -1;
}
return 0;
}
static int DBG_ReferenceRand(void)
{
static uint32_t next = 2025;
next = next * 1103515245 + 12345;
return (next / 65536) % 32768;
}
static void DBG_ReferenceSort(int *array,
size_t size)
{
size_t i, j;
int tmp;
/* Reference sort is... buble sort! */
for (i = 0; i < size; i++)
{
for (j = 1; j < size; j++)
{
if (array[j - 1] > array[j])
{
tmp = array[j - 1];
array[j - 1] = array[j];
array[j] = tmp;
}
}
}
}
static void DBG_FillArrays(int *array,
int *reference,
size_t size,
int mask)
{
size_t i;
int negate;
/* Check if mask needs to be negated */
negate = mask < 0;
if (negate)
mask = -mask;
/* Fill the array */
for (i = 0; i < size; ++i)
{
array[i] = DBG_ReferenceRand();
if (mask > 1)
array[i] = array[i] % mask;
if (negate)
array[i] = -array[i];
if (reference)
reference[i] = array[i];
}
}
static int CheckSort(void)
{
size_t sizes[] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0}, *size;
int reference[317], data[317];
/* Test empty array and one element arrays */
data[0] = 1; data[1] = 2; data[2] = 3;
BH_Sort(data, 0, sizeof(int), DBG_IntEqual);
BH_VERIFY(data[0] == 1);
BH_VERIFY(data[1] == 2);
BH_VERIFY(data[2] == 3);
BH_Sort(data, 1, sizeof(int), DBG_IntEqual);
BH_VERIFY(data[0] == 1);
BH_VERIFY(data[1] == 2);
BH_VERIFY(data[2] == 3);
/* Test array against different sizes */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, 0);
DBG_ReferenceSort(reference, *size);
BH_Sort(data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(memcmp(reference, data, *size * sizeof(int)) == 0);
}
/* Test against negative values */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, -1);
DBG_ReferenceSort(reference, *size);
BH_Sort(data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(memcmp(reference, data, *size * sizeof(int)) == 0);
}
/* Test against duplicates */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, 4);
DBG_ReferenceSort(reference, *size);
BH_Sort(data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(memcmp(reference, data, *size * sizeof(int)) == 0);
}
return 0;
}
static int CheckPartition(void)
{
size_t sizes[] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0}, *size;
int reference[317], data[317], value, *pivot;
/* Test empty array and one element array */
data[0] = 1; data[1] = 2; data[2] = 3;
value = 0;
pivot = BH_Partition(&value, data, 0, sizeof(int), DBG_IntEqual);
BH_VERIFY(pivot != NULL);
BH_VERIFY(data[0] == 1);
BH_VERIFY(data[1] == 2);
BH_VERIFY(data[2] == 3);
pivot = BH_Partition(&value, data, 1, sizeof(int), DBG_IntEqual);
BH_VERIFY(pivot == data);
BH_VERIFY(data[0] == 1);
BH_VERIFY(data[1] == 2);
BH_VERIFY(data[2] == 3);
/* Test array against different sizes */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, 0);
value = 16384;
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
/* Test against negative values */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, -1);
value = -16384;
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
/* Test against duplicates */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, 4);
value = 2;
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
/* Test array against small pivots */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, 0);
value = -100;
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
/* Test array against large pivots */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, 0);
value = 65536;
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
/* Test array against different sizes (pivot inside the array) */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, 0);
value = data[0];
pivot = BH_Partition(data, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
/* Test against negative values (pivot inside the array) */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, -1);
value = data[0];
pivot = BH_Partition(data, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
/* Test against duplicates (pivot inside the array) */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, reference, *size, 4);
value = data[0];
pivot = BH_Partition(data, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
/* Same data test */
for (size = sizes; *size; ++size)
{
memset(data, 0, sizeof(int) * *size);
memset(reference, 0, sizeof(int) * *size);
value = data[*size - 1];
pivot = BH_Partition(data + *size - 1, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
return 0;
}
static int CheckHeapMake(void)
{
size_t sizes[] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0}, *size;
int data[317];
/* Test empty array */
data[0] = 1; data[1] = 2; data[2] = 3;
BH_HeapMake(data, 0, sizeof(int), DBG_IntEqual);
BH_VERIFY(data[0] == 1);
BH_VERIFY(data[1] == 2);
BH_VERIFY(data[2] == 3);
/* Test array against different sizes */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, NULL, *size, 0);
BH_HeapMake(data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, *size) == 0);
}
/* Test array against negative values */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, NULL, *size, -1);
BH_HeapMake(data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, *size) == 0);
}
/* Test against duplicates */
for (size = sizes; *size; ++size)
{
DBG_FillArrays(data, NULL, *size, 4);
BH_HeapMake(data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, *size) == 0);
}
return 0;
}
static int CheckHeapInsert(void)
{
size_t sizes[] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0}, *size;
int data[317], reference[317];
/* Test array against different sizes */
for (size = sizes; *size; ++size)
{
size_t i;
DBG_FillArrays(data, reference, *size, 0);
for (i = 0; i < *size; ++i)
{
int value;
value = data[i];
BH_HeapInsert(&value, data, i, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, i + 1) == 0);
}
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size) == 0);
}
/* Test array against different sizes (inplace)*/
for (size = sizes; *size; ++size)
{
size_t i;
DBG_FillArrays(data, reference, *size, 0);
for (i = 0; i < *size; ++i)
{
BH_HeapInsert(NULL, data, i, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, i + 1) == 0);
}
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size) == 0);
}
return 0;
}
static int CheckHeapRemove(void)
{
size_t sizes[] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0}, *size;
int data[317], reference[317];
/* Test array against different sizes */
for (size = sizes; *size; ++size)
{
size_t i;
DBG_FillArrays(data, reference, *size, 0);
BH_HeapMake(data, *size, sizeof(int), DBG_IntEqual);
for (i = *size; i > 0; i--)
{
BH_VERIFY(DBG_VerifyHeap(data, i) == 0);
BH_HeapRemove(data, i, sizeof(int), DBG_IntEqual);
}
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size) == 0);
}
return 0;
}
static int CheckHeapReplace(void)
{
int data[11] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0};
int reference[11] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0};
int value;
/* Prepare test arrays */
BH_HeapMake(data, 10, sizeof(int), DBG_IntEqual);
BH_HeapMake(reference, 10, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, 10) == 0);
BH_VERIFY(DBG_VerifyHeap(reference, 10) == 0);
/* Verfify heap replace */
value = 20;
BH_HeapReplace(&value, data, 10, sizeof(int), DBG_IntEqual);
BH_HeapRemove(reference, 10, sizeof(int), DBG_IntEqual);
BH_HeapInsert(&value, reference, 9, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, 10) == 0);
BH_VERIFY(DBG_VerifyHeap(reference, 10) == 0);
BH_Sort(data, 10, sizeof(int), DBG_IntEqual);
BH_Sort(reference, 10, sizeof(int), DBG_IntEqual);
BH_VERIFY(memcmp(data, reference, 10 * sizeof(int)) == 0);
/* Verify heap replace on single element array */
value = 400;
BH_HeapReplace(&value, data, 1, sizeof(int), DBG_IntEqual);
BH_HeapRemove(reference, 1, sizeof(int), DBG_IntEqual);
BH_HeapInsert(&value, reference, 0, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, 1) == 0);
BH_VERIFY(DBG_VerifyHeap(reference, 1) == 0);
BH_VERIFY(memcmp(data, reference, 1 * sizeof(int)) == 0);
/* Prepare test arrays */
BH_Sort(data, 10, sizeof(int), DBG_IntEqual);
BH_Sort(reference, 10, sizeof(int), DBG_IntEqual);
BH_HeapMake(data, 10, sizeof(int), DBG_IntEqual);
BH_HeapMake(reference, 10, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, 10) == 0);
BH_VERIFY(DBG_VerifyHeap(reference, 10) == 0);
data[10] = 1000;
value = 1000;
BH_HeapReplace(NULL, data, 10, sizeof(int), DBG_IntEqual);
BH_HeapRemove(reference, 10, sizeof(int), DBG_IntEqual);
BH_HeapInsert(&value, reference, 9, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, 10) == 0);
BH_VERIFY(DBG_VerifyHeap(reference, 10) == 0);
BH_Sort(data, 10, sizeof(int), DBG_IntEqual);
BH_Sort(reference, 10, sizeof(int), DBG_IntEqual);
BH_VERIFY(memcmp(data, reference, 10 * sizeof(int)) == 0);
return 0;
}
int main(int argc, char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UnitAdd("Sort", CheckSort);
BH_UnitAdd("Partition", CheckPartition);
BH_UnitAdd("HeapMake", CheckHeapMake);
BH_UnitAdd("HeapInsert", CheckHeapInsert);
BH_UnitAdd("HeapRemove", CheckHeapRemove);
BH_UnitAdd("HeapReplace", CheckHeapReplace);
return BH_UnitRun();
}

420
test/tests/TestArgs.c Normal file
View File

@@ -0,0 +1,420 @@
#include <BH/Args.h>
#include <BH/Unit.h>
#include <string.h>
typedef struct DBG_State
{
int key[128];
char *args[128];
size_t size;
} DBG_State;
static int DBG_Process(int key,
char *arg,
void *data)
{
DBG_State *state = (DBG_State *)data;
state->key[state->size] = key;
state->args[state->size] = arg;
state->size++;
return BH_OK;
}
static int DBG_AlwaysPass(int key,
char *arg,
void *data)
{
BH_UNUSED(key);
BH_UNUSED(arg);
BH_UNUSED(data);
return BH_OK;
}
static int DBG_AlwaysFail(int key,
char *arg,
void *data)
{
BH_UNUSED(key);
BH_UNUSED(arg);
BH_UNUSED(data);
return BH_ERROR;
}
BH_UNIT_TEST(Empty)
{
int argc = 1;
char *argv[] = {
"./app"
};
BH_ArgsOption options[] = {
{0, NULL, 0, NULL}
};
DBG_State state;
memset(&state, 0, sizeof(state));
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_AlwaysFail, NULL) == BH_OK);
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_AlwaysPass, NULL) == BH_OK);
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_Process, &state) == BH_OK);
BH_VERIFY(state.size == 0);
BH_VERIFY(strcmp(argv[0], "./app") == 0);
return 0;
}
BH_UNIT_TEST(Args)
{
int argc = 4;
char *argv[] = {
"./app",
"a",
"b",
"c"
};
BH_ArgsOption options[] = {
{0, NULL, 0, NULL}
};
DBG_State state;
memset(&state, 0, sizeof(state));
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_Process, &state) == BH_OK);
BH_VERIFY(state.size == 3);
BH_VERIFY(state.key[0] == 0 && strcmp(state.args[0], "a") == 0);
BH_VERIFY(state.key[1] == 0 && strcmp(state.args[1], "b") == 0);
BH_VERIFY(state.key[2] == 0 && strcmp(state.args[2], "c") == 0);
BH_VERIFY(strcmp(argv[0], "./app") == 0);
BH_VERIFY(strcmp(argv[1], "a") == 0);
BH_VERIFY(strcmp(argv[2], "b") == 0);
BH_VERIFY(strcmp(argv[3], "c") == 0);
return 0;
}
BH_UNIT_TEST(Dash)
{
int argc = 5;
char *argv[] = {
"./app",
"a",
"--",
"-a",
"--b"
};
BH_ArgsOption options[] = {
{0, NULL, 0, NULL}
};
DBG_State state;
memset(&state, 0, sizeof(state));
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_Process, &state) == BH_OK);
BH_VERIFY(state.size == 3);
BH_VERIFY(state.key[0] == 0 && strcmp(state.args[0], "a") == 0);
BH_VERIFY(state.key[1] == 0 && strcmp(state.args[1], "-a") == 0);
BH_VERIFY(state.key[2] == 0 && strcmp(state.args[2], "--b") == 0);
BH_VERIFY(strcmp(argv[0], "./app") == 0);
BH_VERIFY(strcmp(argv[1], "--") == 0);
BH_VERIFY(strcmp(argv[2], "a") == 0);
BH_VERIFY(strcmp(argv[3], "-a") == 0);
BH_VERIFY(strcmp(argv[4], "--b") == 0);
return 0;
}
BH_UNIT_TEST(ShortOption)
{
int argc = 12;
char *argv[] = {
"./app",
"a",
"-2",
"b",
"c",
"-2d",
"e",
"-2",
"-",
"f",
"-113",
"-1121",
};
BH_ArgsOption options[] = {
{'1', NULL, 0, NULL},
{'2', NULL, BH_ARGS_VALUE, NULL},
{'3', NULL, BH_ARGS_VALUE | BH_ARGS_OPTIONAL, NULL},
{0, NULL, 0, NULL},
};
DBG_State state;
memset(&state, 0, sizeof(state));
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_Process, &state) == BH_OK);
BH_VERIFY(state.size == 13);
BH_VERIFY(state.key[0] == 0 && strcmp(state.args[0], "a") == 0);
BH_VERIFY(state.key[1] == '2' && strcmp(state.args[1], "b") == 0);
BH_VERIFY(state.key[2] == 0 && strcmp(state.args[2], "c") == 0);
BH_VERIFY(state.key[3] == '2' && strcmp(state.args[3], "d") == 0);
BH_VERIFY(state.key[4] == 0 && strcmp(state.args[4], "e") == 0);
BH_VERIFY(state.key[5] == '2' && strcmp(state.args[5], "-") == 0);
BH_VERIFY(state.key[6] == 0 && strcmp(state.args[6], "f") == 0);
BH_VERIFY(state.key[7] == '1' && state.args[7] == NULL);
BH_VERIFY(state.key[8] == '1' && state.args[8] == NULL);
BH_VERIFY(state.key[9] == '3' && state.args[9] == NULL);
BH_VERIFY(state.key[10] == '1' && state.args[10] == NULL);
BH_VERIFY(state.key[11] == '1' && state.args[11] == NULL);
BH_VERIFY(state.key[12] == '2' && strcmp(state.args[12], "1") == 0);
BH_VERIFY(strcmp(argv[0], "./app") == 0);
BH_VERIFY(strcmp(argv[1], "-2") == 0);
BH_VERIFY(strcmp(argv[2], "b") == 0);
BH_VERIFY(strcmp(argv[3], "-2d") == 0);
BH_VERIFY(strcmp(argv[4], "-2") == 0);
BH_VERIFY(strcmp(argv[5], "-") == 0);
BH_VERIFY(strcmp(argv[6], "-113") == 0);
BH_VERIFY(strcmp(argv[7], "-1121") == 0);
BH_VERIFY(strcmp(argv[8], "a") == 0);
BH_VERIFY(strcmp(argv[9], "c") == 0);
BH_VERIFY(strcmp(argv[10], "e") == 0);
BH_VERIFY(strcmp(argv[11], "f") == 0);
return 0;
}
BH_UNIT_TEST(LongOptions)
{
int argc = 12;
char *argv[] = {
"./app",
"a",
"--def",
"b",
"c",
"--def=d",
"e",
"--def",
"-",
"f",
"--ghj",
"--abc",
};
BH_ArgsOption options[] = {
{1000, "abc", 0, NULL},
{1001, "def", BH_ARGS_VALUE, NULL},
{1002, "ghj", BH_ARGS_VALUE | BH_ARGS_OPTIONAL, NULL},
{0, NULL, 0, NULL},
};
DBG_State state;
memset(&state, 0, sizeof(state));
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_Process, &state) == BH_OK);
BH_VERIFY(state.size == 9);
BH_VERIFY(state.key[0] == 0 && strcmp(state.args[0], "a") == 0);
BH_VERIFY(state.key[1] == 1001 && strcmp(state.args[1], "b") == 0);
BH_VERIFY(state.key[2] == 0 && strcmp(state.args[2], "c") == 0);
BH_VERIFY(state.key[3] == 1001 && strcmp(state.args[3], "d") == 0);
BH_VERIFY(state.key[4] == 0 && strcmp(state.args[4], "e") == 0);
BH_VERIFY(state.key[5] == 1001 && strcmp(state.args[5], "-") == 0);
BH_VERIFY(state.key[6] == 0 && strcmp(state.args[6], "f") == 0);
BH_VERIFY(state.key[7] == 1002 && state.args[7] == NULL);
BH_VERIFY(state.key[8] == 1000 && state.args[8] == NULL);
BH_VERIFY(strcmp(argv[0], "./app") == 0);
BH_VERIFY(strcmp(argv[1], "--def") == 0);
BH_VERIFY(strcmp(argv[2], "b") == 0);
BH_VERIFY(strcmp(argv[3], "--def=d") == 0);
BH_VERIFY(strcmp(argv[4], "--def") == 0);
BH_VERIFY(strcmp(argv[5], "-") == 0);
BH_VERIFY(strcmp(argv[6], "--ghj") == 0);
BH_VERIFY(strcmp(argv[7], "--abc") == 0);
BH_VERIFY(strcmp(argv[8], "a") == 0);
BH_VERIFY(strcmp(argv[9], "c") == 0);
BH_VERIFY(strcmp(argv[10], "e") == 0);
BH_VERIFY(strcmp(argv[11], "f") == 0);
return 0;
}
BH_UNIT_TEST(Complex)
{
int argc = 15;
char *argv[] = {
"./app",
"a",
"-i",
"--input",
"b",
"-i-",
"-i",
"--input",
"-",
"--input",
"--",
"-a",
"-i",
"--input",
"--invalid",
};
BH_ArgsOption options[] = {
{'a', "abc", 0, NULL},
{'i', "input", BH_ARGS_VALUE | BH_ARGS_OPTIONAL, NULL},
{0, NULL, 0, NULL},
};
DBG_State state;
memset(&state, 0, sizeof(state));
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_Process, &state) == BH_OK);
BH_VERIFY(state.size == 11);
BH_VERIFY(state.key[0] == 0 && strcmp(state.args[0], "a") == 0);
BH_VERIFY(state.key[1] == 'i' && state.args[1] == NULL);
BH_VERIFY(state.key[2] == 'i' && strcmp(state.args[2], "b") == 0);
BH_VERIFY(state.key[3] == 'i' && strcmp(state.args[3], "-") == 0);
BH_VERIFY(state.key[4] == 'i' && state.args[4] == NULL);
BH_VERIFY(state.key[5] == 'i' && strcmp(state.args[5], "-") == 0);
BH_VERIFY(state.key[6] == 'i' && state.args[6] == NULL);
BH_VERIFY(state.key[7] == 0 && strcmp(state.args[7], "-a") == 0);
BH_VERIFY(state.key[8] == 0 && strcmp(state.args[8], "-i") == 0);
BH_VERIFY(state.key[9] == 0 && strcmp(state.args[9], "--input") == 0);
BH_VERIFY(state.key[10] == 0 && strcmp(state.args[10], "--invalid") == 0);
BH_VERIFY(strcmp(argv[0], "./app") == 0);
BH_VERIFY(strcmp(argv[1], "-i") == 0);
BH_VERIFY(strcmp(argv[2], "--input") == 0);
BH_VERIFY(strcmp(argv[3], "b") == 0);
BH_VERIFY(strcmp(argv[4], "-i-") == 0);
BH_VERIFY(strcmp(argv[5], "-i") == 0);
BH_VERIFY(strcmp(argv[6], "--input") == 0);
BH_VERIFY(strcmp(argv[7], "-") == 0);
BH_VERIFY(strcmp(argv[8], "--input") == 0);
BH_VERIFY(strcmp(argv[9], "--") == 0);
BH_VERIFY(strcmp(argv[10], "a") == 0);
BH_VERIFY(strcmp(argv[11], "-a") == 0);
BH_VERIFY(strcmp(argv[12], "-i") == 0);
BH_VERIFY(strcmp(argv[13], "--input") == 0);
BH_VERIFY(strcmp(argv[14], "--invalid") == 0);
return 0;
}
BH_UNIT_TEST(InvalidShort)
{
int argc = 4;
char *argv[] = {
"./app",
"a",
"-b",
"-c"
};
BH_ArgsOption options[] = {
{0, NULL, 0, NULL}
};
DBG_State state;
memset(&state, 0, sizeof(state));
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_Process, &state) != BH_OK);
BH_VERIFY(state.size == 2);
BH_VERIFY(state.key[0] == 0 && strcmp(state.args[0], "a") == 0);
BH_VERIFY(state.key[1] == BH_ARGS_UNKNOWN && strcmp(state.args[1], "-b") == 0);
return 0;
}
BH_UNIT_TEST(InvalidLong)
{
int argc = 4;
char *argv[] = {
"./app",
"a",
"--b",
"--c"
};
BH_ArgsOption options[] = {
{0, NULL, 0, NULL}
};
DBG_State state;
memset(&state, 0, sizeof(state));
BH_VERIFY(BH_ArgsParse(argc, argv, options, DBG_Process, &state) != BH_OK);
BH_VERIFY(state.size == 2);
BH_VERIFY(state.key[0] == 0 && strcmp(state.args[0], "a") == 0);
BH_VERIFY(state.key[1] == BH_ARGS_UNKNOWN && strcmp(state.args[1], "--b") == 0);
return 0;
}
BH_UNIT_TEST(Aesthetics)
{
BH_ArgsOption options[] = {
{'a', "abc", 0, NULL},
{'b', "bcd", BH_ARGS_VALUE, "B option"},
{'i', "input", BH_ARGS_VALUE | BH_ARGS_OPTIONAL, "Input option"},
{1000, "long-option", 0, "Long options\nWith newline"},
{'p', NULL, 0, "P option"},
{0, NULL, 0, NULL},
};
BH_ArgsHelp(options, 0);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Empty);
BH_UNIT_ADD(Args);
BH_UNIT_ADD(Dash);
BH_UNIT_ADD(ShortOption);
BH_UNIT_ADD(LongOptions);
BH_UNIT_ADD(Complex);
BH_UNIT_ADD(InvalidShort);
BH_UNIT_ADD(InvalidLong);
BH_UNIT_ADD(Aesthetics);
return BH_UnitRun();
}

87
test/tests/TestBitmap.c Normal file
View File

@@ -0,0 +1,87 @@
#include <BH/Bitmap.h>
#include <BH/Color.h>
#include <BH/IO.h>
#include <BH/Unit.h>
BH_UNIT_TEST(RoundTrip)
{
size_t i, format;
uint16_t data[][4] =
{
{0, 0, 0, 65535},
{0, 0, 65535, 65535},
{0, 65535, 0, 65535},
{65535, 0, 0, 65535},
{0, 65535, 65535, 65535},
{65535, 0, 65535, 65535},
{65535, 65535, 0, 65535},
{65535, 65535, 65535, 65535},
{0, 0, 0, 0},
{0, 0, 65535, 0},
{0, 65535, 0, 0},
{65535, 0, 0, 0},
{0, 65535, 65535, 0},
{65535, 0, 65535, 0},
{65535, 65535, 0, 0},
{65535, 65535, 65535, 0},
};
uint16_t formats[] =
{
BH_BITMAP_RGBA32,
BH_BITMAP_RGBA64,
BH_BITMAP_RGB888,
BH_BITMAP_RGBA8888,
BH_BITMAP_RGB161616,
BH_BITMAP_RGBA16161616,
BH_BITMAP_RGB565,
BH_BITMAP_RGBA1010102,
BH_BITMAP_RGBA8888 | BH_BITMAP_NOALPHA,
BH_BITMAP_RGBA16161616 | BH_BITMAP_NOALPHA,
BH_BITMAP_RGBA1010102 | BH_BITMAP_NOALPHA,
};
for (format = 0; format < sizeof(formats) / sizeof(uint16_t); ++format)
{
for (i = 0; i < 16; ++i)
{
BH_Color source, destination;
uint64_t temp;
temp = 0;
BH_ColorSetRGBA16(&source, data[i][0], data[i][1], data[i][2],
data[i][3]);
BH_BitmapConvertRow(&source.data, BH_BITMAP_RGBA16161616, NULL,
&temp, formats[format], NULL, 1);
BH_BitmapConvertRow(&temp, formats[format], NULL, &destination.data,
BH_BITMAP_RGBA16161616, NULL, 1);
BH_VERIFY(source.data.rgba.r == destination.data.rgba.r);
BH_VERIFY(source.data.rgba.g == destination.data.rgba.g);
BH_VERIFY(source.data.rgba.b == destination.data.rgba.b);
if (formats[format] == BH_BITMAP_RGB888 ||
formats[format] == BH_BITMAP_RGB161616 ||
formats[format] == BH_BITMAP_RGB565 ||
formats[format] & BH_BITMAP_NOALPHA)
BH_VERIFY(destination.data.rgba.a == 65535);
else
BH_VERIFY(source.data.rgba.a == destination.data.rgba.a);
}
}
return 0;
}
int main(int argc, char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(RoundTrip);
return BH_UnitRun();
}

98
test/tests/TestBox2f.c Normal file
View File

@@ -0,0 +1,98 @@
#include <BH/Math/Box2f.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(Union)
{
float aMin[2], aMax[2], bMin[2], bMax[2], rMin[2], rMax[2];
aMin[0] = 1.0f; aMin[1] = 2.0f;
aMax[0] = 5.0f; aMax[1] = 5.0f;
bMin[0] = 0.0f; bMin[1] = 0.0f;
bMax[0] = 4.0f; bMax[1] = 4.0f;
BH_Box2fUnion(aMin, aMax, bMin, bMax, rMin, rMax);
BH_VERIFY_DELTA(rMin[0], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[1], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[1], 5.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Intersect)
{
float aMin[2], aMax[2], bMin[2], bMax[2], rMin[2], rMax[2];
aMin[0] = 1.0f; aMin[1] = 2.0f;
aMax[0] = 5.0f; aMax[1] = 5.0f;
bMin[0] = 0.0f; bMin[1] = 0.0f;
bMax[0] = 4.0f; bMax[1] = 4.0f;
BH_VERIFY(BH_Box2fIntersect(aMin, aMax, bMin, bMax, rMin, rMax) == BH_OK);
BH_VERIFY_DELTA(rMin[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[0], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[1], 4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Contains)
{
float aMin[2], aMax[2], point[2];
aMin[0] = 1.0f; aMin[1] = 2.0f;
aMax[0] = 5.0f; aMax[1] = 5.0f;
point[0] = 0.0f; point[1] = 0.0f;
BH_VERIFY(BH_Box2fContains(aMin, aMax, point) != BH_OK);
point[0] = 1.0f; point[1] = 2.0f;
BH_VERIFY(BH_Box2fContains(aMin, aMax, point) == BH_OK);
point[0] = 4.0f; point[1] = 4.0f;
BH_VERIFY(BH_Box2fContains(aMin, aMax, point) == BH_OK);
point[0] = 6.0f; point[1] = 6.0f;
BH_VERIFY(BH_Box2fContains(aMin, aMax, point) != BH_OK);
return 0;
}
BH_UNIT_TEST(Enclose)
{
float points[4], rMin[2], rMax[2];
points[0] = 5.0f; points[1] = 5.0f;
points[2] = 1.0f; points[3] = 2.0f;
BH_VERIFY(BH_Box2fEnclose(NULL, 0, NULL, NULL) != BH_OK);
BH_VERIFY(BH_Box2fEnclose(points, 2, rMin, rMax) == BH_OK);
BH_VERIFY_DELTA(rMin[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[1], 5.0000f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Union);
BH_UNIT_ADD(Intersect);
BH_UNIT_ADD(Contains);
BH_UNIT_ADD(Enclose);
return BH_UnitRun();
}

104
test/tests/TestBox3f.c Normal file
View File

@@ -0,0 +1,104 @@
#include <BH/Math/Box3f.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(Union)
{
float aMin[3], aMax[3], bMin[3], bMax[3], rMin[3], rMax[3];
aMin[0] = 1.0f; aMin[1] = 2.0f; aMin[2] = 3.0f;
aMax[0] = 5.0f; aMax[1] = 5.0f; aMax[2] = 5.0f;
bMin[0] = 0.0f; bMin[1] = 0.0f; bMin[2] = 0.0f;
bMax[0] = 4.0f; bMax[1] = 4.0f; bMax[2] = 4.0f;
BH_Box3fUnion(aMin, aMax, bMin, bMax, rMin, rMax);
BH_VERIFY_DELTA(rMin[0], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[1], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[2], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[1], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[2], 5.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Intersect)
{
float aMin[3], aMax[3], bMin[3], bMax[3], rMin[3], rMax[3];
aMin[0] = 1.0f; aMin[1] = 2.0f; aMin[2] = 3.0f;
aMax[0] = 5.0f; aMax[1] = 5.0f; aMax[2] = 5.0f;
bMin[0] = 0.0f; bMin[1] = 0.0f; bMin[2] = 0.0f;
bMax[0] = 4.0f; bMax[1] = 4.0f; bMax[2] = 4.0f;
BH_VERIFY(BH_Box3fIntersect(aMin, aMax, bMin, bMax, rMin, rMax) == BH_OK);
BH_VERIFY_DELTA(rMin[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[2], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[0], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[1], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[2], 4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Contains)
{
float aMin[3], aMax[3], point[3];
aMin[0] = 1.0f; aMin[1] = 2.0f; aMin[2] = 3.0f;
aMax[0] = 5.0f; aMax[1] = 5.0f; aMax[2] = 5.0f;
point[0] = 0.0f; point[1] = 0.0f; point[2] = 0.0f;
BH_VERIFY(BH_Box3fContains(aMin, aMax, point) != BH_OK);
point[0] = 1.0f; point[1] = 2.0f; point[2] = 3.0f;
BH_VERIFY(BH_Box3fContains(aMin, aMax, point) == BH_OK);
point[0] = 4.0f; point[1] = 4.0f; point[2] = 4.0f;
BH_VERIFY(BH_Box3fContains(aMin, aMax, point) == BH_OK);
point[0] = 6.0f; point[1] = 6.0f; point[2] = 5.0f;
BH_VERIFY(BH_Box3fContains(aMin, aMax, point) != BH_OK);
return 0;
}
BH_UNIT_TEST(Enclose)
{
float points[6], rMin[3], rMax[3];
points[0] = 5.0f; points[1] = 5.0f; points[2] = 5.0f;
points[3] = 1.0f; points[4] = 2.0f; points[5] = 3.0f;
BH_VERIFY(BH_Box3fEnclose(NULL, 0, NULL, NULL) != BH_OK);
BH_VERIFY(BH_Box3fEnclose(points, 2, rMin, rMax) == BH_OK);
BH_VERIFY_DELTA(rMin[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMin[2], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[1], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(rMax[2], 5.0000f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Union);
BH_UNIT_ADD(Intersect);
BH_UNIT_ADD(Contains);
BH_UNIT_ADD(Enclose);
return BH_UnitRun();
}

126
test/tests/TestBuffer.c Normal file
View File

@@ -0,0 +1,126 @@
#include <BH/IO.h>
#include <BH/Unit.h>
#include <string.h>
#include <stdio.h>
BH_UNIT_TEST(Null)
{
BH_VERIFY(BH_BufferNew(NULL, 0, NULL) == NULL);
return 0;
}
BH_UNIT_TEST(Write)
{
BH_IO *buffer, *io;
char data[16];
int64_t offset;
size_t size;
memset(data, 0, 16);
BH_VERIFY((io = BH_BytesNew(data, 16, NULL)) != NULL);
BH_VERIFY((buffer = BH_BufferNew(io, 4, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(buffer, "1234567", 7, &size) == BH_OK);
BH_VERIFY(size == 7);
BH_VERIFY(BH_IOWrite(buffer, "8901234", 7, &size) == BH_OK);
BH_VERIFY(size == 7);
BH_VERIFY(BH_IOWrite(buffer, "5", 1, &size) == BH_OK);
BH_VERIFY(size == 1);
BH_VERIFY(memcmp(data, "123456789012", 13) == 0);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 12);
BH_VERIFY(BH_IOFlush(buffer) == BH_OK);
BH_VERIFY(memcmp(data, "123456789012345", 15) == 0);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 15);
BH_VERIFY(BH_IOWrite(buffer, "678", 3, &size) == BH_OK);
BH_VERIFY(size == 3);
BH_VERIFY(BH_IOFlush(buffer) != BH_OK);
BH_VERIFY(memcmp(data, "1234567890123456", 16) == 0);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 16);
BH_IOFree(buffer);
BH_IOFree(io);
return 0;
}
BH_UNIT_TEST(Read)
{
BH_IO *buffer, *io;
char data[16];
char tmp[4];
size_t size;
memset(data, '1', 16);
BH_VERIFY((io = BH_BytesNew(data, 16, NULL)) != NULL);
BH_VERIFY((buffer = BH_BufferNew(io, 4, NULL)) != NULL);
BH_VERIFY(BH_IORead(buffer, tmp, 2, &size) == BH_OK);
BH_VERIFY(size == 2);
BH_VERIFY(memcmp(tmp, "11", 2) == 0);
memset(data, '2', 16);
BH_VERIFY(BH_IORead(buffer, tmp, 2, &size) == BH_OK);
BH_VERIFY(size == 2);
BH_VERIFY(memcmp(tmp, "11", 2) == 0);
BH_VERIFY(BH_IORead(buffer, tmp, 2, &size) == BH_OK);
BH_VERIFY(size == 2);
BH_VERIFY(memcmp(tmp, "22", 2) == 0);
BH_IOFree(buffer);
BH_IOFree(io);
return 0;
}
BH_UNIT_TEST(Reset)
{
BH_IO *buffer, *io, *previous;
char data[16];
char tmp[4];
size_t size;
memset(data, '1', 16);
BH_VERIFY((io = BH_BytesNew(data, 16, NULL)) != NULL);
BH_VERIFY((buffer = BH_BufferNew(io, 4, NULL)) != NULL);
BH_VERIFY(BH_IORead(buffer, tmp, 2, &size) == BH_OK);
BH_VERIFY(size == 2);
BH_VERIFY(memcmp(tmp, "11", 2) == 0);
memset(data, '2', 16);
BH_VERIFY(BH_IOCtl(buffer, BH_IO_CTL_GET_IO, &previous) == BH_OK);
BH_VERIFY(previous == io);
BH_VERIFY(BH_IOCtl(buffer, BH_IO_CTL_SET_IO, io) == BH_OK);
BH_VERIFY(BH_IORead(buffer, tmp, 2, &size) == BH_OK);
BH_VERIFY(size == 2);
BH_VERIFY(memcmp(tmp, "22", 2) == 0);
BH_IOFree(buffer);
BH_IOFree(io);
return 0;
}
int main(int argc,
char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(Null);
BH_UNIT_ADD(Write);
BH_UNIT_ADD(Read);
BH_UNIT_ADD(Reset);
return BH_UnitRun();
}

153
test/tests/TestBytes.c Normal file
View File

@@ -0,0 +1,153 @@
#include <BH/IO.h>
#include <BH/Unit.h>
#include <string.h>
BH_UNIT_TEST(Null)
{
char data;
BH_VERIFY(BH_BytesNew(NULL, 0, NULL) == NULL);
BH_VERIFY(BH_BytesNew(&data, 0, NULL) == NULL);
BH_VERIFY(BH_BytesNew(NULL, 1234, NULL) == NULL);
return 0;
}
BH_UNIT_TEST(Read)
{
BH_IO *io;
char buffer1[14] = "Hello, world!";
char buffer2[14];
size_t size;
BH_VERIFY((io = BH_BytesNew(buffer1, 14, NULL)) != NULL);
BH_VERIFY(BH_IORead(io, buffer2, 14, &size) == BH_OK);
BH_VERIFY(size == 14);
BH_VERIFY(memcmp(buffer1, buffer2, 14) == 0);
BH_VERIFY(BH_IOEndOfFile(io));
BH_VERIFY(BH_IORead(io, buffer2, 14, &size) == BH_OK);
BH_VERIFY(size == 0);
BH_VERIFY(BH_IOEndOfFile(io));
BH_IOFree(io);
return 0;
}
BH_UNIT_TEST(Write)
{
BH_IO *io;
char buffer[14];
size_t size;
BH_VERIFY((io = BH_BytesNew(buffer, 14, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "Hello, world!", 14, &size) == BH_OK);
BH_VERIFY(size == 14);
BH_VERIFY(memcmp(buffer, "Hello, world!", 14) == 0);
BH_VERIFY(BH_IOWrite(io, "Something", 10, &size) == BH_OK);
BH_VERIFY(size == 0);
BH_VERIFY(memcmp(buffer, "Hello, world!", 14) == 0);
BH_IOFree(io);
return 0;
}
BH_UNIT_TEST(SeekTell)
{
BH_IO *io;
char buffer[14] = "Hello, world!";
char symbol;
int64_t offset;
size_t size;
BH_VERIFY((io = BH_BytesNew(buffer, 14, NULL)) != NULL);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 0);
BH_VERIFY(BH_IORead(io, &symbol, 1, &size) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(size == 1);
BH_VERIFY(symbol == 'H');
BH_VERIFY(offset == 1);
BH_VERIFY(BH_IOSeek(io, 8, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 8);
BH_VERIFY(BH_IORead(io, &symbol, 1, &size) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(size == 1);
BH_VERIFY(symbol == 'o');
BH_VERIFY(offset == 9);
BH_VERIFY(BH_IOSeek(io, -1, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 8);
BH_VERIFY(BH_IORead(io, &symbol, 1, &size) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(size == 1);
BH_VERIFY(symbol == 'o');
BH_VERIFY(offset == 9);
BH_VERIFY(BH_IOSeek(io, -123456, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 0);
BH_VERIFY(BH_IORead(io, &symbol, 1, &size) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(size == 1);
BH_VERIFY(symbol == 'H');
BH_VERIFY(offset == 1);
BH_VERIFY(BH_IOSeek(io, 123456, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 14);
BH_VERIFY(BH_IORead(io, &symbol, 1, &size) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(size == 0);
BH_VERIFY(offset == 14);
BH_VERIFY(BH_IOSeek(io, -1, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 0);
BH_VERIFY(BH_IOSeek(io, 123456, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 14);
BH_VERIFY(BH_IOSeek(io, 123456, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 14);
BH_VERIFY(BH_IOSeek(io, -123456, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 0);
BH_VERIFY(BH_IOSeek(io, -2, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(BH_IOTell(io, &offset) == BH_OK);
BH_VERIFY(offset == 12);
BH_VERIFY(BH_IORead(io, &symbol, 1, &size) == BH_OK);
BH_VERIFY(size == 1);
BH_VERIFY(symbol == '!');
BH_IOFree(io);
return 0;
}
int main(int argc,
char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(Null);
BH_UNIT_ADD(Write);
BH_UNIT_ADD(Read);
BH_UNIT_ADD(SeekTell);
return BH_UnitRun();
}

59
test/tests/TestColor.c Normal file
View File

@@ -0,0 +1,59 @@
#include <BH/Color.h>
#include <BH/Unit.h>
BH_UNIT_TEST(RoundTrip)
{
BH_Color src, dest;
uint8_t r, g, b, a;
BH_ColorSetRGBA8(&src, 123, 210, 34, 50);
BH_ColorToHSLA(&src, &dest);
BH_ColorRGBA8(&dest, &r, &g, &b, &a);
BH_VERIFY(r == 123);
BH_VERIFY(g == 210);
BH_VERIFY(b == 34);
BH_VERIFY(a == 50);
BH_ColorToHSVA(&dest, &dest);
BH_ColorRGBA8(&dest, &r, &g, &b, &a);
BH_VERIFY(r == 123);
BH_VERIFY(g == 210);
BH_VERIFY(b == 34);
BH_VERIFY(a == 50);
BH_ColorToRGBA(&dest, &dest);
BH_ColorRGBA8(&dest, &r, &g, &b, &a);
BH_VERIFY(r == 123);
BH_VERIFY(g == 210);
BH_VERIFY(b == 34);
BH_VERIFY(a == 50);
BH_ColorToHSVA(&dest, &dest);
BH_ColorRGBA8(&dest, &r, &g, &b, &a);
BH_VERIFY(r == 123);
BH_VERIFY(g == 210);
BH_VERIFY(b == 34);
BH_VERIFY(a == 50);
BH_ColorToHSLA(&src, &dest);
BH_ColorRGBA8(&dest, &r, &g, &b, &a);
BH_VERIFY(r == 123);
BH_VERIFY(g == 210);
BH_VERIFY(b == 34);
BH_VERIFY(a == 50);
return 0;
}
int main(int argc, char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(RoundTrip);
return 0;
}

54
test/tests/TestCommon.c Normal file
View File

@@ -0,0 +1,54 @@
#include <BH/Unit.h>
#include <BH/Common.h>
BH_UNIT_TEST(UADD)
{
BH_VERIFY(!BH_CHECK_UADD_WRAP(100, 100, uint8_t));
BH_VERIFY(!BH_CHECK_UADD_WRAP(0, 0, uint8_t));
BH_VERIFY(BH_CHECK_UADD_WRAP(200, 100, uint8_t));
BH_VERIFY(BH_CHECK_UADD_WRAP(100, 200, uint8_t));
BH_VERIFY(BH_CHECK_UADD_WRAP(255, 1, uint8_t));
BH_VERIFY(BH_CHECK_UADD_WRAP(1, 255, uint8_t));
return 0;
}
BH_UNIT_TEST(USUB)
{
BH_VERIFY(!BH_CHECK_USUB_WRAP(100, 100, uint8_t));
BH_VERIFY(!BH_CHECK_USUB_WRAP(0, 0, uint8_t));
BH_VERIFY(!BH_CHECK_USUB_WRAP(200, 100, uint8_t));
BH_VERIFY(BH_CHECK_USUB_WRAP(100, 200, uint8_t));
BH_VERIFY(!BH_CHECK_USUB_WRAP(255, 1, uint8_t));
BH_VERIFY(BH_CHECK_USUB_WRAP(1, 255, uint8_t));
return 0;
}
BH_UNIT_TEST(UMUL)
{
BH_VERIFY(!BH_CHECK_UMUL_WRAP(0, 2, uint8_t));
BH_VERIFY(!BH_CHECK_UMUL_WRAP(100, 2, uint8_t));
BH_VERIFY(BH_CHECK_UMUL_WRAP(200, 100, uint8_t));
BH_VERIFY(BH_CHECK_UMUL_WRAP(100, 200, uint8_t));
BH_VERIFY(!BH_CHECK_UMUL_WRAP(255, 1, uint8_t));
BH_VERIFY(!BH_CHECK_UMUL_WRAP(1, 255, uint8_t));
return 0;
}
int main(int argc, char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(UADD);
BH_UNIT_ADD(USUB);
BH_UNIT_ADD(UMUL);
return BH_UnitRun();
}

69
test/tests/TestEndian.c Normal file
View File

@@ -0,0 +1,69 @@
#include <BH/Util.h>
#include <BH/Unit.h>
BH_UNIT_TEST(Int16)
{
char buffer[2];
BH_Write16LEs(buffer, -12345);
BH_VERIFY(BH_Read16LEs(buffer) == -12345);
BH_Write16BEs(buffer, BH_Read16BEs(buffer));
BH_VERIFY(BH_Read16LEs(buffer) == -12345);
BH_Write16LEu(buffer, 12345);
BH_VERIFY(BH_Read16LEu(buffer) == 12345);
BH_Write16BEu(buffer, BH_Read16BEu(buffer));
BH_VERIFY(BH_Read16LEu(buffer) == 12345);
return 0;
}
BH_UNIT_TEST(Int32)
{
char buffer[4];
BH_Write32LEs(buffer, -12345);
BH_VERIFY(BH_Read32LEs(buffer) == -12345);
BH_Write32BEs(buffer, BH_Read32BEs(buffer));
BH_VERIFY(BH_Read32LEs(buffer) == -12345);
BH_Write32LEu(buffer, 12345);
BH_VERIFY(BH_Read32LEu(buffer) == 12345);
BH_Write32BEu(buffer, BH_Read32BEu(buffer));
BH_VERIFY(BH_Read32LEu(buffer) == 12345);
return 0;
}
BH_UNIT_TEST(Int64)
{
char buffer[8];
BH_Write64LEs(buffer, -12345);
BH_VERIFY(BH_Read64LEs(buffer) == -12345);
BH_Write64BEs(buffer, BH_Read64BEs(buffer));
BH_VERIFY(BH_Read64LEs(buffer) == -12345);
BH_Write64LEu(buffer, 12345);
BH_VERIFY(BH_Read64LEu(buffer) == 12345);
BH_Write64BEu(buffer, BH_Read64BEu(buffer));
BH_VERIFY(BH_Read64LEu(buffer) == 12345);
return 0;
}
int main(int argc, char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(Int16);
BH_UNIT_ADD(Int32);
BH_UNIT_ADD(Int64);
return BH_UnitRun();
}

540
test/tests/TestFile.c Normal file
View File

@@ -0,0 +1,540 @@
#include <BH/IO.h>
#include <BH/Unit.h>
#include <string.h>
#define FILENAME1 "bhfile1.dat"
#define FILENAME2 "bhfile2.dat"
#define FILENAME3 "bhfile3.dat"
#define FILENAME4 "bhfile4.dat"
/**
* Cleanup any files, that could be left from previous test runs.
*/
static void cleanup(void)
{
remove(FILENAME1);
remove(FILENAME2);
remove(FILENAME3);
remove(FILENAME4);
}
/**
* Check for invalid arguments.
*/
static int checkNull(void)
{
/* Check against NULL pointers */
BH_VERIFY(BH_IORead(NULL, NULL, 0, NULL) != BH_OK);
BH_VERIFY(BH_IOWrite(NULL, NULL, 0, NULL) != BH_OK);
BH_VERIFY(BH_IOPeek(NULL, NULL, 0, NULL) != BH_OK);
BH_VERIFY(BH_IOTell(NULL, NULL) != BH_OK);
BH_VERIFY(BH_IOSeek(NULL, 0, 0) != BH_OK);
BH_VERIFY(BH_IOFlush(NULL) != BH_OK);
BH_VERIFY(BH_IOSize(NULL, NULL) != BH_OK);
BH_VERIFY(BH_IOFlags(NULL, NULL) != BH_OK);
BH_VERIFY(BH_IOClear(NULL) != BH_OK);
BH_VERIFY(BH_IOCtl(NULL, 0, NULL) != BH_OK);
BH_VERIFY(BH_IOCap(NULL, 0) != BH_OK);
BH_VERIFY(BH_IOEndOfFile(NULL) != BH_OK);
BH_VERIFY(BH_IOError(NULL) != BH_OK);
BH_IOFree(NULL);
return 0;
}
/**
* Check for normal mode.
*/
static int checkNormal(void)
{
int64_t position;
char buffer[128];
size_t actual;
BH_IO *io;
/* Check operations for write only access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_WRITE, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOSeek(io, 10, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 1, &actual) != BH_OK);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(BH_IOTell(io, &position) == BH_OK);
BH_VERIFY(position == 20);
BH_IOFree(io);
/* Check operations for read only access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READ, NULL)) != NULL);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "abcde", 5) == 0);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, sizeof(buffer), &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(memcmp(buffer, "1234567890abcde67890", 20) == 0);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) != BH_OK);
BH_VERIFY(BH_IOSeek(io, -5, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "67890", 5) == 0);
BH_IOFree(io);
/* Check operations for read and write access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READWRITE, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOWrite(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "abcde", 5) == 0);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 35, &actual) == BH_OK);
BH_VERIFY(actual == 35);
BH_VERIFY(memcmp(buffer, "abcde12345678901234567890abcde67890", 35) == 0);
BH_IOFree(io);
return 0;
}
/**
* Check for truncate mode.
*/
static int checkTruncate(void)
{
int64_t position;
char buffer[128];
size_t actual;
BH_IO *io;
/* Check operations for write only access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_WRITE | BH_FILE_TRUNCATE, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOSeek(io, 10, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 1, &actual) != BH_OK);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(BH_IOTell(io, &position) == BH_OK);
BH_VERIFY(position == 20);
BH_IOFree(io);
/* Check operations for read only access without truncate */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READ, NULL)) != NULL);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "abcde", 5) == 0);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, sizeof(buffer), &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(memcmp(buffer, "1234567890abcde67890", 20) == 0);
BH_VERIFY(BH_IOSeek(io, -5, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "67890", 5) == 0);
BH_IOFree(io);
/* Check operations for read only access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READ | BH_FILE_TRUNCATE, NULL)) != NULL);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 0);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 0);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) != BH_OK);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, sizeof(buffer), &actual) == BH_OK);
BH_VERIFY(actual == 0);
BH_IOFree(io);
/* Check operations for read and write access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READWRITE | BH_FILE_TRUNCATE, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOWrite(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "abcde", 5) == 0);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 35, &actual) == BH_OK);
BH_VERIFY(actual == 35);
BH_VERIFY(memcmp(buffer, "abcde12345678901234567890abcde67890", 35) == 0);
BH_IOFree(io);
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_WRITE | BH_FILE_TRUNCATE, NULL)) != NULL);
BH_IOFree(io);
return 0;
}
/**
* Check for exist mode.
*/
static int checkExist(void)
{
int64_t position;
char buffer[128];
size_t actual;
BH_IO *io;
/* Check operations for write only access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_WRITE | BH_FILE_EXIST, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOSeek(io, 10, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 1, &actual) != BH_OK);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(BH_IOTell(io, &position) == BH_OK);
BH_VERIFY(position == 20);
BH_IOFree(io);
/* Check operations for read only access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READ | BH_FILE_EXIST, NULL)) != NULL);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "abcde", 5) == 0);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, sizeof(buffer), &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(memcmp(buffer, "1234567890abcde67890", 20) == 0);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) != BH_OK);
BH_VERIFY(BH_IOSeek(io, -5, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "67890", 5) == 0);
BH_IOFree(io);
/* Check operations for read and write access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_WRITE | BH_FILE_READ | BH_FILE_EXIST, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOWrite(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "abcde", 5) == 0);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 35, &actual) == BH_OK);
BH_VERIFY(actual == 35);
BH_VERIFY(memcmp(buffer, "abcde12345678901234567890abcde67890", 35) == 0);
BH_IOFree(io);
/* Check against non existing files */
BH_VERIFY(BH_FileNew(FILENAME2, BH_FILE_WRITE | BH_FILE_EXIST, NULL) == NULL);
BH_VERIFY(BH_FileNew(FILENAME2, BH_FILE_READ | BH_FILE_EXIST, NULL) == NULL);
BH_VERIFY(BH_FileNew(FILENAME2, BH_FILE_READWRITE | BH_FILE_EXIST, NULL) == NULL);
return 0;
}
/**
* Check in append mode.
*/
static int checkAppend(void)
{
int64_t position;
char buffer[128];
size_t actual;
BH_IO *io;
/* Explicitly call cleanup */
cleanup();
/* Check operations for write only access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_WRITE | BH_FILE_APPEND, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOSeek(io, 10, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 1, &actual) != BH_OK);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(BH_IOTell(io, &position) == BH_OK);
BH_VERIFY(position == 25);
BH_IOFree(io);
/* Check operations for read only access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READ | BH_FILE_APPEND, NULL)) != NULL);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "abcde", 5) == 0);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) != BH_OK);
BH_VERIFY(BH_IOSeek(io, -5, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(memcmp(buffer, "abcde", 5) == 0);
BH_IOFree(io);
/* Check operations for read and write access */
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READWRITE | BH_FILE_APPEND, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 40, &actual) == BH_OK);
BH_VERIFY(actual == 40);
BH_VERIFY(memcmp(buffer, "12345678901234567890abcdeabcde1234567890", 40) == 0);
BH_IOFree(io);
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_WRITE | BH_FILE_TRUNCATE, NULL)) != NULL);
BH_IOFree(io);
return 0;
}
/**
* Check for create mode.
*/
static int checkCreate(void)
{
BH_IO *io;
/* Check for already existing file */
BH_VERIFY(BH_FileNew(FILENAME1, BH_FILE_WRITE | BH_FILE_CREATE, NULL) == NULL);
/* Check for new file with write access */
BH_VERIFY((io = BH_FileNew(FILENAME2, BH_FILE_WRITE | BH_FILE_CREATE, NULL)) != NULL);
BH_IOFree(io);
/* Check for new file with read access */
BH_VERIFY((io = BH_FileNew(FILENAME3, BH_FILE_READ | BH_FILE_CREATE, NULL)) != NULL);
BH_IOFree(io);
/* Check for new file with read/write access */
BH_VERIFY((io = BH_FileNew(FILENAME4, BH_FILE_READWRITE | BH_FILE_CREATE, NULL)) != NULL);
BH_IOFree(io);
return 0;
}
/**
* Check for EOF flags.
*/
static int checkEOF(void)
{
char buffer[128];
size_t actual;
BH_IO *io;
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READ | BH_FILE_TRUNCATE, NULL)) != NULL);
BH_VERIFY(BH_IORead(io, buffer, 128, &actual) == BH_OK);
BH_VERIFY(actual == 0);
BH_VERIFY(BH_IOEndOfFile(io));
BH_IOFree(io);
return 0;
}
/**
* Check for error flags.
*/
static int checkError(void)
{
size_t actual;
BH_IO *io;
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READ, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "12345", 5, &actual) != BH_OK);
BH_VERIFY(BH_IOError(io) != BH_OK);
BH_VERIFY(BH_IOClear(io) == BH_OK);
BH_VERIFY(BH_IOError(io) == BH_OK);
BH_IOFree(io);
return 0;
}
/**
* Check peek operation.
*/
static int checkPeek(void)
{
int64_t previous, current;
char buffer[128];
size_t actual;
BH_IO *io;
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READWRITE | BH_FILE_TRUNCATE, NULL)) != NULL);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOTell(io, &previous) == BH_OK);
BH_VERIFY(BH_IOPeek(io, buffer, 128, &actual) == BH_OK);
BH_VERIFY(BH_IOTell(io, &current) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(memcmp(buffer, "12345678901234567890", 20) == 0);
BH_VERIFY(previous == current);
BH_VERIFY(BH_IOSeek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(BH_IOTell(io, &previous) == BH_OK);
BH_VERIFY(BH_IOPeek(io, buffer, 128, &actual) == BH_OK);
BH_VERIFY(BH_IOTell(io, &current) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(memcmp(buffer, "12345678901234567890", 20) == 0);
BH_VERIFY(previous == current);
BH_IOFree(io);
return 0;
}
/**
* Check file size operation.
*/
static int checkSize(void)
{
BH_IO *io;
int64_t size;
BH_VERIFY((io = BH_FileNew(FILENAME1, BH_FILE_READ, NULL)) != NULL);
BH_VERIFY(BH_IOSize(io, &size) == BH_OK);
BH_VERIFY(size == 20);
BH_IOFree(io);
return 0;
}
int main(int argc,
char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
/* Cleanup */
cleanup();
BH_UnitAdd("Null", checkNull);
BH_UnitAdd("Normal", checkNormal);
BH_UnitAdd("Truncate", checkTruncate);
BH_UnitAdd("Exist", checkExist);
BH_UnitAdd("Append", checkAppend);
BH_UnitAdd("Create", checkCreate);
BH_UnitAdd("EOF", checkEOF);
BH_UnitAdd("Error", checkError);
BH_UnitAdd("Peek", checkPeek);
BH_UnitAdd("Size", checkSize);
return BH_UnitRun();
}

364
test/tests/TestFloat.c Normal file
View File

@@ -0,0 +1,364 @@
#include <BH/String.h>
#include <BH/Util.h>
#include <BH/Unit.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
static int compareString(double value,
int format,
int precision,
const char *ref)
{
char str[2000];
int result;
BH_VERIFY(BH_StringFromDouble(str, 2000, value, format, precision, NULL) == BH_OK);
result = strcmp(str, ref);
if (result)
printf("Value: %.17g\tReference: %s\tGot: %s\n", value, ref, str);
return result;
}
static int roundtripString(double value,
int format)
{
double result;
char str[2000];
BH_VERIFY(BH_StringFromDouble(str, 2000, value, format, -1, NULL) == BH_OK);
result = BH_StringToDouble(str, NULL);
if (result != value)
printf("Value: %.17g\tGot: %.17g\tStr: %s\n", value, result, str);
return result != value;
}
BH_UNIT_TEST(FixedFormat)
{
BH_VERIFY(compareString(30.0159265358979323846, 'f', 0, "30") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'f', 1, "30.0") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'f', 2, "30.02") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'f', 3, "30.016") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'f', 4, "30.0159") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'f', 5, "30.01593") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'f', 0, "-30") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'f', 1, "-30.0") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'f', 2, "-30.02") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'f', 3, "-30.016") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'f', 4, "-30.0159") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'f', 5, "-30.01593") == 0);
BH_VERIFY(compareString(0.0, 'f', 0, "0") == 0);
BH_VERIFY(compareString(0.0, 'f', 1, "0.0") == 0);
BH_VERIFY(compareString(-0.0, 'f', 0, "-0") == 0);
BH_VERIFY(compareString(-0.0, 'f', 1, "-0.0") == 0);
BH_VERIFY(compareString(0.00015425, 'f', 0, "0") == 0);
BH_VERIFY(compareString(0.00015425, 'f', 1, "0.0") == 0);
BH_VERIFY(compareString(0.00015425, 'f', 2, "0.00") == 0);
BH_VERIFY(compareString(0.00015425, 'f', 3, "0.000") == 0);
BH_VERIFY(compareString(0.00015425, 'f', 4, "0.0002") == 0);
BH_VERIFY(compareString(0.00015425, 'f', 5, "0.00015") == 0);
BH_VERIFY(compareString(-0.00015425, 'f', 0, "-0") == 0);
BH_VERIFY(compareString(-0.00015425, 'f', 1, "-0.0") == 0);
BH_VERIFY(compareString(-0.00015425, 'f', 2, "-0.00") == 0);
BH_VERIFY(compareString(-0.00015425, 'f', 3, "-0.000") == 0);
BH_VERIFY(compareString(-0.00015425, 'f', 4, "-0.0002") == 0);
BH_VERIFY(compareString(-0.00015425, 'f', 5, "-0.00015") == 0);
BH_VERIFY(compareString(1234567.1234, 'f', 0, "1234567") == 0);
BH_VERIFY(compareString(-1234567.1234, 'f', 0, "-1234567") == 0);
BH_VERIFY(compareString(1230000000.00123, 'f', 0, "1230000000") == 0);
BH_VERIFY(compareString(1230000000.00123, 'f', 1, "1230000000.0") == 0);
BH_VERIFY(compareString(1230000000.00123, 'f', 2, "1230000000.00") == 0);
BH_VERIFY(compareString(1230000000.00123, 'f', 3, "1230000000.001") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'f', 0, "-1230000000") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'f', 1, "-1230000000.0") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'f', 2, "-1230000000.00") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'f', 3, "-1230000000.001") == 0);
return 0;
}
BH_UNIT_TEST(FixedRoundTrip)
{
BH_VERIFY(roundtripString(1.0, 'f') == 0);
BH_VERIFY(roundtripString(-1.0, 'f') == 0);
BH_VERIFY(roundtripString(0.0, 'f') == 0);
BH_VERIFY(roundtripString(-0.0, 'f') == 0);
BH_VERIFY(roundtripString(3.14159, 'f') == 0);
BH_VERIFY(roundtripString(-3.14159, 'f') == 0);
BH_VERIFY(roundtripString(123000000.0, 'f') == 0);
BH_VERIFY(roundtripString(-123000000.0, 'f') == 0);
BH_VERIFY(roundtripString(0.81, 'f') == 0);
BH_VERIFY(roundtripString(-0.81, 'f') == 0);
BH_VERIFY(roundtripString(0.81, 'f') == 0);
BH_VERIFY(roundtripString(-0.81, 'f') == 0);
BH_VERIFY(roundtripString(144115188075855877.0, 'f') == 0);
BH_VERIFY(roundtripString(-144115188075855877.0, 'f') == 0);
BH_VERIFY(roundtripString(DBL_MIN, 'f') == 0);
BH_VERIFY(roundtripString(-DBL_MIN, 'f') == 0);
BH_VERIFY(roundtripString(DBL_MAX, 'f') == 0);
BH_VERIFY(roundtripString(-DBL_MAX, 'f') == 0);
return 0;
}
BH_UNIT_TEST(ScientificFormat)
{
BH_VERIFY(compareString(30.0159265358979323846, 'e', 0, "3e+01") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'e', 1, "3.0e+01") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'e', 2, "3.00e+01") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'e', 3, "3.002e+01") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'e', 4, "3.0016e+01") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'e', 5, "3.00159e+01") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'e', 0, "-3e+01") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'e', 1, "-3.0e+01") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'e', 2, "-3.00e+01") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'e', 3, "-3.002e+01") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'e', 4, "-3.0016e+01") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'e', 5, "-3.00159e+01") == 0);
BH_VERIFY(compareString(0.0, 'e', 0, "0e+00") == 0);
BH_VERIFY(compareString(0.0, 'e', 1, "0.0e+00") == 0);
BH_VERIFY(compareString(-0.0, 'e', 0, "-0e+00") == 0);
BH_VERIFY(compareString(-0.0, 'e', 1, "-0.0e+00") == 0);
BH_VERIFY(compareString(0.00015425, 'e', 0, "2e-04") == 0);
BH_VERIFY(compareString(0.00015425, 'e', 1, "1.5e-04") == 0);
BH_VERIFY(compareString(0.00015425, 'e', 2, "1.54e-04") == 0);
BH_VERIFY(compareString(0.00015425, 'e', 3, "1.543e-04") == 0);
BH_VERIFY(compareString(0.00015425, 'e', 4, "1.5425e-04") == 0);
BH_VERIFY(compareString(0.00015425, 'e', 5, "1.54250e-04") == 0);
BH_VERIFY(compareString(-0.00015425, 'e', 0, "-2e-04") == 0);
BH_VERIFY(compareString(-0.00015425, 'e', 1, "-1.5e-04") == 0);
BH_VERIFY(compareString(-0.00015425, 'e', 2, "-1.54e-04") == 0);
BH_VERIFY(compareString(-0.00015425, 'e', 3, "-1.543e-04") == 0);
BH_VERIFY(compareString(-0.00015425, 'e', 4, "-1.5425e-04") == 0);
BH_VERIFY(compareString(-0.00015425, 'e', 5, "-1.54250e-04") == 0);
BH_VERIFY(compareString(1234567.1234, 'e', 0, "1e+06") == 0);
BH_VERIFY(compareString(-1234567.1234, 'e', 0, "-1e+06") == 0);
BH_VERIFY(compareString(1230000000.00123, 'e', 0, "1e+09") == 0);
BH_VERIFY(compareString(1230000000.00123, 'e', 1, "1.2e+09") == 0);
BH_VERIFY(compareString(1230000000.00123, 'e', 2, "1.23e+09") == 0);
BH_VERIFY(compareString(1230000000.00123, 'e', 3, "1.230e+09") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'e', 0, "-1e+09") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'e', 1, "-1.2e+09") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'e', 2, "-1.23e+09") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'e', 3, "-1.230e+09") == 0);
return 0;
}
BH_UNIT_TEST(ShortestFormat)
{
BH_VERIFY(compareString(30.0159265358979323846, 'g', 0, "3e+01") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'g', 1, "3e+01") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'g', 2, "30") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'g', 3, "30") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'g', 4, "30.02") == 0);
BH_VERIFY(compareString(30.0159265358979323846, 'g', 5, "30.016") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'g', 0, "-3e+01") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'g', 1, "-3e+01") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'g', 2, "-30") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'g', 3, "-30") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'g', 4, "-30.02") == 0);
BH_VERIFY(compareString(-30.0159265358979323846, 'g', 5, "-30.016") == 0);
BH_VERIFY(compareString(0.0, 'g', 0, "0") == 0);
BH_VERIFY(compareString(0.0, 'g', 1, "0") == 0);
BH_VERIFY(compareString(-0.0, 'g', 0, "-0") == 0);
BH_VERIFY(compareString(-0.0, 'g', 1, "-0") == 0);
BH_VERIFY(compareString(0.00015425, 'g', 0, "0.0002") == 0);
BH_VERIFY(compareString(0.00015425, 'g', 1, "0.0002") == 0);
BH_VERIFY(compareString(0.00015425, 'g', 2, "0.00015") == 0);
BH_VERIFY(compareString(0.00015425, 'g', 3, "0.000154") == 0);
BH_VERIFY(compareString(0.00015425, 'g', 4, "0.0001543") == 0);
BH_VERIFY(compareString(0.00015425, 'g', 5, "0.00015425") == 0);
BH_VERIFY(compareString(-0.00015425, 'g', 0, "-0.0002") == 0);
BH_VERIFY(compareString(-0.00015425, 'g', 1, "-0.0002") == 0);
BH_VERIFY(compareString(-0.00015425, 'g', 2, "-0.00015") == 0);
BH_VERIFY(compareString(-0.00015425, 'g', 3, "-0.000154") == 0);
BH_VERIFY(compareString(-0.00015425, 'g', 4, "-0.0001543") == 0);
BH_VERIFY(compareString(-0.00015425, 'g', 5, "-0.00015425") == 0);
BH_VERIFY(compareString(1234567.1234, 'g', 0, "1e+06") == 0);
BH_VERIFY(compareString(-1234567.1234, 'g', 0, "-1e+06") == 0);
BH_VERIFY(compareString(1230000000.00123, 'g', 0, "1e+09") == 0);
BH_VERIFY(compareString(1230000000.00123, 'g', 1, "1e+09") == 0);
BH_VERIFY(compareString(1230000000.00123, 'g', 2, "1.2e+09") == 0);
BH_VERIFY(compareString(1230000000.00123, 'g', 3, "1.23e+09") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'g', 0, "-1e+09") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'g', 1, "-1e+09") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'g', 2, "-1.2e+09") == 0);
BH_VERIFY(compareString(-1230000000.00123, 'g', 3, "-1.23e+09") == 0);
BH_VERIFY(compareString(144115188075855877.0, 'g', 17, "1.4411518807585587e+17") == 0);
BH_VERIFY(compareString(-144115188075855877.0, 'g', 17, "-1.4411518807585587e+17") == 0);
return 0;
}
BH_UNIT_TEST(ScientificRoundTrip)
{
BH_VERIFY(roundtripString(1.0, 'e') == 0);
BH_VERIFY(roundtripString(-1.0, 'e') == 0);
BH_VERIFY(roundtripString(0.0, 'e') == 0);
BH_VERIFY(roundtripString(-0.0, 'e') == 0);
BH_VERIFY(roundtripString(3.14159, 'e') == 0);
BH_VERIFY(roundtripString(-3.14159, 'e') == 0);
BH_VERIFY(roundtripString(123000000.0, 'e') == 0);
BH_VERIFY(roundtripString(-123000000.0, 'e') == 0);
BH_VERIFY(roundtripString(0.81, 'e') == 0);
BH_VERIFY(roundtripString(-0.81, 'e') == 0);
BH_VERIFY(roundtripString(0.81, 'e') == 0);
BH_VERIFY(roundtripString(-0.81, 'e') == 0);
BH_VERIFY(roundtripString(144115188075855877.0, 'e') == 0);
BH_VERIFY(roundtripString(-144115188075855877.0, 'e') == 0);
BH_VERIFY(roundtripString(DBL_MIN, 'e') == 0);
BH_VERIFY(roundtripString(-DBL_MIN, 'e') == 0);
BH_VERIFY(roundtripString(DBL_MAX, 'e') == 0);
BH_VERIFY(roundtripString(-DBL_MAX, 'e') == 0);
return 0;
}
BH_UNIT_TEST(ShortestRoundTrip)
{
BH_VERIFY(roundtripString(1.0, 'g') == 0);
BH_VERIFY(roundtripString(-1.0, 'g') == 0);
BH_VERIFY(roundtripString(0.0, 'g') == 0);
BH_VERIFY(roundtripString(-0.0, 'g') == 0);
BH_VERIFY(roundtripString(3.14159, 'g') == 0);
BH_VERIFY(roundtripString(-3.14159, 'g') == 0);
BH_VERIFY(roundtripString(123000000.0, 'g') == 0);
BH_VERIFY(roundtripString(-123000000.0, 'g') == 0);
BH_VERIFY(roundtripString(0.81, 'g') == 0);
BH_VERIFY(roundtripString(-0.81, 'g') == 0);
BH_VERIFY(roundtripString(0.81, 'g') == 0);
BH_VERIFY(roundtripString(-0.81, 'g') == 0);
BH_VERIFY(roundtripString(144115188075855877.0, 'g') == 0);
BH_VERIFY(roundtripString(-144115188075855877.0, 'g') == 0);
BH_VERIFY(roundtripString(DBL_MIN, 'g') == 0);
BH_VERIFY(roundtripString(-DBL_MIN, 'g') == 0);
BH_VERIFY(roundtripString(DBL_MAX, 'g') == 0);
BH_VERIFY(roundtripString(-DBL_MAX, 'g') == 0);
return 0;
}
BH_UNIT_TEST(Parity)
{
char buffer[2000], output[2000];
uint64_t frac;
double value;
int i, j, k;
for (i = 0; i < 100; i++)
{
frac = (rand() & 0x7FFF);
frac = (frac << 15) | (rand() & 0x7FFF);
frac = (frac << 15) | (rand() & 0x7FFF);
frac = (frac << 15) | (rand() & 0x7FFF);
for (j = 0; j < 100; j++)
{
value = frac * pow(2, (rand() % 2046) - 1024);
for (k = 0; k < 18; k++)
{
sprintf(buffer, "%%.%dg", k);
sprintf(output, buffer, value);
BH_VERIFY(BH_StringFromDouble(buffer, 2000, value, 'g', k, NULL) == BH_OK);
if (strcmp(buffer, output))
{
printf("(%.17g) (%d) %s vs %s\n", value, k, buffer, output);
BH_FAIL("Strings aren't equal");
}
}
}
}
return 0;
}
BH_UNIT_TEST(ToDouble)
{
size_t size;
BH_VERIFY(BH_ClassifyDouble(BH_StringToDouble(" INFa ", &size)) == BH_FP_INFINITE);
BH_VERIFY(size == 5);
BH_VERIFY(BH_ClassifyDouble(BH_StringToDouble(" INFINITYc ", &size)) == BH_FP_INFINITE);
BH_VERIFY(size == 10);
BH_VERIFY(BH_ClassifyDouble(BH_StringToDouble(" -INFb ", &size)) == (BH_FP_INFINITE | BH_FP_NEGATIVE));
BH_VERIFY(size == 6);
BH_VERIFY(BH_ClassifyDouble(BH_StringToDouble(" -INFINITYd ", &size)) == (BH_FP_INFINITE | BH_FP_NEGATIVE));
BH_VERIFY(size == 11);
BH_VERIFY(BH_ClassifyDouble(BH_StringToDouble(" NANe ", &size)) == BH_FP_NAN);
BH_VERIFY(size == 5);
BH_VERIFY_DELTA(BH_StringToDouble(" 1234.0312f ", &size), 1234.0312, 0.00001);
BH_VERIFY(size == 11);
BH_VERIFY_DELTA(BH_StringToDouble(" 3.14159g ", &size), 3.14159, 0.00001);
BH_VERIFY(size == 9);
BH_VERIFY(BH_StringToDouble(" h ", &size) == 0.0);
BH_VERIFY(size == 0);
BH_VERIFY(BH_StringToDouble(" 0 ", &size) == 0.0);
BH_VERIFY(size == 3);
BH_VERIFY(BH_StringToDouble(" 0.0 ", &size) == 0.0);
BH_VERIFY(size == 5);
BH_VERIFY(BH_StringToDouble(" 0. ", &size) == 0.0);
BH_VERIFY(size == 4);
BH_VERIFY(BH_StringToDouble(" .0 ", &size) == 0.0);
BH_VERIFY(size == 4);
BH_VERIFY(BH_StringToDouble(" .Hello ", &size) == 0.0);
BH_VERIFY(size == 0);
BH_VERIFY(BH_StringToDouble(" .E12 ", &size) == 0.0);
BH_VERIFY(size == 0);
return 0;
}
int main(int argc, char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(FixedFormat);
BH_UNIT_ADD(FixedRoundTrip);
BH_UNIT_ADD(ScientificFormat);
BH_UNIT_ADD(ScientificRoundTrip);
BH_UNIT_ADD(ShortestFormat);
BH_UNIT_ADD(ShortestRoundTrip);
BH_UNIT_ADD(Parity);
BH_UNIT_ADD(ToDouble);
return BH_UnitRun();
}

240
test/tests/TestHashmap.c Normal file
View File

@@ -0,0 +1,240 @@
#include <BH/Hashmap.h>
#include <BH/Unit.h>
static size_t DBG_PtrIntHash(const void *ptr)
{
return BH_PTR2INT(ptr);
}
static int DBG_PtrIntEqual(const void *lhs, const void *rhs)
{
return BH_PTR2INT(lhs) - BH_PTR2INT(rhs);
}
static int NewFree(void)
{
BH_Hashmap *hashmap;
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
BH_VERIFY(BH_HashmapEmpty(hashmap) != 0);
BH_VERIFY(BH_HashmapSize(hashmap) == 0);
BH_VERIFY(BH_HashmapCapacity(hashmap) == 0);
BH_VERIFY(BH_HashmapFactor(hashmap) >= 0.15f);
BH_VERIFY(BH_HashmapFactor(hashmap) <= 1.0f);
BH_HashmapFree(hashmap);
return 0;
}
static int GrowShrink(void)
{
BH_Hashmap *hashmap;
void *iter;
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
/* Allocate space for 1024 entries and insert 1 element */
BH_VERIFY(BH_HashmapReserve(hashmap, 1024) == 0);
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR(1337), BH_INT2PTR(80085)) == 0);
/* Check hashmap contents */
iter = BH_HashmapIterNext(hashmap, NULL);
BH_VERIFY(iter != NULL);
BH_VERIFY(BH_PTR2INT(BH_HashmapIterKey(iter)) == 1337);
BH_VERIFY(BH_PTR2INT(BH_HashmapIterValue(iter)) == 80085);
BH_VERIFY(BH_HashmapIterNext(hashmap, iter) == NULL);
BH_VERIFY(BH_HashmapEmpty(hashmap) == 0);
BH_VERIFY(BH_HashmapSize(hashmap) == 1);
BH_VERIFY(BH_HashmapCapacity(hashmap) >= 1024);
/* Change factor and grow */
BH_HashmapSetFactor(hashmap, 0.35f);
/* Check hashmap contents */
iter = BH_HashmapIterNext(hashmap, NULL);
BH_VERIFY(iter != NULL);
BH_VERIFY(BH_PTR2INT(BH_HashmapIterKey(iter)) == 1337);
BH_VERIFY(BH_PTR2INT(BH_HashmapIterValue(iter)) == 80085);
BH_VERIFY(BH_HashmapIterNext(hashmap, iter) == NULL);
BH_VERIFY(BH_HashmapReserve(hashmap, 8192) == 0);
BH_VERIFY(BH_HashmapEmpty(hashmap) == 0);
BH_VERIFY(BH_HashmapSize(hashmap) == 1);
BH_VERIFY(BH_HashmapCapacity(hashmap) >= 8192);
BH_VERIFY_DELTA(BH_HashmapFactor(hashmap), 0.35f, 0.001f);
/* Shrink */
BH_VERIFY(BH_HashmapReserve(hashmap, 0) == 0);
/* Check hashmap contents */
iter = BH_HashmapIterNext(hashmap, NULL);
BH_VERIFY(iter != NULL);
BH_VERIFY(BH_PTR2INT(BH_HashmapIterKey(iter)) == 1337);
BH_VERIFY(BH_PTR2INT(BH_HashmapIterValue(iter)) == 80085);
BH_VERIFY(BH_HashmapIterNext(hashmap, iter) == NULL);
BH_VERIFY(BH_HashmapEmpty(hashmap) == 0);
BH_VERIFY(BH_HashmapSize(hashmap) == 1);
BH_VERIFY(BH_HashmapCapacity(hashmap) >= 1);
BH_VERIFY(BH_HashmapCapacity(hashmap) < 8192);
BH_VERIFY_DELTA(BH_HashmapFactor(hashmap), 0.35f, 0.001f);
/* Shrink to 0 (deallocate) */
BH_HashmapClear(hashmap);
BH_VERIFY(BH_HashmapEmpty(hashmap) != 0);
BH_VERIFY(BH_HashmapSize(hashmap) == 0);
BH_VERIFY(BH_HashmapCapacity(hashmap) > 0);
BH_VERIFY(BH_HashmapReserve(hashmap, 0) == 0);
BH_VERIFY(BH_HashmapEmpty(hashmap) != 0);
BH_VERIFY(BH_HashmapSize(hashmap) == 0);
BH_VERIFY(BH_HashmapCapacity(hashmap) == 0);
/* Check hashmap contents */
iter = BH_HashmapIterNext(hashmap, NULL);
BH_VERIFY(iter == NULL);
BH_HashmapFree(hashmap);
return 0;
}
static int InsertRemove(void)
{
BH_Hashmap *hashmap;
size_t i, added, removed;
void *iter;
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
BH_HashmapSetFactor(hashmap, 1.0f);
/* Insert elements into hashmap */
added = 0;
for (i = 1024; i > 0; i--)
{
added += (i - 1) / 4;
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR((i - 1) / 4), BH_INT2PTR(i)) == 0);
}
/* Remove elements */
iter = BH_HashmapIterNext(hashmap, NULL);
removed = 0;
while (iter)
{
removed += BH_PTR2INT(BH_HashmapIterKey(iter));
BH_HashmapIterRemove(hashmap, iter);
iter = BH_HashmapIterNext(hashmap, NULL);
}
/* Check inserted elements are equal to removed */
BH_VERIFY(added == removed);
BH_HashmapFree(hashmap);
return 0;
}
static int Lookup(void)
{
BH_Hashmap *hashmap;
size_t i;
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
/* Insert elements into hashmap */
for (i = 0; i < 256; i++)
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR(i * 4), BH_INT2PTR(i)) == 0);
/* Lookup inserted elements */
for (i = 0; i < 256; i++)
{
void *value;
BH_VERIFY(BH_HashmapAt(hashmap, BH_INT2PTR(i * 4), NULL) == BH_OK);
BH_VERIFY(BH_HashmapAt(hashmap, BH_INT2PTR(i * 4), &value) == BH_OK);
BH_VERIFY(BH_PTR2INT(value) == (int)i);
}
/* Lookup non-existing elements */
for (i = 256; i < 512; i++)
{
void *value;
BH_VERIFY(BH_HashmapAt(hashmap, BH_INT2PTR(i * 4), NULL) != BH_OK);
BH_VERIFY(BH_HashmapAt(hashmap, BH_INT2PTR(i * 4), &value) != BH_OK);
}
BH_HashmapFree(hashmap);
return 0;
}
static int Clear(void)
{
BH_Hashmap *hashmap;
size_t i;
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
/* Insert elements into hashmap */
for (i = 0; i < 128; i++)
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR(i), 0) == 0);
BH_HashmapClear(hashmap);
/* Remove non-existing elements */
for (i = 0; i < 128; i++)
BH_HashmapRemove(hashmap, BH_INT2PTR(i));
BH_HashmapFree(hashmap);
return 0;
}
static int Fields(void)
{
BH_Hashmap *hashmap;
size_t i;
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
BH_VERIFY(BH_HashmapEmpty(hashmap) == 1);
/* Insert elements into hashmap */
for (i = 0; i < 14; i++)
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR(i), NULL) == 0);
/* Check hashmap fields correspond to getter functions */
BH_VERIFY(BH_HashmapSize(hashmap) == 14);
BH_VERIFY(BH_HashmapCapacity(hashmap) >= 14);
BH_VERIFY(BH_HashmapEmpty(hashmap) == 0);
BH_HashmapFree(hashmap);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
/* Add unit tests */
BH_UnitAdd("NewFree", NewFree);
BH_UnitAdd("GrowShrink", GrowShrink);
BH_UnitAdd("InsertRemove", InsertRemove);
BH_UnitAdd("Lookup", Lookup);
BH_UnitAdd("Clear", Clear);
BH_UnitAdd("Fields", Fields);
return BH_UnitRun();
}

177
test/tests/TestInt.c Normal file
View File

@@ -0,0 +1,177 @@
#include <BH/String.h>
#include <BH/Unit.h>
BH_UNIT_TEST(Int8)
{
char str[9];
size_t size;
BH_VERIFY(BH_StringFromInt8s(str, 9, -13, 16, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt8s(str, &size, 16) == -13);
BH_VERIFY(size == 2);
BH_VERIFY(BH_StringFromInt8s(str, 9, -13, 10, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt8s(str, &size, 10) == -13);
BH_VERIFY(size == 3);
BH_VERIFY(BH_StringFromInt8s(str, 9, -13, 8, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt8s(str, &size, 8) == -13);
BH_VERIFY(size == 3);
BH_VERIFY(BH_StringFromInt8s(str, 9, -13, 2, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt8s(str, &size, 2) == -13);
BH_VERIFY(size == 5);
BH_VERIFY(BH_StringFromInt8u(str, 9, 200, 16, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt8u(str, &size, 16) == 200);
BH_VERIFY(size == 2);
BH_VERIFY(BH_StringFromInt8u(str, 9, 200, 10, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt8u(str, &size, 10) == 200);
BH_VERIFY(size == 3);
BH_VERIFY(BH_StringFromInt8u(str, 9, 200, 8, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt8u(str, &size, 8) == 200);
BH_VERIFY(size == 3);
BH_VERIFY(BH_StringFromInt8u(str, 9, 200, 2, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt8u(str, &size, 2) == 200);
BH_VERIFY(size == 8);
return 0;
}
BH_UNIT_TEST(Int16)
{
char str[17];
size_t size;
BH_VERIFY(BH_StringFromInt16s(str, 17, -1234, 16, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt16s(str, &size, 16) == -1234);
BH_VERIFY(size == 4);
BH_VERIFY(BH_StringFromInt16s(str, 17, -1234, 10, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt16s(str, &size, 10) == -1234);
BH_VERIFY(size == 5);
BH_VERIFY(BH_StringFromInt16s(str, 17, -1234, 8, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt16s(str, &size, 8) == -1234);
BH_VERIFY(size == 5);
BH_VERIFY(BH_StringFromInt16s(str, 17, -1234, 2, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt16s(str, &size, 2) == -1234);
BH_VERIFY(size == 12);
BH_VERIFY(BH_StringFromInt16u(str, 17, 43210, 16, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt16u(str, &size, 16) == 43210);
BH_VERIFY(size == 4);
BH_VERIFY(BH_StringFromInt16u(str, 17, 43210, 10, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt16u(str, &size, 10) == 43210);
BH_VERIFY(size == 5);
BH_VERIFY(BH_StringFromInt16u(str, 17, 43210, 8, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt16u(str, &size, 8) == 43210);
BH_VERIFY(size == 6);
BH_VERIFY(BH_StringFromInt16u(str, 17, 43210, 2, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt16u(str, &size, 2) == 43210);
BH_VERIFY(size == 16);
return 0;
}
BH_UNIT_TEST(Int32)
{
char str[33];
size_t size;
BH_VERIFY(BH_StringFromInt32s(str, 33, -1234567890l, 16, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt32s(str, &size, 16) == -1234567890l);
BH_VERIFY(size == 9);
BH_VERIFY(BH_StringFromInt32s(str, 33, -1234567890l, 10, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt32s(str, &size, 10) == -1234567890l);
BH_VERIFY(size == 11);
BH_VERIFY(BH_StringFromInt32s(str, 33, -1234567890l, 8, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt32s(str, &size, 8) == -1234567890l);
BH_VERIFY(size == 12);
BH_VERIFY(BH_StringFromInt32s(str, 33, -1234567890l, 2, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt32s(str, &size, 2) == -1234567890l);
BH_VERIFY(size == 32);
BH_VERIFY(BH_StringFromInt32u(str, 33, 3456789012ul, 16, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt32u(str, &size, 16) == 3456789012ul);
BH_VERIFY(size == 8);
BH_VERIFY(BH_StringFromInt32u(str, 33, 3456789012ul, 10, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt32u(str, &size, 10) == 3456789012ul);
BH_VERIFY(size == 10);
BH_VERIFY(BH_StringFromInt32u(str, 33, 3456789012ul, 8, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt32u(str, &size, 8) == 3456789012ul);
BH_VERIFY(size == 11);
BH_VERIFY(BH_StringFromInt32u(str, 33, 3456789012ul, 2, NULL) == BH_OK);
BH_VERIFY(BH_StringToInt32u(str, &size, 2) == 3456789012ul);
BH_VERIFY(size == 32);
return 0;
}
BH_UNIT_TEST(Parsing)
{
size_t size;
BH_VERIFY(BH_StringToInt32s(" 0x1234", &size, 16) == 0x1234);
BH_VERIFY(size == 9);
BH_VERIFY(BH_StringToInt32s(" 12345", &size, 10) == 12345);
BH_VERIFY(size == 8);
BH_VERIFY(BH_StringToInt32s(" 0123", &size, 8) == 0123);
BH_VERIFY(size == 7);
BH_VERIFY(BH_StringToInt32s(" 0b1111Hello", &size, 2) == 15);
BH_VERIFY(size == 9);
BH_VERIFY(BH_StringToInt32s(" 0x1234", &size, 0) == 0x1234);
BH_VERIFY(size == 9);
BH_VERIFY(BH_StringToInt32s(" 0123", &size, 0) == 0123);
BH_VERIFY(size == 7);
BH_VERIFY(BH_StringToInt32s(" 123", &size, 0) == 123);
BH_VERIFY(size == 6);
BH_VERIFY(BH_StringToInt32s(" 0b1111", &size, 0) == 15);
BH_VERIFY(size == 9);
BH_VERIFY(BH_StringToInt32s(" 12345Hello", &size, 10) == 12345);
BH_VERIFY(size == 8);
BH_VERIFY(BH_StringToInt32s(" Hello", &size, 10) == 0);
BH_VERIFY(size == 0);
return 0;
}
int main(int argc, char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(Int8);
BH_UNIT_ADD(Int16);
BH_UNIT_ADD(Int32);
BH_UNIT_ADD(Parsing);
return BH_UnitRun();
}

84
test/tests/TestLine.c Normal file
View File

@@ -0,0 +1,84 @@
#include <BH/Math/Line.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(FromPoints)
{
float a[2], b[2], r[3];
a[0] = -8.0f; a[1] = 1.0f;
b[0] = -2.0f; b[1] = 3.0f;
BH_VERIFY(BH_LineFromPoints(a, b, r) == BH_OK);
BH_VERIFY_DELTA(r[0],-0.3162f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.9487f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.4785f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Degenerate)
{
float a[2], b[2], r[3];
a[0] = -8.0f; a[1] = 1.0f;
b[0] = -8.0f; b[1] = 1.0f;
BH_VERIFY(BH_LineFromPoints(a, b, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(Distance)
{
float a[2], b[2], r[3];
a[0] = -8.0f; a[1] = 1.0f;
b[0] = -2.0f; b[1] = 3.0f;
BH_VERIFY(BH_LineFromPoints(a, b, r) == BH_OK);
BH_VERIFY_DELTA(BH_LineDistance(r, a), 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_LineDistance(r, b), 0.0000f, ACCEPTABLE_DELTA);
a[0] = -7.0f; a[1] = 4.0f;
BH_VERIFY_DELTA(BH_LineDistance(r, a), 2.5298f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(ClosestPoint)
{
float a[2], b[2], r[3];
a[0] = -8.0f; a[1] = 1.0f;
b[0] = -2.0f; b[1] = 3.0f;
BH_VERIFY(BH_LineFromPoints(a, b, r) == BH_OK);
a[0] = -7.0f; a[1] = 4.0f;
BH_LineClosestPoint(r, a, b);
BH_VERIFY_DELTA(b[0],-6.2000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[1], 1.6000f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(FromPoints);
BH_UNIT_ADD(Degenerate);
BH_UNIT_ADD(Distance);
BH_UNIT_ADD(ClosestPoint);
return BH_UnitRun();
}

316
test/tests/TestMat3f.c Normal file
View File

@@ -0,0 +1,316 @@
#include <BH/Math/Mat3f.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(Identity)
{
float r[9];
BH_Mat3fIdentity(r);
BH_VERIFY(r[0] == 1.0f);
BH_VERIFY(r[1] == 0.0f);
BH_VERIFY(r[2] == 0.0f);
BH_VERIFY(r[3] == 0.0f);
BH_VERIFY(r[4] == 1.0f);
BH_VERIFY(r[5] == 0.0f);
BH_VERIFY(r[6] == 0.0f);
BH_VERIFY(r[7] == 0.0f);
BH_VERIFY(r[8] == 1.0f);
return 0;
}
BH_UNIT_TEST(Add)
{
float a[9], b[9], r[9];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
b[0] = 2.0f; b[3] = 1.0f; b[6] = 2.0f;
b[1] = 3.0f; b[4] = 1.0f; b[7] = 0.0f;
b[2] = 4.0f; b[5] = 2.0f; b[8] = 4.0f;
BH_Mat3fAdd(a, b, r);
BH_VERIFY_DELTA(r[0], 7.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 8.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Sub)
{
float a[9], b[9], r[9];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
b[0] = 2.0f; b[3] = 1.0f; b[6] = 2.0f;
b[1] = 3.0f; b[4] = 1.0f; b[7] = 0.0f;
b[2] = 4.0f; b[5] = 2.0f; b[8] = 4.0f;
BH_Mat3fSub(a, b, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], -1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 0.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Mul)
{
float a[9], b[9], r[9];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
b[0] = 2.0f; b[3] = 1.0f; b[6] = 2.0f;
b[1] = 3.0f; b[4] = 1.0f; b[7] = 0.0f;
b[2] = 4.0f; b[5] = 2.0f; b[8] = 4.0f;
BH_Mat3fMul(a, b, r);
BH_VERIFY_DELTA(r[0], 21.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 27.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 12.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 18.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 18.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Scale)
{
float a[9], r[9];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
BH_Mat3fScale(a, 10, r);
BH_VERIFY_DELTA(r[0], 50.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 30.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 30.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 20.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 40.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Transpose)
{
float a[9], r[9];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
BH_Mat3fTranspose(a, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Trace)
{
float a[9];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
BH_VERIFY_DELTA(BH_Mat3fTrace(a), 9.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Det)
{
float a[9], b[9];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
b[0] = 2.0f; b[3] = 1.0f; b[6] = 2.0f;
b[1] = 3.0f; b[4] = 1.0f; b[7] = 0.0f;
b[2] = 4.0f; b[5] = 2.0f; b[8] = 4.0f;
BH_VERIFY_DELTA(BH_Mat3fDet(a), 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_Mat3fDet(b), 0.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Inverse)
{
float a[9], b[9], r[9];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
b[0] = 2.0f; b[3] = 1.0f; b[6] = 2.0f;
b[1] = 3.0f; b[4] = 1.0f; b[7] = 0.0f;
b[2] = 4.0f; b[5] = 2.0f; b[8] = 4.0f;
BH_VERIFY(BH_Mat3fInverse(a, r) == BH_OK);
BH_VERIFY_DELTA(r[0], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 1.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.3333f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], -2.3333f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], -0.5000f, ACCEPTABLE_DELTA);
BH_VERIFY(BH_Mat3fInverse(b, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(Translation)
{
float r[9];
BH_Mat3fFromTranslation(1.0f, 2.0f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 1.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Scaling)
{
float r[9];
BH_Mat3fFromScale(1.0f, 2.0f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 1.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Apply)
{
float a[9];
float b[3];
a[0] = 5.0f; a[3] = 1.0f; a[6] = 2.0f;
a[1] = 3.0f; a[4] = 0.0f; a[7] = 0.0f;
a[2] = 1.0f; a[5] = 3.0f; a[8] = 4.0f;
b[0] = 2.0f; b[1] = -1.0f; b[2] = 4.0f;
BH_Mat3fApplyVec3f(a, b, b);
BH_VERIFY_DELTA(b[0], 17.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[2], 15.0000f, ACCEPTABLE_DELTA);
b[0] = 2.0f; b[1] = -1.0f;
BH_Mat3fApplyVec2f(a, b, b);
BH_VERIFY_DELTA(b[0], 11.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[1], 6.0000f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Identity);
BH_UNIT_ADD(Add);
BH_UNIT_ADD(Sub);
BH_UNIT_ADD(Mul);
BH_UNIT_ADD(Scale);
BH_UNIT_ADD(Transpose);
BH_UNIT_ADD(Trace);
BH_UNIT_ADD(Det);
BH_UNIT_ADD(Inverse);
BH_UNIT_ADD(Translation);
BH_UNIT_ADD(Scaling);
BH_UNIT_ADD(Apply);
return BH_UnitRun();
}

404
test/tests/TestMat4f.c Normal file
View File

@@ -0,0 +1,404 @@
#include <BH/Math/Mat4f.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(Identity)
{
float r[16];
BH_Mat4fIdentity(r);
BH_VERIFY(r[0] == 1.0f);
BH_VERIFY(r[1] == 0.0f);
BH_VERIFY(r[2] == 0.0f);
BH_VERIFY(r[3] == 0.0f);
BH_VERIFY(r[4] == 0.0f);
BH_VERIFY(r[5] == 1.0f);
BH_VERIFY(r[6] == 0.0f);
BH_VERIFY(r[7] == 0.0f);
BH_VERIFY(r[8] == 0.0f);
BH_VERIFY(r[9] == 0.0f);
BH_VERIFY(r[10] == 1.0f);
BH_VERIFY(r[11] == 0.0f);
BH_VERIFY(r[12] == 0.0f);
BH_VERIFY(r[13] == 0.0f);
BH_VERIFY(r[14] == 0.0f);
BH_VERIFY(r[15] == 1.0f);
return 0;
}
BH_UNIT_TEST(Add)
{
float a[16], b[16], r[16];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
b[0] = 5.0f; b[4] = 1.0f; b[8] = 2.0f; b[12] = 7.0f;
b[1] = 3.0f; b[5] = 1.0f; b[9] = 0.0f; b[13] = 2.0f;
b[2] = 4.0f; b[6] = 2.0f; b[10] = 4.0f; b[14] = 5.0f;
b[3] = 6.0f; b[7] = 2.0f; b[11] = 0.0f; b[15] = 4.0f;
BH_Mat4fAdd(a, b, r);
BH_VERIFY_DELTA(r[0], 10.0f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 8.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[9], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[10], 8.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[11], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[12], 14.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[13], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[14], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[15], 7.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Sub)
{
float a[16], b[16], r[16];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
b[0] = 5.0f; b[4] = 1.0f; b[8] = 2.0f; b[12] = 7.0f;
b[1] = 3.0f; b[5] = 1.0f; b[9] = 0.0f; b[13] = 2.0f;
b[2] = 4.0f; b[6] = 2.0f; b[10] = 4.0f; b[14] = 5.0f;
b[3] = 6.0f; b[7] = 2.0f; b[11] = 0.0f; b[15] = 4.0f;
BH_Mat4fSub(a, b, r);
BH_VERIFY_DELTA(r[0], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], -4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], -1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], -2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[9], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[10], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[11], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[12], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[13], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[14], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[15], -1.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Mul)
{
float a[16], b[16], r[16];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
b[0] = 5.0f; b[4] = 1.0f; b[8] = 2.0f; b[12] = 7.0f;
b[1] = 3.0f; b[5] = 1.0f; b[9] = 0.0f; b[13] = 2.0f;
b[2] = 4.0f; b[6] = 2.0f; b[10] = 4.0f; b[14] = 5.0f;
b[3] = 6.0f; b[7] = 2.0f; b[11] = 0.0f; b[15] = 4.0f;
BH_Mat4fMul(a, b, r);
BH_VERIFY_DELTA(r[0], 78.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 27.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 60.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 28.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 24.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 7.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 22.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 8.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 18.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[9], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[10], 18.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[11], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[12], 75.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[13], 29.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[14], 53.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[15], 26.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Scale)
{
float a[16], r[16];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
BH_Mat4fScale(a, 10, r);
BH_VERIFY_DELTA(r[0], 50.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 30.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 20.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 30.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 20.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[9], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[10], 40.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[11], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[12], 70.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[13], 20.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[14], 50.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[15], 30.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Transpose)
{
float a[16], r[16];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
BH_Mat4fTranspose(a, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 7.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[9], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[10], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[11], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[12], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[13], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[14], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[15], 3.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Trace)
{
float a[16];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
BH_VERIFY_DELTA(BH_Mat4fTrace(a), 12.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Det)
{
float a[16], b[16];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
b[0] = 5.0f; b[4] = 1.0f; b[8] = 2.0f; b[12] = 7.0f;
b[1] = 3.0f; b[5] = 1.0f; b[9] = 0.0f; b[13] = 2.0f;
b[2] = 4.0f; b[6] = 2.0f; b[10] = 4.0f; b[14] = 5.0f;
b[3] = 6.0f; b[7] = 2.0f; b[11] = 0.0f; b[15] = 4.0f;
BH_VERIFY_DELTA(BH_Mat4fDet(a), 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_Mat4fDet(b), 0.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Inverse)
{
float a[16], b[16], r[16];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
b[0] = 5.0f; b[4] = 1.0f; b[8] = 2.0f; b[12] = 7.0f;
b[1] = 3.0f; b[5] = 1.0f; b[9] = 0.0f; b[13] = 2.0f;
b[2] = 4.0f; b[6] = 2.0f; b[10] = 4.0f; b[14] = 5.0f;
b[3] = 6.0f; b[7] = 2.0f; b[11] = 0.0f; b[15] = 4.0f;
BH_VERIFY(BH_Mat4fInverse(a, r) == BH_OK);
BH_VERIFY_DELTA(r[0], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 1.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 0.6000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 1.8000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], -1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], -0.4000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[9], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[10], -0.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[11], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[12], -0.4000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[13], 1.8000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[14], -2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[15], 0.6000f, ACCEPTABLE_DELTA);
BH_VERIFY(BH_Mat4fInverse(b, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(Translation)
{
float r[16];
BH_Mat4fFromTranslation(1.0f, 2.0f, 3.0f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[9], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[10], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[11], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[12], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[13], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[14], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[15], 1.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Scaling)
{
float r[16];
BH_Mat4fFromScale(1.0f, 2.0f, 3.0f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[4], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[5], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[6], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[7], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[8], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[9], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[10], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[11], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[12], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[13], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[14], 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[15], 1.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Apply)
{
float a[16];
float b[4];
a[0] = 5.0f; a[4] = 1.0f; a[8] = 2.0f; a[12] = 7.0f;
a[1] = 3.0f; a[5] = 0.0f; a[9] = 0.0f; a[13] = 2.0f;
a[2] = 1.0f; a[6] = 3.0f; a[10] = 4.0f; a[14] = 5.0f;
a[3] = 2.0f; a[7] = 0.0f; a[11] = 0.0f; a[15] = 3.0f;
b[0] = 2.0f; b[1] = -1.0f; b[2] = 4.0f; b[3] = 0.0f;
BH_Mat4fApplyVec4f(a, b, b);
BH_VERIFY_DELTA(b[0], 17.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[2], 15.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[3], 4.0000f, ACCEPTABLE_DELTA);
b[0] = 2.0f; b[1] = -1.0f; b[2] = 4.0f;
BH_Mat4fApplyVec3f(a, b, b);
BH_VERIFY_DELTA(b[0], 24.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[1], 8.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(b[2], 20.0000f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Identity);
BH_UNIT_ADD(Add);
BH_UNIT_ADD(Sub);
BH_UNIT_ADD(Mul);
BH_UNIT_ADD(Scale);
BH_UNIT_ADD(Transpose);
BH_UNIT_ADD(Trace);
BH_UNIT_ADD(Det);
BH_UNIT_ADD(Inverse);
BH_UNIT_ADD(Translation);
BH_UNIT_ADD(Scaling);
BH_UNIT_ADD(Apply);
return BH_UnitRun();
}

51
test/tests/TestMath.c Normal file
View File

@@ -0,0 +1,51 @@
#include <BH/Math/Quat.h>
#include <BH/Math/Mat4f.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(QuatMat4fParity)
{
float a[16], b[16], c[4];
BH_Mat4fFromEuler(-2.7671f, -0.8324f, -0.1649f, a);
BH_Quat4fFromEuler(-2.7671f, -0.8324f, -0.1649f, c);
BH_VERIFY_DELTA(c[0], -0.9018f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(c[1], -0.0010f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(c[2], -0.4099f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(c[3], 0.1370f, ACCEPTABLE_DELTA);
BH_Quat4fToMat4f(c, b);
BH_VERIFY_DELTA(a[0], b[0], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[1], b[1], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[2], b[2], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[3], b[3], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[4], b[4], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[5], b[5], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[6], b[6], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[7], b[7], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[8], b[8], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[9], b[9], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[10], b[10], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[11], b[11], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[12], b[12], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[13], b[13], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[14], b[14], ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(a[15], b[15], ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(QuatMat4fParity);
return BH_UnitRun();
}

96
test/tests/TestPlane.c Normal file
View File

@@ -0,0 +1,96 @@
#include <BH/Math/Plane.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(FromPoints)
{
float a[3], b[3], c[3], r[4];
a[0] = 1; a[1] = -2; a[2] = 1;
b[0] = 4; b[1] = -2; b[2] = -2;
c[0] = 4; c[1] = 1; c[2] = 4;
BH_VERIFY(BH_PlaneFromPoints(a, b, c, r) == BH_OK);
BH_VERIFY_DELTA(r[0],-0.4082f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.8165f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2],-0.4082f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3],-2.4495f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Degenerate)
{
float a[3], b[3], c[3], r[4];
a[0] = 1; a[1] = -2; a[2] = 1;
b[0] = 1; b[1] = -2; b[2] = 1;
c[0] = 4; c[1] = 1; c[2] = 4;
BH_VERIFY(BH_PlaneFromPoints(a, b, c, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(Distance)
{
float a[3], b[3], c[3], r[4];
a[0] = 1; a[1] = -2; a[2] = 1;
b[0] = 4; b[1] = -2; b[2] = -2;
c[0] = 4; c[1] = 1; c[2] = 4;
BH_VERIFY(BH_PlaneFromPoints(a, b, c, r) == BH_OK);
BH_VERIFY_DELTA(BH_PlaneDistance(r, a), 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_PlaneDistance(r, b), 0.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_PlaneDistance(r, c), 0.0000f, ACCEPTABLE_DELTA);
a[0] = 3; a[1] = 4; a[2] = 5;
b[0] = 2; b[1] = -1; b[2] = 6;
BH_VERIFY_DELTA(BH_PlaneDistance(r, a), 2.4495f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_PlaneDistance(r, b), -1.6330f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(ClosestPoint)
{
float a[3], b[3], c[3], r[4];
a[0] = 1; a[1] = -2; a[2] = 1;
b[0] = 4; b[1] = -2; b[2] = -2;
c[0] = 4; c[1] = 1; c[2] = 4;
BH_VERIFY(BH_PlaneFromPoints(a, b, c, r) == BH_OK);
b[0] = 3; b[1] = 4; b[2] = 5;
BH_PlaneClosestPoint(r, b, c);
BH_VERIFY_DELTA(c[0], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(c[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(c[2], 6.0000f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(FromPoints);
BH_UNIT_ADD(Degenerate);
BH_UNIT_ADD(Distance);
BH_UNIT_ADD(ClosestPoint);
return BH_UnitRun();
}

131
test/tests/TestQuat.c Normal file
View File

@@ -0,0 +1,131 @@
#include <BH/Math/Quat.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(Identity)
{
float r[4];
BH_Quat4fIdentity(r);
BH_VERIFY_DELTA(r[0], 0.000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 0.000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 1.000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Conjugate)
{
float a[4], r[4];
a[0] = -0.9018f; a[1] = -0.0010f; a[2] = -0.4099f; a[3] = 0.1370f;
BH_Quat4fConjugate(a, r);
BH_VERIFY_DELTA(r[0], 0.9018f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.0010f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 0.4099f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.1370f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(ToEuler)
{
float a[4];
float roll, pitch, yaw;
a[0] = -0.9018f; a[1] = -0.0010f; a[2] = -0.4099f; a[3] = 0.1370f;
BH_Quat4fToEuler(a, &roll, &pitch, &yaw);
BH_VERIFY_DELTA(roll, -2.7671f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(pitch, -0.8324f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(yaw, -0.1649f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(FromEuler)
{
float r[4];
BH_Quat4fFromEuler(-2.7671f, -0.8324f, -0.1649f, r);
BH_VERIFY_DELTA(r[0], -0.9018f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -0.0010f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -0.4099f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.1370f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(ToAxis)
{
float a[4], r[3];
float angle;
a[0] = -0.9018f; a[1] = -0.0010f; a[2] = -0.4099f; a[3] = 0.1370f;
BH_Quat4fToAxis(a, r, &angle);
BH_VERIFY_DELTA(r[0], -0.9104f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -0.0010f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -0.4138f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(angle, 2.8668f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(FromAxis)
{
float a[3], r[4];
a[0] = -0.9104f; a[1] = -0.0010f; a[2] = -0.4138f;
BH_Quat4fFromAxis(a, 2.8668f, r);
BH_VERIFY_DELTA(r[0], -0.9018f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -0.0010f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -0.4099f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.1370f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(InverseMultiply)
{
float a[4], r[4];
a[0] = -0.9018f; a[1] = -0.0010f; a[2] = -0.4099f; a[3] = 0.1370f;
BH_Quat4fInverse(a, r);
BH_Quat4fMul(a, r, r);
BH_VERIFY_DELTA(r[0], 0.000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 0.000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 0.000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 1.000f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Identity);
BH_UNIT_ADD(Conjugate);
BH_UNIT_ADD(ToEuler);
BH_UNIT_ADD(FromEuler);
BH_UNIT_ADD(ToAxis);
BH_UNIT_ADD(FromAxis);
BH_UNIT_ADD(InverseMultiply);
return BH_UnitRun();
}

171
test/tests/TestQueue.c Normal file
View File

@@ -0,0 +1,171 @@
#include <BH/Queue.h>
#include <BH/Unit.h>
static int NewFree(void)
{
BH_Queue *queue;
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
BH_VERIFY(BH_QueueSize(queue) == 0);
BH_VERIFY(BH_QueueCapacity(queue) == 0);
BH_VERIFY(BH_QueueEmpty(queue) != 0);
BH_QueueFree(queue);
return 0;
}
static int GrowShrink(void)
{
BH_Queue *queue;
void *value;
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
/* Reserve 1024 elements and insert item into queue */
BH_VERIFY(BH_QueueReserve(queue, 1024) == BH_OK);
BH_VERIFY(BH_QueueInsert(queue, BH_INT2PTR(1337)) == BH_OK);
BH_VERIFY(BH_QueueCapacity(queue) >= 1024);
BH_VERIFY(BH_QueueSize(queue) == 1);
BH_VERIFY(BH_QueueEmpty(queue) == 0);
/* Check queue content */
BH_VERIFY(BH_QueueFront(queue, &value) == BH_OK);
BH_VERIFY(BH_PTR2INT(value) == 1337);
/* Grow queue */
BH_VERIFY(BH_QueueReserve(queue, 8192) == BH_OK);
BH_VERIFY(BH_QueueCapacity(queue) >= 8192);
BH_VERIFY(BH_QueueSize(queue) == 1);
BH_VERIFY(BH_QueueEmpty(queue) == 0);
/* Check queue content */
BH_VERIFY(BH_QueueFront(queue, &value) == BH_OK);
BH_VERIFY(BH_PTR2INT(value) == 1337);
/* Shrink the queue */
BH_VERIFY(BH_QueueReserve(queue, 0) == BH_OK);
BH_VERIFY(BH_QueueCapacity(queue) >= 1);
BH_VERIFY(BH_QueueCapacity(queue) < 8192);
BH_VERIFY(BH_QueueSize(queue) == 1);
BH_VERIFY(BH_QueueEmpty(queue) == 0);
/* Check queue content */
BH_VERIFY(BH_QueueFront(queue, &value) == BH_OK);
BH_VERIFY(BH_PTR2INT(value) == 1337);
/* Shrink to 0 (deallocate) */
BH_QueueClear(queue);
BH_VERIFY(BH_QueueSize(queue) == 0);
BH_VERIFY(BH_QueueEmpty(queue) != 0);
BH_VERIFY(BH_QueueCapacity(queue) >= 1);
BH_VERIFY(BH_QueueReserve(queue, 0) == BH_OK);
BH_VERIFY(BH_QueueSize(queue) == 0);
BH_VERIFY(BH_QueueEmpty(queue) != 0);
BH_VERIFY(BH_QueueCapacity(queue) == 0);
BH_QueueFree(queue);
return 0;
}
static int InsertRemove(void)
{
BH_Queue *queue;
size_t i, added, removed;
void *iter;
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
added = 0;
for (i = 0; i < 256; i++)
{
added += i * 2;
BH_VERIFY(BH_QueueInsert(queue, BH_INT2PTR(i * 2)) == BH_OK);
}
removed = 0;
iter = BH_QueueIterNext(queue, NULL);
while (iter)
{
void *value;
BH_VERIFY(BH_QueueFront(queue, &value) == BH_OK);
removed += BH_PTR2INT(value);
BH_QueueRemove(queue);
iter = BH_QueueIterNext(queue, NULL);
}
BH_VERIFY(added == removed);
BH_VERIFY(BH_QueueEmpty(queue) != 0);
BH_VERIFY(BH_QueueSize(queue) == 0);
BH_QueueFree(queue);
return 0;
}
static int Rollover(void)
{
BH_Queue *queue;
size_t i, j, capacity;
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
BH_VERIFY(BH_QueueReserve(queue, 128) == 0);
capacity = BH_QueueCapacity(queue);
for (i = 0; i < 128; i++)
{
for (j = 0; j < 3; j++)
BH_QueueRemove(queue);
for (j = 0; j < 4 && BH_QueueSize(queue) < 128; j++)
BH_VERIFY(BH_QueueInsert(queue, BH_INT2PTR(i * 4 + j)) == 0);
}
BH_VERIFY(BH_QueueSize(queue) == 128);
BH_VERIFY(BH_QueueCapacity(queue) == capacity);
BH_QueueFree(queue);
return 0;
}
static int Fields(void)
{
BH_Queue *queue;
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
BH_VERIFY(BH_QueueInsert(queue, BH_INT2PTR(1337)) == 0);
BH_VERIFY(BH_QueueSize(queue) == 1);
BH_VERIFY(BH_QueueEmpty(queue) == 0);
BH_VERIFY(BH_QueueCapacity(queue) >= 1);
BH_QueueFree(queue);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UnitAdd("NewFree", NewFree);
BH_UnitAdd("GrowShrink", GrowShrink);
BH_UnitAdd("InsertRemove", InsertRemove);
BH_UnitAdd("Rollover", Rollover);
BH_UnitAdd("Fields", Fields);
return BH_UnitRun();
}

267
test/tests/TestRay2f.c Normal file
View File

@@ -0,0 +1,267 @@
#include <BH/Math/Ray2f.h>
#include <BH/Math/Vec2f.h>
#include <BH/Math/Box2f.h>
#include <BH/Math/Line.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(RayIntersectLine)
{
float a[2], b[2], p[2], d[2], r[3];
float time;
a[0] = 4.0000f; a[1] = 9.0000f;
b[0] = 2.0000f; b[1] = 5.0000f;
p[0] = -5.0000f; p[1] = 3.0000f;
d[0] = 0.8944f; d[1] = 0.4472f;
BH_VERIFY(BH_LineFromPoints(a, b, r) == BH_OK);
BH_VERIFY(BH_Ray2fIntersectLine(p, d, r, &time, r) == BH_OK);
BH_VERIFY_DELTA(time, 8.9443f, ACCEPTABLE_DELTA * 10);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
BH_Vec2fScale(d, time, r);
BH_Vec2fAdd(p, r, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
d[0] = -2.0000f; d[1] = -4.0000f;
BH_VERIFY(BH_LineFromPoints(a, b, r) == BH_OK);
BH_VERIFY(BH_Ray2fIntersectLine(p, d, r, &time, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(RayIntersectRay)
{
float p1[2], d1[2], p2[2], d2[2], r[2];
float time;
p1[0] = -5.0000f; p1[1] = 3.0000f;
d1[0] = 0.8944f; d1[1] = 0.4472f;
p2[0] = 4.0000f; p2[1] = 9.0000f;
d2[0] = -0.4472f; d2[1] =-0.8944f;
BH_VERIFY(BH_Ray2fIntersectRay(p1, d1, p2, d2, &time, r) == BH_OK);
BH_VERIFY_DELTA(time, 8.9443f, ACCEPTABLE_DELTA * 10);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
BH_Vec2fScale(d1, time, r);
BH_Vec2fAdd(p1, r, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
BH_VERIFY(BH_Ray2fIntersectRay(p1, d1, p2, d1, &time, r) != BH_OK);
d1[0] = 0.0000f; d1[1] = 1.0000f;
BH_VERIFY(BH_Ray2fIntersectRay(p1, d1, p2, d2, &time, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(RayIntersectSegment)
{
float p[2], d[2], a[2], b[2], r[2];
float time;
p[0] = -5.0000f; p[1] = 3.0000f;
d[0] = 0.8944f; d[1] = 0.4472f;
a[0] = 4.0000f; a[1] = 9.0000f;
b[0] = 2.0000f; b[1] = 5.0000f;
BH_VERIFY(BH_Ray2fIntersectSegment(p, d, a, b, &time, r) == BH_OK);
BH_VERIFY_DELTA(time, 8.9443f, ACCEPTABLE_DELTA * 10);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
BH_Vec2fScale(d, time, r);
BH_Vec2fAdd(p, r, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
d[0] = -2.0000f; d[1] = -4.0000f;
BH_VERIFY(BH_Ray2fIntersectSegment(p, d, a, b, &time, r) != BH_OK);
d[0] = 1.0000f; d[1] = 0.0000f;
BH_VERIFY(BH_Ray2fIntersectSegment(p, d, a, b, &time, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(SegmentIntersectLine)
{
float a1[2], b1[2], a2[2], b2[2], r[3];
float time;
a1[0] = -5.0000f; a1[1] = 3.0000f;
b1[0] = 5.0000f; b1[1] = 8.0000f;
a2[0] = 4.0000f; a2[1] = 9.0000f;
b2[0] = 2.0000f; b2[1] = 5.0000f;
BH_VERIFY(BH_LineFromPoints(a2, b2, r) == BH_OK);
BH_VERIFY(BH_Segment2fIntersectLine(a1, b1, r, &time, r) == BH_OK);
BH_VERIFY_DELTA(time, 0.8000f, ACCEPTABLE_DELTA * 10);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
BH_Vec2fLerp(a1, b1, time, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(SegmentIntersectSegment)
{
float a1[2], b1[2], a2[2], b2[2], r[2];
float time;
a1[0] = -5.0000f; a1[1] = 3.0000f;
b1[0] = 5.0000f; b1[1] = 8.0000f;
a2[0] = 4.0000f; a2[1] = 9.0000f;
b2[0] = 2.0000f; b2[1] = 5.0000f;
BH_VERIFY(BH_Segment2fIntersectSegment(a1, b1, a2, b2, &time, r) == BH_OK);
BH_VERIFY_DELTA(time, 0.8000f, ACCEPTABLE_DELTA * 10);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
BH_Vec2fLerp(a1, b1, time, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Time)
{
float a1[2], b1[2], a2[2], b2[2], r[2];
float time1, time2;
a1[0] = -5.0000f; a1[1] = 3.0000f;
b1[0] = 10.0000f; b1[1] = 5.0000f;
a2[0] = 4.0000f; a2[1] = 9.0000f;
b2[0] = -2.0000f; b2[1] =-4.0000f;
BH_VERIFY(BH_Ray2fIntersectTime(a1, b1, a2, b2, &time1, &time2) == BH_OK);
BH_VERIFY_DELTA(time1, 0.8000f, ACCEPTABLE_DELTA * 10);
BH_VERIFY_DELTA(time2, 0.5000f, ACCEPTABLE_DELTA * 10);
BH_Vec2fScale(b1, time1, r);
BH_Vec2fAdd(a1, r, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
BH_Vec2fScale(b2, time2, r);
BH_Vec2fAdd(a2, r, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 7.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(RayBox)
{
float start[2], direction[2], bMin[2], bMax[2], r[2];
float time;
bMin[0] =-2.0f; bMin[1] =-2.0f;
bMax[0] = 3.0f; bMax[1] = 3.0f;
start[0] = 0.0f; start[1] = 0.0f;
direction[0] = 1.0f; direction[1] = 0.0f;
BH_VERIFY(BH_Ray2fIntersectBox2f(start, direction, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box2fContains(bMin, bMax, r) == BH_OK);
start[0] = -4.0f; start[1] = 0.0f;
BH_VERIFY(BH_Ray2fIntersectBox2f(start, direction, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box2fContains(bMin, bMax, r) == BH_OK);
start[0] = 4.0f; start[1] = 0.0f;
BH_VERIFY(BH_Ray2fIntersectBox2f(start, direction, bMin, bMax, &time, r) != BH_OK);
start[0] = 4.0f; start[1] = 0.0f;
direction[0] = -1.0f; direction[1] = 0.0f;
BH_VERIFY(BH_Ray2fIntersectBox2f(start, direction, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box2fContains(bMin, bMax, r) == BH_OK);
start[0] = 4.0f; start[1] = 4.0f;
direction[0] = -1.0f; direction[1] = 0.0f;
BH_VERIFY(BH_Ray2fIntersectBox2f(start, direction, bMin, bMax, &time, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(SegmentBox)
{
float start[2], end[2], bMin[2], bMax[2], r[2];
float time;
bMin[0] =-2.0f; bMin[1] =-2.0f;
bMax[0] = 3.0f; bMax[1] = 3.0f;
start[0] = 0.0f; start[1] = 0.0f;
end[0] = 5.0f; end[1] = 0.0f;
BH_VERIFY(BH_Segment2fIntersectBox2f(start, end, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box2fContains(bMin, bMax, r) == BH_OK);
start[0] = -4.0f; start[1] = 0.0f;
BH_VERIFY(BH_Segment2fIntersectBox2f(start, end, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box2fContains(bMin, bMax, r) == BH_OK);
start[0] = 4.0f; start[1] = 0.0f;
BH_VERIFY(BH_Segment2fIntersectBox2f(start, end, bMin, bMax, &time, r) != BH_OK);
start[0] = 4.0f; start[1] = 0.0f;
end[0] = -5.0f; end[1] = 0.0f;
BH_VERIFY(BH_Segment2fIntersectBox2f(start, end, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box2fContains(bMin, bMax, r) == BH_OK);
start[0] = 4.0f; start[1] = 4.0f;
end[0] = -5.0f; end[1] = 4.0f;
BH_VERIFY(BH_Segment2fIntersectBox2f(start, end, bMin, bMax, &time, r) != BH_OK);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(RayIntersectLine);
BH_UNIT_ADD(RayIntersectRay);
BH_UNIT_ADD(RayIntersectSegment);
BH_UNIT_ADD(SegmentIntersectLine);
BH_UNIT_ADD(SegmentIntersectSegment);
BH_UNIT_ADD(Time);
BH_UNIT_ADD(RayBox);
BH_UNIT_ADD(SegmentBox);
return BH_UnitRun();
}

171
test/tests/TestRay3f.c Normal file
View File

@@ -0,0 +1,171 @@
#include <BH/Math/Ray3f.h>
#include <BH/Math/Vec3f.h>
#include <BH/Math/Box3f.h>
#include <BH/Math/Plane.h>
#include <BH/Math/Misc.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(RayIntersectTriangle)
{
float a[3], b[3], c[3], p[3], d[3], out[3], t;
a[0] =-3.0000f; a[1] = 1.0000f; a[2] = 2.0000f;
b[0] =-5.0000f; b[1] =-2.0000f; b[2] = 0.0000f;
c[0] =-6.0000f; c[1] = 2.5000f; c[2] =-1.0000f;
p[0] =-1.5000f; p[1] = 1.0000f; p[2] = 1.0000f;
d[0] =-1.0000f; d[1] = 0.0000f; d[2] = 0.0000f;
BH_VERIFY(BH_Ray3fIntersectTriangle(p, d, a, b, c, &t, out) == BH_OK);
BH_VERIFY_DELTA(t, 2.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[0],-4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[1], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[2], 1.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(SegmentIntersectTriangle)
{
float a[3], b[3], c[3], d[3], f[3], out[3], t;
a[0] =-3.0000f; a[1] = 1.0000f; a[2] = 2.0000f;
b[0] =-5.0000f; b[1] =-2.0000f; b[2] = 0.0000f;
c[0] =-6.0000f; c[1] = 2.5000f; c[2] =-1.0000f;
d[0] =-1.5000f; d[1] = 1.0000f; d[2] = 1.0000f;
f[0] =-6.0000f; f[1] = 1.0000f; f[2] = 1.0000f;
BH_VERIFY(BH_Segment3fIntersectTriangle(d, f, a, b, c, &t, out) == BH_OK);
BH_VERIFY_DELTA(out[0],-4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[1], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[2], 1.0000f, ACCEPTABLE_DELTA);
BH_Vec3fLerp(d, f, t, out);
BH_VERIFY_DELTA(out[0],-4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[1], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[2], 1.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Barycentric)
{
float a[3], b[3], c[3], p[3], d[3], out[3], t;
a[0] =-3.0000f; a[1] = 1.0000f; a[2] = 2.0000f;
b[0] =-5.0000f; b[1] =-2.0000f; b[2] = 0.0000f;
c[0] =-6.0000f; c[1] = 2.5000f; c[2] =-1.0000f;
p[0] =-1.5000f; p[1] = 1.0000f; p[2] = 1.0000f;
d[0] =-1.0000f; d[1] = 0.0000f; d[2] = 0.0000f;
BH_VERIFY(BH_Ray3fIntersectTriangle(p, d, a, b, c, &t, out) == BH_OK);
(void)t;
BH_Triangle3fBarycentric(a, b, c, out, out);
BH_VERIFY(out[0] >= 0.0f);
BH_VERIFY(out[1] >= 0.0f);
BH_VERIFY(out[2] >= 0.0f);
BH_VERIFY(out[0] <= 1.0f);
BH_VERIFY(out[1] <= 1.0f);
BH_VERIFY(out[2] <= 1.0f);
BH_VERIFY_DELTA(out[0] + out[1] + out[2], 1.0000f, ACCEPTABLE_DELTA);
BH_Vec3fBarycentric(a, b, c, out[1], out[2], out);
BH_VERIFY_DELTA(out[0],-4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[1], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(out[2], 1.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(RayBox)
{
float start[3], direction[3], bMin[3], bMax[3], r[3];
float time;
bMin[0] =-2.0f; bMin[1] =-2.0f; bMin[2] =-2.0f;
bMax[0] = 3.0f; bMax[1] = 3.0f; bMax[2] = 3.0f;
start[0] = 0.0f; start[1] = 0.0f; start[2] = 0.0f;
direction[0] = 1.0f; direction[1] = 0.0f; direction[2] = 0.0f;
BH_VERIFY(BH_Ray3fIntersectBox3f(start, direction, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box3fContains(bMin, bMax, r) == BH_OK);
start[0] = -4.0f; start[1] = 0.0f; start[2] = 0.0f;
BH_VERIFY(BH_Ray3fIntersectBox3f(start, direction, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box3fContains(bMin, bMax, r) == BH_OK);
start[0] = 4.0f; start[1] = 0.0f; start[2] = 0.0f;
BH_VERIFY(BH_Ray3fIntersectBox3f(start, direction, bMin, bMax, &time, r) != BH_OK);
start[0] = 4.0f; start[1] = 0.0f; start[2] = 0.0f;
direction[0] = -1.0f; direction[1] = 0.0f; direction[2] = 0.0f;
BH_VERIFY(BH_Ray3fIntersectBox3f(start, direction, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box3fContains(bMin, bMax, r) == BH_OK);
start[0] = 4.0f; start[1] = 4.0f; start[2] = 4.0f;
direction[0] = -1.0f; direction[1] = 0.0f; direction[2] = 0.0f;
BH_VERIFY(BH_Ray3fIntersectBox3f(start, direction, bMin, bMax, &time, r) != BH_OK);
return 0;
}
BH_UNIT_TEST(SegmentBox)
{
float start[3], end[3], bMin[3], bMax[3], r[3];
float time;
bMin[0] =-2.0f; bMin[1] =-2.0f; bMin[2] =-2.0f;
bMax[0] = 3.0f; bMax[1] = 3.0f; bMax[2] = 3.0f;
start[0] = 0.0f; start[1] = 0.0f; start[2] = 0.0f;
end[0] = 5.0f; end[1] = 0.0f; end[2] = 0.0f;
BH_VERIFY(BH_Segment3fIntersectBox3f(start, end, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box3fContains(bMin, bMax, r) == BH_OK);
start[0] = -4.0f; start[1] = 0.0f; start[2] = 0.0f;
BH_VERIFY(BH_Segment3fIntersectBox3f(start, end, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box3fContains(bMin, bMax, r) == BH_OK);
start[0] = 4.0f; start[1] = 0.0f; start[2] = 0.0f;
BH_VERIFY(BH_Segment3fIntersectBox3f(start, end, bMin, bMax, &time, r) != BH_OK);
start[0] = 4.0f; start[1] = 0.0f; start[2] = 0.0f;
end[0] = -5.0f; end[1] = 0.0f; end[2] = 0.0f;
BH_VERIFY(BH_Segment3fIntersectBox3f(start, end, bMin, bMax, &time, r) == BH_OK);
BH_VERIFY(BH_Box3fContains(bMin, bMax, r) == BH_OK);
start[0] = 4.0f; start[1] = 4.0f; start[2] = 4.0f;
end[0] = -5.0f; end[1] = 4.0f; end[2] = 0.0f;
BH_VERIFY(BH_Segment3fIntersectBox3f(start, end, bMin, bMax, &time, r) != BH_OK);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(RayIntersectTriangle);
BH_UNIT_ADD(SegmentIntersectTriangle);
BH_UNIT_ADD(Barycentric);
BH_UNIT_ADD(RayBox);
BH_UNIT_ADD(SegmentBox);
return BH_UnitRun();
}

125
test/tests/TestThread.c Normal file
View File

@@ -0,0 +1,125 @@
#include <BH/Thread.h>
#include <BH/Unit.h>
#include <time.h>
BH_UNIT_TEST(Sleep)
{
time_t start;
start = time(NULL);
BH_ThreadSleep(5000);
BH_VERIFY(time(NULL) - start >= 5);
return 0;
}
BH_UNIT_TEST(Mutex)
{
BH_Mutex *mutex;
BH_VERIFY((mutex = BH_MutexNew()) != NULL);
BH_VERIFY(BH_MutexLock(mutex) == BH_OK);
BH_VERIFY(BH_MutexTryLock(mutex) != BH_OK);
BH_VERIFY(BH_MutexUnlock(mutex) == BH_OK);
BH_VERIFY(BH_MutexTryLock(mutex) == BH_OK);
BH_VERIFY(BH_MutexUnlock(mutex) == BH_OK);
BH_MutexFree(mutex);
return 0;
}
BH_UNIT_TEST(Semaphore)
{
BH_Semaphore *semaphore;
time_t start;
start = time(NULL);
BH_VERIFY((semaphore = BH_SemaphoreNew(1)) != NULL);
BH_VERIFY(BH_SemaphoreWait(semaphore) == BH_OK);
BH_VERIFY(BH_SemaphoreTryWait(semaphore) != BH_OK);
BH_VERIFY(BH_SemaphoreWaitFor(semaphore, 5000) == BH_TIMEOUT);
BH_VERIFY(BH_SemaphorePost(semaphore) == BH_OK);
BH_VERIFY(BH_SemaphoreTryWait(semaphore) == BH_OK);
BH_VERIFY(BH_SemaphorePost(semaphore) == BH_OK);
BH_VERIFY(BH_SemaphoreWaitFor(semaphore, 5000) == BH_OK);
BH_VERIFY(BH_SemaphorePost(semaphore) == BH_OK);
BH_VERIFY(time(NULL) - start >= 5);
BH_SemaphoreFree(semaphore);
return 0;
}
BH_UNIT_TEST(Condition)
{
BH_Condition *condition;
BH_Mutex *mutex;
time_t start;
start = time(NULL);
BH_VERIFY((condition = BH_ConditionNew()) != NULL);
BH_VERIFY((mutex = BH_MutexNew()) != NULL);
BH_VERIFY(BH_MutexLock(mutex) == BH_OK);
BH_VERIFY(BH_ConditionWaitFor(condition, mutex, 5000) == BH_TIMEOUT);
BH_VERIFY(BH_ConditionSignal(condition) == BH_OK);
BH_VERIFY(BH_ConditionBroadcast(condition) == BH_OK);
BH_VERIFY(BH_MutexUnlock(mutex) == BH_OK);
BH_VERIFY(time(NULL) - start >= 5);
BH_ConditionFree(condition);
BH_MutexFree(mutex);
return 0;
}
static int ThreadCallback(void *data)
{
*(int *)data = 12345;
return 0;
}
BH_UNIT_TEST(Thread)
{
BH_Thread *thread;
int data = 0;
BH_VERIFY((thread = BH_ThreadNew(0, ThreadCallback, &data)) != NULL);
BH_VERIFY(BH_ThreadJoin(thread) == BH_OK);
BH_VERIFY(data == 12345);
return 0;
}
BH_UNIT_TEST(Spinlock)
{
int lock = 0;
BH_SpinlockLock(&lock);
BH_VERIFY(BH_SpinlockTryLock(&lock) != BH_OK);
BH_SpinlockUnlock(&lock);
BH_VERIFY(BH_SpinlockTryLock(&lock) == BH_OK);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Sleep);
BH_UNIT_ADD(Mutex);
BH_UNIT_ADD(Semaphore);
BH_UNIT_ADD(Condition);
BH_UNIT_ADD(Thread);
BH_UNIT_ADD(Spinlock);
return BH_UnitRun();
}

36
test/tests/TestTimer.c Normal file
View File

@@ -0,0 +1,36 @@
#include <BH/Unit.h>
#include <BH/Timer.h>
#include <BH/Thread.h>
BH_UNIT_TEST(General)
{
BH_Timer *timer;
BH_VERIFY((timer = BH_TimerNew()) != NULL);
BH_ThreadSleep(5000);
BH_VERIFY(BH_TimerMilliseconds(timer) >= 5000);
BH_VERIFY(BH_TimerNanoseconds(timer) >= 5000000000);
BH_VERIFY(BH_TimerRestart(timer) >= 5000);
BH_VERIFY(BH_TimerRestart(timer) < 5000);
BH_ThreadSleep(5000);
BH_VERIFY(BH_TimerMilliseconds(timer) >= 5000);
BH_TimerStart(timer);
BH_VERIFY(BH_TimerMilliseconds(timer) < 5000);
BH_TimerFree(timer);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(General);
return BH_UnitRun();
}

225
test/tests/TestUnicode.c Normal file
View File

@@ -0,0 +1,225 @@
#include <BH/Unit.h>
#include <BH/Unicode.h>
#include <BH/IO.h>
#include <stdlib.h>
struct TestCase
{
char *input;
size_t size;
size_t read;
uint32_t result;
};
BH_UNIT_TEST(Case)
{
size_t i, j;
for (i = 0; i < 0x110000; i++)
{
j = BH_UnicodeLower(i);
if (j == i)
{
j = BH_UnicodeUpper(i);
j = BH_UnicodeLower(j);
}
else
j = BH_UnicodeUpper(j);
/* Some exceptions */
if (i == 0x130 && j == 0x49)
continue;
else if (i == 0x131 && j == 0x69)
continue;
else if (i == 0x1C5 && j == 0x1C4)
continue;
else if (i == 0x1C8 && j == 0x1C7)
continue;
else if (i == 0x1CB && j == 0x1CA)
continue;
BH_VERIFY(i == j);
}
return 0;
}
BH_UNIT_TEST(Utf8)
{
const struct TestCase *current;
const struct TestCase cases[] =
{
/* Normal cases */
{"\x00", 1, 1, 0},
{"\xC2\x80", 2, 2, 0x80},
{"\xE0\xA0\x80", 3, 3, 0x800},
{"\xF0\x90\x80\x80", 4, 4, 0x10000},
{"\x7F", 1, 1, 0x7F},
{"\xDF\xBF", 2, 2, 0x7FF},
{"\xEF\xBF\xBF", 3, 3, 0xFFFF},
{"\xED\x9F\xBF", 3, 3, 0xD7FF},
{"\xEE\x80\x80", 3, 3, 0xE000},
{"\xEF\xBF\xBD", 3, 3, 0xFFFD},
{"H", 1, 1, 'H'},
{"\xCE\xBA", 2, 2, 0x3BA},
/* Lonely start characters */
{"\xC0 ", 2, 1, -1},
{"\xC1 ", 2, 1, -1},
{"\xC2 ", 2, 1, -1},
{"\xC3 ", 2, 1, -1},
{"\xC4 ", 2, 1, -1},
/* Malformed sequences */
{"\x80", 1, -1, -1},
{"\xBF", 1, -1, -1},
{"\xFE", 1, -1, -1},
{"\xFF", 1, -1, -1},
/* Overlong sequences */
{"\xC0\xAF", 2, 1, -1},
/* UTF-16 surrogate pairs */
{"\xED\xA0\x80", 3, -1, -1},
{"\xED\xAE\x80", 3, -1, -1},
{"\xED\xB0\x80", 3, -1, -1},
{"\xED\xBF\xBF", 3, -1, -1},
{NULL, 0, 0, 0}
};
char buffer[8];
uint32_t unit;
size_t i, outSize, inSize;
/* Encode and decode all character in a valid UTF-8 range */
for (i = 0; i < 0x110000; i++)
{
inSize = BH_UnicodeEncodeUtf8(i, buffer);
/* Check for surrogate pairs */
if (i > 0xD7FF && i < 0xE000)
{
BH_VERIFY(inSize == 0);
continue;
}
BH_VERIFY(inSize > 0);
outSize = BH_UnicodeDecodeUtf8(buffer, inSize, &unit);
BH_VERIFY(inSize == outSize);
BH_VERIFY(unit == i);
}
/* Test special cases */
for (current = cases; current->input; current++)
{
i = BH_UnicodeDecodeUtf8(current->input, current->size, &unit);
if (current->read == (size_t)-1 && i)
i = -1;
if (i != current->read || unit != current->result)
{
printf("\tcase %d\n", (int)(current - cases));
BH_VERIFY(i == current->read);
BH_VERIFY(unit == current->result);
}
}
return 0;
}
BH_UNIT_TEST(Utf16)
{
char buffer[8];
uint32_t unit;
size_t i, outSize, inSize;
/* Encode and decode all character in a valid UTF-8 range */
for (i = 0; i < 0x110000; i++)
{
/* Check for little endian */
inSize = BH_UnicodeEncodeUtf16LE(i, buffer);
if (i > 0xD7FF && i < 0xE000)
{
BH_VERIFY(inSize == 0);
continue;
}
BH_VERIFY(inSize > 0);
outSize = BH_UnicodeDecodeUtf16LE(buffer, inSize, &unit);
BH_VERIFY(inSize == outSize);
BH_VERIFY(unit == i);
/* Check for big endian */
inSize = BH_UnicodeEncodeUtf16BE(i, buffer);
if (i > 0xD7FF && i < 0xE000)
{
BH_VERIFY(inSize == 0);
continue;
}
BH_VERIFY(inSize > 0);
outSize = BH_UnicodeDecodeUtf16BE(buffer, inSize, &unit);
BH_VERIFY(inSize == outSize);
BH_VERIFY(unit == i);
}
return 0;
}
BH_UNIT_TEST(Utf32)
{
char buffer[8];
uint32_t unit;
size_t i, outSize, inSize;
/* Encode and decode all character in a valid UTF-8 range */
for (i = 0; i < 0x110000; i++)
{
/* Check for little endian */
inSize = BH_UnicodeEncodeUtf32LE(i, buffer);
if (i > 0xD7FF && i < 0xE000)
{
BH_VERIFY(inSize == 0);
continue;
}
BH_VERIFY(inSize > 0);
outSize = BH_UnicodeDecodeUtf32LE(buffer, inSize, &unit);
BH_VERIFY(inSize == outSize);
BH_VERIFY(unit == i);
/* Check for big endian */
inSize = BH_UnicodeEncodeUtf32BE(i, buffer);
if (i > 0xD7FF && i < 0xE000)
{
BH_VERIFY(inSize == 0);
continue;
}
BH_VERIFY(inSize > 0);
outSize = BH_UnicodeDecodeUtf32BE(buffer, inSize, &unit);
BH_VERIFY(inSize == outSize);
BH_VERIFY(unit == i);
}
return 0;
}
int main(int argc, char **argv)
{
BH_UNUSED(argc);
BH_UNUSED(argv);
BH_UNIT_ADD(Case);
BH_UNIT_ADD(Utf8);
BH_UNIT_ADD(Utf16);
BH_UNIT_ADD(Utf32);
return BH_UnitRun();
}

284
test/tests/TestVec2f.c Normal file
View File

@@ -0,0 +1,284 @@
#include <BH/Math/Vec2f.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(Add)
{
float a[2], b[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
BH_Vec2fAdd(a, b, r);
BH_VERIFY_DELTA(r[0], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 8.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Sub)
{
float a[2], b[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
BH_Vec2fSub(a, b, r);
BH_VERIFY_DELTA(r[0], -4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Mul)
{
float a[2], b[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
BH_Vec2fMul(a, b, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 12.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Scale)
{
float a[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
BH_Vec2fScale(a, 10.0000f, r);
BH_VERIFY_DELTA(r[0], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 20.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(MulAdd)
{
float a[2], b[2], c[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
c[0] = 1.5000f; c[1] = 2.5000f;
BH_Vec2fMulAdd(a, b, c, r);
BH_VERIFY_DELTA(r[0], 6.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 14.5000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Negate)
{
float a[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
BH_Vec2fNegate(a, r);
BH_VERIFY_DELTA(r[0], -1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -2.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Dot)
{
float a[2], b[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
BH_VERIFY_DELTA(BH_Vec2fDot(a, b), 17.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Cross)
{
float a[2], b[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
BH_VERIFY_DELTA(BH_Vec2fCross(a, b), -4.0f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Length)
{
float a[2];
a[0] = 1.0000f; a[1] = 2.0000f;
BH_VERIFY_DELTA(BH_Vec2fLength(a), sqrt(5.0000f), ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Normal)
{
float a[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
BH_Vec2fNormal(a, r);
BH_VERIFY_DELTA(r[0], 1.0000f / sqrt(5.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f / sqrt(5.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_Vec2fNormalEx(a, r), sqrt(5.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[0], 1.0000f / sqrt(5.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f / sqrt(5.0000f), ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Min)
{
float a[2], b[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
BH_Vec2fMin(a, b, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_Vec2fMin(b, a, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Max)
{
float a[2], b[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
BH_Vec2fMax(a, b, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_Vec2fMax(b, a, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Lerp)
{
float a[2], b[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
BH_Vec2fLerp(a, b, 0.0000f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_Vec2fLerp(a, b, 0.5000f, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 4.0000f, ACCEPTABLE_DELTA);
BH_Vec2fLerp(a, b, 1.0000f, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Project)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 4.0000f; b[1] = 3.0000f;
BH_Vec2fProject(a, b, r);
BH_VERIFY_DELTA(r[0], 1.6000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 1.2000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Barycentric)
{
float a[2], b[2], c[2], r[2];
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 5.0000f; b[1] = 6.0000f;
c[0] = 1.5000f; c[1] = 2.5000f;
BH_Vec2fBarycentric(a, b, c, 0.5f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 4.2500f, ACCEPTABLE_DELTA);
BH_Vec2fBarycentric(a, b, c, 0.25f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 2.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.2500f, ACCEPTABLE_DELTA);
a[0] = 1.0000f; a[1] = 2.0000f;
b[0] = 4.0000f; b[1] = 3.0000f;
c[0] = 4.0000f; c[1] = 4.0000f;
BH_Vec2fBarycentric(a, b, c, 0.0f, 0.0f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_Vec2fBarycentric(a, b, c, 0.5f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.5000f, ACCEPTABLE_DELTA);
BH_Vec2fBarycentric(a, b, c, 0.25f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.2500f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Add);
BH_UNIT_ADD(Sub);
BH_UNIT_ADD(Mul);
BH_UNIT_ADD(Scale);
BH_UNIT_ADD(MulAdd);
BH_UNIT_ADD(Negate);
BH_UNIT_ADD(Dot);
BH_UNIT_ADD(Cross);
BH_UNIT_ADD(Length);
BH_UNIT_ADD(Normal);
BH_UNIT_ADD(Min);
BH_UNIT_ADD(Max);
BH_UNIT_ADD(Lerp);
BH_UNIT_ADD(Project);
BH_UNIT_ADD(Barycentric);
return BH_UnitRun();
}

147
test/tests/TestVec2i.c Normal file
View File

@@ -0,0 +1,147 @@
#include <BH/Math/Vec2i.h>
#include <BH/Unit.h>
BH_UNIT_TEST(Add)
{
int a[2], b[2], r[2];
a[0] = 1; a[1] = 2;
b[0] = 5; b[1] = 6;
BH_Vec2iAdd(a, b, r);
BH_VERIFY(r[0] == 6);
BH_VERIFY(r[1] == 8);
return 0;
}
BH_UNIT_TEST(Sub)
{
int a[2], b[2], r[2];
a[0] = 1; a[1] = 2;
b[0] = 5; b[1] = 6;
BH_Vec2iSub(a, b, r);
BH_VERIFY(r[0] == -4);
BH_VERIFY(r[1] == -4);
return 0;
}
BH_UNIT_TEST(Mul)
{
int a[2], b[2], r[2];
a[0] = 1; a[1] = 2;
b[0] = 5; b[1] = 6;
BH_Vec2iMul(a, b, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 12);
return 0;
}
BH_UNIT_TEST(Scale)
{
int a[2], r[2];
a[0] = 1; a[1] = 2;
BH_Vec2iScale(a, 10, r);
BH_VERIFY(r[0] == 10);
BH_VERIFY(r[1] == 20);
return 0;
}
BH_UNIT_TEST(MulAdd)
{
int a[2], b[2], c[2], r[2];
a[0] = 1; a[1] = 2;
b[0] = 5; b[1] = 6;
c[0] = 4; c[1] = 3;
BH_Vec2iMulAdd(a, b, c, r);
BH_VERIFY(r[0] == 9);
BH_VERIFY(r[1] == 15);
return 0;
}
BH_UNIT_TEST(Negate)
{
int a[2], r[2];
a[0] = 1; a[1] = 2;
BH_Vec2iNegate(a, r);
BH_VERIFY(r[0] == -1);
BH_VERIFY(r[1] == -2);
return 0;
}
BH_UNIT_TEST(Min)
{
int a[2], b[2], r[2];
a[0] = 1; a[1] = 2;
b[0] = 5; b[1] = 6;
BH_Vec2iMin(a, b, r);
BH_VERIFY(r[0] == 1);
BH_VERIFY(r[1] == 2);
BH_Vec2iMin(b, a, r);
BH_VERIFY(r[0] == 1);
BH_VERIFY(r[1] == 2);
return 0;
}
BH_UNIT_TEST(Max)
{
int a[2], b[2], r[2];
a[0] = 1; a[1] = 2;
b[0] = 5; b[1] = 6;
BH_Vec2iMax(a, b, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 6);
BH_Vec2iMax(b, a, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 6);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Add);
BH_UNIT_ADD(Sub);
BH_UNIT_ADD(Mul);
BH_UNIT_ADD(Scale);
BH_UNIT_ADD(MulAdd);
BH_UNIT_ADD(Negate);
BH_UNIT_ADD(Min);
BH_UNIT_ADD(Max);
return BH_UnitRun();
}

309
test/tests/TestVec3f.c Normal file
View File

@@ -0,0 +1,309 @@
#include <BH/Math/Vec3f.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(Add)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
BH_Vec3fAdd(a, b, r);
BH_VERIFY_DELTA(r[0], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 8.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 10.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Sub)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
BH_Vec3fSub(a, b, r);
BH_VERIFY_DELTA(r[0], -4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Mul)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
BH_Vec3fMul(a, b, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 12.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 21.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Scale)
{
float a[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
BH_Vec3fScale(a, 10.0000f, r);
BH_VERIFY_DELTA(r[0], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 20.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 30.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(MulAdd)
{
float a[3], b[3], c[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
c[0] = 1.5000f; c[1] = 2.5000f; c[2] = 3.5000f;
BH_Vec3fMulAdd(a, b, c, r);
BH_VERIFY_DELTA(r[0], 6.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 14.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 24.5000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Negate)
{
float a[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
BH_Vec3fNegate(a, r);
BH_VERIFY_DELTA(r[0], -1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -3.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Dot)
{
float a[3], b[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
BH_VERIFY_DELTA(BH_Vec3fDot(a, b), 38.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Cross)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
BH_Vec3fCross(a, b, r);
BH_VERIFY_DELTA(r[0], -4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 8.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Length)
{
float a[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
BH_VERIFY_DELTA(BH_Vec3fLength(a), sqrt(14.0000f), ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Normal)
{
float a[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
BH_Vec3fNormal(a, r);
BH_VERIFY_DELTA(r[0], 1.0000f / sqrt(14.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f / sqrt(14.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f / sqrt(14.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_Vec3fNormalEx(a, r), sqrt(14.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[0], 1.0000f / sqrt(14.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f / sqrt(14.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f / sqrt(14.0000f), ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Min)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
BH_Vec3fMin(a, b, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_Vec3fMin(b, a, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Max)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
BH_Vec3fMax(a, b, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 7.0000f, ACCEPTABLE_DELTA);
BH_Vec3fMax(b, a, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 7.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Lerp)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
BH_Vec3fLerp(a, b, 0.0000f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_Vec3fLerp(a, b, 0.5000f, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 5.0000f, ACCEPTABLE_DELTA);
BH_Vec3fLerp(a, b, 1.0000f, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 7.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Project)
{
float a[3], b[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 4.0000f; b[1] = 3.0000f; b[2] = 2.0000f;
BH_Vec3fProject(a, b, r);
BH_VERIFY_DELTA(r[0], 2.2069f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 1.6552f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 1.1034f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Barycentric)
{
float a[3], b[3], c[3], r[3];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f;
c[0] = 1.5000f; c[1] = 2.5000f; c[2] = 3.5000f;
BH_Vec3fBarycentric(a, b, c, 0.5f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 4.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 5.2500f, ACCEPTABLE_DELTA);
BH_Vec3fBarycentric(a, b, c, 0.25f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 2.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 4.2500f, ACCEPTABLE_DELTA);
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f;
b[0] = 4.0000f; b[1] = 3.0000f; b[2] = 2.0000f;
c[0] = 4.0000f; c[1] = 4.0000f; c[2] = 4.0000f;
BH_Vec3fBarycentric(a, b, c, 0.0f, 0.0f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_Vec3fBarycentric(a, b, c, 0.5f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_Vec3fBarycentric(a, b, c, 0.25f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.2500f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Add);
BH_UNIT_ADD(Sub);
BH_UNIT_ADD(Mul);
BH_UNIT_ADD(Scale);
BH_UNIT_ADD(MulAdd);
BH_UNIT_ADD(Negate);
BH_UNIT_ADD(Dot);
BH_UNIT_ADD(Cross);
BH_UNIT_ADD(Length);
BH_UNIT_ADD(Normal);
BH_UNIT_ADD(Min);
BH_UNIT_ADD(Max);
BH_UNIT_ADD(Lerp);
BH_UNIT_ADD(Project);
BH_UNIT_ADD(Barycentric);
return BH_UnitRun();
}

157
test/tests/TestVec3i.c Normal file
View File

@@ -0,0 +1,157 @@
#include <BH/Math/Vec3i.h>
#include <BH/Unit.h>
BH_UNIT_TEST(Add)
{
int a[3], b[3], r[3];
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 5; b[1] = 6; b[2] = 7;
BH_Vec3iAdd(a, b, r);
BH_VERIFY(r[0] == 6);
BH_VERIFY(r[1] == 8);
BH_VERIFY(r[2] == 10);
return 0;
}
BH_UNIT_TEST(Sub)
{
int a[3], b[3], r[3];
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 5; b[1] = 6; b[2] = 7;
BH_Vec3iSub(a, b, r);
BH_VERIFY(r[0] == -4);
BH_VERIFY(r[1] == -4);
BH_VERIFY(r[2] == -4);
return 0;
}
BH_UNIT_TEST(Mul)
{
int a[3], b[3], r[3];
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 5; b[1] = 6; b[2] = 7;
BH_Vec3iMul(a, b, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 12);
BH_VERIFY(r[2] == 21);
return 0;
}
BH_UNIT_TEST(Scale)
{
int a[3], r[3];
a[0] = 1; a[1] = 2; a[2] = 3;
BH_Vec3iScale(a, 10, r);
BH_VERIFY(r[0] == 10);
BH_VERIFY(r[1] == 20);
BH_VERIFY(r[2] == 30);
return 0;
}
BH_UNIT_TEST(MulAdd)
{
int a[3], b[3], c[3], r[3];
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 5; b[1] = 6; b[2] = 7;
c[0] = 4; c[1] = 3; c[2] = 2;
BH_Vec3iMulAdd(a, b, c, r);
BH_VERIFY(r[0] == 9);
BH_VERIFY(r[1] == 15);
BH_VERIFY(r[2] == 23);
return 0;
}
BH_UNIT_TEST(Negate)
{
int a[3], r[3];
a[0] = 1; a[1] = 2; a[2] = 3;
BH_Vec3iNegate(a, r);
BH_VERIFY(r[0] == -1);
BH_VERIFY(r[1] == -2);
BH_VERIFY(r[2] == -3);
return 0;
}
BH_UNIT_TEST(Min)
{
int a[3], b[3], r[3];
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 5; b[1] = 6; b[2] = 7;
BH_Vec3iMin(a, b, r);
BH_VERIFY(r[0] == 1);
BH_VERIFY(r[1] == 2);
BH_VERIFY(r[2] == 3);
BH_Vec3iMin(b, a, r);
BH_VERIFY(r[0] == 1);
BH_VERIFY(r[1] == 2);
BH_VERIFY(r[2] == 3);
return 0;
}
BH_UNIT_TEST(Max)
{
int a[3], b[3], r[3];
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 5; b[1] = 6; b[2] = 7;
BH_Vec3iMax(a, b, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 6);
BH_VERIFY(r[2] == 7);
BH_Vec3iMax(b, a, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 6);
BH_VERIFY(r[2] == 7);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Add);
BH_UNIT_ADD(Sub);
BH_UNIT_ADD(Mul);
BH_UNIT_ADD(Scale);
BH_UNIT_ADD(MulAdd);
BH_UNIT_ADD(Negate);
BH_UNIT_ADD(Min);
BH_UNIT_ADD(Max);
return BH_UnitRun();
}

313
test/tests/TestVec4f.c Normal file
View File

@@ -0,0 +1,313 @@
#include <BH/Math/Vec4f.h>
#include <BH/Unit.h>
#define ACCEPTABLE_DELTA 0.0001f
BH_UNIT_TEST(Add)
{
float a[4], b[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
BH_Vec4fAdd(a, b, r);
BH_VERIFY_DELTA(r[0], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 8.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 12.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Sub)
{
float a[4], b[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
BH_Vec4fSub(a, b, r);
BH_VERIFY_DELTA(r[0], -4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], -4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Mul)
{
float a[4], b[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
BH_Vec4fMul(a, b, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 12.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 21.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 32.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Scale)
{
float a[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
BH_Vec4fScale(a, 10.0000f, r);
BH_VERIFY_DELTA(r[0], 10.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 20.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 30.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 40.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(MulAdd)
{
float a[4], b[4], c[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
c[0] = 1.5000f; c[1] = 2.5000f; c[2] = 3.5000f; c[3] = 4.5000f;
BH_Vec4fMulAdd(a, b, c, r);
BH_VERIFY_DELTA(r[0], 6.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 14.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 24.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 36.5000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Negate)
{
float a[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
BH_Vec4fNegate(a, r);
BH_VERIFY_DELTA(r[0], -1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], -2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], -3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], -4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Dot)
{
float a[4], b[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
BH_VERIFY_DELTA(BH_Vec4fDot(a, b), 70.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Length)
{
float a[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
BH_VERIFY_DELTA(BH_Vec4fLength(a), sqrt(30.0000f), ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Normal)
{
float a[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
BH_Vec4fNormal(a, r);
BH_VERIFY_DELTA(r[0], 1.0f / sqrt(30.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0f / sqrt(30.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0f / sqrt(30.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 4.0f / sqrt(30.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(BH_Vec4fNormalEx(a, r), sqrt(30.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[0], 1.0000f / sqrt(30.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f / sqrt(30.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f / sqrt(30.0000f), ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 4.0000f / sqrt(30.0000f), ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Min)
{
float a[4], b[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
BH_Vec4fMin(a, b, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 4.0000f, ACCEPTABLE_DELTA);
BH_Vec4fMin(b, a, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 4.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Max)
{
float a[4], b[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
BH_Vec4fMax(a, b, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 7.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 8.0000f, ACCEPTABLE_DELTA);
BH_Vec4fMax(b, a, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 7.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 8.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Lerp)
{
float a[4], b[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
BH_Vec4fLerp(a, b, 0.0000f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 4.0000f, ACCEPTABLE_DELTA);
BH_Vec4fLerp(a, b, 0.5000f, r);
BH_VERIFY_DELTA(r[0], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 6.0000f, ACCEPTABLE_DELTA);
BH_Vec4fLerp(a, b, 1.0000f, r);
BH_VERIFY_DELTA(r[0], 5.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 6.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 7.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 8.0000f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Project)
{
float a[4], b[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 4.0000f; b[1] = 3.0000f; b[2] = 2.0000f; b[3] = 1.0000f;
BH_Vec4fProject(a, b, r);
BH_VERIFY_DELTA(r[0], 2.6667f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 1.3333f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 0.6667f, ACCEPTABLE_DELTA);
return 0;
}
BH_UNIT_TEST(Barycentric)
{
float a[4], b[4], c[4], r[4];
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 5.0000f; b[1] = 6.0000f; b[2] = 7.0000f; b[3] = 8.0000f;
c[0] = 1.5000f; c[1] = 2.5000f; c[2] = 3.5000f; c[3] = 4.5000f;
BH_Vec4fBarycentric(a, b, c, 0.5f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 4.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 5.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 6.2500f, ACCEPTABLE_DELTA);
BH_Vec4fBarycentric(a, b, c, 0.25f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 2.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 4.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 5.2500f, ACCEPTABLE_DELTA);
a[0] = 1.0000f; a[1] = 2.0000f; a[2] = 3.0000f; a[3] = 4.0000f;
b[0] = 4.0000f; b[1] = 3.0000f; b[2] = 2.0000f; b[3] = 1.0000f;
c[0] = 4.0000f; c[1] = 4.0000f; c[2] = 4.0000f; c[3] = 4.0000f;
BH_Vec4fBarycentric(a, b, c, 0.0f, 0.0f, r);
BH_VERIFY_DELTA(r[0], 1.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 2.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 4.0000f, ACCEPTABLE_DELTA);
BH_Vec4fBarycentric(a, b, c, 0.5f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 4.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.5000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.0000f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 2.5000f, ACCEPTABLE_DELTA);
BH_Vec4fBarycentric(a, b, c, 0.25f, 0.5f, r);
BH_VERIFY_DELTA(r[0], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[1], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[2], 3.2500f, ACCEPTABLE_DELTA);
BH_VERIFY_DELTA(r[3], 3.2500f, ACCEPTABLE_DELTA);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Add);
BH_UNIT_ADD(Sub);
BH_UNIT_ADD(Mul);
BH_UNIT_ADD(Scale);
BH_UNIT_ADD(MulAdd);
BH_UNIT_ADD(Negate);
BH_UNIT_ADD(Dot);
BH_UNIT_ADD(Length);
BH_UNIT_ADD(Normal);
BH_UNIT_ADD(Min);
BH_UNIT_ADD(Max);
BH_UNIT_ADD(Lerp);
BH_UNIT_ADD(Project);
BH_UNIT_ADD(Barycentric);
return BH_UnitRun();
}

167
test/tests/TestVec4i.c Normal file
View File

@@ -0,0 +1,167 @@
#include <BH/Math/Vec4i.h>
#include <BH/Unit.h>
BH_UNIT_TEST(Add)
{
int a[4], b[4], r[4];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4;
b[0] = 5; b[1] = 6; b[2] = 7; b[3] = 8;
BH_Vec4iAdd(a, b, r);
BH_VERIFY(r[0] == 6);
BH_VERIFY(r[1] == 8);
BH_VERIFY(r[2] == 10);
BH_VERIFY(r[3] == 12);
return 0;
}
BH_UNIT_TEST(Sub)
{
int a[4], b[4], r[4];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4;
b[0] = 5; b[1] = 6; b[2] = 7; b[3] = 8;
BH_Vec4iSub(a, b, r);
BH_VERIFY(r[0] == -4);
BH_VERIFY(r[1] == -4);
BH_VERIFY(r[2] == -4);
BH_VERIFY(r[3] == -4);
return 0;
}
BH_UNIT_TEST(Mul)
{
int a[4], b[4], r[4];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4;
b[0] = 5; b[1] = 6; b[2] = 7; b[3] = 8;
BH_Vec4iMul(a, b, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 12);
BH_VERIFY(r[2] == 21);
BH_VERIFY(r[3] == 32);
return 0;
}
BH_UNIT_TEST(Scale)
{
int a[4], r[4];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4;
BH_Vec4iScale(a, 10, r);
BH_VERIFY(r[0] == 10);
BH_VERIFY(r[1] == 20);
BH_VERIFY(r[2] == 30);
BH_VERIFY(r[3] == 40);
return 0;
}
BH_UNIT_TEST(MulAdd)
{
int a[4], b[4], c[4], r[4];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4;
b[0] = 5; b[1] = 6; b[2] = 7; b[3] = 8;
c[0] = 4; c[1] = 3; c[2] = 2; c[3] = 1;
BH_Vec4iMulAdd(a, b, c, r);
BH_VERIFY(r[0] == 9);
BH_VERIFY(r[1] == 15);
BH_VERIFY(r[2] == 23);
BH_VERIFY(r[3] == 33);
return 0;
}
BH_UNIT_TEST(Negate)
{
int a[4], r[4];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4;
BH_Vec4iNegate(a, r);
BH_VERIFY(r[0] == -1);
BH_VERIFY(r[1] == -2);
BH_VERIFY(r[2] == -3);
BH_VERIFY(r[3] == -4);
return 0;
}
BH_UNIT_TEST(Min)
{
int a[4], b[4], r[4];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4;
b[0] = 5; b[1] = 6; b[2] = 7; b[3] = 8;
BH_Vec4iMin(a, b, r);
BH_VERIFY(r[0] == 1);
BH_VERIFY(r[1] == 2);
BH_VERIFY(r[2] == 3);
BH_VERIFY(r[3] == 4);
BH_Vec4iMin(b, a, r);
BH_VERIFY(r[0] == 1);
BH_VERIFY(r[1] == 2);
BH_VERIFY(r[2] == 3);
BH_VERIFY(r[3] == 4);
return 0;
}
BH_UNIT_TEST(Max)
{
int a[4], b[4], r[4];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4;
b[0] = 5; b[1] = 6; b[2] = 7; b[3] = 8;
BH_Vec4iMax(a, b, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 6);
BH_VERIFY(r[2] == 7);
BH_VERIFY(r[3] == 8);
BH_Vec4iMax(b, a, r);
BH_VERIFY(r[0] == 5);
BH_VERIFY(r[1] == 6);
BH_VERIFY(r[2] == 7);
BH_VERIFY(r[3] == 8);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
BH_UNIT_ADD(Add);
BH_UNIT_ADD(Sub);
BH_UNIT_ADD(Mul);
BH_UNIT_ADD(Scale);
BH_UNIT_ADD(MulAdd);
BH_UNIT_ADD(Negate);
BH_UNIT_ADD(Min);
BH_UNIT_ADD(Max);
return BH_UnitRun();
}