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

Change code and naming style, fix several bugs, removed math types.

Browse Source 
After a while I felt that putting underscores between words was not the
best solution, so I changed the underscores to capital letters.

Fixed consistency bug between POSIX/Win32 platform in BH_FileOpen.

Removed definitions for math types (vector, matrix, etc.) due to
potential aliasing issues.
This commit is contained in:
Mikhail Romanko
2025-01-30 13:53:26 +03:00
parent 8d73a9b473
commit c89cf8f316
22 changed files with 3400 additions and 4135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
test/src/testalgo.c
View File

@@ -4,17 +4,17 @@
#include <stdlib.h>
static int int_equal(const void *lhs,
const void *rhs)
static int DBG_IntEqual(const void *lhs,
const void *rhs)
{
return *(const int*)lhs - *(const int*)rhs;
}
static int verify_partition(size_t index,
int pivot,
int *array,
size_t size)
static int DBG_VerifyPartition(size_t index,
int pivot,
int *array,
size_t size)
{
size_t i;
@@ -30,8 +30,8 @@ static int verify_partition(size_t index,
}
static int verify_heap(int *array,
size_t size)
static int DBG_VerifyHeap(int *array,
size_t size)
{
size_t i, left, right;
@@ -50,7 +50,7 @@ static int verify_heap(int *array,
}
static int reference_rand(void)
static int DBG_ReferenceRand(void)
{
static uint32_t next = 2025;
next = next * 1103515245 + 12345;
@@ -58,7 +58,8 @@ static int reference_rand(void)
}
static void reference_sort(int *array, size_t size)
static void DBG_ReferenceSort(int *array,
size_t size)
{
size_t i, j;
int tmp;
@@ -79,10 +80,10 @@ static void reference_sort(int *array, size_t size)
}
static void fill_arrays(int *array,
int *reference,
size_t size,
int mask)
static void DBG_FillArrays(int *array,
int *reference,
size_t size,
int mask)
{
size_t i;
int negate;
@@ -95,7 +96,7 @@ static void fill_arrays(int *array,
/* Fill the array */
for (i = 0; i < size; ++i)
{
array[i] = reference_rand();
array[i] = DBG_ReferenceRand();
if (mask > 1)
array[i] = array[i] % mask;
@@ -109,19 +110,19 @@ static void fill_arrays(int *array,
}
static int check_sort(void)
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), int_equal);
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), int_equal);
BH_Sort(data, 1, sizeof(int), DBG_IntEqual);
BH_VERIFY(data[0] == 1);
BH_VERIFY(data[1] == 2);
BH_VERIFY(data[2] == 3);
@@ -129,27 +130,27 @@ static int check_sort(void)
/* Test array against different sizes */
for (size = sizes; *size; ++size)
{
fill_arrays(data, reference, *size, 0);
reference_sort(reference, *size);
bh_sort(data, *size, sizeof(int), int_equal);
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)
{
fill_arrays(data, reference, *size, -1);
reference_sort(reference, *size);
bh_sort(data, *size, sizeof(int), int_equal);
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)
{
fill_arrays(data, reference, *size, 4);
reference_sort(reference, *size);
bh_sort(data, *size, sizeof(int), int_equal);
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);
}
@@ -157,7 +158,7 @@ static int check_sort(void)
}
static int check_partition(void)
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;
@@ -165,13 +166,13 @@ static int check_partition(void)
/* 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), int_equal);
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), int_equal);
pivot = BH_Partition(&value, data, 1, sizeof(int), DBG_IntEqual);
BH_VERIFY(pivot == data);
BH_VERIFY(data[0] == 1);
BH_VERIFY(data[1] == 2);
@@ -180,104 +181,104 @@ static int check_partition(void)
/* Test array against different sizes */
for (size = sizes; *size; ++size)
{
fill_arrays(data, reference, *size, 0);
DBG_FillArrays(data, reference, *size, 0);
value = 16384;
pivot = bh_partition(&value, data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
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)
{
fill_arrays(data, reference, *size, -1);
DBG_FillArrays(data, reference, *size, -1);
value = -16384;
pivot = bh_partition(&value, data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
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)
{
fill_arrays(data, reference, *size, 4);
DBG_FillArrays(data, reference, *size, 4);
value = 2;
pivot = bh_partition(&value, data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
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)
{
fill_arrays(data, reference, *size, 0);
DBG_FillArrays(data, reference, *size, 0);
value = -100;
pivot = bh_partition(&value, data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
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)
{
fill_arrays(data, reference, *size, 0);
DBG_FillArrays(data, reference, *size, 0);
value = 65536;
pivot = bh_partition(&value, data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(&value, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
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)
{
fill_arrays(data, reference, *size, 0);
DBG_FillArrays(data, reference, *size, 0);
value = data[0];
pivot = bh_partition(data, data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(data, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
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)
{
fill_arrays(data, reference, *size, -1);
DBG_FillArrays(data, reference, *size, -1);
value = data[0];
pivot = bh_partition(data, data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(data, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
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)
{
fill_arrays(data, reference, *size, 4);
DBG_FillArrays(data, reference, *size, 4);
value = data[0];
pivot = bh_partition(data, data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(data, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
@@ -287,11 +288,11 @@ static int check_partition(void)
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), int_equal);
BH_VERIFY(verify_partition(pivot - data, value, data, *size) == 0);
pivot = BH_Partition(data + *size - 1, data, *size, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyPartition(pivot - data, value, data, *size) == 0);
reference_sort(data, *size);
reference_sort(reference, *size);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size * sizeof(int)) == 0);
}
@@ -299,14 +300,14 @@ static int check_partition(void)
}
static int check_heap_make(void)
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_heap_make(data, 0, sizeof(int), int_equal);
BH_HeapMake(data, 0, sizeof(int), DBG_IntEqual);
BH_VERIFY(data[0] == 1);
BH_VERIFY(data[1] == 2);
BH_VERIFY(data[2] == 3);
@@ -314,32 +315,32 @@ static int check_heap_make(void)
/* Test array against different sizes */
for (size = sizes; *size; ++size)
{
fill_arrays(data, NULL, *size, 0);
bh_heap_make(data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_heap(data, *size) == 0);
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)
{
fill_arrays(data, NULL, *size, -1);
bh_heap_make(data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_heap(data, *size) == 0);
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)
{
fill_arrays(data, NULL, *size, 4);
bh_heap_make(data, *size, sizeof(int), int_equal);
BH_VERIFY(verify_heap(data, *size) == 0);
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 check_heap_insert(void)
static int CheckHeapInsert(void)
{
size_t sizes[] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0}, *size;
int data[317], reference[317];
@@ -348,18 +349,18 @@ static int check_heap_insert(void)
for (size = sizes; *size; ++size)
{
size_t i;
fill_arrays(data, reference, *size, 0);
DBG_FillArrays(data, reference, *size, 0);
for (i = 0; i < *size; ++i)
{
int value;
value = data[i];
bh_heap_insert(&value, data, i, sizeof(int), int_equal);
BH_VERIFY(verify_heap(data, i + 1) == 0);
BH_HeapInsert(&value, data, i, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, i + 1) == 0);
}
reference_sort(data, *size);
reference_sort(reference, *size);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size) == 0);
}
@@ -367,15 +368,15 @@ static int check_heap_insert(void)
for (size = sizes; *size; ++size)
{
size_t i;
fill_arrays(data, reference, *size, 0);
DBG_FillArrays(data, reference, *size, 0);
for (i = 0; i < *size; ++i)
{
bh_heap_insert(NULL, data, i, sizeof(int), int_equal);
BH_VERIFY(verify_heap(data, i + 1) == 0);
BH_HeapInsert(NULL, data, i, sizeof(int), DBG_IntEqual);
BH_VERIFY(DBG_VerifyHeap(data, i + 1) == 0);
}
reference_sort(data, *size);
reference_sort(reference, *size);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size) == 0);
}
@@ -383,7 +384,7 @@ static int check_heap_insert(void)
}
static int check_heap_remove(void)
static int CheckHeapRemove(void)
{
size_t sizes[] = {1, 2, 3, 5, 11, 23, 41, 79, 163, 317, 0}, *size;
int data[317], reference[317];
@@ -392,17 +393,17 @@ static int check_heap_remove(void)
for (size = sizes; *size; ++size)
{
size_t i;
fill_arrays(data, reference, *size, 0);
bh_heap_make(data, *size, sizeof(int), int_equal);
DBG_FillArrays(data, reference, *size, 0);
BH_HeapMake(data, *size, sizeof(int), DBG_IntEqual);
for (i = *size; i > 0; i--)
{
BH_VERIFY(verify_heap(data, i) == 0);
bh_heap_remove(data, i, sizeof(int), int_equal);
BH_VERIFY(DBG_VerifyHeap(data, i) == 0);
BH_HeapRemove(data, i, sizeof(int), DBG_IntEqual);
}
reference_sort(data, *size);
reference_sort(reference, *size);
DBG_ReferenceSort(data, *size);
DBG_ReferenceSort(reference, *size);
BH_VERIFY(memcmp(data, reference, *size) == 0);
}
@@ -410,57 +411,57 @@ static int check_heap_remove(void)
}
static int check_heap_replace(void)
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_heap_make(data, 10, sizeof(int), int_equal);
bh_heap_make(reference, 10, sizeof(int), int_equal);
BH_VERIFY(verify_heap(data, 10) == 0);
BH_VERIFY(verify_heap(reference, 10) == 0);
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_heap_replace(&value, data, 10, sizeof(int), int_equal);
bh_heap_remove(reference, 10, sizeof(int), int_equal);
bh_heap_insert(&value, reference, 9, sizeof(int), int_equal);
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(verify_heap(data, 10) == 0);
BH_VERIFY(verify_heap(reference, 10) == 0);
bh_sort(data, 10, sizeof(int), int_equal);
bh_sort(reference, 10, sizeof(int), int_equal);
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_heap_replace(&value, data, 1, sizeof(int), int_equal);
bh_heap_remove(reference, 1, sizeof(int), int_equal);
bh_heap_insert(&value, reference, 0, sizeof(int), int_equal);
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(verify_heap(data, 1) == 0);
BH_VERIFY(verify_heap(reference, 1) == 0);
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), int_equal);
bh_sort(reference, 10, sizeof(int), int_equal);
bh_heap_make(data, 10, sizeof(int), int_equal);
bh_heap_make(reference, 10, sizeof(int), int_equal);
BH_VERIFY(verify_heap(data, 10) == 0);
BH_VERIFY(verify_heap(reference, 10) == 0);
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_heap_replace(NULL, data, 10, sizeof(int), int_equal);
bh_heap_remove(reference, 10, sizeof(int), int_equal);
bh_heap_insert(&value, reference, 9, sizeof(int), int_equal);
BH_VERIFY(verify_heap(data, 10) == 0);
BH_VERIFY(verify_heap(reference, 10) == 0);
bh_sort(data, 10, sizeof(int), int_equal);
bh_sort(reference, 10, sizeof(int), int_equal);
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;
@@ -472,12 +473,12 @@ int main(int argc, char **argv)
BH_UNUSED(argc);
BH_UNUSED(argv);
bh_unit_add("sort", check_sort);
bh_unit_add("partition", check_partition);
bh_unit_add("heap_make", check_heap_make);
bh_unit_add("heap_insert", check_heap_insert);
bh_unit_add("heap_remove", check_heap_remove);
bh_unit_add("heap_replace", check_heap_replace);
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_unit_run();
return BH_UnitRun();
}

