diff --git a/include/queue.h b/include/queue.h
index 00a28bc..418edda 100644
--- a/include/queue.h
+++ b/include/queue.h
@@ -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);
diff --git a/test/test.c b/test/test.c
index d3f6edf..20e3027 100644
--- a/test/test.c
+++ b/test/test.c
@@ -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)
diff --git a/test/test_stack.c b/test/test_stack.c
index 808cf8a..056399a 100644
--- a/test/test_stack.c
+++ b/test/test_stack.c
@@ -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)