pchen/cKit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

测试用例

Browse Source
This commit is contained in:
pchen
2026-08-29 11:39:28 +08:00
parent a0758766c5
commit 8fd65b0de0
19 changed files with 1723 additions and 432 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Foundation/c_Array.t.c
+45 -49
View File
@@ -8,90 +8,90 @@
/* TEST CASES */
/* ========================================================================== */
C_TEST_FRAME_INIT();
// 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));
C_ASSERT_EQ_INT(C_SUCCESS, err);
C_ASSERT_EQ_INT(5, c_Array_Length(&arr));
C_ASSERT_EQ_INT(sizeof(int), c_Array_Size(&arr));
C_ASSERT_PTR_NOT_NULL(arr.array);
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
void test_array_heap_new_delete(void) {
static void test_array_heap_new_delete(void) {
c_Array_t* arr = c_Array_New(10, sizeof(double));
C_ASSERT_PTR_NOT_NULL(arr);
C_ASSERT_EQ_INT(10, c_Array_Length(arr));
C_ASSERT_EQ_INT(sizeof(double), c_Array_Size(arr));
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);
C_ASSERT_PTR_NULL(arr); // Ensure pointer is zeroed out by reference parameter modification
ASSERT_TRUE(arr==NULL); // Ensure pointer is zeroed out by reference parameter modification
}
// 3. Put and Get Data Element Scenarios
void test_array_put_and_get(void) {
static void test_array_put_and_get(void) {
c_Array_t* arr = c_Array_New(3, sizeof(int));
C_ASSERT_PTR_NOT_NULL(arr);
C_ASSERT_EQ_INT(3, arr->length);
ASSERT_PTR_NOT_NULL(arr);
ASSERT_INT_EQ(3, arr->length);
int val1 = 100, val2 = 200, val3 = 300;
// Put elements inside length limits
C_ASSERT_EQ_INT(C_SUCCESS, c_Array_Put(arr, 0, &val1));
C_ASSERT_EQ_INT(C_SUCCESS, c_Array_Put(arr, 1, &val2));
C_ASSERT_EQ_INT(C_SUCCESS, c_Array_Put(arr, 2, &val3));
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;
C_ASSERT_EQ_INT(C_ERR_PARAM, c_Array_Put(arr, 3, &val_bad));
ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Put(arr, 3, &val_bad));
// Get verification
void* fetch_ptr = NULL;
C_ASSERT_EQ_INT(C_SUCCESS, c_Array_Get(arr, 1, &fetch_ptr));
C_ASSERT_PTR_NOT_NULL(fetch_ptr);
C_ASSERT_EQ_INT(200, *(int*)fetch_ptr);
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
C_ASSERT_EQ_INT(C_ERR_PARAM, c_Array_Get(arr, 5, &fetch_ptr));
ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Get(arr, 5, &fetch_ptr));
c_Array_Delete(&arr);
}
// 4. Memory Resizing Limits Verification
void test_array_resize(void) {
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
C_ASSERT_EQ_INT(C_SUCCESS, c_Array_Resize(arr, 4));
C_ASSERT_EQ_INT(4, c_Array_Length(arr));
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;
C_ASSERT_EQ_INT(C_SUCCESS, c_Array_Get(arr, 1, &res_ptr));
C_ASSERT_EQ_INT(84, *(int*)res_ptr);
ASSERT_INT_EQ(C_SUCCESS, c_Array_Get(arr, 1, &res_ptr));
ASSERT_INT_EQ(84, *(int*)res_ptr);
// Resize down to 1 element
C_ASSERT_EQ_INT(C_SUCCESS, c_Array_Resize(arr, 1));
C_ASSERT_EQ_INT(1, c_Array_Length(arr));
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
C_ASSERT_EQ_INT(C_ERR_PARAM, c_Array_Get(arr, 1, &res_ptr));
ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Get(arr, 1, &res_ptr));
c_Array_Delete(&arr);
}
// 5. Deep Copy Execution Verification
void test_array_copy_and_copy_to(void) {
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);
@@ -100,21 +100,21 @@ void test_array_copy_and_copy_to(void) {
// 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
C_ASSERT_PTR_NOT_NULL(copied_arr);
C_ASSERT_EQ_INT(2, c_Array_Length(copied_arr));
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);
C_ASSERT_EQ_INT(22, *(int*)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));
C_ASSERT_EQ_INT(C_SUCCESS, c_Array_CopyTo(source, &dest));
ASSERT_INT_EQ(C_SUCCESS, c_Array_CopyTo(source, &dest));
c_Array_Get(&dest, 2, &data_ptr);
C_ASSERT_EQ_INT(33, *(int*)data_ptr);
ASSERT_INT_EQ(33, *(int*)data_ptr);
// Clean up all resources
c_Array_Delete(&copied_arr);
@@ -122,20 +122,16 @@ void test_array_copy_and_copy_to(void) {
c_Array_Delete(&source);
}
/* ========================================================================== */
/* SUITE BINDINGS & ENTRY MAIN */
/* ========================================================================== */
static
void array_data_structure_suite(void) {
C_TEST_CASE_RUN(test_array_stack_init_destroy);
C_TEST_CASE_RUN(test_array_heap_new_delete);
C_TEST_CASE_RUN(test_array_put_and_get);
C_TEST_CASE_RUN(test_array_resize);
C_TEST_CASE_RUN(test_array_copy_and_copy_to);
}
int main(void) {
C_TEST_SUITE_RUN(array_data_structure_suite);
C_TEST_FRAME_REPORT();
return (g_test_ctx.tests_passed == g_test_ctx.tests_run) ? 0 : 1;
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;
}