570
test/src/testfile.c
View File

@@ -24,41 +24,41 @@ static void cleanup(void)
/**
* Check for invalid arguments.
*/
static int check_null(void)
static int checkNull(void)
{
bh_io_t *io;
BH_IO *io;
/* Check against NULL pointers */
BH_VERIFY(bh_file_new(NULL) == NULL);
BH_VERIFY(bh_io_classname(NULL) == NULL);
BH_VERIFY(bh_io_open(NULL, 0) != BH_OK);
BH_VERIFY(bh_io_close(NULL) != BH_OK);
BH_VERIFY(bh_io_read(NULL, NULL, 0, NULL) != BH_OK);
BH_VERIFY(bh_io_write(NULL, NULL, 0, NULL) != BH_OK);
BH_VERIFY(bh_io_peek(NULL, NULL, 0, NULL) != BH_OK);
BH_VERIFY(bh_io_tell(NULL, NULL) != BH_OK);
BH_VERIFY(bh_io_seek(NULL, 0, 0) != BH_OK);
BH_VERIFY(bh_io_flush(NULL) != BH_OK);
BH_VERIFY(bh_io_size(NULL, NULL) != BH_OK);
BH_VERIFY(bh_io_flags(NULL) == BH_IO_FLAG_ERROR);
BH_VERIFY(bh_io_clear(NULL) == BH_OK);
bh_io_free(NULL);
BH_VERIFY(BH_FileNew(NULL) == NULL);
BH_VERIFY(BH_IOClassname(NULL) == NULL);
BH_VERIFY(BH_IOOpen(NULL, 0) != BH_OK);
BH_VERIFY(BH_IOClose(NULL) != BH_OK);
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) == BH_IO_FLAG_ERROR);
BH_VERIFY(BH_IOClear(NULL) == BH_OK);
BH_IOFree(NULL);
/* Check against NULL pointers and valid IO object */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, 0) != BH_OK);
BH_VERIFY(bh_io_close(io) != BH_OK);
BH_VERIFY(bh_io_read(io, NULL, 0, NULL) != BH_OK);
BH_VERIFY(bh_io_write(io, NULL, 0, NULL) != BH_OK);
BH_VERIFY(bh_io_peek(io, NULL, 0, NULL) != BH_OK);
BH_VERIFY(bh_io_tell(io, NULL) != BH_OK);
BH_VERIFY(bh_io_seek(io, 0, 0) != BH_OK);
BH_VERIFY(bh_io_flush(io) != BH_OK);
BH_VERIFY(bh_io_size(io, NULL) != BH_OK);
BH_VERIFY(bh_io_flags(io) == BH_IO_FLAG_ERROR);
BH_VERIFY(bh_io_clear(io) == BH_OK);
bh_io_free(io);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, 0) != BH_OK);
BH_VERIFY(BH_IOClose(io) != BH_OK);
BH_VERIFY(BH_IORead(io, NULL, 0, NULL) != BH_OK);
BH_VERIFY(BH_IOWrite(io, NULL, 0, NULL) != BH_OK);
BH_VERIFY(BH_IOPeek(io, NULL, 0, NULL) != BH_OK);
BH_VERIFY(BH_IOTell(io, NULL) != BH_OK);
BH_VERIFY(BH_IOSeek(io, 0, 0) != BH_OK);
BH_VERIFY(BH_IOFlush(io) != BH_OK);
BH_VERIFY(BH_IOSize(io, NULL) != BH_OK);
BH_VERIFY(BH_IOFlags(io) == BH_IO_FLAG_ERROR);
BH_VERIFY(BH_IOClear(io) == BH_OK);
BH_IOFree(io);
return 0;
}
@@ -67,93 +67,93 @@ static int check_null(void)
/**
* Check for normal mode.
*/
static int check_normal(void)
static int checkNormal(void)
{
int64_t position;
char buffer[128];
size_t actual;
bh_io_t *io;
BH_IO *io;
/* Check operations for write only access */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_open(io, BH_IO_READ) != BH_OK);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ) != BH_OK);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_seek(io, 10, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_write(io, "abcde", 5, &actual) == BH_OK);
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_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 1, &actual) != BH_OK);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(bh_io_tell(io, &position) == BH_OK);
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_io_close(io);
BH_IOClose(io);
/* Check operations for read only access */
BH_VERIFY(bh_io_open(io, BH_IO_READ) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 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_io_read(io, buffer, 5, &actual) == 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_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, sizeof(buffer), &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 == 20);
BH_VERIFY(memcmp(buffer, "1234567890abcde67890", 20) == 0);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) != BH_OK);
BH_VERIFY(bh_io_seek(io, -5, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == BH_OK);
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_io_free(io);
BH_IOFree(io);
/* Check operations for read and write access */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_READ) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_READ) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_write(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == BH_OK);
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_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 35, &actual) == BH_OK);
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_io_close(io);
BH_IOClose(io);
bh_io_free(io);
BH_IOFree(io);
return 0;
}
@@ -161,108 +161,108 @@ static int check_normal(void)
/**
* Check for truncate mode.
*/
static int check_truncate(void)
static int checkTruncate(void)
{
int64_t position;
char buffer[128];
size_t actual;
bh_io_t *io;
BH_IO *io;
/* Check operations for write only access */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_seek(io, 10, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_write(io, "abcde", 5, &actual) == BH_OK);
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_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 1, &actual) != BH_OK);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(bh_io_tell(io, &position) == BH_OK);
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_io_close(io);
BH_IOClose(io);
/* Check operations for read only access without truncate */
BH_VERIFY(bh_io_open(io, BH_IO_READ) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == 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_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, sizeof(buffer), &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 == 20);
BH_VERIFY(memcmp(buffer, "1234567890abcde67890", 20) == 0);
BH_VERIFY(bh_io_seek(io, -5, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 5, &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_io_close(io);
BH_IOClose(io);
/* Check operations for read only access */
BH_VERIFY(bh_io_open(io, BH_IO_READ | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 0);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 5, &actual) == BH_OK);
BH_VERIFY(actual == 0);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) != BH_OK);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, sizeof(buffer), &actual) == BH_OK);
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_io_free(io);
BH_IOFree(io);
/* Check operations for read and write access */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_READ | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_READ | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_write(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == BH_OK);
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_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 35, &actual) == BH_OK);
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_io_close(io);
BH_IOClose(io);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
bh_io_close(io);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_IOClose(io);
bh_io_free(io);
BH_IOFree(io);
return 0;
}
@@ -270,100 +270,100 @@ static int check_truncate(void)
/**
* Check for exist mode.
*/
static int check_exist(void)
static int checkExist(void)
{
int64_t position;
char buffer[128];
size_t actual;
bh_io_t *io;
BH_IO *io;
/* Check operations for write only access */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_EXIST) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_EXIST) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_seek(io, 10, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_write(io, "abcde", 5, &actual) == BH_OK);
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_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 1, &actual) != BH_OK);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(bh_io_tell(io, &position) == BH_OK);
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_io_close(io);
BH_IOClose(io);
/* Check operations for read only access */
BH_VERIFY(bh_io_open(io, BH_IO_READ | BH_IO_EXIST) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ | BH_IO_EXIST) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == 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_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, sizeof(buffer), &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 == 20);
BH_VERIFY(memcmp(buffer, "1234567890abcde67890", 20) == 0);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) != BH_OK);
BH_VERIFY(bh_io_seek(io, -5, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == BH_OK);
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_io_free(io);
BH_IOFree(io);
/* Check operations for read and write access */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_READ | BH_IO_EXIST) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_READ | BH_IO_EXIST) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_write(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890abcde67890", 20, &actual) == BH_OK);
BH_VERIFY(actual == 20);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == BH_OK);
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_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 35, &actual) == BH_OK);
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_io_close(io);
bh_io_free(io);
BH_IOClose(io);
BH_IOFree(io);
/* Check against non existing files */
BH_VERIFY((io = bh_file_new(FILENAME2)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_EXIST) != BH_OK);
BH_VERIFY((bh_io_flags(io) & BH_IO_FLAG_OPEN) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_READ | BH_IO_EXIST) != BH_OK);
BH_VERIFY((bh_io_flags(io) & BH_IO_FLAG_OPEN) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_READ | BH_IO_EXIST) != BH_OK);
BH_VERIFY((bh_io_flags(io) & BH_IO_FLAG_OPEN) == 0);
bh_io_free(io);
BH_VERIFY((io = BH_FileNew(FILENAME2)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_EXIST) != BH_OK);
BH_VERIFY((BH_IOFlags(io) & BH_IO_FLAG_OPEN) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ | BH_IO_EXIST) != BH_OK);
BH_VERIFY((BH_IOFlags(io) & BH_IO_FLAG_OPEN) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_READ | BH_IO_EXIST) != BH_OK);
BH_VERIFY((BH_IOFlags(io) & BH_IO_FLAG_OPEN) == 0);
BH_IOFree(io);
return 0;
}
@@ -371,83 +371,83 @@ static int check_exist(void)
/**
* Check in append mode.
*/
static int check_append(void)
static int checkAppend(void)
{
int64_t position;
char buffer[128];
size_t actual;
bh_io_t *io;
BH_IO *io;
/* Explicitly call cleanup */
cleanup();
/* Check operations for write only access */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_APPEND) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_APPEND) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_seek(io, 10, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_write(io, "abcde", 5, &actual) == BH_OK);
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_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 1, &actual) != BH_OK);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_END) == BH_OK);
BH_VERIFY(bh_io_tell(io, &position) == BH_OK);
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_io_close(io);
BH_IOClose(io);
/* Check operations for read only access */
BH_VERIFY(bh_io_open(io, BH_IO_READ | BH_IO_APPEND) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ | BH_IO_APPEND) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 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_io_read(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(memcmp(buffer, "1234567890", 10) == 0);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == 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_io_write(io, "1234567890", 10, &actual) != BH_OK);
BH_VERIFY(bh_io_seek(io, -5, BH_IO_SEEK_CUR) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 5, &actual) == BH_OK);
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_io_close(io);
BH_IOClose(io);
/* Check operations for read and write access */
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_READ | BH_IO_APPEND) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_READ | BH_IO_APPEND) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "abcde", 5, &actual) == BH_OK);
BH_VERIFY(actual == 5);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_read(io, buffer, 40, &actual) == BH_OK);
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_io_close(io);
BH_IOClose(io);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
bh_io_close(io);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_IOClose(io);
bh_io_free(io);
BH_IOFree(io);
return 0;
}
@@ -455,37 +455,37 @@ static int check_append(void)
/**
* Check for create mode.
*/
static int check_create(void)
static int checkCreate(void)
{
bh_io_t *io;
BH_IO *io;
/* Check for already existing file */
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_CREATE) != BH_OK);
BH_VERIFY((bh_io_flags(io) & BH_IO_FLAG_OPEN) == 0);
bh_io_free(io);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_CREATE) != BH_OK);
BH_VERIFY((BH_IOFlags(io) & BH_IO_FLAG_OPEN) == 0);
BH_IOFree(io);
/* Check for new file with write access */
BH_VERIFY((io = bh_file_new(FILENAME2)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_CREATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
bh_io_free(io);
BH_VERIFY((io = BH_FileNew(FILENAME2)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_CREATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_IOFree(io);
/* Check for new file with read access */
BH_VERIFY((io = bh_file_new(FILENAME3)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_READ | BH_IO_CREATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
bh_io_free(io);
BH_VERIFY((io = BH_FileNew(FILENAME3)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ | BH_IO_CREATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_IOFree(io);
/* Check for new file with read/write access */
BH_VERIFY((io = bh_file_new(FILENAME4)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_READ | BH_IO_CREATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
bh_io_free(io);
BH_VERIFY((io = BH_FileNew(FILENAME4)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_READ | BH_IO_CREATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_IOFree(io);
return 0;
}
@@ -494,23 +494,23 @@ static int check_create(void)
/**
* Check for EOF flags.
*/
static int check_eof(void)
static int checkEOF(void)
{
char buffer[128];
size_t actual;
bh_io_t *io;
BH_IO *io;
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_READ | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_read(io, buffer, 128, &actual) == BH_OK);
BH_VERIFY(BH_IORead(io, buffer, 128, &actual) == BH_OK);
BH_VERIFY(actual == 0);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_EOF);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_EOF);
bh_io_close(io);
bh_io_free(io);
BH_IOClose(io);
BH_IOFree(io);
return 0;
}
@@ -519,23 +519,23 @@ static int check_eof(void)
/**
* Check for error flags.
*/
static int check_error(void)
static int checkError(void)
{
size_t actual;
bh_io_t *io;
BH_IO *io;
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_READ) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "12345", 5, &actual) != BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_ERROR);
BH_VERIFY(bh_io_clear(io) == BH_OK);
BH_VERIFY((bh_io_flags(io) & BH_IO_FLAG_ERROR) == 0);
BH_VERIFY(BH_IOWrite(io, "12345", 5, &actual) != BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_ERROR);
BH_VERIFY(BH_IOClear(io) == BH_OK);
BH_VERIFY((BH_IOFlags(io) & BH_IO_FLAG_ERROR) == 0);
bh_io_close(io);
bh_io_free(io);
BH_IOClose(io);
BH_IOFree(io);
return 0;
}
@@ -544,42 +544,42 @@ static int check_error(void)
/**
* Check peek operation.
*/
static int check_peek(void)
static int checkPeek(void)
{
int64_t previous, current;
char buffer[128];
size_t actual;
bh_io_t *io;
BH_IO *io;
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_WRITE | BH_IO_READ | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(bh_io_flags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_WRITE | BH_IO_READ | BH_IO_TRUNCATE) == BH_OK);
BH_VERIFY(BH_IOFlags(io) & BH_IO_FLAG_OPEN);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_write(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(BH_IOWrite(io, "1234567890", 10, &actual) == BH_OK);
BH_VERIFY(actual == 10);
BH_VERIFY(bh_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_tell(io, &previous) == BH_OK);
BH_VERIFY(bh_io_peek(io, buffer, 128, &actual) == BH_OK);
BH_VERIFY(bh_io_tell(io, &current) == BH_OK);
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_io_seek(io, 0, BH_IO_SEEK_SET) == BH_OK);
BH_VERIFY(bh_io_tell(io, &previous) == BH_OK);
BH_VERIFY(bh_io_peek(io, buffer, 128, &actual) == BH_OK);
BH_VERIFY(bh_io_tell(io, &current) == BH_OK);
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_io_close(io);
bh_io_free(io);
BH_IOClose(io);
BH_IOFree(io);
return 0;
}
@@ -588,20 +588,20 @@ static int check_peek(void)
/**
* Check file size operation.
*/
static int check_size(void)
static int checkSize(void)
{
bh_io_t *io;
BH_IO *io;
int64_t size;
BH_VERIFY((io = bh_file_new(FILENAME1)) != NULL);
BH_VERIFY(strcmp(bh_io_classname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(bh_io_open(io, BH_IO_READ) == BH_OK);
BH_VERIFY((io = BH_FileNew(FILENAME1)) != NULL);
BH_VERIFY(strcmp(BH_IOClassname(io), BH_FILE_CLASSNAME) == 0);
BH_VERIFY(BH_IOOpen(io, BH_IO_READ) == BH_OK);
BH_VERIFY(bh_io_size(io, &size) == BH_OK);
BH_VERIFY(BH_IOSize(io, &size) == BH_OK);
BH_VERIFY(size == 20);
bh_io_close(io);
bh_io_free(io);
BH_IOClose(io);
BH_IOFree(io);
return 0;
}
@@ -615,16 +615,16 @@ int main(int argc,
/* Cleanup */
cleanup();
bh_unit_add("null", check_null);
bh_unit_add("normal", check_normal);
bh_unit_add("truncate", check_truncate);
bh_unit_add("exist", check_exist);
bh_unit_add("append", check_append);
bh_unit_add("create", check_create);
bh_unit_add("eof", check_eof);
bh_unit_add("error", check_error);
bh_unit_add("peek", check_peek);
bh_unit_add("size", check_size);
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_unit_run();
return BH_UnitRun();
}

190
test/src/testhashmap.c
View File

@@ -2,161 +2,161 @@
#include <bh/unit.h>
static size_t direct_hash(const void *ptr)
static size_t DBG_PtrIntHash(const void *ptr)
{
return BH_PTR2INT(ptr);
}
static int direct_equal(const void *lhs, const void *rhs)
static int DBG_PtrIntEqual(const void *lhs, const void *rhs)
{
return BH_PTR2INT(lhs) - BH_PTR2INT(rhs);
}
static int new_free(void)
static int NewFree(void)
{
bh_hashmap_t *hashmap;
BH_Hashmap *hashmap;
hashmap = bh_hashmap_new(direct_equal, direct_hash);
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
BH_VERIFY(bh_hashmap_empty(hashmap) != 0);
BH_VERIFY(bh_hashmap_size(hashmap) == 0);
BH_VERIFY(bh_hashmap_capacity(hashmap) == 0);
BH_VERIFY(bh_hashmap_factor(hashmap) >= 0.15f);
BH_VERIFY(bh_hashmap_factor(hashmap) <= 1.0f);
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_hashmap_free(hashmap);
BH_HashmapFree(hashmap);
return 0;
}
static int grow_shrink(void)
static int GrowShrink(void)
{
bh_hashmap_t *hashmap;
BH_Hashmap *hashmap;
void *iter;
hashmap = bh_hashmap_new(direct_equal, direct_hash);
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
/* Allocate space for 1024 entries and insert 1 element */
BH_VERIFY(bh_hashmap_reserve(hashmap, 1024) == 0);
BH_VERIFY(bh_hashmap_insert(hashmap, BH_INT2PTR(1337), BH_INT2PTR(80085)) == 0);
BH_VERIFY(BH_HashmapReserve(hashmap, 1024) == 0);
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR(1337), BH_INT2PTR(80085)) == 0);
/* Check hashmap contents */
iter = bh_hashmap_iter_next(hashmap, NULL);
iter = BH_HashmapIterNext(hashmap, NULL);
BH_VERIFY(iter != NULL);
BH_VERIFY(BH_PTR2INT(bh_hashmap_iter_key(iter)) == 1337);
BH_VERIFY(BH_PTR2INT(bh_hashmap_iter_value(iter)) == 80085);
BH_VERIFY(bh_hashmap_iter_next(hashmap, iter) == NULL);
BH_VERIFY(bh_hashmap_empty(hashmap) == 0);
BH_VERIFY(bh_hashmap_size(hashmap) == 1);
BH_VERIFY(bh_hashmap_capacity(hashmap) >= 1024);
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_hashmap_set_factor(hashmap, 0.35f);
BH_HashmapSetFactor(hashmap, 0.35f);
/* Check hashmap contents */
iter = bh_hashmap_iter_next(hashmap, NULL);
iter = BH_HashmapIterNext(hashmap, NULL);
BH_VERIFY(iter != NULL);
BH_VERIFY(BH_PTR2INT(bh_hashmap_iter_key(iter)) == 1337);
BH_VERIFY(BH_PTR2INT(bh_hashmap_iter_value(iter)) == 80085);
BH_VERIFY(bh_hashmap_iter_next(hashmap, iter) == NULL);
BH_VERIFY(bh_hashmap_reserve(hashmap, 8192) == 0);
BH_VERIFY(bh_hashmap_empty(hashmap) == 0);
BH_VERIFY(bh_hashmap_size(hashmap) == 1);
BH_VERIFY(bh_hashmap_capacity(hashmap) >= 8192);
BH_VERIFY(bh_hashmap_factor(hashmap) == 0.35f);
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_hashmap_reserve(hashmap, 0) == 0);
BH_VERIFY(BH_HashmapReserve(hashmap, 0) == 0);
/* Check hashmap contents */
iter = bh_hashmap_iter_next(hashmap, NULL);
iter = BH_HashmapIterNext(hashmap, NULL);
BH_VERIFY(iter != NULL);
BH_VERIFY(BH_PTR2INT(bh_hashmap_iter_key(iter)) == 1337);
BH_VERIFY(BH_PTR2INT(bh_hashmap_iter_value(iter)) == 80085);
BH_VERIFY(bh_hashmap_iter_next(hashmap, iter) == NULL);
BH_VERIFY(bh_hashmap_empty(hashmap) == 0);
BH_VERIFY(bh_hashmap_size(hashmap) == 1);
BH_VERIFY(bh_hashmap_capacity(hashmap) >= 1);
BH_VERIFY(bh_hashmap_capacity(hashmap) < 8192);
BH_VERIFY(bh_hashmap_factor(hashmap) == 0.35f);
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_hashmap_clear(hashmap);
BH_VERIFY(bh_hashmap_empty(hashmap) != 0);
BH_VERIFY(bh_hashmap_size(hashmap) == 0);
BH_VERIFY(bh_hashmap_capacity(hashmap) > 0);
BH_HashmapClear(hashmap);
BH_VERIFY(BH_HashmapEmpty(hashmap) != 0);
BH_VERIFY(BH_HashmapSize(hashmap) == 0);
BH_VERIFY(BH_HashmapCapacity(hashmap) > 0);
BH_VERIFY(bh_hashmap_reserve(hashmap, 0) == 0);
BH_VERIFY(bh_hashmap_empty(hashmap) != 0);
BH_VERIFY(bh_hashmap_size(hashmap) == 0);
BH_VERIFY(bh_hashmap_capacity(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_hashmap_iter_next(hashmap, NULL);
iter = BH_HashmapIterNext(hashmap, NULL);
BH_VERIFY(iter == NULL);
bh_hashmap_free(hashmap);
BH_HashmapFree(hashmap);
return 0;
}
static int insert_remove(void)
static int InsertRemove(void)
{
bh_hashmap_t *hashmap;
BH_Hashmap *hashmap;
size_t i, added, removed;
void *iter;
hashmap = bh_hashmap_new(direct_equal, direct_hash);
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
bh_hashmap_set_factor(hashmap, 1.0f);
BH_HashmapSetFactor(hashmap, 1.0f);
/* Insert elements into hashmap */
added = 0;
for (i = 1024; i > 0; i--)
{
added += (i - 1) / 4;
BH_VERIFY(bh_hashmap_insert(hashmap, BH_INT2PTR((i - 1) / 4), BH_INT2PTR(i)) == 0);
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR((i - 1) / 4), BH_INT2PTR(i)) == 0);
}
/* Remove elements */
iter = bh_hashmap_iter_next(hashmap, NULL);
iter = BH_HashmapIterNext(hashmap, NULL);
removed = 0;
while (iter)
{
removed += BH_PTR2INT(bh_hashmap_iter_key(iter));
bh_hashmap_iter_remove(hashmap, iter);
removed += BH_PTR2INT(BH_HashmapIterKey(iter));
BH_HashmapIterRemove(hashmap, iter);
iter = bh_hashmap_iter_next(hashmap, NULL);
iter = BH_HashmapIterNext(hashmap, NULL);
}
/* Check inserted elements are equal to removed */
BH_VERIFY(added == removed);
bh_hashmap_free(hashmap);
BH_HashmapFree(hashmap);
return 0;
}
static int lookup(void)
static int Lookup(void)
{
bh_hashmap_t *hashmap;
BH_Hashmap *hashmap;
size_t i;
hashmap = bh_hashmap_new(direct_equal, direct_hash);
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
/* Insert elements into hashmap */
for (i = 0; i < 256; i++)
BH_VERIFY(bh_hashmap_insert(hashmap, BH_INT2PTR(i * 4), BH_INT2PTR(i)) == 0);
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_hashmap_at(hashmap, BH_INT2PTR(i * 4), NULL) == BH_OK);
BH_VERIFY(bh_hashmap_at(hashmap, BH_INT2PTR(i * 4), &value) == BH_OK);
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);
}
@@ -165,55 +165,55 @@ static int lookup(void)
{
void *value;
BH_VERIFY(bh_hashmap_at(hashmap, BH_INT2PTR(i * 4), NULL) != BH_OK);
BH_VERIFY(bh_hashmap_at(hashmap, BH_INT2PTR(i * 4), &value) != BH_OK);
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_hashmap_free(hashmap);
BH_HashmapFree(hashmap);
return 0;
}
static int clear(void)
static int Clear(void)
{
bh_hashmap_t *hashmap;
BH_Hashmap *hashmap;
size_t i;
hashmap = bh_hashmap_new(direct_equal, direct_hash);
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
/* Insert elements into hashmap */
for (i = 0; i < 128; i++)
BH_VERIFY(bh_hashmap_insert(hashmap, BH_INT2PTR(i), 0) == 0);
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR(i), 0) == 0);
bh_hashmap_clear(hashmap);
BH_HashmapClear(hashmap);
/* Remove non-existing elements */
for (i = 0; i < 128; i++)
bh_hashmap_remove(hashmap, BH_INT2PTR(i));
BH_HashmapRemove(hashmap, BH_INT2PTR(i));
bh_hashmap_free(hashmap);
BH_HashmapFree(hashmap);
return 0;
}
static int fields(void)
static int Fields(void)
{
bh_hashmap_t *hashmap;
BH_Hashmap *hashmap;
size_t i;
hashmap = bh_hashmap_new(direct_equal, direct_hash);
hashmap = BH_HashmapNew(DBG_PtrIntEqual, DBG_PtrIntHash);
BH_VERIFY(hashmap != NULL);
BH_VERIFY(bh_hashmap_empty(hashmap) == 1);
BH_VERIFY(BH_HashmapEmpty(hashmap) == 1);
/* Insert elements into hashmap */
for (i = 0; i < 14; i++)
BH_VERIFY(bh_hashmap_insert(hashmap, BH_INT2PTR(i), NULL) == 0);
BH_VERIFY(BH_HashmapInsert(hashmap, BH_INT2PTR(i), NULL) == 0);
/* Check hashmap fields correspond to getter functions */
BH_VERIFY(bh_hashmap_size(hashmap) == 14);
BH_VERIFY(bh_hashmap_capacity(hashmap) >= 14);
BH_VERIFY(bh_hashmap_empty(hashmap) == 0);
BH_VERIFY(BH_HashmapSize(hashmap) == 14);
BH_VERIFY(BH_HashmapCapacity(hashmap) >= 14);
BH_VERIFY(BH_HashmapEmpty(hashmap) == 0);
bh_hashmap_free(hashmap);
BH_HashmapFree(hashmap);
return 0;
}
@@ -223,12 +223,12 @@ int main(int argc, char **argv)
(void)argv;
/* Add unit tests */
bh_unit_add("new_free", new_free);
bh_unit_add("grow_shrink", grow_shrink);
bh_unit_add("insert_remove", insert_remove);
bh_unit_add("lookup", lookup);
bh_unit_add("clear", clear);
bh_unit_add("fields", fields);
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_unit_run();
return BH_UnitRun();
}

