add some fake semaphore support to the library

Author: mattheweshleman

cpputest-for-freertos-lib/CMakeLists.txt

@@ -41,6 +41,7 @@ add_library(cpputest-for-freertos-lib
         src/cpputest_freertos_assert.cpp
         src/cpputest_freertos_timers.cpp
         src/cpputest_main.cpp
+        src/cpputest_freertos_semaphore.cpp
 )
 
 add_subdirectory(tests)

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

@@ -97,8 +97,8 @@ typedef uint64_t     TickType_t;
 
 #endif /* if ( configNUMBER_OF_CORES == 1 ) */
 
-extern void vPortYield( void );
-#define portYIELD()                                           vPortYield()
+#define portYIELD() do {} while(0)
+#define portYIELD_FROM_ISR(x) do {} while(0)
 
 /* Task function macros as described on the FreeRTOS.org WEB site. */
 #define portTASK_FUNCTION_PROTO( vFunction, pvParameters )    void vFunction( void * pvParameters )

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

@@ -0,0 +1,17 @@
+
+#ifndef CPPUTEST_FOR_FREERTOS_LIB_CPPUTEST_FREERTOS_FAKE_QUEUE_HPP
+#define CPPUTEST_FOR_FREERTOS_LIB_CPPUTEST_FREERTOS_FAKE_QUEUE_HPP
+
+#include <deque>
+#include <vector>
+#include "FreeRTOS.h"
+
+typedef struct QueueDefinition
+{
+    UBaseType_t queueLength = {};
+    UBaseType_t itemSize = {};
+    uint8_t queueType = {};
+    std::deque<std::vector<uint8_t>> queue = {};
+} FakeQueue;
+
+#endif //CPPUTEST_FOR_FREERTOS_LIB_CPPUTEST_FREERTOS_FAKE_QUEUE_HPP

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

@@ -24,20 +24,11 @@
 ///***************************************************************************
 /// @endcond
 
-#include <deque>
-#include <vector>
+#include "cpputest_freertos_fake_queue.hpp"
 #include <cstring>
 #include "FreeRTOS.h"
 #include "queue.h"
 
-typedef struct QueueDefinition
-{
-    UBaseType_t queueLength = {};
-    UBaseType_t itemSize = {};
-    uint8_t queueType = {};
-    std::deque<std::vector<uint8_t>> queue = {};
-} FakeQueue;
-
 extern "C" QueueHandle_t xQueueGenericCreate(const UBaseType_t queueLength,
                                              const UBaseType_t itemSize,
                                              const uint8_t queueType)

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

@@ -0,0 +1,37 @@
+#include "cpputest_freertos_fake_queue.hpp"
+#include <cstring>
+#include "queue.h"
+#include "semphr.h"
+
+extern "C" BaseType_t xQueueSemaphoreTake(QueueHandle_t queue, TickType_t ticks)
+{
+    (void) ticks;  //ignore in cpputest fake semaphore
+
+    uint64_t dummy;
+    return xQueueReceive(queue, &dummy, ticks);
+}
+
+
+extern "C" BaseType_t xQueueGiveFromISR(QueueHandle_t queue,
+                                        BaseType_t * const pxHigherPriorityTaskWoken)
+{
+    (void)pxHigherPriorityTaskWoken;
+    return xSemaphoreGive(queue);
+}
+
+extern "C" QueueHandle_t xQueueCreateCountingSemaphore(const UBaseType_t maxCount,
+                                                       const UBaseType_t initialCount)
+{
+    QueueHandle_t sema = xQueueCreate(maxCount, 0);
+    if (sema == nullptr)
+    {
+        return nullptr;
+    }
+
+    for (int i = 0; i < initialCount; ++i)
+    {
+        xSemaphoreGive(sema);
+    }
+
+    return sema;
+}

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

@@ -5,6 +5,7 @@ set(TEST_SOURCES
         cpputest_freertos_timers_tests.cpp
         cpputest_freertos_queue_tests.cpp
         cpputest_freertos_task_tests.cpp
+        cpputest_freertos_semaphore_tests.cpp
 )
 
 # this include expects TEST_SOURCES and TEST_APP_NAME to be

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

