Merge pull request #11 from shishir-dey/feature/better-unit-testing

Enable unit testing, register the tests with CTest, and allow the creation of multiple test executables

Author: shishir-dey

CMakeLists.txt

@@ -4,6 +4,9 @@ project(stm32-devops-template)
 
 message("HOST=${HOST}")
 
+# Enable testing
+enable_testing()
+
 enable_language(C ASM)
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
@@ -15,38 +18,46 @@ set(COMMON_SOURCES
 )
 
 if( HOST )
-        set(HOST_SOURCES
-                test/test_linked_list.c
-                lib/Unity/src/unity_internals.h
-                lib/Unity/src/unity.h
-                lib/Unity/src/unity.c
-        )
+        # Collect all test source files matching test/test_*.c
+        file(GLOB TEST_SOURCES "test/test_*.c")
 
-        set(HOST_EXECUTABLE
-                ${PROJECT_NAME}.out
-        )
+        # Loop over each test source file
+        foreach(TEST_SOURCE ${TEST_SOURCES})
 
-        add_executable(${HOST_EXECUTABLE}
-                ${HOST_SOURCES}
-                ${COMMON_SOURCES}
+        # Get the file name without the directory and extension
+        get_filename_component(TEST_NAME ${TEST_SOURCE} NAME_WE)
+
+        # Create an executable for each test
+        add_executable(${TEST_NAME}
+                ${TEST_SOURCE}
+                ${COMMON_SOURCES}  # Common sources if needed
+                lib/Unity/src/unity.c
         )
 
-        target_compile_definitions(${HOST_EXECUTABLE} PRIVATE
+        # Set compile definitions if needed
+        target_compile_definitions(${TEST_NAME} PRIVATE
         )
 
-        target_include_directories(${HOST_EXECUTABLE} PRIVATE
+        # Include directories
+        target_include_directories(${TEST_NAME} PRIVATE
                 lib/linked_list
                 lib/Unity/src
         )
 
-        target_compile_options(${HOST_EXECUTABLE} PRIVATE
+        # Set compile options
+        target_compile_options(${TEST_NAME} PRIVATE
                 -Wall
-
                 $<$<CONFIG:Debug>:-Og>
         )
 
-        target_link_options(${HOST_EXECUTABLE} PRIVATE
+        # Set link options if needed
+        target_link_options(${TEST_NAME} PRIVATE
         )
+
+        # Register the test with ctest
+        add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
+
+        endforeach()
 else() 
         set(TARGET_SOURCES
                 src/main.c

lib/linked_list/linked_list.c

@@ -1,49 +1,75 @@
-#include <stdlib.h>
 #include "linked_list.h"
+#include <stddef.h>
 
-/// @brief Initialize a new linked list
-/// @return Pointer to the new list
-Node *InitList()
+static node_t* head = NULL;
+
+status_t ll_init(node_t* initial_node)
 {
-    Node *list = malloc(sizeof(Node));
-    list->data = NULL;
-    list->next = NULL;
-    return list;
+    if (initial_node == NULL) {
+        return FAILURE;
+    }
+    head = initial_node;
+    head->data = NULL;
+    head->next = NULL;
+    return SUCCESS;
 }
 
-/// @brief Add a new node to the list
-/// @param list Pointer to the list
-/// @param data Pointer to the data to add
-void AddNode(Node *list, void *data)
+status_t ll_insert_at_head(node_t* new_node)
 {
-    if (list->data == NULL)
-    {
-        list->data = data;
-        list->next = NULL;
-    }
-    else
-    {
-        Node *node = list;
-        while (node->next != NULL)
-        {
-            node = node->next;
-        }
-        node->next = malloc(sizeof(Node));
-        node->next->data = data;
-        node->next->next = NULL;
+    if (new_node == NULL) {
+        return FAILURE;
     }
+    new_node->next = head;
+    head = new_node;
+    return SUCCESS;
 }
 
-/// @brief Delete the list
-/// @param list Pointer to the list
-void DeleteList(Node *list)
+status_t ll_insert_at_tail(node_t* new_node)
 {
-    Node *current = list;
-    while (current != NULL)
-    {
-        Node *next = current->next;
-        free(current);
-        current = next;
-    }
-    *list = (Node){NULL, NULL};
-}
+    if (new_node == NULL) {
+        return FAILURE;
+    }
+
+    if (head == NULL) {
+        head = new_node;
+        head->next = NULL;
+        return SUCCESS;
+    }
+
+    node_t* current = head;
+    while (current->next != NULL) {
+        current = current->next;
+    }
+    current->next = new_node;
+    new_node->next = NULL;
+    return SUCCESS;
+}
+
+status_t ll_delete_at_head()
+{
+    if (head == NULL) {
+        return FAILURE;
+    }
+
+    head = head->next;
+    return SUCCESS;
+}
+
+status_t ll_delete_at_tail()
+{
+    if (head == NULL) {
+        return FAILURE;
+    }
+
+    if (head->next == NULL) {
+        head = NULL;
+        return SUCCESS;
+    }
+
+    node_t* current = head;
+    while (current->next->next != NULL) {
+        current = current->next;
+    }
+    current->next = NULL;
+    return SUCCESS;
+}

lib/linked_list/linked_list.h

@@ -1,16 +1,54 @@
 #ifndef LINKED_LIST_H
 #define LINKED_LIST_H
 
-struct _Node
-{
-    void *data;
-    struct _Node *next;
+struct _Node {
+    void* data;
+    struct _Node* next;
 };
 
-typedef struct _Node Node;
+typedef struct _Node node_t;
 
-Node *InitList();
-void AddNode(Node *list, void *data);
-void DeleteList(Node *list);
+typedef enum {
+    SUCCESS,
+    FAILURE
+} status_t;
+
+/**
+ * @brief Initializes the linked list with an initial node.
+ *
+ * @param initial_node Pointer to the initial node to be added to the list.
+ * @return status_t SUCCESS if initialization is successful, FAILURE otherwise.
+ */
+status_t ll_init(node_t* initial_node);
+
+/**
+ * @brief Inserts a new node at the head of the linked list.
+ *
+ * @param new_node Pointer to the new node to be inserted at the head.
+ * @return status_t SUCCESS if insertion is successful, FAILURE otherwise.
+ */
+status_t ll_insert_at_head(node_t* new_node);
+
+/**
+ * @brief Inserts a new node at the tail of the linked list.
+ *
+ * @param new_node Pointer to the new node to be inserted at the tail.
+ * @return status_t SUCCESS if insertion is successful, FAILURE otherwise.
+ */
+status_t ll_insert_at_tail(node_t* new_node);
+
+/**
+ * @brief Deletes the node at the head of the linked list.
+ *
+ * @return status_t SUCCESS if deletion is successful, FAILURE if the list is empty.
+ */
+status_t ll_delete_at_head();
+
+/**
+ * @brief Deletes the node at the tail of the linked list.
+ *
+ * @return status_t SUCCESS if deletion is successful, FAILURE if the list is empty.
+ */
+status_t ll_delete_at_tail();
 
 #endif

test/test_linked_list.c

@@ -1,48 +1,78 @@
 #include "../lib/Unity/src/unity.h"
 #include "../lib/linked_list/linked_list.h"
 
+// Global node variables
+node_t test_node_initial;
+node_t test_node1;
+node_t test_node2;
+
 void setUp(void)
 {
+    ll_init(&test_node_initial);
 }
 
 void tearDown(void)
 {
 }
 
-void testLinkedListAddNode(void)
+void resetTest(void)
 {
-    Node *list = InitList();
-    TEST_ASSERT_NULL(list->data);
-    TEST_ASSERT_NULL(list->next);
-    AddNode(list, "test");
-    TEST_ASSERT_EQUAL_STRING("test", list->data);
-    TEST_ASSERT_NULL(list->next);
-    AddNode(list, "test2");
-    TEST_ASSERT_EQUAL_STRING("test2", list->next->data);
-    TEST_ASSERT_NULL(list->next->next);
-    DeleteList(list);
+    tearDown();
+    setUp();
 }
 
-void testLinkedListDeleteList(void)
+void test_ll_init(void)
 {
-    Node *list = InitList();
-    AddNode(list, 1);
-    AddNode(list, 2);
-    AddNode(list, 3);
-    DeleteList(list);
-    TEST_ASSERT_NULL(list->data);
+    TEST_ASSERT_EQUAL(SUCCESS, ll_init(&test_node_initial));
 }
 
-void resetTest(void)
+void test_ll_insert_at_head(void)
 {
-    tearDown();
-    setUp();
+    resetTest();
+    test_node1.data = "test";
+    test_node1.next = NULL;
+    TEST_ASSERT_EQUAL(SUCCESS, ll_insert_at_head(&test_node1));
+}
+
+void test_ll_insert_at_tail(void)
+{
+    resetTest();
+    test_node1.data = "test1";
+    test_node1.next = NULL;
+    test_node2.data = "test2";
+    test_node2.next = NULL;
+    TEST_ASSERT_EQUAL(SUCCESS, ll_insert_at_tail(&test_node1));
+    TEST_ASSERT_EQUAL(SUCCESS, ll_insert_at_tail(&test_node2));
+}
+
+void test_ll_delete_at_head(void)
+{
+    resetTest();
+    test_node1.data = "test";
+    test_node1.next = NULL;
+    ll_insert_at_head(&test_node1);
+    TEST_ASSERT_EQUAL(SUCCESS, ll_delete_at_head());
+}
+
+void test_ll_delete_at_tail(void)
+{
+    resetTest();
+    test_node1.data = "test1";
+    test_node1.next = NULL;
+    test_node2.data = "test2";
+    test_node2.next = NULL;
+    ll_insert_at_tail(&test_node1);
+    ll_insert_at_tail(&test_node2);
+    TEST_ASSERT_EQUAL(SUCCESS, ll_delete_at_tail());
 }
 
 int main(void)
 {
-    UnityBegin("test_linked_list.c");
-    RUN_TEST(testLinkedListAddNode, 33);
-    RUN_TEST(testLinkedListDeleteList, 44);
-    UnityEnd();
-}
+    UNITY_BEGIN();
+    RUN_TEST(test_ll_init);
+    RUN_TEST(test_ll_insert_at_head);
+    RUN_TEST(test_ll_insert_at_tail);
+    RUN_TEST(test_ll_delete_at_head);
+    RUN_TEST(test_ll_delete_at_tail);
+    return UNITY_END();
+}