1112
test/src/testmath.c
View File

File diff suppressed because it is too large Load Diff

144
test/src/testqueue.c
View File

@@ -2,156 +2,156 @@
#include <bh/unit.h>
static int new_free(void)
static int NewFree(void)
{
bh_queue_t *queue;
BH_Queue *queue;
queue = bh_queue_new();
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
BH_VERIFY(bh_queue_size(queue) == 0);
BH_VERIFY(bh_queue_capacity(queue) == 0);
BH_VERIFY(bh_queue_empty(queue) != 0);
BH_VERIFY(BH_QueueSize(queue) == 0);
BH_VERIFY(BH_QueueCapacity(queue) == 0);
BH_VERIFY(BH_QueueEmpty(queue) != 0);
bh_queue_free(queue);
BH_QueueFree(queue);
return 0;
}
static int grow_shrink(void)
static int GrowShrink(void)
{
bh_queue_t *queue;
BH_Queue *queue;
void *value;
queue = bh_queue_new();
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
/* Reserve 1024 elements and insert item into queue */
BH_VERIFY(bh_queue_reserve(queue, 1024) == BH_OK);
BH_VERIFY(bh_queue_insert(queue, BH_INT2PTR(1337)) == BH_OK);
BH_VERIFY(bh_queue_capacity(queue) >= 1024);
BH_VERIFY(bh_queue_size(queue) == 1);
BH_VERIFY(bh_queue_empty(queue) == 0);
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_queue_front(queue, &value) == BH_OK);
BH_VERIFY(BH_QueueFront(queue, &value) == BH_OK);
BH_VERIFY(BH_PTR2INT(value) == 1337);
/* Grow queue */
BH_VERIFY(bh_queue_reserve(queue, 8192) == BH_OK);
BH_VERIFY(bh_queue_capacity(queue) >= 8192);
BH_VERIFY(bh_queue_size(queue) == 1);
BH_VERIFY(bh_queue_empty(queue) == 0);
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_queue_front(queue, &value) == BH_OK);
BH_VERIFY(BH_QueueFront(queue, &value) == BH_OK);
BH_VERIFY(BH_PTR2INT(value) == 1337);
/* Shrink the queue */
BH_VERIFY(bh_queue_reserve(queue, 0) == BH_OK);
BH_VERIFY(bh_queue_capacity(queue) >= 1);
BH_VERIFY(bh_queue_capacity(queue) < 8192);
BH_VERIFY(bh_queue_size(queue) == 1);
BH_VERIFY(bh_queue_empty(queue) == 0);
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_queue_front(queue, &value) == BH_OK);
BH_VERIFY(BH_QueueFront(queue, &value) == BH_OK);
BH_VERIFY(BH_PTR2INT(value) == 1337);
/* Shrink to 0 (deallocate) */
bh_queue_clear(queue);
BH_VERIFY(bh_queue_size(queue) == 0);
BH_VERIFY(bh_queue_empty(queue) != 0);
BH_VERIFY(bh_queue_capacity(queue) >= 1);
BH_QueueClear(queue);
BH_VERIFY(BH_QueueSize(queue) == 0);
BH_VERIFY(BH_QueueEmpty(queue) != 0);
BH_VERIFY(BH_QueueCapacity(queue) >= 1);
BH_VERIFY(bh_queue_reserve(queue, 0) == BH_OK);
BH_VERIFY(bh_queue_size(queue) == 0);
BH_VERIFY(bh_queue_empty(queue) != 0);
BH_VERIFY(bh_queue_capacity(queue) == 0);
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_queue_free(queue);
BH_QueueFree(queue);
return 0;
}
static int insert_remove(void)
static int InsertRemove(void)
{
bh_queue_t *queue;
BH_Queue *queue;
size_t i, added, removed;
void *iter;
queue = bh_queue_new();
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
added = 0;
for (i = 0; i < 256; i++)
{
added += i * 2;
BH_VERIFY(bh_queue_insert(queue, BH_INT2PTR(i * 2)) == BH_OK);
BH_VERIFY(BH_QueueInsert(queue, BH_INT2PTR(i * 2)) == BH_OK);
}
removed = 0;
iter = bh_queue_iter_next(queue, NULL);
iter = BH_QueueIterNext(queue, NULL);
while (iter)
{
void *value;
BH_VERIFY(bh_queue_front(queue, &value) == BH_OK);
BH_VERIFY(BH_QueueFront(queue, &value) == BH_OK);
removed += BH_PTR2INT(value);
bh_queue_remove(queue);
iter = bh_queue_iter_next(queue, NULL);
BH_QueueRemove(queue);
iter = BH_QueueIterNext(queue, NULL);
}
BH_VERIFY(added == removed);
BH_VERIFY(bh_queue_empty(queue) != 0);
BH_VERIFY(bh_queue_size(queue) == 0);
BH_VERIFY(BH_QueueEmpty(queue) != 0);
BH_VERIFY(BH_QueueSize(queue) == 0);
bh_queue_free(queue);
BH_QueueFree(queue);
return 0;
}
static int rollover(void)
static int Rollover(void)
{
bh_queue_t *queue;
BH_Queue *queue;
size_t i, j, capacity;
queue = bh_queue_new();
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
BH_VERIFY(bh_queue_reserve(queue, 128) == 0);
capacity = bh_queue_capacity(queue);
BH_VERIFY(BH_QueueReserve(queue, 128) == 0);
capacity = BH_QueueCapacity(queue);
for (i = 0; i < 128; i++)
{
for (j = 0; j < 3; j++)
bh_queue_remove(queue);
BH_QueueRemove(queue);
for (j = 0; j < 4 && bh_queue_size(queue) < 128; j++)
BH_VERIFY(bh_queue_insert(queue, BH_INT2PTR(i * 4 + j)) == 0);
for (j = 0; j < 4 && BH_QueueSize(queue) < 128; j++)
BH_VERIFY(BH_QueueInsert(queue, BH_INT2PTR(i * 4 + j)) == 0);
}
BH_VERIFY(bh_queue_size(queue) == 128);
BH_VERIFY(bh_queue_capacity(queue) == capacity);
BH_VERIFY(BH_QueueSize(queue) == 128);
BH_VERIFY(BH_QueueCapacity(queue) == capacity);
bh_queue_free(queue);
BH_QueueFree(queue);
return 0;
}
static int fields(void)
static int Fields(void)
{
bh_queue_t *queue;
BH_Queue *queue;
queue = bh_queue_new();
queue = BH_QueueNew();
BH_VERIFY(queue != NULL);
BH_VERIFY(bh_queue_insert(queue, BH_INT2PTR(1337)) == 0);
BH_VERIFY(bh_queue_size(queue) == 1);
BH_VERIFY(bh_queue_empty(queue) == 0);
BH_VERIFY(bh_queue_capacity(queue) >= 1);
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_queue_free(queue);
BH_QueueFree(queue);
return 0;
}
@@ -161,11 +161,11 @@ int main(int argc, char **argv)
(void)argc;
(void)argv;
bh_unit_add("new_free", new_free);
bh_unit_add("grow_shrink", grow_shrink);
bh_unit_add("insert_remove", insert_remove);
bh_unit_add("rollover", rollover);
bh_unit_add("fields", fields);
BH_UnitAdd("NewFree", NewFree);
BH_UnitAdd("GrowShrink", GrowShrink);
BH_UnitAdd("InsertRemove", InsertRemove);
BH_UnitAdd("Rollover", Rollover);
BH_UnitAdd("Fields", Fields);
return bh_unit_run();
return BH_UnitRun();
}