@@ -0,0 +1,121 @@
+#include "FreeRTOS.h"
+#include "semphr.h"
+#include "CppUTest/TestHarness.h"
+
+TEST_GROUP(SemaphoreTests)
+{
+    SemaphoreHandle_t mSemaUnderTest;
+
+    void setup() final
+    {
+    }
+
+    void teardown() final
+    {
+        if (mSemaUnderTest != nullptr)
+        {
+            vSemaphoreDelete(mSemaUnderTest);
+        }
+    }
+
+    void CreateBinarySemaphore()
+    {
+        mSemaUnderTest = xSemaphoreCreateBinary();
+        CHECK_TRUE(mSemaUnderTest != nullptr);
+    }
+
+    void CreateCountingSemaphore(uint32_t count = 10, uint32_t initial = 0)
+    {
+        mSemaUnderTest = xSemaphoreCreateCounting(count, initial);
+        CHECK_TRUE(mSemaUnderTest != nullptr);
+    }
+};
+
+TEST(SemaphoreTests, can_create_a_binary_semaphore)
+{
+    CreateBinarySemaphore();
+}
+
+TEST(SemaphoreTests, can_read_binary_semaphore_count)
+{
+    CreateBinarySemaphore();
+
+    auto count = uxSemaphoreGetCount(mSemaUnderTest);
+    CHECK_EQUAL(0, count);
+}
+
+TEST(SemaphoreTests, can_read_binary_semaphore_count_after_give)
+{
+    CreateBinarySemaphore();
+    CHECK_EQUAL(0, uxSemaphoreGetCount(mSemaUnderTest));
+
+    xSemaphoreGive(mSemaUnderTest);
+    CHECK_EQUAL(1, uxSemaphoreGetCount(mSemaUnderTest));
+}
+
+TEST(SemaphoreTests, binary_semaphore_count_is_one_after_multiple_gives)
+{
+    CreateBinarySemaphore();
+    CHECK_EQUAL(0, uxSemaphoreGetCount(mSemaUnderTest));
+    CHECK_EQUAL(pdTRUE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(pdFALSE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(pdFALSE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(1, uxSemaphoreGetCount(mSemaUnderTest));
+}
+
+TEST(SemaphoreTests, binary_semaphore_count_is_zero_after_give_then_take)
+{
+    CreateBinarySemaphore();
+    CHECK_EQUAL(0, uxSemaphoreGetCount(mSemaUnderTest));
+
+    xSemaphoreGive(mSemaUnderTest);
+    CHECK_EQUAL(1, uxSemaphoreGetCount(mSemaUnderTest));
+
+    CHECK_EQUAL(pdTRUE, xSemaphoreTake(mSemaUnderTest, 1000));
+    CHECK_EQUAL(0, uxSemaphoreGetCount(mSemaUnderTest));
+}
+
+TEST(SemaphoreTests, binary_semaphore_take_rtn_false_when_not_yet_signaled)
+{
+    CreateBinarySemaphore();
+    CHECK_EQUAL(0, uxSemaphoreGetCount(mSemaUnderTest));
+    CHECK_EQUAL(pdFALSE, xSemaphoreTake(mSemaUnderTest, 1000));
+}
+
+TEST(SemaphoreTests, can_create_a_counting_semaphore)
+{
+    CreateCountingSemaphore();
+}
+
+TEST(SemaphoreTests, counting_semaphore_honors_initial_count)
+{
+    CreateCountingSemaphore(10, 3);
+    CHECK_EQUAL(3, uxSemaphoreGetCount(mSemaUnderTest));
+}
+
+TEST(SemaphoreTests, counting_semaphore_honors_initial_count_when_zero)
+{
+    CreateCountingSemaphore(10, 0);
+    CHECK_EQUAL(0, uxSemaphoreGetCount(mSemaUnderTest));
+}
+
+TEST(SemaphoreTests, counting_semaphore_rtns_false_when_exceed_give_max)
+{
+    CreateCountingSemaphore(3, 0);
+    CHECK_EQUAL(pdTRUE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(pdTRUE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(pdTRUE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(pdFALSE, xSemaphoreGive(mSemaUnderTest));
+}
+
+TEST(SemaphoreTests, counting_semaphore_give_take_match)
+{
+    CreateCountingSemaphore(3, 0);
+    CHECK_EQUAL(pdTRUE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(pdTRUE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(pdTRUE, xSemaphoreGive(mSemaUnderTest));
+    CHECK_EQUAL(pdTRUE, xSemaphoreTake(mSemaUnderTest, 1000));
+    CHECK_EQUAL(pdTRUE, xSemaphoreTake(mSemaUnderTest, 1000));
+    CHECK_EQUAL(pdTRUE, xSemaphoreTake(mSemaUnderTest, 1000));
+    CHECK_EQUAL(pdFALSE, xSemaphoreTake(mSemaUnderTest, 1000));
+}