137 lines
4.0 KiB
C
137 lines
4.0 KiB
C
#include "c_Array.h"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "c_Test.h"
|
|
|
|
|
|
/* ========================================================================== */
|
|
/* TEST CASES */
|
|
/* ========================================================================== */
|
|
|
|
|
|
// 1. Stack Initialization and Destruction Loop
|
|
static
|
|
void test_array_stack_init_destroy(void) {
|
|
c_Array_t arr;
|
|
c_err_t err = c_Array_Init(&arr, 5, sizeof(int));
|
|
|
|
ASSERT_LL_EQ(C_SUCCESS, err);
|
|
ASSERT_LL_EQ(5, c_Array_Length(&arr));
|
|
ASSERT_LL_EQ(sizeof(int), c_Array_Size(&arr));
|
|
ASSERT_PTR_NOT_NULL(arr.array);
|
|
|
|
c_Array_Destroy(&arr);
|
|
}
|
|
|
|
// 2. Heap Dynamic Allocation Lifecycles
|
|
static void test_array_heap_new_delete(void) {
|
|
c_Array_t* arr = c_Array_New(10, sizeof(double));
|
|
|
|
ASSERT_PTR_NOT_NULL(arr);
|
|
ASSERT_LL_EQ(10, c_Array_Length(arr));
|
|
ASSERT_LL_EQ(sizeof(double), c_Array_Size(arr));
|
|
|
|
c_Array_Delete(&arr);
|
|
ASSERT_TRUE(arr==NULL); // Ensure pointer is zeroed out by reference parameter modification
|
|
}
|
|
|
|
// 3. Put and Get Data Element Scenarios
|
|
static void test_array_put_and_get(void) {
|
|
c_Array_t* arr = c_Array_New(3, sizeof(int));
|
|
ASSERT_PTR_NOT_NULL(arr);
|
|
ASSERT_INT_EQ(3, arr->length);
|
|
|
|
int val1 = 100, val2 = 200, val3 = 300;
|
|
|
|
// Put elements inside length limits
|
|
ASSERT_INT_EQ(C_SUCCESS, c_Array_Put(arr, 0, &val1));
|
|
ASSERT_INT_EQ(C_SUCCESS, c_Array_Put(arr, 1, &val2));
|
|
ASSERT_INT_EQ(C_SUCCESS, c_Array_Put(arr, 2, &val3));
|
|
|
|
// Out of bounds checks
|
|
int val_bad = 999;
|
|
ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Put(arr, 3, &val_bad));
|
|
|
|
// Get verification
|
|
void* fetch_ptr = NULL;
|
|
ASSERT_INT_EQ(C_SUCCESS, c_Array_Get(arr, 1, &fetch_ptr));
|
|
ASSERT_PTR_NOT_NULL(fetch_ptr);
|
|
ASSERT_INT_EQ(200, *(int*)fetch_ptr);
|
|
|
|
// Out of bounds get verification
|
|
ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Get(arr, 5, &fetch_ptr));
|
|
|
|
c_Array_Delete(&arr);
|
|
}
|
|
|
|
// 4. Memory Resizing Limits Verification
|
|
static void test_array_resize(void) {
|
|
c_Array_t* arr = c_Array_New(2, sizeof(int));
|
|
int val0 = 42, val1 = 84;
|
|
c_Array_Put(arr, 0, &val0);
|
|
c_Array_Put(arr, 1, &val1);
|
|
|
|
// Resize up to 4 elements
|
|
ASSERT_INT_EQ(C_SUCCESS, c_Array_Resize(arr, 4));
|
|
ASSERT_INT_EQ(4, c_Array_Length(arr));
|
|
|
|
// Verify older elements remain structurally untouched
|
|
void* res_ptr = NULL;
|
|
ASSERT_INT_EQ(C_SUCCESS, c_Array_Get(arr, 1, &res_ptr));
|
|
ASSERT_INT_EQ(84, *(int*)res_ptr);
|
|
|
|
// Resize down to 1 element
|
|
ASSERT_INT_EQ(C_SUCCESS, c_Array_Resize(arr, 1));
|
|
ASSERT_INT_EQ(1, c_Array_Length(arr));
|
|
|
|
// Index 1 should now be unreachable / out of bounds
|
|
ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Get(arr, 1, &res_ptr));
|
|
|
|
c_Array_Delete(&arr);
|
|
}
|
|
|
|
// 5. Deep Copy Execution Verification
|
|
static void test_array_copy_and_copy_to(void) {
|
|
c_Array_t* source = c_Array_New(3, sizeof(int));
|
|
int a = 11, b = 22, c = 33;
|
|
c_Array_Put(source, 0, &a);
|
|
c_Array_Put(source, 1, &b);
|
|
c_Array_Put(source, 2, &c);
|
|
|
|
// Test c_Array_Copy (creates a new array object on the heap)
|
|
c_Array_t* copied_arr = c_Array_Copy(source, 2); // copy only first 2 items
|
|
ASSERT_PTR_NOT_NULL(copied_arr);
|
|
ASSERT_INT_EQ(2, c_Array_Length(copied_arr));
|
|
|
|
void* data_ptr = NULL;
|
|
c_Array_Get(copied_arr, 1, &data_ptr);
|
|
ASSERT_INT_EQ(22, *(int*)data_ptr);
|
|
|
|
// Test c_Array_CopyTo (copies into an already initialized destination)
|
|
c_Array_t dest;
|
|
c_Array_Init(&dest, 3, sizeof(int));
|
|
|
|
ASSERT_INT_EQ(C_SUCCESS, c_Array_CopyTo(source, &dest));
|
|
|
|
c_Array_Get(&dest, 2, &data_ptr);
|
|
ASSERT_INT_EQ(33, *(int*)data_ptr);
|
|
|
|
// Clean up all resources
|
|
c_Array_Delete(&copied_arr);
|
|
c_Array_Destroy(&dest);
|
|
c_Array_Delete(&source);
|
|
}
|
|
|
|
|
|
int main(void) {
|
|
TEST_START(array_data_structure_suite);
|
|
|
|
RUN_TEST(test_array_stack_init_destroy);
|
|
RUN_TEST(test_array_heap_new_delete);
|
|
RUN_TEST(test_array_put_and_get);
|
|
RUN_TEST(test_array_resize);
|
|
RUN_TEST(test_array_copy_and_copy_to);
|
|
|
|
TEST_REPORT();
|
|
RETURN_TEST_STATUS;
|
|
} |