253 lines
9.0 KiB
C
253 lines
9.0 KiB
C
#include "c_ArrayList.h"
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
#include <c_Test.h>
|
||
|
||
/* ------------------------------------------------------------------------------------------------------------------ */
|
||
/* */
|
||
|
||
typedef struct {
|
||
size_t active_allocations;
|
||
size_t total_alloc_bytes;
|
||
size_t total_free_bytes;
|
||
size_t realloc_calls;
|
||
size_t realloc_in_place_count; // 记录有多少次 Realloc 实现了就地复用（模拟伙伴系统）
|
||
} TestMemoryTracker_t;
|
||
|
||
static TestMemoryTracker_t g_tracker = {0};
|
||
|
||
static size_t mock_buddy_power_of_two(size_t size) {
|
||
if (size == 0) return 0;
|
||
size_t p = 1;
|
||
while (p < size) p <<= 1;
|
||
return p;
|
||
}
|
||
|
||
static void* test_alloc(size_t size, void* ctx) {
|
||
TestMemoryTracker_t* tracker = (TestMemoryTracker_t*)ctx;
|
||
if (tracker) {
|
||
tracker->active_allocations++;
|
||
tracker->total_alloc_bytes += size;
|
||
}
|
||
return malloc(size);
|
||
}
|
||
static void test_free(void* ptr, void* ctx) {
|
||
TestMemoryTracker_t* tracker = (TestMemoryTracker_t*)ctx;
|
||
if (ptr && tracker) {
|
||
tracker->active_allocations--;
|
||
}
|
||
free(ptr);
|
||
}
|
||
|
||
static void* test_realloc(void* ptr, size_t old_size, size_t new_size, void* ctx) {
|
||
TestMemoryTracker_t* tracker = (TestMemoryTracker_t*)ctx;
|
||
if (tracker) tracker->realloc_calls++;
|
||
|
||
if (new_size == 0) {
|
||
test_free(ptr, ctx);
|
||
if (tracker) tracker->total_free_bytes += old_size;
|
||
return NULL;
|
||
}
|
||
|
||
if (!ptr) {
|
||
return test_alloc(new_size, ctx);
|
||
}
|
||
|
||
// 【模拟伙伴系统核心逻辑】：如果新旧大小落在同一个 2 的幂阶数区间，则直接原地返回，零搬迁！
|
||
size_t old_buddy = mock_buddy_power_of_two(old_size);
|
||
size_t new_buddy = mock_buddy_power_of_two(new_size);
|
||
|
||
if (old_buddy == new_buddy && old_buddy != 0) {
|
||
if (tracker) tracker->realloc_in_place_count++;
|
||
return ptr;
|
||
}
|
||
|
||
// 阶数改变，模拟搬迁
|
||
void* new_ptr = malloc(new_size);
|
||
if (!new_ptr) return NULL;
|
||
|
||
size_t copy_size = (old_size < new_size) ? old_size : new_size;
|
||
memcpy(new_ptr, ptr, copy_size);
|
||
free(ptr);
|
||
|
||
if (tracker) {
|
||
tracker->total_alloc_bytes += new_size;
|
||
tracker->total_free_bytes += old_size;
|
||
}
|
||
return new_ptr;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------------------------------------------------------ */
|
||
/* */
|
||
|
||
// 供 RUN_TEST_FIXTURE 使用的 Setup 和 Teardown 钩子
|
||
static void custom_allocator_setup(void) {
|
||
memset(&g_tracker, 0, sizeof(TestMemoryTracker_t));
|
||
}
|
||
|
||
static void custom_allocator_teardown(void) {
|
||
// 每次测试结束，严格确保没有发生内存泄漏
|
||
// 注意：不能在此处直接调用带有返回的断言，因为破坏了测试函数的封装，仅在内部测试中做二次校验或由测试用例本身断言。
|
||
}
|
||
|
||
|
||
/* ------------------------------------------------------------------------------------------------------------------ */
|
||
/* */
|
||
|
||
typedef struct {
|
||
int node_id;
|
||
float threshold;
|
||
char name[16];
|
||
} SensorNode_t;
|
||
|
||
/* ------------------------------------------------------------------------------------------------------------------ */
|
||
/* */
|
||
|
||
// 测试一：基础生命周期与边界防御测试
|
||
TEST_CASE(test_lifecycle_and_defense) {
|
||
c_ArrayList_t list;
|
||
|
||
// 防御测试：无效参数传入
|
||
ASSERT_INT_EQ_MSG(C_ERR_PARAM, c_ArrayList_Init(NULL, sizeof(int), 4, NULL), "Should return C_ERR_PARAM when self is NULL");
|
||
ASSERT_INT_EQ_MSG(C_ERR_PARAM, c_ArrayList_Init(&list, 0, 4, NULL), "Should return C_ERR_PARAM when item_size is 0");
|
||
ASSERT_INT_EQ(0, c_ArrayList_Size(NULL));
|
||
|
||
// 正常原地初始化
|
||
c_err_t err = c_ArrayList_Init(&list, sizeof(int), 5, NULL);
|
||
ASSERT_INT_EQ(C_SUCCESS, err);
|
||
ASSERT_INT_EQ(0, c_ArrayList_Size(&list));
|
||
ASSERT_INT_EQ(5, list.capacity);
|
||
ASSERT_PTR_NOT_NULL(list.array);
|
||
|
||
// 销毁幂等性与清除检查
|
||
c_ArrayList_Destroy(&list);
|
||
ASSERT_TRUE(list.array == NULL);
|
||
ASSERT_INT_EQ(0, list.capacity);
|
||
ASSERT_INT_EQ(0, list.size);
|
||
|
||
c_ArrayList_Destroy(&list); // 重复销毁不应崩溃
|
||
}
|
||
|
||
// 测试二：泛型值复制存储、安全 Read/Get 访问测试
|
||
TEST_CASE(test_value_copy_and_access) {
|
||
c_ArrayList_t list;
|
||
c_ArrayList_Init(&list, sizeof(SensorNode_t), 2, NULL);
|
||
|
||
SensorNode_t node1 = { .node_id = 101, .threshold = 45.2f, .name = "Temp01" };
|
||
SensorNode_t node2 = { .node_id = 102, .threshold = 12.8f, .name = "Humid02" };
|
||
|
||
// 写入测试
|
||
ASSERT_INT_EQ(C_SUCCESS, c_ArrayList_Add(&list, &node1));
|
||
ASSERT_INT_EQ(C_SUCCESS, c_ArrayList_Add(&list, &node2));
|
||
ASSERT_INT_EQ(2, c_ArrayList_Size(&list));
|
||
|
||
// 强隔离隔离性检查：修改外部临时变量，内部数据不应被污染
|
||
node1.node_id = 999;
|
||
|
||
// 1. 测试 c_ArrayList_Read 拷出副本能力
|
||
SensorNode_t read_buffer;
|
||
ASSERT_INT_EQ(C_SUCCESS, c_ArrayList_Read(&list, 0, &read_buffer));
|
||
ASSERT_INT_EQ(101, read_buffer.node_id); // 应该依旧是原值 101
|
||
ASSERT_DOUBLE_EQ_MSG(45.2f, read_buffer.threshold, "Float precision checking");
|
||
ASSERT_TRUE(strcmp(read_buffer.name, "Temp01") == 0);
|
||
|
||
// 2. 测试 c_ArrayList_Get 直接指针读取能力
|
||
SensorNode_t* direct_ptr = (SensorNode_t*)c_ArrayList_Get(&list, 1);
|
||
ASSERT_PTR_NOT_NULL(direct_ptr);
|
||
ASSERT_INT_EQ(102, direct_ptr->node_id);
|
||
|
||
// 3. 越界保护检查
|
||
ASSERT_INT_EQ(C_ERR_PARAM, c_ArrayList_Read(&list, 2, &read_buffer));
|
||
ASSERT_TRUE(c_ArrayList_Get(&list, 5) == NULL);
|
||
|
||
c_ArrayList_Destroy(&list);
|
||
}
|
||
|
||
// 测试三：高危内存移动（memmove）及 Remove 位移正确性测试
|
||
TEST_CASE(test_element_removal_and_shifting) {
|
||
c_ArrayList_t list;
|
||
c_ArrayList_Init(&list, sizeof(int), 5, NULL);
|
||
|
||
int values[] = {10, 20, 30, 40, 50};
|
||
for(int i = 0; i < 5; i++) {
|
||
c_ArrayList_Add(&list, &values[i]);
|
||
}
|
||
|
||
// 移除中间的数字 30 (索引 2) 并精准接住拷出值
|
||
int removed_val = 0;
|
||
ASSERT_INT_EQ(C_ERR_OK, c_ArrayList_Remove(&list, 2, &removed_val));
|
||
ASSERT_INT_EQ(30, removed_val);
|
||
ASSERT_INT_EQ(4, c_ArrayList_Size(&list));
|
||
|
||
// 极其严苛地检测后面所有元素的向前位移是否对齐正确
|
||
ASSERT_INT_EQ(10, *(int*)c_ArrayList_Get(&list, 0));
|
||
ASSERT_INT_EQ(20, *(int*)c_ArrayList_Get(&list, 1));
|
||
ASSERT_INT_EQ(40, *(int*)c_ArrayList_Get(&list, 2)); // 40 顶替了 30 的位置
|
||
ASSERT_INT_EQ(50, *(int*)c_ArrayList_Get(&list, 3)); // 50 顶替了 40 的位置
|
||
|
||
// 验证静默删除（out_item 为 NULL）
|
||
ASSERT_INT_EQ(C_SUCCESS, c_ArrayList_Remove(&list, 0, NULL));
|
||
ASSERT_INT_EQ(20, *(int*)c_ArrayList_Get(&list, 0)); // 20 变成了头元素
|
||
|
||
c_ArrayList_Destroy(&list);
|
||
}
|
||
|
||
// 测试四：挂载自定义分配器，并验证伙伴系统（Buddy System）的 O(1) 就地复用优化
|
||
TEST_CASE(test_buddy_system_allocator_integration) {
|
||
c_Allocator_t buddy_allocator = {
|
||
.alloc = test_alloc,
|
||
.realloc = test_realloc,
|
||
.free = test_free,
|
||
.ud = &g_tracker
|
||
};
|
||
|
||
c_ArrayList_t list;
|
||
// 单个元素 8 字节，初始容量 2。整个缓冲区 = 2 * 8 = 16 字节
|
||
c_ArrayList_Init(&list, 8, 2, &buddy_allocator);
|
||
|
||
// 验证 active_allocations 计数 (1控制头由调用者在栈分配，因此分配器内只有 1 个内部数据缓冲区 array)
|
||
ASSERT_INT_EQ(1, g_tracker.active_allocations);
|
||
|
||
// 1. 显式调整容量从 2 -> 3
|
||
// 旧大小 16 字节 (2^4)，新大小 24 字节 (向上对齐到 2^5 = 32)，阶数改变，模拟真实搬迁
|
||
ASSERT_INT_EQ(C_SUCCESS, c_ArrayList_Resize(&list, 3));
|
||
ASSERT_INT_EQ(0, g_tracker.realloc_in_place_count); // 跨越了幂次墙，没有就地复用
|
||
|
||
// 2. 深度契合点：再次调整容量从 3 -> 4
|
||
// 旧大小 24 字节 (2^5 范围内)，新大小 32 字节 (刚好跨入 2^5 满额边界)
|
||
// 【期望结果】：落在同一阶数内，c_Buddy_Realloc 应当直接 O(1) 返回原指针！
|
||
ASSERT_INT_EQ(C_SUCCESS, c_ArrayList_Resize(&list, 4));
|
||
ASSERT_INT_EQ(1, g_tracker.realloc_in_place_count); // 完美！命中伙伴系统就地复用优化次数 1 次
|
||
|
||
// 3. 极限截断缩小到 0
|
||
ASSERT_INT_EQ(C_SUCCESS, c_ArrayList_Resize(&list, 0));
|
||
ASSERT_INT_EQ(0, c_ArrayList_Size(&list));
|
||
ASSERT_INT_EQ(0, list.capacity);
|
||
ASSERT_TRUE(list.array == NULL);
|
||
|
||
c_ArrayList_Destroy(&list);
|
||
|
||
// 验证测试环境有没有发生任何内存泄漏
|
||
ASSERT_INT_EQ_MSG(0, g_tracker.active_allocations, "Memory leak detected inside allocator!");
|
||
}
|
||
|
||
/* ------------------------------------------------------------------------------------------------------------------ */
|
||
/* */
|
||
|
||
int main(int argc, char** argv){
|
||
|
||
TEST_START(C_ArrayList_Module_Tests);
|
||
|
||
// 运行常规测试
|
||
RUN_TEST(test_lifecycle_and_defense);
|
||
RUN_TEST(test_value_copy_and_access);
|
||
RUN_TEST(test_element_removal_and_shifting);
|
||
|
||
// 使用 Fixture 模式运行涉及自定义状态追踪的伙伴系统测试
|
||
RUN_TEST_FIXTURE(test_buddy_system_allocator_integration, custom_allocator_setup, custom_allocator_teardown);
|
||
|
||
TEST_REPORT();
|
||
|
||
RETURN_TEST_STATUS;
|
||
}
|