diff --git a/include/common.h b/include/common.h
index 50ffb2c..a07a133 100644
--- a/include/common.h
+++ b/include/common.h
@@ -11,7 +11,7 @@
 #ifndef _COMMON_H_
 #define _COMMON_H_
 
-#define NDEBUG 1
+// #define NDEBUG 1
 
 #include <stdint.h>
 #include <stdbool.h>
diff --git a/src/queue.c b/src/queue.c
index da0d515..a16d7d6 100644
--- a/src/queue.c
+++ b/src/queue.c
@@ -34,7 +34,7 @@ done:
     return NULL;
 }
 
-bool queue_push(struct _queue* self, void* obj)
+static bool queue_push(struct _queue* self, void* obj)
 {
     assert(self != NULL);
     assert(obj != NULL);
@@ -73,7 +73,7 @@ done:
     return false;
 }
 
-bool queue_pop(struct _queue* self, void* obj)
+static bool queue_pop(struct _queue* self, void* obj)
 {
     assert(self != NULL);
     if (self->empty(self))
@@ -92,7 +92,7 @@ bool queue_pop(struct _queue* self, void* obj)
     return true;
 }
 
-bool queue_back(struct _queue* self, void* obj)
+static bool queue_back(struct _queue* self, void* obj)
 {
     assert(self != NULL);
     if (self->empty(self))
@@ -103,7 +103,7 @@ bool queue_back(struct _queue* self, void* obj)
     return true;
 }
 
-bool queue_front(struct _queue* self, void* obj)
+static bool queue_front(struct _queue* self, void* obj)
 {
     assert(self != NULL);
     if (self->empty(self))
@@ -114,7 +114,7 @@ bool queue_front(struct _queue* self, void* obj)
     return true;
 }
 
-bool queue_clear(struct _queue* self)
+static bool queue_clear(struct _queue* self)
 {
     assert(self != NULL);
     struct _queue_node* node = self->_front;
@@ -132,25 +132,25 @@ bool queue_clear(struct _queue* self)
     return true;
 }
 
-bool queue_empty(struct _queue* self)
+static bool queue_empty(struct _queue* self)
 {
     assert(self != NULL);
-    return !self->size(self);
+    return self->_size == 0;
 }
 
-uint32_t queue_size(struct _queue* self)
+static uint32_t queue_size(struct _queue* self)
 {
     assert(self != NULL);
     return self->_size;
 }
 
-void queue_destory(struct _queue* self)
+static void queue_destory(struct _queue* self)
 {
     assert(self != NULL);
     self->clear(self);
 }
 
