Updated to use new cmake setup for cpputest

tests/CMakeLists.txt

@@ -1,6 +1,8 @@
 project(Tests)
 
-# TEST_DIRS 
+# TEST_DIRS
+
+add_subdirectory(shared)
 add_subdirectory(simple_test)
 
 # TEST_RUNNER
@@ -9,8 +11,7 @@ add_executable(AllTests
 )
 
 target_link_libraries(AllTests
-    ${CPPUTEST_LIBRARIES}/libCppUTest.a
-    ${CPPUTEST_LIBRARIES}/libCppUTestExt.a
+    ${CPPUTEST_LIBRARIES}
     # TEST_LINKS
     simple_test
 )

tests/MockTests.cpp

@@ -0,0 +1,12 @@
+#include "CppUTest/CommandLineTestRunner.h"
+
+// ImportTestGroups
+IMPORT_TEST_GROUP(test_MockRegEdit);
+IMPORT_TEST_GROUP(test_MockADC);
+
+// START: main
+int main(int argc, char **argv)
+{
+    return RUN_ALL_TESTS(argc, argv);
+}
+// END: main

tests/shared/CMakeLists.txt

@@ -0,0 +1,5 @@
+# File: tests/shared/CMakeLists.txt
+
+add_subdirectory(mocks)
+add_subdirectory(fakes)
+add_subdirectory(stubs)

tests/shared/mocks/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_subdirectory(MockRegEdit)
+add_subdirectory(MockADC)
+add_subdirectory(TimerMock)
+
+
+

tests/shared/mocks/MockADC/CMakeLists.txt

