vTaskDelay: will track and move time forward and coordinates with timers.

Author: mattheweshleman

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

@@ -0,0 +1,44 @@
+/// @brief Support methods to help with unit testing for FreeRTOS task
+///        related methods.
+/// @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_FREERTOS_TASK_HPP
+#define CPPUTEST_FOR_FREERTOS_LIB_CPPUTEST_FREERTOS_TASK_HPP
+
+namespace cms {
+    namespace test {
+
+        /**
+         * Init, prepare for task related usage, primarily for time
+         * related tracking.
+         */
+        void TaskInit();
+
+        /**
+         * Clean up/destroy the fake CppUTest for task details, primarily
+         * related to time.
+         */
+        void TaskDestroy();
+    }
+}
+
+#endif //CPPUTEST_FOR_FREERTOS_LIB_CPPUTEST_FREERTOS_TASK_HPP

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

@@ -7,10 +7,35 @@
 namespace cms {
 namespace test {
 
-    void InitTimers();
-    void DestroyTimers();
+    /**
+     * Initialize the functional but fake CppUTest for FreeRTOS timers.
+     */
+    void TimersInit();
+
+    /**
+     * Clean up/destroy the fake CppUTest for FreeRTOS timers.
+     */
+    void TimersDestroy();
+
+    /**
+     * check if the current unit test has initialized the timer
+     * subsystem or not.
+     * @return true: yes, TimersInit() was called, so timers are active.
+     */
+    bool TimersIsActive();
+
+    /**
+     * Move Time Forward.
+     * @param duration
+     */
     void MoveTimeForward(std::chrono::nanoseconds duration);
 
+    /**
+     * Get the current time, as duration since Init was called.
+     * @return
+     */
+    std::chrono::nanoseconds GetCurrentInternalTime();
+
 } //namespace
 }//namespace
 

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

@@ -28,6 +28,25 @@
 /// @endcond
 #include "FreeRTOS.h"
 #include "task.h"
+#include "cpputest_freertos_timers.hpp"
+
+namespace cms {
+namespace test {
+
+    static TickType_t s_tickCount = 0;
+
+    void TaskInit()
+    {
+        s_tickCount = 0;
+    }
+
+    void TaskDestroy()
+    {
+        s_tickCount = 0;
+    }
+
+} //namespace test
+} //namespace cms
 
 extern "C" BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
                         const char * const pcName,
@@ -48,4 +67,31 @@ extern "C" BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
 extern "C" void vTaskDelete( TaskHandle_t xTaskToDelete )
 {
     (void)xTaskToDelete;
-}
+}
+
+extern "C" void vTaskDelay(const TickType_t ticks)
+{
+    if (cms::test::TimersIsActive())
+    {
+        auto duration = std::chrono::milliseconds {pdTICKS_TO_MS(ticks)};
+        cms::test::MoveTimeForward(duration);
+    }
+    else
+    {
+        cms::test::s_tickCount += ticks;
+    }
+}
+
+extern "C" TickType_t xTaskGetTickCount(void)
+{
+    if (cms::test::TimersIsActive())
+    {
+        auto current = cms::test::GetCurrentInternalTime();
+        auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(current);
+        return pdMS_TO_TICKS(milliseconds.count());
+    }
+    else
+    {
+        return cms::test::s_tickCount;
+    }
+}

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

