abdelrahman/wizapp-stdlib
0
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Update wapp array C API

Browse Source
This commit is contained in:
Abdelrahman Said
2025-12-07 21:56:16 +00:00
committed by Abdelrahman Said
parent 551836d4c8
commit 2b49bfcdbf
10 changed files with 365 additions and 3991 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
tests/array/test_i32_array.c
View File

@@ -4,16 +4,16 @@
TestFuncResult test_i32_array(void) {
b8 result;
I32Array array = wapp_i32_array(1, 2, 3, 4, 5, 6, 7);
result = array.count == 7 && array.capacity == 16;
i32 *array = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7);
result = wapp_array_count(i32, array) == 7 && wapp_array_capacity(i32, array) == 16;
i32 *item;
u64 count = array.count;
u64 index = 0;
i32 item;
u64 count = wapp_array_count(i32, array);
u64 index = 0;
b8 running = true;
while (running) {
item = wapp_i32_array_get(&array, index);
result = result && item && (*item == (i32)(index + 1));
item = wapp_array_get(i32, array, index);
result = result && item && item == (i32)(index + 1);
++index;
running = index < count;
@@ -25,8 +25,8 @@ TestFuncResult test_i32_array(void) {
TestFuncResult test_i32_array_with_capacity(void) {
b8 result;
I32Array array = wapp_i32_array_with_capacity(64);
result = array.count == 0 && array.capacity == 64;
i32 *array = wapp_array_with_capacity(i32, 64);
result = wapp_array_count(i32, array) == 0 && wapp_array_capacity(i32, array) == 64;
return wapp_tester_result(result);
}
@@ -34,15 +34,15 @@ TestFuncResult test_i32_array_with_capacity(void) {
TestFuncResult test_i32_array_get(void) {
b8 result = true;
I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *item;
u64 count = array.count;
u64 index = 0;
i32 item;
u64 count = wapp_array_count(i32, array);
u64 index = 0;
b8 running = true;
while (running) {
item = wapp_i32_array_get(&array, index);
result = result && item && (*item == (i32)index);
item = wapp_array_get(i32, array, index);
result = result && item == (i32)index;
++index;
running = index < count;
@@ -54,17 +54,17 @@ TestFuncResult test_i32_array_get(void) {
TestFuncResult test_i32_array_set(void) {
b8 result = true;
I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *item;
u64 count = array.count;
u64 index = 0;
i32 item;
u64 count = wapp_array_count(i32, array);
u64 index = 0;
b8 running = true;
while (running) {
i32 num = (i32)(index * 2);
wapp_i32_array_set(&array, index, &num);
item = wapp_i32_array_get(&array, index);
result = result && item && (*item == (i32)(index * 2));
wapp_array_set(i32, array, index, &num);
item = wapp_array_get(i32, array, index);
result = result && item == (i32)(index * 2);
++index;
running = index < count;
@@ -76,17 +76,17 @@ TestFuncResult test_i32_array_set(void) {
TestFuncResult test_i32_array_append_capped(void) {
b8 result;
I32Array array = wapp_i32_array_with_capacity(64);
wapp_i32_array_append_capped(&array, &((i32){10}));
i32 *array = wapp_array_with_capacity(i32, 64);
wapp_array_append_capped(i32, array, &((i32){10}));
result = array.count == 1;
i32 *item = wapp_i32_array_get(&array, 0);
result = result && item && *item == 10;
result = wapp_array_count(i32, array) == 1;
i32 item = wapp_array_get(i32, array, 0);
result = result && item == 10;
array = wapp_i32_array(1);
wapp_i32_array_append_capped(&array, &((i32){10}));
array = wapp_array(i32, 1);
wapp_array_append_capped(i32, array, &((i32){10}));
result = result && array.count == 2;
result = result && wapp_array_count(i32, array) == 2;
return wapp_tester_result(result);
}
@@ -94,41 +94,14 @@ TestFuncResult test_i32_array_append_capped(void) {
TestFuncResult test_i32_array_extend_capped(void) {
b8 result;
I32Array array1 = wapp_i32_array(1, 2, 3, 4);
I32Array array2 = wapp_i32_array(10, 20);
i32 *array1 = wapp_array(i32, 1, 2, 3, 4);
i32 *array2 = wapp_array(i32, 10, 20);
result = array1.count == 4 && array2.count == 2;
result = wapp_array_count(i32, array1) == 4 && wapp_array_count(i32, array2) == 2;
wapp_i32_array_extend_capped(&array1, &array2);
wapp_array_extend_capped(i32, array1, array2);
result = result && array1.count == 6;
return wapp_tester_result(result);
}
TestFuncResult test_i32_array_clear(void) {
b8 result;
I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8);
result = array.count == 9;
wapp_i32_array_clear(&array);
result = result && array.count == 0;
return wapp_tester_result(result);
}
TestFuncResult test_i32_array_pop(void) {
b8 result;
I32Array array1 = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_i32_array_with_capacity(32);
i32 item1 = wapp_i32_array_pop(&array1);
i32 item2 = wapp_i32_array_pop(&array2);
result = item1 == 8 && item2 == 0;
result = result && wapp_array_count(i32, array1) == 6;
return wapp_tester_result(result);
}
@@ -136,31 +109,31 @@ TestFuncResult test_i32_array_pop(void) {
TestFuncResult test_i32_array_copy_capped(void) {
b8 result;
I32Array src = wapp_i32_array(1, 2, 3, 4, 5);
I32Array dst1 = wapp_i32_array(1, 2, 3, 4, 5, 6);
I32Array dst2 = wapp_i32_array(1, 2);
i32 *src = wapp_array(i32, 1, 2, 3, 4, 5);
i32 *dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6);
i32 *dst2 = wapp_array(i32, 1, 2);
u64 expected_count = 5;
wapp_i32_array_copy_capped(&src, &dst1);
result = dst1.count == expected_count;
wapp_array_copy_capped(i32, dst1, src);
result = wapp_array_count(i32, dst1) == expected_count;
u64 index = 0;
b8 running = true;
while (running) {
result = result && (*wapp_i32_array_get(&src, index) == *wapp_i32_array_get(&dst1, index));
result = result && wapp_array_get(i32, src, index) == wapp_array_get(i32, dst1, index);
++index;
running = index < expected_count;
}
expected_count = 4;
wapp_i32_array_copy_capped(&src, &dst2);
result = result && dst2.count == expected_count;
wapp_array_copy_capped(i32, dst2, src);
result = result && wapp_array_count(i32, dst2) == expected_count;
index = 0;
running = true;
while (running) {
result = result && (*wapp_i32_array_get(&src, index) == *wapp_i32_array_get(&dst2, index));
result = result && wapp_array_get(i32, src, index) == wapp_array_get(i32, dst2, index);
++index;
running = index < expected_count;
@@ -174,9 +147,9 @@ TestFuncResult test_i32_array_alloc_capacity(void) {
Allocator allocator = wapp_mem_arena_allocator_init(MB(4));
u64 capacity = 32;
I32Array *array = wapp_i32_array_alloc_capacity(&allocator, capacity);
i32 *array = wapp_array_alloc_capacity(i32, &allocator, capacity);
result = array && array->capacity == capacity;
result = array && wapp_array_capacity(i32, array) == capacity;
wapp_mem_arena_allocator_destroy(&allocator);
@@ -187,23 +160,23 @@ TestFuncResult test_i32_array_append_alloc(void) {
b8 result;
Allocator allocator = wapp_mem_arena_allocator_init(MB(4));
I32Array array1 = wapp_i32_array(1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_i32_array(1, 2);
i32 *array1 = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *array2 = wapp_array(i32, 1, 2);
I32Array *arr_ptr = wapp_i32_array_append_alloc(&allocator, &array1, &((i32){10}));
result = arr_ptr == &array1;
i32 *arr_ptr = wapp_array_append_alloc(i32, &allocator, array1, &((i32){10}));
result = arr_ptr == array1;
u64 count = 4;
u64 index = 0;
b8 running = true;
while (running) {
i32 num = (i32)index;
arr_ptr = wapp_i32_array_append_alloc(&allocator, &array2, &num);
arr_ptr = wapp_array_append_alloc(i32, &allocator, array2, &num);
++index;
running = index < count;
}
result = result && arr_ptr != &array2;
result = result && arr_ptr != array2;
wapp_mem_arena_allocator_destroy(&allocator);
@@ -214,15 +187,15 @@ TestFuncResult test_i32_array_extend_alloc(void) {
b8 result;
Allocator allocator = wapp_mem_arena_allocator_init(MB(4));
I32Array array1 = wapp_i32_array(1, 2, 3, 4, 5, 6, 7, 8);
I32Array array2 = wapp_i32_array(1, 2);
I32Array array3 = wapp_i32_array(1, 2, 3, 4);
i32 *array1 = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *array2 = wapp_array(i32, 1, 2);
i32 *array3 = wapp_array(i32, 1, 2, 3, 4);
I32Array *arr_ptr = wapp_i32_array_extend_alloc(&allocator, &array1, &array3);
result = arr_ptr == &array1;
i32 *arr_ptr = wapp_array_extend_alloc(i32, &allocator, array1, array3);
result = arr_ptr == array1;
arr_ptr = wapp_i32_array_extend_alloc(&allocator, &array2, &array3);
result = result && arr_ptr != &array2;
arr_ptr = wapp_array_extend_alloc(i32, &allocator, array2, array3);
result = result && arr_ptr != array2;
wapp_mem_arena_allocator_destroy(&allocator);
@@ -233,32 +206,32 @@ TestFuncResult test_i32_array_copy_alloc(void) {
b8 result;
Allocator allocator = wapp_mem_arena_allocator_init(MB(4));
I32Array src = wapp_i32_array(1, 2, 3, 4, 5);
I32Array dst1 = wapp_i32_array(1, 2, 3, 4, 5, 6);
I32Array dst2 = wapp_i32_array(1, 2);
I32Array *array_ptr = NULL;
i32 *src = wapp_array(i32, 1, 2, 3, 4, 5);
i32 *dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6);
i32 *dst2 = wapp_array(i32, 1, 2);
i32 *array_ptr = NULL;
u64 expected_count = 5;
array_ptr = wapp_i32_array_copy_alloc(&allocator, &src, &dst1);
result = array_ptr->count == expected_count && array_ptr == &dst1;
array_ptr = wapp_array_copy_alloc(i32, &allocator, dst1, src);
result = wapp_array_count(i32, array_ptr) == expected_count && array_ptr == dst1;
u64 index = 0;
b8 running = true;
while (running) {
result = result && (*wapp_i32_array_get(&src, index) == *wapp_i32_array_get(array_ptr, index));
result = result && wapp_array_get(i32, src, index) == wapp_array_get(i32, array_ptr, index);
++index;
running = index < expected_count;
}
expected_count = 5;
array_ptr = wapp_i32_array_copy_alloc(&allocator, &src, &dst2);
result = result && array_ptr->count == expected_count && array_ptr != &dst2;
array_ptr = wapp_array_copy_alloc(i32, &allocator, dst2, src);
result = result && wapp_array_count(i32, array_ptr) == expected_count && array_ptr != dst2;
index = 0;
running = true;
while (running) {
result = result && (*wapp_i32_array_get(&src, index) == *wapp_i32_array_get(array_ptr, index));
result = result && wapp_array_get(i32, src, index) == wapp_array_get(i32, array_ptr, index);
++index;
running = index < expected_count;
@@ -268,3 +241,30 @@ TestFuncResult test_i32_array_copy_alloc(void) {
return wapp_tester_result(result);
}
TestFuncResult test_i32_array_pop(void) {
b8 result;
i32 *array1 = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
i32 *array2 = wapp_array_with_capacity(i32, 32);
i32 item1 = wapp_array_pop(i32, array1);
i32 item2 = wapp_array_pop(i32, array2);
result = item1 == 8 && item2 == 0;
return wapp_tester_result(result);
}
TestFuncResult test_i32_array_clear(void) {
b8 result;
i32 *array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8);
result = wapp_array_count(i32, array) == 9;
wapp_array_clear(i32, array);
result = result && wapp_array_count(i32, array) == 0;
return wapp_tester_result(result);
}