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-30 01:48:03 +08:00
parent 84ebd52c24
commit 7940b67827
170 changed files with 2704 additions and 21276 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Foundation/c_Array.t.c
+56 -124
View File
@@ -1,137 +1,69 @@
#include "c_Array.h"
#include <stdlib.h>
#include <stdio.h>
#include "c_Test.h"
/* ========================================================================== */
/* TEST CASES */
/* ========================================================================== */
// 用于测试的密集结构体
typedef struct {
uint8_t r;
uint8_t g;
uint8_t b;
} PixelRGB_t;
TEST_CASE(test_fixed_generic_array_flow) {
c_Array_t img_line;
// 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));
// 初始化一个长度固定为 3 的 RGB 像素扁平大数组
ASSERT_INT_EQ(C_ERR_OK, c_Array_Init(&img_line, sizeof(PixelRGB_t), 3, NULL));
ASSERT_INT_EQ(3, c_Array_Size(&img_line));
ASSERT_PTR_NOT_NULL(img_line.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);
PixelRGB_t red = { .r = 255, .g = 0, .b = 0 };
PixelRGB_t green = { .r = 0, .g = 255, .b = 0 };
PixelRGB_t white = { .r = 255, .g = 255, .b = 255 };
c_Array_Destroy(&arr);
// 1. 验证定点写入 (Write)
ASSERT_INT_EQ(C_ERR_OK, c_Array_Write(&img_line, 0, &red));
ASSERT_INT_EQ(C_ERR_OK, c_Array_Write(&img_line, 1, &green));
// 防御越界写入，应当报错拒绝
ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Write(&img_line, 3, &white));
// 2. 验证定点读取与值复制强屏障 (Read)
PixelRGB_t read_res;
ASSERT_INT_EQ(C_ERR_OK, c_Array_Read(&img_line, 0, &read_res));
ASSERT_INT_EQ(255, read_res.r);
ASSERT_INT_EQ(0, read_res.g);
// 修改局部临时变量，验证内部数据不受二次污染
red.r = 123;
ASSERT_INT_EQ(C_ERR_OK, c_Array_Read(&img_line, 0, &read_res));
ASSERT_INT_EQ(255, read_res.r); // 内部依旧是 255，证明完美值隔离
// 3. 验证原位窥探能力 (Get)
PixelRGB_t* direct_ptr = (PixelRGB_t*)c_Array_Get(&img_line, 1);
ASSERT_PTR_NOT_NULL(direct_ptr);
ASSERT_INT_EQ(255, direct_ptr->g);
// 严苛验证固定物理内存布局：
// 索引 1 的地址必须与数组首地址精准偏移 1 个 item_size 字节，完全不存在任何链式空隙
ASSERT_TRUE((void*)((char*)img_line.array + sizeof(PixelRGB_t)) == (void*)direct_ptr);
// 4. 验证全局批量刷值功能 (Fill)
ASSERT_INT_EQ(C_ERR_OK, c_Array_Fill(&img_line, &white));
// 抽样验证填充后的每一项是否全变成了白色
PixelRGB_t* check_p2 = (PixelRGB_t*)c_Array_Get(&img_line, 2);
ASSERT_INT_EQ(255, check_p2->r);
ASSERT_INT_EQ(255, check_p2->g);
ASSERT_INT_EQ(255, check_p2->b);
c_Array_Destroy(&img_line);
}
// 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);
printf("\n");
TEST_START(C_Fixed_Array_Core_Layout_Tests);
RUN_TEST(test_fixed_generic_array_flow);
TEST_REPORT();
RETURN_TEST_STATUS;
}
}