@@ -7,27 +7,44 @@ namespace test {
 
     static FakeTimers* s_fakeTimers = nullptr;
 
-    void InitTimers()
+    void TimersInit()
     {
         configASSERT(s_fakeTimers == nullptr);
 
         std::chrono::milliseconds sysTick { configTICK_RATE_HZ * 1/1000 };
         s_fakeTimers = new FakeTimers(sysTick);
     }
 
-    void DestroyTimers()
+    void TimersDestroy()
     {
         configASSERT(s_fakeTimers != nullptr);
         delete s_fakeTimers;
         s_fakeTimers = nullptr;
     }
 
+    bool TimersIsActive()
+    {
+        return s_fakeTimers != nullptr;
+    }
+
     void MoveTimeForward(std::chrono::nanoseconds duration)
     {
         configASSERT(s_fakeTimers != nullptr);
         s_fakeTimers->MoveTimeForward(duration);
     }
 
+    std::chrono::nanoseconds GetCurrentInternalTime()
+    {
+        if (TimersIsActive())
+        {
+            return s_fakeTimers->GetCurrentInternalTime();
+        }
+        else
+        {
+            return std::chrono::nanoseconds (0);
+        }
+    }
+
     std::chrono::nanoseconds TicksToChrono(TickType_t ticks)
     {
         std::chrono::milliseconds rtn(pdTICKS_TO_MS(ticks));
@@ -122,15 +139,6 @@ extern "C" BaseType_t xTimerGenericCommandFromTask( TimerHandle_t xTimer,
     return pdPASS;
 }
 
-extern "C" TickType_t xTaskGetTickCount(void)
-{
-    configASSERT(s_fakeTimers != nullptr);
-    auto current = s_fakeTimers->GetCurrentInternalTime();
-    auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(current);
-
-    return pdMS_TO_TICKS(milliseconds.count());
-}
-
 extern "C" BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer )
 {
     configASSERT(s_fakeTimers != nullptr);

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

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

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

@@ -0,0 +1,61 @@
+/// @brief Tests of CppUTest FreeRTOS task methods.
+/// @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 "task.h"
+#include "cpputest_freertos_timers.hpp"
+#include "cpputest_freertos_task.hpp"
+#include "CppUTest/TestHarness.h"
+
+TEST_GROUP(TaskTests)
+{
+    void setup() final
+    {
+        cms::test::TaskInit();
+    }
+
+    void teardown() final
+    {
+        cms::test::TaskDestroy();
+    }
+};
+
+TEST(TaskTests, task_delay_method_is_available_and_tracks_time_when_not_using_timers)
+{
+    auto count1 = xTaskGetTickCount();
+    vTaskDelay(100);
+    auto count2 = xTaskGetTickCount();
+    CHECK_EQUAL(100, count2 - count1);
+}
+
+TEST(TaskTests, task_delay_method_will_move_timers_time_forward_if_timers_are_active)
+{
+    cms::test::TimersInit();
+    auto count1 = xTaskGetTickCount();
+    vTaskDelay(100);
+    auto count2 = xTaskGetTickCount();
+    CHECK_EQUAL(100, count2 - count1);
+    auto fromTimers = cms::test::GetCurrentInternalTime();
+
+    CHECK_TRUE(std::chrono::milliseconds(pdTICKS_TO_MS(100)) == fromTimers);
+    cms::test::TimersDestroy();
+}

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

@@ -32,12 +32,12 @@ TEST_GROUP(TimersTests)
 {
     void setup() final
     {
-        cms::test::InitTimers();
+        cms::test::TimersInit();
     }
 
     void teardown() final
     {
-        cms::test::DestroyTimers();
+        cms::test::TimersDestroy();
         mock().clear();
     }
 };

example/services/hwLockCtrlService/test/hwLockCtrlServiceTests.cpp

@@ -24,6 +24,7 @@ SOFTWARE.
 #include "hwLockCtrlService.h"
 #include "cpputest_freertos_timers.hpp"
 #include "cpputest_freertos_assert.hpp"
+#include "cpputest_freertos_task.hpp"
 #include "CppUTest/TestHarness.h"
 #include "CppUTestExt/MockSupport.h"
 #include "hwLockCtrl.h"
@@ -60,7 +61,8 @@ TEST_GROUP(HwLockCtrlServiceTests)
 {
     void setup() final
     {
-        cms::test::InitTimers();
+        cms::test::TaskInit();
+        cms::test::TimersInit();
         HLCS_Init();
         HLCS_RegisterChangeStateCallback(TestLockStateCallback);
         HLCS_RegisterSelfTestResultCallback(TestSelfTestResultCallback);
@@ -70,7 +72,8 @@ TEST_GROUP(HwLockCtrlServiceTests)
     {
         HLCS_Destroy(); //ensure we are stopped/clean/destroyed.
         mock().clear();
-        cms::test::DestroyTimers();
+        cms::test::TimersDestroy();
+        cms::test::TaskDestroy();
     }
 
     void GiveProcessingTime()