@@ -0,0 +1,11 @@
+add_library(MockADC STATIC
+    MockADC.c
+)
+
+target_include_directories(MockADC PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+target_link_libraries(MockADC
+    ${CPPUTEST_LIBRARIES}
+)

tests/shared/mocks/MockADC/MockADC.c

@@ -0,0 +1,79 @@
+/*
+ * Author: username
+ * Date: 2024
+ * filename: MockADC.c
+ * description: module_purpose
+ */
+
+#include "MockADC.h"
+#include "CppUTestExt/MockSupport_c.h"
+
+#define FAKESIZE 256
+
+uint16_t    fake_data[FAKESIZE];
+int         fake_index = 0;
+
+static bool is_setup   = false;
+
+void        ADC_SetPin(uint8_t pin_num)
+{
+    return;
+}
+
+void ADC_Setup(void)
+{
+    is_setup = true;
+    return;
+}
+
+void ADC_Init(uint8_t pin_num)
+{
+    mock_c()->actualCall("ADC_Init")->withUnsignedIntParameters("pin_num", pin_num);
+}
+
+void ADC_Enable(void)
+{
+    mock_c()->actualCall("ADC_Enable");
+}
+
+void ADC_Disable(void)
+{
+    mock_c()->actualCall("ADC_Disable");
+}
+
+uint16_t ADC_ReadValue_Impl(uint8_t pin_num)
+{
+    mock_c()->actualCall("ADC_ReadValue_Impl")->withUnsignedIntParameters("pin_num", pin_num);
+
+    if (fake_index == 0)
+    {
+        return 0;
+    }
+    return fake_data[--fake_index];
+}
+
+uint16_t (*ADC_ReadValue)(uint8_t pin_num) = ADC_ReadValue_Impl;
+
+void MockADC_PushValue(uint16_t value)
+{
+    if (fake_index >= FAKESIZE - 1)
+    {
+        return;
+    }
+    fake_data[fake_index++] = value;
+}
+
+void MockADC_ZeroIndex(void)
+{
+    fake_index = 0;
+}
+
+int MockADC_GetIndex(void)
+{
+    return fake_index;
+}
+
+bool MockADC_IsSetup(void)
+{
+    return is_setup;
+}

tests/shared/mocks/MockADC/MockADC.h

@@ -0,0 +1,29 @@
+/**
+ * @brief PUT_TEXT_HERE
+ * @details This file is...
+ * @author username
+ * @date todays_date
+ * @copyright None
+ * @file MOCKADC.h
+ */
+
+#ifndef MOCKADC_H
+#define MOCKADC_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+void ADC_Setup(void);
+void ADC_SetPin(uint8_t pin_num);
+void ADC_Init(uint8_t pin_num);
+void ADC_Enable(void);
+void ADC_Disable(void);
+
+extern uint16_t (*ADC_ReadValue)(uint8_t pin_num);
+
+void MockADC_PushValue(uint16_t value);
+void MockADC_ZeroIndex(void);
+int  MockADC_GetIndex(void);
+bool MockADC_IsSetup(void);
+
+#endif // MOCKADC_H

tests/shared/mocks/MockRegEdit/CMakeLists.txt

@@ -0,0 +1,12 @@
+add_library(MockRegEdit STATIC
+    MockRegEdit.c
+)
+
+target_include_directories(MockRegEdit PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+    ${CMAKE_SOURCE_DIR}/src/RegEdit/
+)
+
+target_link_libraries(MockRegEdit
+    ${CPPUTEST_LIBRARIES}
+)

tests/shared/mocks/MockRegEdit/MockRegEdit.c

@@ -0,0 +1,217 @@
+/*
+ * Author: username
+ * Date: 2024
+ * filename: MockRegEdit.c
+ * description: module_purpose
+ */
+
+#include "MockRegEdit.h"
+#include "CppUTestExt/MockSupport_c.h"
+
+// For 64-Bit systems and register access.
+
+void RegEdit_u64_SetRegister(void *reg)
+{
+    mock_c()->actualCall("RegEdit_u64_SetRegister")->withPointerParameters("reg", reg);
+}
+
+void RegEdit_u64_ClearRegister(void *reg)
+{
+    mock_c()->actualCall("RegEdit_u64_ClearRegister")->withPointerParameters("reg", reg);
+}
+
+void RegEdit_u64_SetBit(void *reg, uint8_t bit_num)
+{
+    mock_c()->actualCall("RegEdit_u64_SetBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
+}
+
+void RegEdit_u64_ClearBit(void *reg, uint8_t bit_num)
+{
+    mock_c()->actualCall("RegEdit_u64_ClearBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
+}
+
+bool RegEdit_u64_IsBitSet(void *reg, uint8_t bit_num)
+{
+    return mock_c()->actualCall("RegEdit_u64_IsBitSet")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num)->returnBoolValueOrDefault(true);
+    // return mock_c()->returnBoolValueOrDefault(true);
+}
+
+void RegEdit_u64_OR_Num(void *reg, uint64_t num)
+{
+    mock_c()->actualCall("RegEdit_u64_OR_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+void RegEdit_u64_AND_Num(void *reg, uint64_t num)
+{
+    mock_c()->actualCall("RegEdit_u64_AND_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+void RegEdit_u64_SetNum(void *reg, uint64_t num)
+{
+    mock_c()->actualCall("RegEdit_u64_SetNum")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+uint64_t RegEdit_u64_ReadReg(void *reg)
+{
+    uint64_t value = *(uint64_t *)reg;
+
+    mock_c()->actualCall("RegEdit_u64_ReadReg")->withPointerParameters("reg", reg)->returnUnsignedIntValueOrDefault(value);
+
+    return value;
+}
+
+// For 32-Bit systems and register access.
+
+void RegEdit_u32_SetRegister(void *reg)
+{
+    mock_c()->actualCall("RegEdit_u32_SetRegister")->withPointerParameters("reg", reg);
+}
+
+void RegEdit_u32_ClearRegister(void *reg)
+{
+    mock_c()->actualCall("RegEdit_u32_ClearRegister")->withPointerParameters("reg", reg);
+}
+
+void RegEdit_u32_SetBit(void *reg, uint8_t bit_num)
+{
+    mock_c()->actualCall("RegEdit_u32_SetBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
+}
+
+void RegEdit_u32_ClearBit(void *reg, uint8_t bit_num)
+{
+    mock_c()->actualCall("RegEdit_u32_ClearBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
+}
+
+bool RegEdit_u32_IsBitSet(void *reg, uint8_t bit_num)
+{
+    return mock_c()->actualCall("RegEdit_u32_IsBitSet")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num)->returnBoolValueOrDefault(true);
+    // return mock_c()->returnBoolValueOrDefault(true);
+}
+
+void RegEdit_u32_OR_Num(void *reg, uint32_t num)
+{
+    mock_c()->actualCall("RegEdit_u32_OR_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+void RegEdit_u32_AND_Num(void *reg, uint32_t num)
+{
+    mock_c()->actualCall("RegEdit_u32_AND_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+void RegEdit_u32_SetNum(void *reg, uint32_t num)
+{
+    mock_c()->actualCall("RegEdit_u32_SetNum")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+uint32_t RegEdit_u32_ReadReg(void *reg)
+{
+    uint32_t value = *(uint32_t *)reg;
+
+    mock_c()->actualCall("RegEdit_u32_ReadReg")->withPointerParameters("reg", reg)->returnUnsignedIntValueOrDefault(value);
+
+    return value;
+}
+
+// For 16-Bit systems and register access.
+
+void RegEdit_u16_SetRegister(void *reg)
+{
+    mock_c()->actualCall("RegEdit_u16_SetRegister")->withPointerParameters("reg", reg);
+}
+
+void RegEdit_u16_ClearRegister(void *reg)
+{
+    mock_c()->actualCall("RegEdit_u16_ClearRegister")->withPointerParameters("reg", reg);
+}
+
+void RegEdit_u16_SetBit(void *reg, uint8_t bit_num)
+{
+    mock_c()->actualCall("RegEdit_u16_SetBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
+}
+
+void RegEdit_u16_ClearBit(void *reg, uint8_t bit_num)
+{
+    mock_c()->actualCall("RegEdit_u16_ClearBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
+}
+
+bool RegEdit_u16_IsBitSet(void *reg, uint8_t bit_num)
+{
+    return mock_c()->actualCall("RegEdit_u16_IsBitSet")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num)->returnBoolValueOrDefault(true);
+    // return mock_c()->returnBoolValueOrDefault(true);
+}
+
+void RegEdit_u16_OR_Num(void *reg, uint16_t num)
+{
+    mock_c()->actualCall("RegEdit_u16_OR_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+void RegEdit_u16_AND_Num(void *reg, uint16_t num)
+{
+    mock_c()->actualCall("RegEdit_u16_AND_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+void RegEdit_u16_SetNum(void *reg, uint16_t num)
+{
+    mock_c()->actualCall("RegEdit_u16_SetNum")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+uint16_t RegEdit_u16_ReadReg(void *reg)
+{
+    uint16_t value = *(uint16_t *)reg;
+
+    mock_c()->actualCall("RegEdit_u16_ReadReg")->withPointerParameters("reg", reg)->returnUnsignedIntValueOrDefault(value);
+
+    return value;
+}
+
+// For 8-Bit systems and register access.
+
+void RegEdit_u8_SetRegister(void *reg)
+{
+    mock_c()->actualCall("RegEdit_u8_SetRegister")->withPointerParameters("reg", reg);
+}
+
+void RegEdit_u8_ClearRegister(void *reg)
+{
+    mock_c()->actualCall("RegEdit_u8_ClearRegister")->withPointerParameters("reg", reg);
+}
+
+void RegEdit_u8_SetBit(void *reg, uint8_t bit_num)
+{
+    mock_c()->actualCall("RegEdit_u8_SetBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
+}
+
+void RegEdit_u8_ClearBit(void *reg, uint8_t bit_num)
+{
+    mock_c()->actualCall("RegEdit_u8_ClearBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
+}
+
+bool RegEdit_u8_IsBitSet(void *reg, uint8_t bit_num)
+{
+    return mock_c()->actualCall("RegEdit_u8_IsBitSet")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num)->returnBoolValueOrDefault(true);
+    // return mock_c()->returnBoolValueOrDefault(true);
+}
+
+void RegEdit_u8_OR_Num(void *reg, uint8_t num)
+{
+    mock_c()->actualCall("RegEdit_u8_OR_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+void RegEdit_u8_AND_Num(void *reg, uint8_t num)
+{
+    mock_c()->actualCall("RegEdit_u8_AND_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+void RegEdit_u8_SetNum(void *reg, uint8_t num)
+{
+    mock_c()->actualCall("RegEdit_u8_SetNum")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
+}
+
+uint8_t RegEdit_u8_ReadReg(void *reg)
+{
+    uint8_t value = *(uint8_t *)reg;
+
+    mock_c()->actualCall("RegEdit_u8_ReadReg")->withPointerParameters("reg", reg)->returnUnsignedIntValueOrDefault(value);
+
+    return value;
+}

tests/shared/mocks/MockRegEdit/MockRegEdit.h

@@ -0,0 +1,19 @@
+/**
+ * @brief Mock of the RegEdit module.
+ * @details This file is just re-exports the RegEdit functions plus extras.
+ * @author Jake G
+ * @date 2025-12-21
+ * @copyright None
+ * @file MockRegEdit.h
+ */
+
+#ifndef MOCKREGEDIT_H
+#define MOCKREGEDIT_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "RegEdit.h"
+
+#endif // MOCKREGEDIT_H

tests/shared/mocks/MockRegEdit/u8_comparator.cpp

@@ -0,0 +1,55 @@
+#include "u8_comparator.hpp"
+#include "CppUTest/SimpleString.h"
+
+/*
+class MyTypeComparator : public MockNamedValueComparator
+{
+public:
+    virtual bool isEqual(const void* object1, const void* object2)
+    {
+        return object1 == object2;
+    }
+    virtual SimpleString valueToString(const void* object)
+    {
+        return StringFrom(object);
+    }
+};
+*/
+
+bool UInt8PointerComparator::isEqual(const void *object1, const void *object2)
+{
+    const uint8_t *ptr1 = reinterpret_cast<const uint8_t *>(object1);
+    const uint8_t *ptr2 = reinterpret_cast<const uint8_t *>(object2);
+    return std::memcmp(ptr1, ptr2, sizeof(uint8_t)) == 0;
+}
+
+SimpleString UInt8PointerComparator::valueToString(const void *object)
+{
+    const uint8_t *ptr = reinterpret_cast<const uint8_t *>(object);
+    return StringFromFormat("0x%02x", *ptr);
+}
+
+/*
+bool UInt8PointerComparator::isEqual(const void* object1, const void* object2) const {
+    const uint8_t* ptr1 = static_cast<const uint8_t*>(object1);
+    const uint8_t* ptr2 = static_cast<const uint8_t*>(object2);
+    return std::memcmp(ptr1, ptr2, sizeof(uint8_t)) == 0;
+}
+
+SimpleString UInt8PointerComparator::valueToString(const void* object) const {
+    const uint8_t* ptr = static_cast<const uint8_t*>(object);
+    return StringFromFormat("0x%02x", *ptr);
+}
+*/
+
+bool UInt8Comparator::isEqual(const void *object1, const void *object2)
+{
+    return (uint8_t *)object1 == (uint8_t *)object2;
+}
+
+SimpleString UInt8Comparator::valueToString(const void *object)
+{
+    // uint8_t value = reinterpret_cast<uint8_t>(object);
+    const uint8_t *ptr = reinterpret_cast<const uint8_t *>(object);
+    return StringFromFormat("0x%02x", *ptr);
+}

tests/shared/mocks/MockRegEdit/u8_comparator.hpp

@@ -0,0 +1,20 @@
+#ifndef U8_COMPARATOR_H
+#define U8_COMPARATOR_H
+
+#include <cstdint>
+#include <cstring>
+#include <CppUTestExt/MockSupport.h>
+
+class UInt8PointerComparator : public MockNamedValueComparator {
+public:
+    virtual bool isEqual(const void* object1, const void* object2) override;
+    SimpleString valueToString(const void* object) override;
+};
+
+class UInt8Comparator : public MockNamedValueComparator {
+    public:
+        virtual bool isEqual(const void* object1, const void* object2) override;
+        SimpleString valueToString(const void* object) override;
+};
+
+#endif //U8_COMPARATOR_H

tests/shared/mocks/TimerMock/CMakeLists.txt

@@ -0,0 +1,11 @@
+add_library(TimerMock STATIC
+    TimerMock.c
+)
+
+target_include_directories(TimerMock PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+target_link_libraries(TimerMock
+    ${CPPUTEST_LIBRARIES}
+)

tests/shared/mocks/TimerMock/TimerMock.c

@@ -0,0 +1,30 @@
+/*
+ * Author: Jake G
+ * Date: 2024-09-02
+ * filename: TimerMock.c
+ * description: mocks timers
+ */
+
+#include "TimerMock.h"
+#include "CppUTestExt/MockSupport_c.h"
+#include <stdbool.h>
+
+static bool timer_started = false;
+
+void        Timer_Start(void)
+{
+    mock_c()->actualCall("Timer_Start");
+    timer_started = true;
+}
+
+void Timer_Stop(void)
+{
+    mock_c()->actualCall("Timer_Stop");
+    timer_started = false;
+}
+
+uint16_t Timer_GetOverflowCount(void)
+{
+    uint16_t time = 0xAAAA;
+    return mock_c()->actualCall("Timer_GetOverflowCount")->returnUnsignedIntValueOrDefault(time);
+}

tests/shared/mocks/TimerMock/TimerMock.h

@@ -0,0 +1,25 @@
+/**
+ * @brief A Mock of the timer module.
+ * @details This file is only used for testing.
+ * @author Jake G
+ * @date 2024-09-02
+ * @copyright None
+ * @file TimerMock.h
+ */
+
+#ifndef TIMER_MOCK_H
+#define TIMER_MOCK_H
+
+#include <stdint.h>
+
+/**
+ * A function
+ * @param a The first argument
+ */
+void     Timer_Start(void);
+
+void     Timer_Stop(void);
+
+uint16_t Timer_GetOverflowCount(void);
+
+#endif // TIMER_MOCK_H

tests/simple_test/CMakeLists.txt

@@ -5,7 +5,6 @@ add_library(simple_test
 )
 
 target_link_libraries(simple_test
-    ${CPPUTEST_LIBRARIES}/libCppUTest.a
-    ${CPPUTEST_LIBRARIES}/libCppUTestExt.a
+    ${CPPUTEST_LIBRARIES}
 )