From fb7ac936231a587b27130521436c734e9c2c44b5 Mon Sep 17 00:00:00 2001 From: jf-home Date: Fri, 15 May 2026 01:40:59 +0800 Subject: [PATCH] =?UTF-8?q?refactor(queue):=20=E7=BB=9F=E4=B8=80=E5=88=9D?= =?UTF-8?q?=E5=A7=8B=E5=8C=96=E6=8E=A5=E5=8F=A3=E5=B9=B6=E6=B7=BB=E5=8A=A0?= =?UTF-8?q?=20resize=20=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- demo/demo_queue.c | 6 +- include/queue.h | 5 +- include/stack.h | 2 +- perf/perf_queue.c | 3 +- src/graph.c | 2 +- src/queue.c | 52 +-- src/tree.c | 10 +- test/test_queue.c | 870 +++++++++++++++++++--------------------------- 8 files changed, 405 insertions(+), 545 deletions(-) diff --git a/demo/demo_queue.c b/demo/demo_queue.c index f347605..308d513 100644 --- a/demo/demo_queue.c +++ b/demo/demo_queue.c @@ -17,7 +17,7 @@ static void demo_queue_num(void) int temp = 0; size_t len = sizeof(data) / sizeof(data[0]); - queue_t queue = queue_new(sizeof(int)); + queue_t queue = queue_new(sizeof(int), len); queue->print_obj = print_num; printf("\n\n----- demo_queue_num -----\n"); @@ -101,7 +101,7 @@ static void demo_queue_char(void) char temp = 0; size_t len = sizeof(data) / sizeof(data[0]) - 1; - queue_t queue = queue_new2(sizeof(char), 10); + queue_t queue = queue_new(sizeof(char), 10); queue->print_obj = print_char; printf("\n\n----- demo_queue_char -----\n"); @@ -213,7 +213,7 @@ static void demo_queue_struct(void) struct _student temp; size_t len = sizeof(data) / sizeof(data[0]) - 1; - queue_t queue = queue_new(sizeof(struct _student)); + queue_t queue = queue_new(sizeof(struct _student), len); queue->print_obj = print_struct; printf("\n\n----- demo_queue_struct -----\n"); diff --git a/include/queue.h b/include/queue.h index 370c2b9..c65c3a4 100644 --- a/include/queue.h +++ b/include/queue.h @@ -31,6 +31,7 @@ struct _queue bool (*front)(struct _queue* self, void* obj); // base + size_t (*resize)(struct _queue* self, size_t capacity); size_t (*size)(struct _queue* self); size_t (*capacity)(struct _queue* self); bool (*empty)(struct _queue* self); @@ -47,9 +48,7 @@ struct _queue typedef struct _queue* queue_t; // create and free queue -queue_t queue_new2( size_t obj_size, size_t capacity); +queue_t queue_new(size_t obj_size, size_t capacity); void queue_free(queue_t* queue); -#define queue_new(obj_size) queue_new2(obj_size, 16) - #endif // _QUEUE_H_ diff --git a/include/stack.h b/include/stack.h index e417829..31f1e26 100644 --- a/include/stack.h +++ b/include/stack.h @@ -29,7 +29,7 @@ struct _stack bool (*peek)(struct _stack* self, void* obj); // base - size_t (*resize)(struct _stack* self, size_t new_size); + size_t (*resize)(struct _stack* self, size_t capacity); size_t (*size)(struct _stack* self); size_t (*capacity)(struct _stack* self); bool (*empty)(struct _stack* self); diff --git a/perf/perf_queue.c b/perf/perf_queue.c index 4aba382..8364d6e 100644 --- a/perf/perf_queue.c +++ b/perf/perf_queue.c @@ -14,8 +14,7 @@ static queue_t queue = NULL; void perf_queue_new(void) { - // queue = queue_new2(g_test_obj.obj_size, g_test_obj.capacity); - queue = queue_new(g_test_obj.obj_size); + queue = queue_new(g_test_obj.obj_size, g_test_obj.capacity); } void perf_queue_push(void) diff --git a/src/graph.c b/src/graph.c index 67f1a26..3e3d197 100644 --- a/src/graph.c +++ b/src/graph.c @@ -1009,7 +1009,7 @@ static bool graph_init(struct _graph *self, size_t obj_size) { return false; } - self->queue = queue_new(sizeof(struct _graph_node *)); + self->queue = queue_new(sizeof(struct _graph_node *), 16); if (self->queue == NULL) { stack_free(&self->stack); diff --git a/src/queue.c b/src/queue.c index 3127e77..55b8903 100644 --- a/src/queue.c +++ b/src/queue.c @@ -39,25 +39,11 @@ static bool queue_front(struct _queue* self, void* obj) return self->_deque->front(self->_deque, obj); } -static bool queue_clear(struct _queue* self) +static size_t queue_resize(struct _queue* self, size_t capacity) { unicstl_assert(self != NULL); unicstl_assert(self->_deque != NULL); - return self->_deque->clear(self->_deque); -} - -static bool queue_empty(struct _queue* self) -{ - unicstl_assert(self != NULL); - unicstl_assert(self->_deque != NULL); - return self->_deque->empty(self->_deque); -} - -static bool queue_full(struct _queue* self) -{ - unicstl_assert(self != NULL); - unicstl_assert(self->_deque != NULL); - return self->_deque->full(self->_deque); + return self->_deque->resize(self->_deque, capacity); } static size_t queue_size(struct _queue* self) @@ -75,6 +61,28 @@ static size_t queue_capacity(struct _queue* self) return self->_deque->capacity(self->_deque); } +static bool queue_empty(struct _queue* self) +{ + unicstl_assert(self != NULL); + unicstl_assert(self->_deque != NULL); + return self->_deque->empty(self->_deque); +} + +static bool queue_full(struct _queue* self) +{ + unicstl_assert(self != NULL); + unicstl_assert(self->_deque != NULL); + return self->_deque->full(self->_deque); +} + +static bool queue_clear(struct _queue* self) +{ + unicstl_assert(self != NULL); + unicstl_assert(self->_deque != NULL); + return self->_deque->clear(self->_deque); +} + + static void queue_destory(struct _queue* self) { unicstl_assert(self != NULL); @@ -127,10 +135,6 @@ static iterator_t queue_iter(struct _queue* self) static bool queue_init(struct _queue * self, size_t obj_size, size_t capacity) { unicstl_assert(self != NULL); - if(self == NULL || obj_size == 0 || capacity == 0) - { - return false; - } // -------------------- private -------------------- self->_deque = deque_new(obj_size, capacity); @@ -138,13 +142,10 @@ static bool queue_init(struct _queue * self, size_t obj_size, size_t capacity) { return false; } + // self->_destory = queue_destory; - // iter - self->_iter.hasnext = queue_iter_hasnext; - self->_iter.next = queue_iter_next; - // -------------------- public -------------------- // kernel self->push = queue_push; @@ -153,6 +154,7 @@ static bool queue_init(struct _queue * self, size_t obj_size, size_t capacity) self->front = queue_front; // base + self->resize = queue_resize; self->size = queue_size; self->capacity = queue_capacity; self->empty = queue_empty; @@ -180,7 +182,7 @@ static bool queue_init(struct _queue * self, size_t obj_size, size_t capacity) * * @return queue_t 队列指针 */ -queue_t queue_new2(size_t obj_size, size_t capacity) +queue_t queue_new(size_t obj_size, size_t capacity) { struct _queue * queue = NULL; queue = (struct _queue *)unicstl_malloc(sizeof(struct _queue)); diff --git a/src/tree.c b/src/tree.c index 9ce34e9..2352e56 100644 --- a/src/tree.c +++ b/src/tree.c @@ -75,7 +75,7 @@ static size_t tree_height_node(struct _tree* self, struct _tree_node* root) size_t count_next_level = 0; struct _tree_node* node = root; - queue_t queue = queue_new(sizeof(struct _tree_node*)); + queue_t queue = queue_new(sizeof(struct _tree_node*), self->size(self)); queue->push(queue, &node); while (!queue->empty(queue)) @@ -1058,7 +1058,7 @@ static bool tree_clear(struct _tree* self) } struct _tree_node* node = self->_root; - queue_t queue = queue_new(sizeof(struct _tree_node*)); + queue_t queue = queue_new(sizeof(struct _tree_node*), self->size(self)); queue->push(queue, &node); while (!queue->empty(queue)) @@ -1393,7 +1393,7 @@ static bool tree_avl_init(struct _tree* self, size_t obj_size) { return false; } - self->queue = queue_new(sizeof(struct _tree_node*)); + self->queue = queue_new(sizeof(struct _tree_node*), self->size(self)); if (self->queue == NULL) { stack_free(&self->stack); @@ -1440,12 +1440,12 @@ static bool tree_rb_init(struct _tree* self, size_t obj_size) self->_root = NULL; - self->stack = stack_new(sizeof(struct _tree_node*), self->size(self)); + self->stack = stack_new(sizeof(struct _tree_node*), 16); if (self->stack == NULL) { return false; } - self->queue = queue_new(sizeof(struct _tree_node*)); + self->queue = queue_new(sizeof(struct _tree_node*), 16); if (self->queue == NULL) { stack_free(&self->stack); diff --git a/test/test_queue.c b/test/test_queue.c index 2809fcd..8989a8c 100644 --- a/test/test_queue.c +++ b/test/test_queue.c @@ -1,55 +1,52 @@ /** - * @file demo_queue->c + * @file test_queue.c * @author wenjf (Orig5826@163.com) - * @brief + * @brief * @version 0.1 - * @date 2024-08-28 - * - * @copyright Copyright (c) 2024 - * + * @date 2026-05-15 + * + * @copyright Copyright (c) 2026 + * */ #include "test.h" static void test_queue_new(void) { - queue_t queue = NULL; - queue = queue_new(sizeof(int)); + // [invalid param] if obj_size==0, unit test is not needed. because assert will be triggered. + // TEST_ASSERT_NULL(queue_new(0, 0)); + // TEST_ASSERT_NULL(queue_new(0, 1)); + + queue_t queue = queue_new(sizeof(int), 10); TEST_ASSERT_NOT_NULL(queue); queue_free(&queue); - - TEST_ASSERT_NULL(queue_new(0)); - - // ------------------------------ - queue = queue_new2(sizeof(int), 10); - TEST_ASSERT_NOT_NULL(queue); - queue_free(&queue); - - TEST_ASSERT_NULL(queue_new2(0, 0)); - TEST_ASSERT_NULL(queue_new2(0, 1)); - TEST_ASSERT_NULL(queue_new2(sizeof(int), 0)); - - // ------------------------------ TEST_ASSERT_NULL(queue); +} + +static void test_queue_new_lazy(void) +{ + queue_t queue = queue_new(sizeof(int), 0); + TEST_ASSERT_NOT_NULL(queue); + TEST_ASSERT_EQUAL_size_t(0, queue->capacity(queue)); + + int temp = 0; + TEST_ASSERT_TRUE(queue->push(queue, &temp)); + TEST_ASSERT_EQUAL_size_t(UNICSTL_CAPACITY_INIT, queue->capacity(queue)); queue_free(&queue); } static void test_queue_push(void) { - int temp = 0; - int data[] = { 1,2,3,4,5,6,7,8,9,10 }; - size_t len = sizeof(data) / sizeof(data[0]); size_t i = 0; + int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int temp = 0; + size_t len = sizeof(data) / sizeof(data[0]); - queue_t queue = NULL; + queue_t queue = queue_new(sizeof(int), len); + queue->print_obj = print_num; - // ------------------------------ - queue = queue_new(sizeof(int)); - - TEST_ASSERT_TRUE(queue->empty(queue)); - for(i = 0; i < len; i++) + for (i = 0; i < len; i++) { TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); TEST_ASSERT_TRUE(queue->front(queue, &temp)); TEST_ASSERT_EQUAL_INT(data[0], temp); @@ -57,158 +54,39 @@ static void test_queue_push(void) TEST_ASSERT_TRUE(queue->back(queue, &temp)); TEST_ASSERT_EQUAL_INT(data[i], temp); - TEST_ASSERT_FALSE(queue->empty(queue)); - } - queue_free(&queue); - - // ------------------------------ - queue = queue_new2(sizeof(int), len); - - TEST_ASSERT_TRUE(queue->empty(queue)); - for(i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[0], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); - - TEST_ASSERT_FALSE(queue->empty(queue)); } + TEST_ASSERT_TRUE(queue->push(queue, &data[0])); + TEST_ASSERT_EQUAL_INT(len + 1, queue->size(queue)); + queue_free(&queue); +} - // ------------------------------ - // if capacity is less than data len - queue = queue_new2(sizeof(int), len - 2); - - for(i = 0; i < len; i++) - { - if(i < queue->capacity(queue)) - { - TEST_ASSERT_FALSE(queue->full(queue)); - - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - } - else - { - TEST_ASSERT_TRUE(queue->full(queue)); - - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - } - } +static void test_queue_push_invalid(void) +{ + queue_t queue = queue_new(sizeof(int), 1); + TEST_ASSERT_FALSE(queue->push(queue, NULL)); queue_free(&queue); } static void test_queue_pop(void) { - int temp = 0; - int data[] = { 1,2,3,4,5,6,7,8,9,10 }; - size_t len = sizeof(data) / sizeof(data[0]); size_t i = 0; + int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int temp = 0; + size_t len = sizeof(data) / sizeof(data[0]); - queue_t queue = NULL; + queue_t queue = queue_new(sizeof(int), len); + queue->print_obj = print_num; - // ------------------------------ - queue = queue_new(sizeof(int)); - - for(i = 0; i < len; i++) + TEST_ASSERT_FALSE(queue->front(queue, &temp)); + TEST_ASSERT_FALSE(queue->back(queue, &temp)); + for (i = 0; i < len; i++) { queue->push(queue, &data[i]); } - for (i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); + TEST_ASSERT_EQUAL_INT(len, queue->size(queue)); - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[len - 1], temp); - - TEST_ASSERT_TRUE(queue->pop(queue, &temp)); - - if (!queue->empty(queue)) - { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i + 1], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[len - 1], temp); - } - else - { - TEST_ASSERT_FALSE(queue->front(queue, &temp)); - TEST_ASSERT_FALSE(queue->back(queue, &temp)); - } - - TEST_ASSERT_FALSE(queue->full(queue)); - } - TEST_ASSERT_TRUE(queue->empty(queue)); - TEST_ASSERT_FALSE(queue->pop(queue, &temp)); - queue_free(&queue); - - // ------------------------------ - queue = queue_new2(sizeof(int), len); - - for(i = 0; i < len; i++) - { - queue->push(queue, &data[i]); - } - TEST_ASSERT_TRUE(queue->full(queue)); - for (i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[len - 1], temp); - - TEST_ASSERT_TRUE(queue->pop(queue, &temp)); - - if (!queue->empty(queue)) - { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i + 1], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[len - 1], temp); - } - else - { - TEST_ASSERT_FALSE(queue->front(queue, &temp)); - TEST_ASSERT_FALSE(queue->back(queue, &temp)); - } - - TEST_ASSERT_FALSE(queue->full(queue)); - } - TEST_ASSERT_TRUE(queue->empty(queue)); - TEST_ASSERT_FALSE(queue->pop(queue, &temp)); - queue_free(&queue); - - // ------------------------------ - // if capacity is less than data len - queue = queue_new2(sizeof(int), len - 2); - - for(i = 0; i < len; i++) - { - if(i < queue->capacity(queue)) - { - TEST_ASSERT_FALSE(queue->full(queue)); - - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - } - else - { - TEST_ASSERT_TRUE(queue->full(queue)); - - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - } - } - // TEST_ASSERT_TRUE(queue->full(queue)); - size_t capacity = queue->capacity(queue); for (i = 0; i < len; i++) { if (!queue->empty(queue)) @@ -226,154 +104,356 @@ static void test_queue_pop(void) TEST_ASSERT_EQUAL_INT(data[i + 1], temp); TEST_ASSERT_TRUE(queue->back(queue, &temp)); - // TEST_ASSERT_EQUAL_INT(data[capacity - 1], temp); + TEST_ASSERT_EQUAL_INT(data[len - 1], temp); } else { - TEST_ASSERT_FALSE(queue->pop(queue, &temp)); - TEST_ASSERT_FALSE(queue->front(queue, &temp)); TEST_ASSERT_FALSE(queue->back(queue, &temp)); } - TEST_ASSERT_FALSE(queue->full(queue)); } + TEST_ASSERT_TRUE(queue->empty(queue)); + + // ---------- no return ---------- + for (i = 0; i < 2; i++) + { + queue->push(queue, &data[i]); + } + TEST_ASSERT_TRUE(queue->pop(queue, NULL)); + TEST_ASSERT_TRUE(queue->pop(queue, NULL)); + TEST_ASSERT_FALSE(queue->pop(queue, NULL)); + queue_free(&queue); } - -static void test_queue_clear(void) +static void test_queue_back(void) { - int temp = 0; - int data[] = { 1,2,3,4,5,6,7,8,9,10 }; - size_t len = sizeof(data) / sizeof(data[0]); size_t i = 0; + int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int temp = 0; + size_t len = sizeof(data) / sizeof(data[0]); - queue_t queue = NULL; + queue_t queue = queue_new(sizeof(int), len); - // ------------------------------ - queue = queue_new(sizeof(int)); - - for(i = 0; i < len; i++) + TEST_ASSERT_FALSE(queue->back(queue, &temp)); + for (i = 0; i < len; i++) { queue->push(queue, &data[i]); } - TEST_ASSERT_TRUE(queue->clear(queue)); - for(i = 0; i < len; i++) + for (i = 0; i < len; i++) { - queue->push(queue, &data[i]); - } - TEST_ASSERT_FALSE(queue->empty(queue)); - TEST_ASSERT_TRUE(queue->clear(queue)); - TEST_ASSERT_TRUE(queue->empty(queue)); - TEST_ASSERT_TRUE(queue->clear(queue)); - queue_free(&queue); + queue->pop(queue, &temp); - // ------------------------------ - queue = queue_new2(sizeof(int), len); - - TEST_ASSERT_TRUE(queue->clear(queue)); - for(i = 0; i < len; i++) - { - queue->push(queue, &data[i]); + if (i != len - 1) + { + TEST_ASSERT_TRUE(queue->front(queue, &temp)); + TEST_ASSERT_EQUAL_INT(data[i + 1], temp); + } + else + { + TEST_ASSERT_FALSE(queue->front(queue, &temp)); + } } - TEST_ASSERT_FALSE(queue->empty(queue)); - TEST_ASSERT_TRUE(queue->clear(queue)); - TEST_ASSERT_TRUE(queue->empty(queue)); - TEST_ASSERT_TRUE(queue->clear(queue)); + queue_free(&queue); } +static void test_queue_back_invalid(void) +{ + queue_t queue = queue_new(sizeof(int), 1); + TEST_ASSERT_FALSE(queue->back(queue, NULL)); + queue_free(&queue); +} -static void test_queue_num(void) +static void test_queue_front(void) { size_t i = 0; - int data[] = { 1,2,3,4,5,6,7,8,9,10 }; + int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int temp = 0; size_t len = sizeof(data) / sizeof(data[0]); - queue_t queue = NULL; - queue = queue_new(sizeof(int)); - TEST_ASSERT_NOT_NULL(queue); - + queue_t queue = queue_new(sizeof(int), len); queue->print_obj = print_num; - TEST_ASSERT_TRUE(queue->clear(queue)); - TEST_ASSERT_FALSE(queue->front(queue, &temp)); - TEST_ASSERT_FALSE(queue->back(queue, &temp)); - for (i = 0; i < len; i++) { - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[0], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); - } - - TEST_ASSERT_FALSE(queue->empty(queue)); - TEST_ASSERT_TRUE(queue->clear(queue)); - TEST_ASSERT_TRUE(queue->empty(queue)); - for (i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); + queue->push(queue, &data[i]); } for (i = 0; i < len; i++) { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[len - 1], temp); - - TEST_ASSERT_TRUE(queue->pop(queue, &temp)); + if (!queue->empty(queue)) + { + TEST_ASSERT_TRUE(queue->pop(queue, &temp)); + } + else + { + TEST_ASSERT_FALSE(queue->pop(queue, &temp)); + } if (!queue->empty(queue)) { TEST_ASSERT_TRUE(queue->front(queue, &temp)); - // TEST_PRINTF("front = %d", temp); TEST_ASSERT_EQUAL_INT(data[i + 1], temp); TEST_ASSERT_TRUE(queue->back(queue, &temp)); TEST_ASSERT_EQUAL_INT(data[len - 1], temp); } + else + { + TEST_ASSERT_FALSE(queue->front(queue, &temp)); + TEST_ASSERT_FALSE(queue->back(queue, &temp)); + } } TEST_ASSERT_TRUE(queue->empty(queue)); - TEST_ASSERT_FALSE(queue->pop(queue, &temp)); + + // ---------- no return ---------- + for (i = 0; i < 2; i++) + { + queue->push(queue, &data[i]); + } + TEST_ASSERT_TRUE(queue->pop(queue, NULL)); + TEST_ASSERT_TRUE(queue->pop(queue, NULL)); + TEST_ASSERT_FALSE(queue->pop(queue, NULL)); queue_free(&queue); - TEST_ASSERT_NULL(queue); +} + +static void test_queue_front_invalid(void) +{ + queue_t queue = queue_new(sizeof(int), 1); + TEST_ASSERT_FALSE(queue->front(queue, NULL)); + queue_free(&queue); +} + +static void test_queue_iter(void) +{ + size_t i = 0; + int data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int temp = 0; + size_t len = sizeof(data) / sizeof(data[0]); + + queue_t queue = queue_new(sizeof(int), len); + queue->print_obj = print_num; + + for (i = 0; i < len; i++) + { + queue->push(queue, &data[i]); + } + + iterator_t iter = queue->iter(queue); + i = 0; + TEST_ASSERT_TRUE(iter->hasnext(iter)); + while(iter->hasnext(iter)) + { + temp = *(int *)iter->next(iter); + TEST_ASSERT_EQUAL_INT(data[i], temp); + i++; + } + TEST_ASSERT_EQUAL_INT(len, i); + + queue_free(&queue); +} + +static void test_queue_resize(void) +{ + int temp = 0; + int data[] = { 1,2,3,4,5,6,7,8,9,10 }; + size_t len = sizeof(data) / sizeof(data[0]); + size_t i = 0; + + queue_t queue = queue_new(sizeof(int), len); + + TEST_ASSERT_EQUAL_INT(len, queue->capacity(queue)); + TEST_ASSERT_TRUE(queue->resize(queue, 16)); + TEST_ASSERT_EQUAL_INT(16, queue->capacity(queue)); + + for(i = 0; i < len; i++) + { + queue->push(queue, &data[i]); + } + TEST_ASSERT_EQUAL_INT(16, queue->capacity(queue)); + TEST_ASSERT_EQUAL_INT(len, queue->size(queue)); + + TEST_ASSERT_TRUE(queue->resize(queue, 8)); + TEST_ASSERT_EQUAL_INT(8, queue->capacity(queue)); + TEST_ASSERT_EQUAL_INT(8, queue->size(queue)); + + TEST_ASSERT_TRUE(queue->front(queue, &temp)); + TEST_ASSERT_EQUAL_INT(data[0], temp); + TEST_ASSERT_TRUE(queue->back(queue, &temp)); + TEST_ASSERT_EQUAL_INT(data[7], temp); + + for(i = 0; i < len; i++) + { + if(i < 8) + { + TEST_ASSERT_TRUE(queue->pop(queue, &temp)); + TEST_ASSERT_EQUAL_INT(data[i], temp); + } + else + { + TEST_ASSERT_FALSE(queue->pop(queue, &temp)); + } + } + TEST_ASSERT_EQUAL_INT(8, queue->capacity(queue)); + TEST_ASSERT_EQUAL_INT(0, queue->size(queue)); + + queue_free(&queue); +} + +static void test_queue_resize_invalid(void) +{ + int temp = 0; + int data[] = { 1,2,3,4,5,6,7,8,9,10 }; + size_t len = sizeof(data) / sizeof(data[0]); + size_t i = 0; + + queue_t queue = queue_new(sizeof(int), len); + + TEST_ASSERT_EQUAL_INT(len, queue->capacity(queue)); + TEST_ASSERT_FALSE(queue->resize(queue, 0)); + TEST_ASSERT_FALSE(queue->resize(queue, -1)); + + queue_free(&queue); +} + +static void test_queue_resize_edge(void) +{ + queue_t queue = queue_new(sizeof(int), 10); + + TEST_ASSERT_EQUAL_INT(10, queue->capacity(queue)); + TEST_ASSERT_TRUE(queue->resize(queue, 10)); + TEST_ASSERT_EQUAL_INT(10, queue->capacity(queue)); + + queue_free(&queue); +} + +static void test_queue_dynamic(void) +{ + int temp = 0; + int data[] = { 1,2,3,4,5,6,7,8,9,10 }; + + size_t i = 0; + size_t len = 2; + queue_t queue = queue_new(sizeof(int), len); + + for(i = 0; i < len; i++) + { + TEST_ASSERT_TRUE(queue->push(queue, &data[i])); + TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); + + TEST_ASSERT_TRUE(queue->back(queue, &temp)); + TEST_ASSERT_EQUAL_INT(data[i], temp); + + TEST_ASSERT_EQUAL_INT(len, queue->capacity(queue)); + if(i < len - 1) + { + TEST_ASSERT_FALSE(queue->full(queue)); + } + else + { + TEST_ASSERT_TRUE(queue->full(queue)); + } + } + + len *= 2; + for(; i < len; i++) + { + TEST_ASSERT_TRUE(queue->push(queue, &data[i])); + TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); + + TEST_ASSERT_TRUE(queue->back(queue, &temp)); + TEST_ASSERT_EQUAL_INT(data[i], temp); + + TEST_ASSERT_EQUAL_INT(len, queue->capacity(queue)); + if(i < len - 1) + { + TEST_ASSERT_FALSE(queue->full(queue)); + } + else + { + TEST_ASSERT_TRUE(queue->full(queue)); + } + } + + len *= 2; + for(; i < len; i++) + { + TEST_ASSERT_TRUE(queue->push(queue, &data[i])); + TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); + + TEST_ASSERT_TRUE(queue->back(queue, &temp)); + TEST_ASSERT_EQUAL_INT(data[i], temp); + + TEST_ASSERT_EQUAL_INT(len, queue->capacity(queue)); + if(i < len - 1) + { + TEST_ASSERT_FALSE(queue->full(queue)); + } + else + { + TEST_ASSERT_TRUE(queue->full(queue)); + } + } + + queue_free(&queue); +} + +static void test_queue_status(void) +{ + size_t i = 0; + int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int temp = 0; + size_t len = sizeof(data) / sizeof(data[0]); + + queue_t queue = queue_new(sizeof(int), len); + queue->print_obj = print_num; + + TEST_ASSERT_EQUAL_INT(len, queue->capacity(queue)); + TEST_ASSERT_EQUAL_INT(0, queue->size(queue)); + + TEST_ASSERT_TRUE(queue->empty(queue)); + TEST_ASSERT_FALSE(queue->full(queue)); + + for (i = 0; i < len - 1; i++) + { + TEST_ASSERT_TRUE(queue->push(queue, &data[i])); + + TEST_ASSERT_FALSE(queue->empty(queue)); + TEST_ASSERT_FALSE(queue->full(queue)); + } + TEST_ASSERT_TRUE(queue->push(queue, &data[i])); + TEST_ASSERT_TRUE(queue->full(queue)); + TEST_ASSERT_TRUE(queue->push(queue, &data[i])); + + TEST_ASSERT_TRUE(queue->clear(queue)); + TEST_ASSERT_TRUE(queue->empty(queue)); + TEST_ASSERT_FALSE(queue->full(queue)); + + queue_free(&queue); } static void test_queue_struct(void) { size_t i = 0; struct _student data[] = { - {"zhao", 1001}, {"qian", 1002}, {"sun", 1003}, {"li", 1004}, - "zhou", 1005, "wu", 1006, "zheng", 1007, "wang", 1008, + "zhao", 1001, "qian", 1002, "sun", 1003, "li", 1004, + "zhou", 1005, "wu", 1006, "zheng", 1007, "wang", 1008, + "feng", 1009, "cheng",1010, }; - struct _student temp; - size_t len = sizeof(data) / sizeof(data[0]) - 1; + struct _student temp = {0}; + size_t len = sizeof(data) / sizeof(data[0]); - queue_t queue = queue_new(sizeof(struct _student)); + queue_t queue = queue_new(sizeof(struct _student), len); TEST_ASSERT_NOT_NULL(queue); - queue->print_obj = print_struct; - TEST_ASSERT_TRUE(queue->clear(queue)); - - TEST_ASSERT_FALSE(queue->front(queue, &temp)); - TEST_ASSERT_FALSE(queue->back(queue, &temp)); - for (i = 0; i < len; i++) { TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); TEST_ASSERT_TRUE(queue->front(queue, &temp)); TEST_ASSERT_EQUAL_INT(data[0].id, temp.id); @@ -382,8 +462,9 @@ static void test_queue_struct(void) TEST_ASSERT_TRUE(queue->back(queue, &temp)); TEST_ASSERT_EQUAL_INT(data[i].id, temp.id); TEST_ASSERT_EQUAL_STRING(data[i].name, temp.name); - } + TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); + } TEST_ASSERT_FALSE(queue->empty(queue)); TEST_ASSERT_TRUE(queue->clear(queue)); TEST_ASSERT_TRUE(queue->empty(queue)); @@ -392,20 +473,18 @@ static void test_queue_struct(void) TEST_ASSERT_TRUE(queue->push(queue, &data[i])); } - // while (!queue->empty(queue)) - for(i = 0; i < len; i++) + for (i = 0; i < len + 1; i++) { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i].id, temp.id); - TEST_ASSERT_EQUAL_STRING(data[i].name, temp.name); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[len - 1].id, temp.id); - TEST_ASSERT_EQUAL_STRING(data[len - 1].name, temp.name); - - TEST_ASSERT_TRUE(queue->pop(queue, &temp)); - - if (!queue->empty(queue)) + if(!queue->empty(queue)) + { + TEST_ASSERT_TRUE(queue->pop(queue, &temp)); + } + else + { + TEST_ASSERT_FALSE(queue->pop(queue, &temp)); + } + + if(!queue->empty(queue)) { TEST_ASSERT_TRUE(queue->front(queue, &temp)); TEST_ASSERT_EQUAL_INT(data[i + 1].id, temp.id); @@ -415,268 +494,49 @@ static void test_queue_struct(void) TEST_ASSERT_EQUAL_INT(data[len - 1].id, temp.id); TEST_ASSERT_EQUAL_STRING(data[len - 1].name, temp.name); } - } - TEST_ASSERT_TRUE(queue->empty(queue)); - TEST_ASSERT_FALSE(queue->pop(queue, &temp)); - queue_free(&queue); - TEST_ASSERT_NULL(queue); -} - -static void test_queue2_num(void) -{ - size_t i = 0; - int data[] = { 1,2,3,4,5,6,7,8,9,10 }; - int temp = 0; - size_t len = sizeof(data) / sizeof(data[0]); - size_t capacity = len; - - queue_t queue = NULL; - queue = queue_new2(sizeof(int), capacity); - TEST_ASSERT_NOT_NULL(queue); - - queue->print_obj = print_num; - - TEST_ASSERT_TRUE(queue->clear(queue)); - - TEST_ASSERT_FALSE(queue->front(queue, &temp)); - TEST_ASSERT_FALSE(queue->back(queue, &temp)); - - for (i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[0], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); - } - - TEST_ASSERT_FALSE(queue->empty(queue)); - TEST_ASSERT_TRUE(queue->clear(queue)); - TEST_ASSERT_TRUE(queue->empty(queue)); - for (i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - } - - for (i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[len - 1], temp); - - TEST_ASSERT_TRUE(queue->pop(queue, &temp)); - - if (!queue->empty(queue)) - { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - // TEST_PRINTF("front = %d", temp); - TEST_ASSERT_EQUAL_INT(data[i + 1], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[len - 1], temp); - } - } - TEST_ASSERT_TRUE(queue->empty(queue)); - TEST_ASSERT_FALSE(queue->pop(queue, &temp)); - - queue_free(&queue); - TEST_ASSERT_NULL(queue); -} - -static void test_queue2_struct(void) -{ - size_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; - size_t len = sizeof(data) / sizeof(data[0]) - 1; - size_t capacity = len - 2; - - queue_t queue = NULL; - queue = queue_new2(sizeof(struct _student), capacity); - TEST_ASSERT_NOT_NULL(queue); - - queue->print_obj = print_struct; - - TEST_ASSERT_TRUE(queue->empty(queue)); - TEST_ASSERT_FALSE(queue->full(queue)); - TEST_ASSERT_FALSE(queue->front(queue, &temp)); - TEST_ASSERT_FALSE(queue->back(queue, &temp)); - - for (i = 0; i < len; i++) - { - if(i < queue->capacity(queue)) - { - TEST_ASSERT_FALSE(queue->full(queue)); - - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - } - else - { - TEST_ASSERT_TRUE(queue->full(queue)); - - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - } - - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[0].id, temp.id); - TEST_ASSERT_EQUAL_STRING(data[0].name, temp.name); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[queue->size(queue) - 1].id, temp.id); - TEST_ASSERT_EQUAL_STRING(data[queue->size(queue) - 1].name, temp.name); - } - - TEST_ASSERT_FALSE(queue->empty(queue)); - TEST_ASSERT_TRUE(queue->clear(queue)); - TEST_ASSERT_TRUE(queue->empty(queue)); - for (i = 0; i < len; i++) - { - if(i < queue->capacity(queue)) - { - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - } - else - { - TEST_ASSERT_FALSE(queue->push(queue, &data[i])); - } - } - - for(i = 0; i < len; i++) - { - if (!queue->empty(queue)) - { - TEST_ASSERT_TRUE(queue->pop(queue, &temp)); - } - else - { - TEST_ASSERT_FALSE(queue->pop(queue, &temp)); - } - - if (!queue->empty(queue)) - { - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i + 1].id, temp.id); - TEST_ASSERT_EQUAL_STRING(data[i + 1].name, temp.name); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - // TEST_ASSERT_EQUAL_INT(data[queue->size(queue) - 1].id, temp.id); - // TEST_ASSERT_EQUAL_STRING(data[queue->size(queue) - 1].name, temp.name); - } else { TEST_ASSERT_FALSE(queue->front(queue, &temp)); TEST_ASSERT_FALSE(queue->back(queue, &temp)); } - - TEST_ASSERT_FALSE(queue->full(queue)); } + TEST_ASSERT_TRUE(queue->empty(queue)); + queue_free(&queue); TEST_ASSERT_NULL(queue); } -static void test_queue_iter(void) -{ - size_t i = 0; - int data[] = { 1,2,3,4,5,6,7,8,9,10 }; - int temp = 0; - size_t len = sizeof(data) / sizeof(data[0]); - - queue_t queue = NULL; - queue = queue_new(sizeof(int)); - TEST_ASSERT_NOT_NULL(queue); - queue->print_obj = print_num; - - for (i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[0], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); - } - - iterator_t iter = queue->iter(queue); - i = 0; - while(iter->hasnext(iter)) - { - temp = *(int *)iter->next(iter); - // printf("%d ", temp); - TEST_ASSERT_EQUAL_INT(data[i], temp); - i++; - } - - queue_free(&queue); - TEST_ASSERT_NULL(queue); -} - - -static void test_queue2_iter(void) -{ - size_t i = 0; - int data[] = { 1,2,3,4,5,6,7,8,9,10 }; - int temp = 0; - size_t len = sizeof(data) / sizeof(data[0]); - size_t capacity = len; - - queue_t queue = NULL; - queue = queue_new2(sizeof(int), capacity); - TEST_ASSERT_NOT_NULL(queue); - queue->print_obj = print_num; - - for (i = 0; i < len; i++) - { - TEST_ASSERT_TRUE(queue->push(queue, &data[i])); - TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); - - TEST_ASSERT_TRUE(queue->front(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[0], temp); - - TEST_ASSERT_TRUE(queue->back(queue, &temp)); - TEST_ASSERT_EQUAL_INT(data[i], temp); - } - - iterator_t iter = queue->iter(queue); - i = 0; - while(iter->hasnext(iter)) - { - temp = *(int *)iter->next(iter); - TEST_ASSERT_EQUAL_INT(data[i], temp); - i++; - } - - queue_free(&queue); - TEST_ASSERT_NULL(queue); -} - void test_queue(void) { UnitySetTestFile(__FILE__); + // ---------- kernel ---------- RUN_TEST(test_queue_new); + RUN_TEST(test_queue_new_lazy); + RUN_TEST(test_queue_push); + RUN_TEST(test_queue_push_invalid); + RUN_TEST(test_queue_pop); - RUN_TEST(test_queue_clear); - RUN_TEST(test_queue_num); - RUN_TEST(test_queue_struct); + RUN_TEST(test_queue_back); + RUN_TEST(test_queue_back_invalid); - RUN_TEST(test_queue2_num); - RUN_TEST(test_queue2_struct); + RUN_TEST(test_queue_front); + RUN_TEST(test_queue_front_invalid); RUN_TEST(test_queue_iter); - RUN_TEST(test_queue2_iter); + + RUN_TEST(test_queue_resize); + RUN_TEST(test_queue_resize_invalid); + RUN_TEST(test_queue_resize_edge); + + RUN_TEST(test_queue_dynamic); + + // ---------- base ---------- + RUN_TEST(test_queue_status); + + // ---------- ext ---------- + RUN_TEST(test_queue_struct); }