-void queue_print(struct _queue* self)
+static void queue_print(struct _queue* self)
 {
     assert(self != NULL);
 
@@ -164,13 +164,19 @@ void queue_print(struct _queue* self)
 
 bool queue_init(struct _queue * queue, uint32_t obj_size)
 {
-    assert(queue != NULL);
-    assert(obj_size > 0);
+    // assert(queue != NULL);
+    // assert(obj_size > 0);
     if(queue == NULL || obj_size == 0)
     {
         return false;
     }
 
+    // The queue is only initialized once
+    if(queue->_obj_size != 0)
+    {
+        return false;
+    }
+
     // attribute init
     queue->_size = 0;
     queue->_obj_size = obj_size;
@@ -195,7 +201,7 @@ bool queue_init(struct _queue * queue, uint32_t obj_size)
 
 
 
-bool queue2_push(struct _queue* self, void* obj)
+static bool queue2_push(struct _queue* self, void* obj)
 {
     assert(self != NULL);
     assert(obj != NULL);
@@ -221,7 +227,7 @@ bool queue2_push(struct _queue* self, void* obj)
     return true;
 }
 
-bool queue2_pop(struct _queue* self, void* obj)
+static bool queue2_pop(struct _queue* self, void* obj)
 {
     assert(self != NULL);
     if (self->empty(self))
@@ -247,7 +253,7 @@ bool queue2_pop(struct _queue* self, void* obj)
     return true;
 }
 
-bool queue2_back(struct _queue* self, void* obj)
+static bool queue2_back(struct _queue* self, void* obj)
 {
     assert(self != NULL);
     if (self->empty(self))
@@ -268,7 +274,7 @@ bool queue2_back(struct _queue* self, void* obj)
     return true;
 }
 
-bool queue2_front(struct _queue* self, void* obj)
+static bool queue2_front(struct _queue* self, void* obj)
 {
     assert(self != NULL);
     if (self->empty(self))
@@ -281,7 +287,7 @@ bool queue2_front(struct _queue* self, void* obj)
     return true;
 }
 
-bool queue2_clear(struct _queue* self)
+static bool queue2_clear(struct _queue* self)
 {
     assert(self != NULL);
     self->_index_front = 0;
@@ -290,25 +296,25 @@ bool queue2_clear(struct _queue* self)
     return true;
 }
 
-bool queue2_full(struct _queue* self)
+static bool queue2_full(struct _queue* self)
 {
     assert(self != NULL);
     return self->size(self) == self->capacity(self);
 }
 
-uint32_t queue2_capacity(struct _queue* self)
+static uint32_t queue2_capacity(struct _queue* self)
 {
     assert(self != NULL);
     return self->_capacity;
 }
 
-void queue2_destory(struct _queue* self)
+static void queue2_destory(struct _queue* self)
 {
     assert(self != NULL);
     self->clear(self);
 }
 
-void queue2_print(struct _queue* self)
+static void queue2_print(struct _queue* self)
 {
     assert(self != NULL);
     uint32_t index = 0;
@@ -328,14 +334,20 @@ void queue2_print(struct _queue* self)
 
 bool queue_init2(struct _queue * queue, uint32_t obj_size, uint32_t capacity)
 {
-    assert(queue != NULL);
-    assert(obj_size > 0);
-    assert(capacity > 0);
+    // assert(queue != NULL);
+    // assert(obj_size > 0);
+    // assert(capacity > 0);
     if(queue == NULL || obj_size == 0 || capacity == 0)
     {
         return false;
     }
 
+    // The queue is only initialized once
+    if(queue->_obj_size != 0)
+    {
+        return false;
+    }
+
     // attribute init
     queue->_size = 0;
     queue->_obj_size = obj_size;
diff --git a/test/test_queue.c b/test/test_queue.c
index 74440aa..c715ab8 100644
--- a/test/test_queue.c
+++ b/test/test_queue.c
@@ -19,6 +19,8 @@ static void test_queue_new(void)
     queue_free(&queue);
     TEST_ASSERT_NULL(queue);
 
+    TEST_ASSERT_NOT_NULL(&queue);
+    queue_free(&queue);
     queue_free(NULL);
 }
 
@@ -28,17 +30,19 @@ static void test_queue_init(void)
 
     // ------------------------------
     queue = queue_new();
-    TEST_ASSERT_TRUE(queue_init(queue, sizeof(int)));
     TEST_ASSERT_FALSE(queue_init(NULL, sizeof(int)));
     TEST_ASSERT_FALSE(queue_init(queue, 0));
+    TEST_ASSERT_TRUE(queue_init(queue, sizeof(int)));
+    TEST_ASSERT_FALSE(queue_init(queue, sizeof(int)));     // The queue is only initialized once
     queue_free(&queue);
 
     // ------------------------------
     queue = queue_new();
-    TEST_ASSERT_TRUE(queue_init2(queue, sizeof(int), 1));
-    TEST_ASSERT_FALSE(queue_init2(NULL, sizeof(int),1 ));
+    TEST_ASSERT_FALSE(queue_init2(NULL, sizeof(int), 1));
     TEST_ASSERT_FALSE(queue_init2(queue, 0, 1));
     TEST_ASSERT_FALSE(queue_init2(queue, sizeof(int), 0));
+    TEST_ASSERT_TRUE(queue_init2(queue, sizeof(int), 1));
+    TEST_ASSERT_FALSE(queue_init2(queue, sizeof(int), 1));  // The queue is only initialized once
     queue_free(&queue);
 }
 
@@ -55,6 +59,7 @@ static void test_queue_push(void)
     // ------------------------------
     queue = queue_new();
     queue_init(queue, sizeof(int));
+    TEST_ASSERT_TRUE(queue->empty(queue));
     for(i = 0; i < len; i++)
     {
         TEST_ASSERT_TRUE(queue->push(queue, &data[i]));
@@ -65,12 +70,15 @@ 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_new();
     queue_init2(queue, sizeof(int), len);
+    TEST_ASSERT_TRUE(queue->empty(queue));
     for(i = 0; i < len; i++)
     {
         TEST_ASSERT_TRUE(queue->push(queue, &data[i]));
@@ -81,33 +89,34 @@ 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);
 
     // ------------------------------
     // if capacity is less than data len
-    uint32_t capacity = len - 1;
     queue = queue_new();
-    queue_init2(queue, sizeof(int), capacity);
+    queue_init2(queue, sizeof(int), len - 2);
     for(i = 0; i < len; i++)
     {
-        if(i == capacity - 1)
+        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));
-
-            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);
         }
         else
         {
-            
+            TEST_ASSERT_TRUE(queue->full(queue));
+
+            TEST_ASSERT_FALSE(queue->push(queue, &data[i]));
+            TEST_ASSERT_EQUAL_INT(queue->capacity(queue), queue->size(queue));
         }
     }
     queue_free(&queue);
+    // queue->empty(queue);
 }