apaki/unicstl
1
0
Fork 0
mirror of https://gitee.com/apaki/unicstl.git synced 2025-07-03 15:56:52 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

stack单测，完善push、pop等

Browse Source
This commit is contained in:
建峰 2024-08-30 01:10:45 +08:00
parent 03f4396227
commit e3f547875f
3 changed files with 194 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/queue.h
View File

@ -55,8 +55,8 @@ struct _queue
};
typedef struct _queue* queue_t;
bool queue_init(struct _queue * queue, uint32_t obj_size);
bool queue_init2(struct _queue * queue, uint32_t obj_size, uint32_t capacity);
bool queue_init(struct _queue* self, uint32_t obj_size);
bool queue_init2(struct _queue* self, uint32_t obj_size, uint32_t capacity);
queue_t queue_new(void);
void queue_free(queue_t* queue);

4
test/test.c
View File

@ -60,7 +60,9 @@ void print_str(void* obj)
// --------------------------------------------------
void setUp(void)
{
// before each test
static uint32_t item_cnt = 1;
printf("[%4d] ", item_cnt);
item_cnt+=1;
}
void tearDown(void)

200
test/test_stack.c
View File

@ -270,28 +270,45 @@ static void test_stack_num(void)
stack_t stack = NULL;
stack = stack_new();
TEST_ASSERT_NOT_NULL(stack);
TEST_ASSERT_TRUE(stack_init(stack, sizeof(int)));
stack->print_obj = print_num;
TEST_ASSERT_FALSE(stack->peek(stack, &temp));
TEST_ASSERT_TRUE(stack->clear(stack));
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
TEST_ASSERT_EQUAL_INT(i + 1, stack->size(stack));
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[i], temp);
}
TEST_ASSERT_FALSE(stack->empty(stack));
TEST_ASSERT_TRUE(stack->clear(stack));
TEST_ASSERT_TRUE(stack->empty(stack));
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
}
for (i = 0; i < len; i++)
{
stack->push(stack, &data[i]);
stack->peek(stack, &temp);
}
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[stack->size(stack) - 1], temp);
for (i = 0; i < len + 1; i++)
{
if (true == stack->pop(stack, &temp))
TEST_ASSERT_TRUE(stack->pop(stack, &temp));
if (!stack->empty(stack))
{
if(false != stack->peek(stack, &temp))
{
TEST_ASSERT_EQUAL(data[len - 2 - i], temp);
}
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[stack->size(stack) - 1], temp);
}
}
TEST_ASSERT_TRUE(stack->empty(stack));
TEST_ASSERT_FALSE(stack->pop(stack, &temp));
stack_free(&stack);
TEST_ASSERT_NULL(stack);
@ -299,18 +316,179 @@ static void test_stack_num(void)
static void test_stack_struct(void)
{
uint32_t i = 0;
struct _student data[] = {
{"zhao", 1001}, {"qian", 1002}, {"sun", 1003}, {"li", 1004},
"zhou", 1005, "wu", 1006, "zheng", 1007, "wang", 1008,
};
struct _student temp;
uint32_t len = sizeof(data) / sizeof(data[0]) - 1;
stack_t stack = stack_new();
TEST_ASSERT_NOT_NULL(stack);
stack_init(stack, sizeof(struct _student));
stack->print_obj = print_struct;
TEST_ASSERT_FALSE(stack->peek(stack, &temp));
TEST_ASSERT_TRUE(stack->clear(stack));
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
TEST_ASSERT_EQUAL_INT(i + 1, stack->size(stack));
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[i].id, temp.id);
TEST_ASSERT_EQUAL_STRING(data[i].name, temp.name);
}
TEST_ASSERT_FALSE(stack->empty(stack));
TEST_ASSERT_TRUE(stack->clear(stack));
TEST_ASSERT_TRUE(stack->empty(stack));
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
}
for(i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[stack->size(stack) - 1].id, temp.id);
TEST_ASSERT_EQUAL_STRING(data[stack->size(stack) - 1].name, temp.name);
TEST_ASSERT_TRUE(stack->pop(stack, &temp));
if (!stack->empty(stack))
{
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[stack->size(stack) - 1].id, temp.id);
TEST_ASSERT_EQUAL_STRING(data[stack->size(stack) - 1].name, temp.name);
}
}
TEST_ASSERT_TRUE(stack->empty(stack));
TEST_ASSERT_FALSE(stack->pop(stack, &temp));
stack_free(&stack);
TEST_ASSERT_NULL(stack);
}
static void test_stack2_num(void)
{
uint32_t i = 0;
int data[] = { 1,2,3,4,5,6,7,8,9,10 };
int temp = 0;
uint32_t len = sizeof(data) / sizeof(data[0]);
uint32_t capacity = len;
stack_t stack = NULL;
stack = stack_new();
TEST_ASSERT_NOT_NULL(stack);
TEST_ASSERT_TRUE(stack_init2(stack, sizeof(int), capacity));
stack->print_obj = print_num;
TEST_ASSERT_FALSE(stack->peek(stack, &temp));
TEST_ASSERT_TRUE(stack->clear(stack));
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
TEST_ASSERT_EQUAL_INT(i + 1, stack->size(stack));
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[i], temp);
}
TEST_ASSERT_FALSE(stack->empty(stack));
TEST_ASSERT_TRUE(stack->clear(stack));
TEST_ASSERT_TRUE(stack->empty(stack));
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
}
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[stack->size(stack) - 1], temp);
TEST_ASSERT_TRUE(stack->pop(stack, &temp));
if (!stack->empty(stack))
{
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[stack->size(stack) - 1], temp);
}
}
TEST_ASSERT_TRUE(stack->empty(stack));
TEST_ASSERT_FALSE(stack->pop(stack, &temp));
stack_free(&stack);
TEST_ASSERT_NULL(stack);
}
static void test_stack2_struct(void)
{
uint32_t i = 0;
struct _student data[] = {
{"zhao", 1001}, {"qian", 1002}, {"sun", 1003}, {"li", 1004},
"zhou", 1005, "wu", 1006, "zheng", 1007, "wang", 1008,
};
struct _student temp;
uint32_t len = sizeof(data) / sizeof(data[0]) - 1;
uint32_t capacity = len - 2;
stack_t stack = NULL;
stack = stack_new();
TEST_ASSERT_NOT_NULL(stack);
TEST_ASSERT_TRUE(stack_init2(stack, sizeof(struct _student), capacity));
stack->print_obj = print_struct;
TEST_ASSERT_FALSE(stack->peek(stack, &temp));
TEST_ASSERT_TRUE(stack->empty(stack));
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
TEST_ASSERT_EQUAL_INT(i + 1, stack->size(stack));
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[stack->size(stack) - 1].id, temp.id);
TEST_ASSERT_EQUAL_STRING(data[stack->size(stack) - 1].name, temp.name);
}
TEST_ASSERT_FALSE(stack->empty(stack));
TEST_ASSERT_TRUE(stack->clear(stack));
TEST_ASSERT_TRUE(stack->empty(stack));
for (i = 0; i < len; i++)
{
TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
TEST_ASSERT_EQUAL_INT(i + 1, stack->size(stack));
}
for(i = 0; i < len; i++)
{
if (!stack->empty(stack))
{
TEST_ASSERT_TRUE(stack->pop(stack, &temp));
}
else
{
TEST_ASSERT_FALSE(stack->pop(stack, &temp));
}
if (!stack->empty(stack))
{
TEST_ASSERT_TRUE(stack->peek(stack, &temp));
TEST_ASSERT_EQUAL_INT(data[stack->size(stack) - 1].id, temp.id);
TEST_ASSERT_EQUAL_STRING(data[stack->size(stack) - 1].name, temp.name);
}
else
{
TEST_ASSERT_FALSE(stack->peek(stack, &temp));
}
}
stack_free(&stack);
TEST_ASSERT_NULL(stack);
}
void test_stack(void)