queue: get rid of printf, return bool result on enqueue, add unit tests for corner cases

Author: polesskiy-dev

Makefile

@@ -41,11 +41,11 @@
         T elements[maxQueueCapacity]; \
     } QUEUE_##T; \
     void QUEUE_##T##_Ctor(QUEUE_##T *const q); \
-    void QUEUE_##T##_Enqueue(QUEUE_##T *const q, T item); \
+    bool QUEUE_##T##_Enqueue(QUEUE_##T *const q, T item); \
     T QUEUE_##T##_Dequeue(QUEUE_##T *const q); \
     int QUEUE_##T##_GetSize(QUEUE_##T *const q);          \
     T QUEUE_##T##_Peek(QUEUE_##T *const q); \
-bool QUEUE_##T##_IsFull(QUEUE_##T *const q);
+    bool QUEUE_##T##_IsFull(QUEUE_##T *const q);
 
 /**
  * @struct QUEUE_T
@@ -78,20 +78,22 @@ void QUEUE_T_Ctor(QUEUE_T *const q);
  * @param q Pointer to the queue.
  * @param item The item to be enqueued.
  *
+ * @return `true` if element enqueued (queue wasn't full), `false` otherwise.
+ *
  * ####Example:
  * @code
  * QUEUE_int q;
  * QUEUE_int_Ctor(&q);
  * QUEUE_int_Enqueue(&q, 5);
  * @endcode
  */
-void QUEUE_T_Enqueue(QUEUE_T *const q, T item);
+bool QUEUE_T_Enqueue(QUEUE_T *const q, T item);
 
 /**
  * @brief Dequeues an element from the queue.
  *
  * @param q Pointer to the queue.
- * @return The dequeued item.
+ * @return The dequeued item or NULL
  *
  * ####Example:
  * @code
@@ -123,7 +125,7 @@ int QUEUE_T_GetSize(QUEUE_T *const q);
  * @brief Peeks at the front element of the queue.
  *
  * @param q Pointer to the queue.
- * @return The element at the front of the queue.
+ * @return The element at the front of the queue or NULL
  *
  * ####Example:
  * @code

src/queue/queue.h

@@ -9,21 +9,22 @@
         q->rear = -1; \
     } \
     \
-    void QUEUE_##T##_Enqueue(QUEUE_##T *const q, T item) { \
+    bool QUEUE_##T##_Enqueue(QUEUE_##T *const q, T item) { \
         if (((q->rear + 1) % maxQueueCapacity) == q->front) { \
-            printf("Queue is full. Cannot enqueue.\n"); \
-            return; \
+            /* Queue is full. Cannot enqueue.*/ \
+            return false; \
         } \
         q->rear = (q->rear + 1) % maxQueueCapacity; \
         q->elements[q->rear] = item; \
         if (q->front == -1) { \
             q->front = 0; \
         } \
+        return true; \
     } \
     \
     T QUEUE_##T##_Dequeue(QUEUE_##T *const q) { \
         if (q->front == -1) { \
-            printf("Queue is empty. Cannot dequeue.\n"); \
+            /* Queue is empty. Cannot dequeue. */ \
             return (T){0}; \
         } \
         T item = q->elements[q->front]; \
@@ -49,7 +50,7 @@
     \
     T QUEUE_##T##_Peek(QUEUE_##T *const q) { \
         if (q->front == -1) { \
-            printf("Queue is empty. Cannot peek.\n"); \
+            /* "Queue is empty. Cannot peek.\n"); */ \
             return (T){0}; \
         } \
         return q->elements[q->front]; \

src/queue/queue_impl.h

@@ -3,15 +3,15 @@
 #include "../../src/queue/queue_impl.h"
 
 // We're using a queue of integers for simplicity
-#define QUEUE_SIZE 5
+#define QUEUE_SIZE 4
 DECLARE_QUEUE(int, QUEUE_SIZE)
 QUEUE_IMPLEMENTATION(int, QUEUE_SIZE)
 
 QUEUE_int q;
 
 void setUp(void) {
     // This is run before EACH test
-    QUEUE_int_Ctor(&q); // constructor
+    QUEUE_int_Ctor(&q); // constructor, BEWARE: it's not emptying actual elements
 }
 
 void tearDown(void) {
@@ -48,11 +48,33 @@ void test_queue_isfull(void) {
     TEST_ASSERT_TRUE(QUEUE_int_IsFull(&q));
 }
 
+void test_queue_dequeue_empty(void) {
+    TEST_ASSERT_EQUAL_INT(0, QUEUE_int_Dequeue(&q));
+    TEST_ASSERT_EQUAL_INT(0, QUEUE_int_GetSize(&q));
+}
+
+void test_queue_peek_empty(void) {
+    TEST_ASSERT_EQUAL_INT(0, QUEUE_int_Peek(&q));
+    TEST_ASSERT_EQUAL_INT(0, QUEUE_int_GetSize(&q));
+}
+
+void test_queue_enqueue_full(void) {
+    for (int i = 0; i < QUEUE_SIZE; i++) {
+        TEST_ASSERT_TRUE(QUEUE_int_Enqueue(&q, i));
+    }
+    TEST_ASSERT_FALSE(QUEUE_int_Enqueue(&q, 99));
+    TEST_ASSERT_EQUAL_INT(QUEUE_SIZE, QUEUE_int_GetSize(&q));
+}
+
 int main(void) {
     UNITY_BEGIN();
     RUN_TEST(test_queue_ctor);
     RUN_TEST(test_queue_enqueue);
     RUN_TEST(test_queue_dequeue);
     RUN_TEST(test_queue_isfull);
+    RUN_TEST(test_queue_dequeue_empty);
+    RUN_TEST(test_queue_peek_empty);
+    RUN_TEST(test_queue_enqueue_full);
+
     return UNITY_END();
 }