enable queue sets (work in progress)

Author: mattheweshleman

cpputest-for-freertos-lib/CMakeLists.txt

@@ -38,6 +38,7 @@ set(FREERTOS_KERNEL_PATH ${CMS_FREERTOS_KERNEL_TOP_DIR} CACHE INTERNAL "")
 add_library(cpputest-for-freertos-lib
         src/cpputest_for_freertos_task.cpp
         src/cpputest_for_freertos_queue.cpp
+        src/cpputest_for_freertos_queue_set.cpp
         src/cpputest_for_freertos_assert.cpp
         src/cpputest_for_freertos_timers.cpp
         src/cpputest_main.cpp

cpputest-for-freertos-lib/include/cpputest_for_freertos_memory.hpp

@@ -0,0 +1,50 @@
+/// @brief Support methods to help with unit testing for FreeRTOS, memory allocation
+///        related support, such as unique_ptr types for allocated queues, etc.
+/// @ingroup
+/// @cond
+///***************************************************************************
+///
+/// Copyright (C) 2024 Matthew Eshleman. All rights reserved.
+///
+/// This program is open source software: you can redistribute it and/or
+/// modify it under the terms of the GNU General Public License as published
+/// by the Free Software Foundation, either version 3 of the License, or
+/// (at your option) any later version.
+///
+/// Alternatively, upon written permission from Matthew Eshleman, this program
+/// may be distributed and modified under the terms of a Commercial
+/// License. For further details, see the Contact Information below.
+///
+/// Contact Information:
+///   Matthew Eshleman
+///   https://covemountainsoftware.com
+///   [email protected]
+///***************************************************************************
+/// @endcond
+#ifndef CPPUTEST_FOR_FREERTOS_LIB_CPPUTEST_FOR_FREERTOS_MEMORY_HPP
+#define CPPUTEST_FOR_FREERTOS_LIB_CPPUTEST_FOR_FREERTOS_MEMORY_HPP
+
+#include "FreeRTOS.h"
+#include "queue.h"
+#include <memory>
+#include <functional>
+
+namespace cms {
+    namespace test {
+
+        struct FreeRTOSQueueDeleter
+        {
+            void operator()(struct QueueDefinition * handle)
+            {
+                if (handle != nullptr)
+                {
+                    vQueueDelete(handle);
+                }
+            }
+        };
+
+        using unique_queue = std::unique_ptr<struct QueueDefinition, FreeRTOSQueueDeleter>;
+    } //namespace test
+} //namespace cms
+
+#endif //CPPUTEST_FOR_FREERTOS_LIB_CPPUTEST_FOR_FREERTOS_MEMORY_HPP

cpputest-for-freertos-lib/port/include/FreeRTOSConfig.h

@@ -594,7 +594,7 @@ void cmsAssertCalled( const char * pcFile, unsigned long ulLine );
 #define configUSE_MUTEXES                      1
 #define configUSE_RECURSIVE_MUTEXES            1
 #define configUSE_COUNTING_SEMAPHORES          1
-#define configUSE_QUEUE_SETS                   0
+#define configUSE_QUEUE_SETS                   1
 #define configUSE_APPLICATION_TASK_TAG         0
 
 /* Set the following INCLUDE_* constants to 1 to incldue the named API function,

cpputest-for-freertos-lib/src/cpputest_for_freertos_fake_queue.hpp

@@ -14,6 +14,7 @@ typedef struct QueueDefinition
     std::deque<std::vector<uint8_t>> queue = {};
     uint64_t recursiveCallCount = {};
     const char * registryName = nullptr;
+    struct QueueDefinition * queueSetContainer = nullptr;
 } FakeQueue;
 
 namespace cms {

cpputest-for-freertos-lib/src/cpputest_for_freertos_queue.cpp

@@ -139,6 +139,11 @@ extern "C" BaseType_t xQueueGenericSend(QueueHandle_t queue,
         configASSERT(true == false);
     }
 
+    if (queue->queueSetContainer != nullptr)
+    {
+        xQueueGenericSend(queue->queueSetContainer, &queue, ticks, queueSEND_TO_BACK);
+    }
+
     return pdTRUE;
 }
 

cpputest-for-freertos-lib/src/cpputest_for_freertos_queue_set.cpp

@@ -0,0 +1,86 @@
+/// @brief Provides an implementation of a fake FreeRTOS queue set
+///        cpputest-for-freertos-lib assumes that a queue set should be
+///        functional, i.e. not a mock.
+///
+/// @ingroup
+/// @cond
+///***************************************************************************
+///
+/// Copyright (C) 2024 Matthew Eshleman. All rights reserved.
+///
+/// This program is open source software: you can redistribute it and/or
+/// modify it under the terms of the GNU General Public License as published
+/// by the Free Software Foundation, either version 3 of the License, or
+/// (at your option) any later version.
+///
+/// Alternatively, upon written permission from Matthew Eshleman, this program
+/// may be distributed and modified under the terms of a Commercial
+/// License. For further details, see the Contact Information below.
+///
+/// Contact Information:
+///   Matthew Eshleman
+///   https://covemountainsoftware.com
+///   [email protected]
+///***************************************************************************
+/// @endcond
+
+#include "cpputest_for_freertos_fake_queue.hpp"
+#include "FreeRTOS.h"
+#include "queue.h"
+
+extern "C" QueueSetHandle_t xQueueCreateSet(const UBaseType_t eventQueueLength)
+{
+    return xQueueGenericCreate(eventQueueLength, sizeof(QueueHandle_t), queueQUEUE_TYPE_SET);
+}
+
+extern "C" BaseType_t xQueueAddToSet(QueueSetMemberHandle_t itemToAdd, QueueSetHandle_t set)
+{
+    auto fakeItemToAdd = static_cast<FakeQueue *>(itemToAdd);
+    auto fakeSet = static_cast<FakeQueue *>(set);
+
+    configASSERT(fakeItemToAdd != nullptr);
+    configASSERT(fakeSet != nullptr);
+
+    if ((fakeItemToAdd->queueSetContainer != nullptr) ||
+        (!fakeItemToAdd->queue.empty()))
+    {
+        return pdFAIL;
+    }
+    else
+    {
+        fakeItemToAdd->queueSetContainer = fakeSet;
+        return pdPASS;
+    }
+}
+
+extern "C" BaseType_t xQueueRemoveFromSet(QueueSetMemberHandle_t itemToRemove, QueueSetHandle_t set)
+{
+    auto fakeItemToRemove = static_cast<FakeQueue *>(itemToRemove);
+
+    configASSERT(fakeItemToRemove != nullptr);
+    configASSERT(set != nullptr);
+
+    if ((fakeItemToRemove->queueSetContainer != set) ||
+        (!fakeItemToRemove->queue.empty()))
+    {
+        return pdFAIL;
+    }
+    else
+    {
+        fakeItemToRemove->queueSetContainer = nullptr;
+        return pdPASS;
+    }
+}
+
+extern "C" QueueSetMemberHandle_t xQueueSelectFromSet(QueueSetHandle_t queueSet, const TickType_t ticksToWait)
+{
+    QueueSetMemberHandle_t rtnItem = nullptr;
+
+    auto result = xQueueReceive(queueSet, &rtnItem, ticksToWait );
+    if (result == pdTRUE)
+    {
+        return rtnItem;
+    }
+
+    return nullptr;
+}

cpputest-for-freertos-lib/tests/CMakeLists.txt

@@ -4,6 +4,7 @@ set(TEST_SOURCES
         cpputest_for_freertos_assert_tests.cpp
         cpputest_for_freertos_timers_tests.cpp
         cpputest_for_freertos_queue_tests.cpp
+        cpputest_for_freertos_queue_set_tests.cpp
         cpputest_for_freertos_task_tests.cpp
         cpputest_for_freertos_semaphore_tests.cpp
         cpputest_for_freertos_mutex_tests.cpp

cpputest-for-freertos-lib/tests/cpputest_for_freertos_queue_set_tests.cpp

@@ -0,0 +1,151 @@
+/// @brief Tests of CppUTest for FreeRTOS queue sets.
+/// @ingroup
+/// @cond
+///***************************************************************************
+///
+/// Copyright (C) 2024 Matthew Eshleman. All rights reserved.
+///
+/// This program is open source software: you can redistribute it and/or
+/// modify it under the terms of the GNU General Public License as published
+/// by the Free Software Foundation, either version 3 of the License, or
+/// (at your option) any later version.
+///
+/// Alternatively, upon written permission from Matthew Eshleman, this program
+/// may be distributed and modified under the terms of a Commercial
+/// License. For further details, see the Contact Information below.
+///
+/// Contact Information:
+///   Matthew Eshleman
+///   https://covemountainsoftware.com
+///   [email protected]
+///***************************************************************************
+/// @endcond
+
+#include "FreeRTOS.h"
+#include "queue.h"
+#include "cpputest_for_freertos_memory.hpp"
+
+//must be last
+#include "CppUTest/TestHarness.h"
+
+TEST_GROUP(QueueSetTests)
+{
+    cms::test::unique_queue mUnderTest = nullptr;
+
+    void setup() final
+    {
+    }
+
+    void teardown() final
+    {
+    }
+
+    void CreateSetUnderTest(UBaseType_t length)
+    {
+        auto set = xQueueCreateSet(length);
+        mUnderTest = cms::test::unique_queue(set);
+        CHECK_TRUE(mUnderTest != nullptr);
+    }
+
+    static cms::test::unique_queue CreateQueue(UBaseType_t len, UBaseType_t itemSize)
+    {
+        auto rtn = xQueueCreate(len, itemSize);
+        CHECK_TRUE(rtn != nullptr);
+        cms::test::unique_queue queue(rtn);
+        return queue;
+    }
+
+    cms::test::unique_queue CreateQueueAndAddToUnderTestSet(UBaseType_t len, UBaseType_t itemSize) const
+    {
+        auto created = xQueueCreate(len, itemSize);
+        CHECK_TRUE(created != nullptr);
+
+        auto rtn = xQueueAddToSet(created, mUnderTest.get());
+        CHECK_EQUAL(pdPASS, rtn);
+
+        cms::test::unique_queue queue(created);
+        return queue;
+    }
+};
+
+TEST(QueueSetTests, can_create_a_queue_set)
+{
+    CreateSetUnderTest(2);
+}
+
+TEST(QueueSetTests, can_add_a_queue_to_a_set_and_remove_from_set)
+{
+    CreateSetUnderTest(2);
+
+    auto queue = CreateQueue(2, 2);
+    auto rtn = xQueueAddToSet(queue.get(), mUnderTest.get());
+    CHECK_EQUAL(pdPASS, rtn);
+
+    rtn = xQueueRemoveFromSet(queue.get(), mUnderTest.get());
+    CHECK_EQUAL(pdPASS, rtn);
+}
+
+TEST(QueueSetTests, adding_a_queue_with_events_to_a_set_fails)
+{
+    const int testValue = 234;
+    CreateSetUnderTest(2);
+    auto queue = CreateQueue(2, sizeof(int));
+    auto rtn = xQueueSendToBack(queue.get(), &testValue, portMAX_DELAY);
+    CHECK_EQUAL(pdTRUE, rtn);
+
+    rtn = xQueueAddToSet(queue.get(), mUnderTest.get());
+    CHECK_EQUAL(pdFAIL, rtn);
+}
+
+TEST(QueueSetTests, adding_a_queue_already_added_to_a_set_fails)
+{
+    CreateSetUnderTest(2);
+    auto queue = CreateQueue(2, sizeof(int));
+    auto rtn = xQueueAddToSet(queue.get(), mUnderTest.get());
+    CHECK_EQUAL(pdPASS, rtn);
+
+    //add it again should fail
+    rtn = xQueueAddToSet(queue.get(), mUnderTest.get());
+    CHECK_EQUAL(pdFAIL, rtn);
+}
+
+TEST(QueueSetTests, can_add_a_queue_to_a_set_and_fails_to_remove_from_another_set)
+{
+    CreateSetUnderTest(2);
+    cms::test::unique_queue otherSet(xQueueCreateSet(2));
+    CHECK_TRUE(otherSet != nullptr);
+
+    auto queue = CreateQueueAndAddToUnderTestSet(2, 2);
+
+    auto rtn = xQueueRemoveFromSet(queue.get(), otherSet.get());
+    CHECK_EQUAL(pdFAIL, rtn);
+}
+
+TEST(QueueSetTests, select_from_set_will_not_block_and_return_null_if_no_events)
+{
+    CreateSetUnderTest(2);
+    auto queue = CreateQueueAndAddToUnderTestSet(2, sizeof(int));
+
+    auto selectResult = xQueueSelectFromSet(mUnderTest.get(), portMAX_DELAY);
+    CHECK_EQUAL(nullptr, selectResult);
+}
+
+TEST(QueueSetTests, select_from_set_will_return_expected_queue_with_event)
+{
+    const uint16_t testValue = 4321;
+
+    CreateSetUnderTest(2);
+    auto queue = CreateQueueAndAddToUnderTestSet(2, sizeof(testValue));
+
+    auto rtn = xQueueSendToBack(queue.get(), &testValue, 1000);
+    CHECK_EQUAL(pdTRUE, rtn);
+
+    auto selectResult = xQueueSelectFromSet(mUnderTest.get(), portMAX_DELAY);
+    CHECK_TRUE(selectResult != nullptr);
+    CHECK_EQUAL(queue.get(), selectResult);
+
+    uint16_t receivedValue = 0;
+    rtn = xQueueReceive(selectResult, &receivedValue, portMAX_DELAY);
+    CHECK_EQUAL(pdTRUE, rtn);
+    CHECK_EQUAL(testValue, receivedValue);
+}