Automatic formatting standard applied to tests dir.

+ Added u32 type funcs.
+ Added u64 type funcs.
+ Added u16 type funcs.
+ Added u8 type funcs.

.gitignore

@@ -10,3 +10,4 @@ build/cmake_install.cmake
 build/compile_commands.json
 .cache/clangd/index
 build/.cache/clangd/index
+tags

otto.sh

@@ -11,6 +11,10 @@ MODULE_DIR="${TEMPLATE_FILES}/modules"
 CHIP="ch32v003"
 
 generate_tags_file () {
+    echo "generate_tags_file()"
+    # Saving current directory
+    #CUR_DIR=$(pwd)
+
     uctags --recurse=yes \
         --languages=C,C++,Asm \
         --extras=+q \
@@ -19,7 +23,7 @@ generate_tags_file () {
         --exclude=build \
         --exclude=.git \
         --exclude=.template_files \
-        .
+        ./
 }
 
 format_source_code () {
@@ -287,7 +291,7 @@ flash_microcontroller () {
 }
 
 run_c_tests () {
-    generate_tags_file()
+    generate_tags_file
     format_source_code 
     clear_cmake_cache
     cmake -DUNIT_TESTING=ON  -DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE} ../

src/RegEdit/RegEdit.c

@@ -1,61 +1,232 @@
 /*
- * Author: username
+ * Author: Jake G 
- * Date: 2024
+ * Date: 2025
  * filename: RegEdit.c
- * description: module_purpose
+ * description: Provides a register editing interface. 
  */
 
 #include "RegEdit.h"
 
-void RegEdit_SetRegister(void *reg)
+// For 64-Bit systems and register access.
+
+void RegEdit_u64_SetRegister(void *reg)
 {
-    uint8_t *reg_ptr = (uint8_t *)reg;
+    uint64_t *reg_ptr = (uint64_t *)reg;
-    *reg_ptr         = 0xFF;
+    //*reg_ptr         = 0xFFFFFFFFFFFFFFFF;
+    *reg_ptr = UINT64_MAX;
 }
 
-void RegEdit_ClearRegister(void *reg)
+void RegEdit_u64_ClearRegister(void *reg)
 {
-    uint8_t *reg_ptr = (uint8_t *)reg;
+    uint64_t *reg_ptr = (uint64_t *)reg;
-    *reg_ptr         = 0x00;
+    *reg_ptr          = 0;
 }
 
-void RegEdit_SetBit(void *reg, uint8_t bit_num)
+void RegEdit_u64_SetBit(void *reg, uint8_t bit_num)
+{
+    uint64_t *reg_ptr = (uint64_t *)reg;
+    *reg_ptr |= (uint64_t)(1 << bit_num);
+}
+
+void RegEdit_u64_ClearBit(void *reg, uint8_t bit_num)
+{
+    uint64_t *reg_ptr = (uint64_t *)reg;
+    *reg_ptr &= ~(1 << bit_num);
+}
+
+bool RegEdit_u64_IsBitSet(void *reg, uint8_t bit_num)
+{
+    uint64_t *reg_ptr = (uint64_t *)reg;
+    return *reg_ptr & (1 << bit_num);
+}
+
+void RegEdit_u64_OR_Num(void *reg, uint64_t num)
+{
+    uint64_t *reg_ptr = (uint64_t *)reg;
+    *reg_ptr |= num;
+}
+
+void RegEdit_u64_AND_Num(void *reg, uint64_t num)
+{
+    uint64_t *reg_ptr = (uint64_t *)reg;
+    *reg_ptr &= num;
+}
+
+void RegEdit_u64_SetNum(void *reg, uint64_t num)
+{
+    uint64_t *reg_ptr = (uint64_t *)reg;
+    *reg_ptr          = num;
+}
+
+uint64_t RegEdit_u64_ReadReg(void *reg)
+{
+    uint64_t *reg_ptr = (uint64_t *)reg;
+    return *reg_ptr;
+}
+
+// For 32-Bit systems and register access.
+
+void RegEdit_u32_SetRegister(void *reg)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    *reg_ptr          = UINT32_MAX;
+}
+
+void RegEdit_u32_ClearRegister(void *reg)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    *reg_ptr          = 0;
+}
+
+void RegEdit_u32_SetBit(void *reg, uint8_t bit_num)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    *reg_ptr |= (uint32_t)(1 << bit_num);
+}
+
+void RegEdit_u32_ClearBit(void *reg, uint8_t bit_num)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    *reg_ptr &= ~(1 << bit_num);
+}
+
+bool RegEdit_u32_IsBitSet(void *reg, uint8_t bit_num)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    return *reg_ptr & (1 << bit_num);
+}
+
+void RegEdit_u32_OR_Num(void *reg, uint32_t num)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    *reg_ptr |= num;
+}
+
+void RegEdit_u32_AND_Num(void *reg, uint32_t num)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    *reg_ptr &= num;
+}
+
+void RegEdit_u32_SetNum(void *reg, uint32_t num)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    *reg_ptr          = num;
+}
+
+uint32_t RegEdit_u32_ReadReg(void *reg)
+{
+    uint32_t *reg_ptr = (uint32_t *)reg;
+    return *reg_ptr;
+}
+
+// For 16-Bit systems and register access.
+
+void RegEdit_u16_SetRegister(void *reg)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    *reg_ptr          = UINT16_MAX;
+}
+
+void RegEdit_u16_ClearRegister(void *reg)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    *reg_ptr          = 0;
+}
+
+void RegEdit_u16_SetBit(void *reg, uint8_t bit_num)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    *reg_ptr |= (uint16_t)(1 << bit_num);
+}
+
+void RegEdit_u16_ClearBit(void *reg, uint8_t bit_num)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    *reg_ptr &= ~(1 << bit_num);
+}
+
+bool RegEdit_u16_IsBitSet(void *reg, uint8_t bit_num)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    return *reg_ptr & (1 << bit_num);
+}
+
+void RegEdit_u16_OR_Num(void *reg, uint16_t num)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    *reg_ptr |= num;
+}
+
+void RegEdit_u16_AND_Num(void *reg, uint16_t num)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    *reg_ptr &= num;
+}
+
+void RegEdit_u16_SetNum(void *reg, uint16_t num)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    *reg_ptr          = num;
+}
+
+uint16_t RegEdit_u16_ReadReg(void *reg)
+{
+    uint16_t *reg_ptr = (uint16_t *)reg;
+    return *reg_ptr;
+}
+
+// For 8-Bit systems and register access.
+
+void RegEdit_u8_SetRegister(void *reg)
+{
+    uint8_t *reg_ptr = (uint8_t *)reg;
+    *reg_ptr         = UINT8_MAX;
+}
+
+void RegEdit_u8_ClearRegister(void *reg)
+{
+    uint8_t *reg_ptr = (uint8_t *)reg;
+    *reg_ptr         = 0;
+}
+
+void RegEdit_u8_SetBit(void *reg, uint8_t bit_num)
 {
     uint8_t *reg_ptr = (uint8_t *)reg;
     *reg_ptr |= (uint8_t)(1 << bit_num);
 }
 
-void RegEdit_ClearBit(void *reg, uint8_t bit_num)
+void RegEdit_u8_ClearBit(void *reg, uint8_t bit_num)
 {
     uint8_t *reg_ptr = (uint8_t *)reg;
     *reg_ptr &= ~(1 << bit_num);
 }
 
-bool RegEdit_IsBitSet(void *reg, uint8_t bit_num)
+bool RegEdit_u8_IsBitSet(void *reg, uint8_t bit_num)
 {
     uint8_t *reg_ptr = (uint8_t *)reg;
     return *reg_ptr & (1 << bit_num);
 }
 
-void RegEdit_OR_Num(void *reg, uint8_t num)
+void RegEdit_u8_OR_Num(void *reg, uint8_t num)
 {
     uint8_t *reg_ptr = (uint8_t *)reg;
     *reg_ptr |= num;
 }
 
-void RegEdit_AND_Num(void *reg, uint8_t num)
+void RegEdit_u8_AND_Num(void *reg, uint8_t num)
 {
     uint8_t *reg_ptr = (uint8_t *)reg;
     *reg_ptr &= num;
 }
 
-void RegEdit_SetNum(void *reg, uint8_t num)
+void RegEdit_u8_SetNum(void *reg, uint8_t num)
 {
     uint8_t *reg_ptr = (uint8_t *)reg;
     *reg_ptr         = num;
 }
 
-uint8_t RegEdit_ReadReg(void *reg)
+uint8_t RegEdit_u8_ReadReg(void *reg)
 {
     uint8_t *reg_ptr = (uint8_t *)reg;
     return *reg_ptr;

src/RegEdit/RegEdit.h

@@ -11,67 +11,85 @@
 #define REGEDIT_H
 
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
-/**
+// Template of function signitures.
- *
+// XX: RegEdit_uxx
- * @param reg The register address.
+// REGTYPE: fixed width type.
- */
+/*
-void RegEdit_SetRegister(void *reg);
+void XX_SetRegister(void *reg);
+void XX_ClearRegister(void *reg);
+void XX_SetBit(void *reg, uint8_t bit_num);
+void XX_ClearBit(void *reg, uint8_t bit_num);
+bool XX_IsBitSet(void *reg, uint8_t bit_num);
+void XX_OR_Num(void *reg, REGTYPE num);
+void XX_AND_Num(void *reg, REGTYPE num);
+void XX_SetNum(void *reg, REGTYPE num);
+REGTYPE XX_ReadReg(void *reg);
+*/
+
+// For 64-Bit systems and register access.
 
 /**
- *
+ * @brief Sets all the bits in pointed register.
  * @param reg The register address.
  */
-void RegEdit_ClearRegister(void *reg);
+void     RegEdit_u64_SetRegister(void *reg);
 
 /**
- *
+ * @brief Clears all the bits in pointed register.
+ * @param reg The register address.
+ */
+void     RegEdit_u64_ClearRegister(void *reg);
+
+/**
+ * @brief Set's a specific bit in a register.
  * @param reg The register address.
  * @param bit_num The bit location.
  */
-void RegEdit_SetBit(void *reg, uint8_t bit_num);
+void     RegEdit_u64_SetBit(void *reg, uint8_t bit_num);
+void     RegEdit_u64_ClearBit(void *reg, uint8_t bit_num);
+bool     RegEdit_u64_IsBitSet(void *reg, uint8_t bit_num);
+void     RegEdit_u64_OR_Num(void *reg, uint64_t num);
+void     RegEdit_u64_AND_Num(void *reg, uint64_t num);
+void     RegEdit_u64_SetNum(void *reg, uint64_t num);
+uint64_t RegEdit_u64_ReadReg(void *reg);
 
-/**
+// For 32-Bit systems and register access.
- *
- * @param reg The register address.
- * @param bit_num The bit location.
- */
-void RegEdit_ClearBit(void *reg, uint8_t bit_num);
 
-/**
+void     RegEdit_u32_SetRegister(void *reg);
- *
+void     RegEdit_u32_ClearRegister(void *reg);
- * @param reg The register address.
+void     RegEdit_u32_SetBit(void *reg, uint8_t bit_num);
- * @param bit_num The bit location.
+void     RegEdit_u32_ClearBit(void *reg, uint8_t bit_num);
- * @return
+bool     RegEdit_u32_IsBitSet(void *reg, uint8_t bit_num);
- */
+void     RegEdit_u32_OR_Num(void *reg, uint32_t num);
-bool RegEdit_IsBitSet(void *reg, uint8_t bit_num);
+void     RegEdit_u32_AND_Num(void *reg, uint32_t num);
+void     RegEdit_u32_SetNum(void *reg, uint32_t num);
+uint32_t RegEdit_u32_ReadReg(void *reg);
 
-/**
+// For 16-Bit systems and register access.
- *
- * @param reg The register address.
- * @param num The bit location.
- */
-void RegEdit_OR_Num(void *reg, uint8_t num);
 
-/**
+void     RegEdit_u16_SetRegister(void *reg);
- *
+void     RegEdit_u16_ClearRegister(void *reg);
- * @param reg The register address.
+void     RegEdit_u16_SetBit(void *reg, uint8_t bit_num);
- * @param num The bit location.
+void     RegEdit_u16_ClearBit(void *reg, uint8_t bit_num);
- */
+bool     RegEdit_u16_IsBitSet(void *reg, uint8_t bit_num);
-void RegEdit_AND_Num(void *reg, uint8_t num);
+void     RegEdit_u16_OR_Num(void *reg, uint16_t num);
+void     RegEdit_u16_AND_Num(void *reg, uint16_t num);
+void     RegEdit_u16_SetNum(void *reg, uint16_t num);
+uint16_t RegEdit_u16_ReadReg(void *reg);
 
-/**
+// For 8-Bit systems and register access.
- *
- * @param reg The register address.
- * @param num The bit location.
- */
-void RegEdit_SetNum(void *reg, uint8_t num);
 
-/**
+void    RegEdit_u8_SetRegister(void *reg);
- *
+void    RegEdit_u8_ClearRegister(void *reg);
- * @param reg The register address.
+void    RegEdit_u8_SetBit(void *reg, uint8_t bit_num);
- */
+void    RegEdit_u8_ClearBit(void *reg, uint8_t bit_num);
-uint8_t RegEdit_ReadReg(void *reg);
+bool    RegEdit_u8_IsBitSet(void *reg, uint8_t bit_num);
+void    RegEdit_u8_OR_Num(void *reg, uint8_t num);
+void    RegEdit_u8_AND_Num(void *reg, uint8_t num);
+void    RegEdit_u8_SetNum(void *reg, uint8_t num);
+uint8_t RegEdit_u8_ReadReg(void *reg);
 
 #endif // REGEDIT_H

src/blink/blink.h

@@ -8,6 +8,8 @@
 #ifndef BLINK_H
 #define BLINK_H
 
+#include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
 extern volatile uint32_t *GPIO_PORT_BSHR;

tests/ADC/test_ADC.cpp

@@ -1,6 +1,6 @@
 /*
- * Author: Jake G 
+ * Author: Jake G
- * Date: 2024 
+ * Date: 2024
  * filename: test_ADC.c
  * description: module_purpose
  */
@@ -9,65 +9,56 @@
 #include "CppUTestExt/MockSupport.h"
 #include <cstdint>
 
-extern "C" 
+extern "C"
 {
-#include "ch32v003hw.h"
 #include "ADC.h"
+#include "ch32v003hw.h"
 }
 
-TEST_GROUP(test_ADC)
+TEST_GROUP(test_ADC){
-{
+    void   setup(){
-    void setup()
-    {
 
-    }
+    } void teardown(){
-    void teardown()
-    {
         mock().checkExpectations();
-        mock().clear();
+mock().clear();
-    }
+}
-};
+}
+;
 
 TEST(test_ADC, FirstTest)
 {
-   CHECK(true);
+    CHECK(true);
 }
 
 TEST(test_ADC, ADC_PowerOnTest)
 {
     // The ADCON bit should be high in the ADC_CTRL2 register.
-   mock().expectOneCall("RegEdit_SetBit")
+    mock().expectOneCall("RegEdit_SetBit").withPointerParameter("reg", (void *)&ADC1->CTLR2).withUnsignedIntParameter("bit_num", ADC_ADON);
-       .withPointerParameter("reg", (void *) &ADC1->CTLR2)
-       .withUnsignedIntParameter("bit_num", ADC_ADON); 
 
     ADC_PowerOn();
 }
 
 TEST(test_ADC, ADC_SetupSetsRegisters)
 {
-    
+    // R32_GPIOD_CFGLR --> 0x40011400
-    //R32_GPIOD_CFGLR --> 0x40011400
+    // DESC: PD port configuration register low
-    //DESC: PD port configuration register low 
+    // RESET VALUE--> 0x44444444
-    //RESET VALUE--> 0x44444444
-    
-    //R32_GPIOD_INDR --> 0x40011408
-    //DESC: PD port input data register
 
-    //R32_GPIOD_BSHR --> 0x40011410
+    // R32_GPIOD_INDR --> 0x40011408
-    //DESC: PD port set/reset register
+    // DESC: PD port input data register
 
-    //R32_GPIOD_BCR --> 0x40011414
+    // R32_GPIOD_BSHR --> 0x40011410
-    //DESC: PD port reset register
+    // DESC: PD port set/reset register
-    
-    //R32_GPIOD_LCKR --> 0x40011418
-    //DESC: PD port configuration lock register
 
-    //Setup the ADC clock and divider. The internal HSI-XC is 24MHz.
+    // R32_GPIOD_BCR --> 0x40011414
+    // DESC: PD port reset register
 
-    
+    // R32_GPIOD_LCKR --> 0x40011418
-    //Setup PORTD pin(s) as analog input.
+    // DESC: PD port configuration lock register
 
+    // Setup the ADC clock and divider. The internal HSI-XC is 24MHz.
 
+    // Setup PORTD pin(s) as analog input.
 
     /*
     //Clears control register A for ADC0
@@ -99,9 +90,9 @@ TEST(test_ADC, ADC_SetupSetsRegisters)
     mock().expectOneCall("RegEdit_SetBit")
         .withPointerParameter("reg", (void *) &ADC0.CTRLD)
         .withUnsignedIntParameter("bit_num", 4);
-    
+
     */
-    ADC_Setup();     
+    ADC_Setup();
 }
 
 TEST(test_ADC, ADC_InitPortAPin7UsesCorrectRegisters)
@@ -111,8 +102,8 @@ TEST(test_ADC, ADC_InitPortAPin7UsesCorrectRegisters)
     mock().expectOneCall("RegEdit_ClearBit")
         .withPointerParameter("reg", (void *) &PORTA.DIR)
         .withUnsignedIntParameter("bit_num", 7);
- 
+
-    //Check that the pullup is off 
+    //Check that the pullup is off
     mock().expectOneCall("RegEdit_ClearBit")
         .withPointerParameter("reg", (void *) &PORTA.OUT)
         .withUnsignedIntParameter("bit_num", 7);
@@ -134,8 +125,8 @@ TEST(test_ADC, ADC_InitPortAPin0UsesCorrectRegisters)
     mock().expectOneCall("RegEdit_ClearBit")
         .withPointerParameter("reg", (void *) &PORTA.DIR)
         .withUnsignedIntParameter("bit_num", 0);
- 
+
-    //Check that the pullup is off 
+    //Check that the pullup is off
     mock().expectOneCall("RegEdit_ClearBit")
         .withPointerParameter("reg", (void *) &PORTA.OUT)
         .withUnsignedIntParameter("bit_num", 0);
@@ -145,7 +136,7 @@ TEST(test_ADC, ADC_InitPortAPin0UsesCorrectRegisters)
     mock().expectOneCall("RegEdit_SetBit")
         .withPointerParameter("reg", (void *) &PORTA.PIN0CTRL)
         .withUnsignedIntParameter("bit_num", PORT_ISC_INPUT_DISABLE_gc);
-    
+
     */
 
     ADC_Init(0);
@@ -153,7 +144,7 @@ TEST(test_ADC, ADC_InitPortAPin0UsesCorrectRegisters)
 
 TEST(test_ADC, ADC_InitDoesNothingOnHighPinNumbers)
 {
-    //mock().expectNoCall("RegEdit_SetBit");
+    // mock().expectNoCall("RegEdit_SetBit");
     ADC_Init(8);
 }
 
@@ -166,7 +157,6 @@ TEST(test_ADC, ADC_EnablePasses)
 
     */
     ADC_Enable();
-
 }
 
 TEST(test_ADC, ADC_DisablePasses)
@@ -190,40 +180,35 @@ TEST(test_ADC, ADC_SetPinSetsRightRegisters)
     mock().expectOneCall("RegEdit_SetNum")
         .withPointerParameter("reg", (void *) &ADC0.MUXPOS)
         .withUnsignedIntParameter("num", 4);
-    
+
     */
     ADC_SetPin(4);
 }
 
-
 TEST(test_ADC, ADC_SetPinFailsOnInvalidPin)
 {
     ADC_SetPin(8);
 }
 
-
 static uint16_t ADC_ReadValueFake(uint8_t pin_num)
 {
     return 512;
 }
 
-TEST_GROUP(test_ADCRead)
+TEST_GROUP(test_ADCRead){
-{
+    void setup(){
-    void setup()
-    {
         UT_PTR_SET(ADC_ReadValue, ADC_ReadValueFake);
-    }
+}
 
-    void teardown()
+void teardown()
-    {
+{
-
+}
-    }
+}
-};
+;
 
 TEST(test_ADCRead, FunctionPointerSwapWorks)
 {
     uint16_t value = ADC_ReadValue(0);
-    
+
     LONGS_EQUAL(512, value);
 }
-

tests/AllTests.cpp

@@ -1,15 +1,14 @@
 #include "CppUTest/CommandLineTestRunner.h"
 
-
+// ImportTestGroups
-//ImportTestGroups
 IMPORT_TEST_GROUP(simple_test);
 IMPORT_TEST_GROUP(test_ADC);
 IMPORT_TEST_GROUP(test_RegEdit);
 IMPORT_TEST_GROUP(test_blink);
 
-//START: main
+// START: main
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
     return RUN_ALL_TESTS(argc, argv);
 }
-//END: main
+// END: main

tests/MockADC/test_MockADC.cpp

@@ -1,36 +1,32 @@
 /*
- * Author: Jake G 
+ * Author: Jake G
- * Date: 2024 
+ * Date: 2024
  * filename: test_MockADC.c
- * description: 
+ * description:
  */
 
 #include "CppUTest/CommandLineTestRunner.h"
 #include "CppUTestExt/MockSupport.h"
 #include <cstdint>
 
-extern "C" 
+extern "C"
 {
 #include "MockADC.h"
 }
 
-TEST_GROUP(test_MockADC)
+TEST_GROUP(test_MockADC){
-{
+    void   setup(){
-    void setup()
-    {
 
-    }
+    } void teardown(){
-    void teardown()
-    {
         mock().checkExpectations();
-        mock().clear();
+mock().clear();
-    }
+}
-};
+}
+;
 
 TEST(test_MockADC, ADC_InitExpects)
 {
-    mock().expectOneCall("ADC_Init")
+    mock().expectOneCall("ADC_Init").withUnsignedIntParameter("pin_num", 7);
-        .withUnsignedIntParameter("pin_num", 7);
 
     ADC_Init(7);
 }
@@ -42,7 +38,6 @@ TEST(test_MockADC, ADC_EnableExpects)
     ADC_Enable();
 }
 
-
 TEST(test_MockADC, ADC_DisableExpect)
 {
     mock().expectOneCall("ADC_Disable");
@@ -54,22 +49,18 @@ TEST(test_MockADC, ADC_ReadValue)
 {
     MockADC_ZeroIndex();
     MockADC_PushValue(512);
- 
+
-    mock().expectOneCall("ADC_ReadValue_Impl")
+    mock().expectOneCall("ADC_ReadValue_Impl").withUnsignedIntParameter("pin_num", 0x2);
-        .withUnsignedIntParameter("pin_num", 0x2);
 
     uint16_t val = ADC_ReadValue(0x2);
     LONGS_EQUAL(512, val);
-    
 }
 
 TEST(test_MockADC, ADC_ReadValueReturnsZeroOnEmptyBuffer)
 {
     MockADC_ZeroIndex();
-    
+
-    mock().expectOneCall("ADC_ReadValue_Impl")
+    mock().expectOneCall("ADC_ReadValue_Impl").withUnsignedIntParameter("pin_num", 0x2).andReturnValue(0x0000);
-        .withUnsignedIntParameter("pin_num", 0x2)
-        .andReturnValue(0x0000);
 
     uint16_t val = ADC_ReadValue(0x2);
     LONGS_EQUAL(0, val);
@@ -78,8 +69,9 @@ TEST(test_MockADC, ADC_ReadValueReturnsZeroOnEmptyBuffer)
 TEST(test_MockADC, MockADC_PushValueDoesntOverflowArray)
 {
     MockADC_ZeroIndex();
-    for(int i = 0; i < 257; i++){
+    for (int i = 0; i < 257; i++)
-        MockADC_PushValue(512+i); 
+    {
+        MockADC_PushValue(512 + i);
         CHECK_TRUE(MockADC_GetIndex() <= 255);
     }
 }
@@ -87,7 +79,7 @@ TEST(test_MockADC, MockADC_PushValueDoesntOverflowArray)
 TEST(test_MockADC, MockADC_SetupSetsGlobal)
 {
     CHECK_FALSE(MockADC_IsSetup());
-    
+
     ADC_Setup();
 
     CHECK_TRUE(MockADC_IsSetup());

tests/MockRegEdit/test_MockRegEdit.cpp

@@ -1,6 +1,6 @@
 /*
  * Author: username
- * Date: todays_date 
+ * Date: todays_date
  * filename: test_MockRegEdit.c
  * description: module_purpose
  */
@@ -9,160 +9,123 @@
 #include "CppUTestExt/MockSupport.h"
 #include <cstdint>
 
-extern "C" 
+extern "C"
 {
 #include "MockRegEdit.h"
 }
 
-
+TEST_GROUP(test_MockRegEdit){
-
+    void setup(){} void teardown(){
-
-TEST_GROUP(test_MockRegEdit)
-{
-    void setup()
-    {
-    }
-    void teardown()
-    {
         mock().clear();
-    }
+}
-};
+}
-
+;
 
 TEST(test_MockRegEdit, RegEdit_ClearRegisterExpectedCallPasses)
 {
-    uint8_t a;
+    uint8_t  a;
     uint8_t *b = &a;
 
-    mock().expectOneCall("RegEdit_ClearRegister")
+    mock().expectOneCall("RegEdit_ClearRegister").withPointerParameter("reg", b);
-        .withPointerParameter("reg", b);
 
     RegEdit_ClearRegister(b);
 
     mock().checkExpectations();
 }
 
-
 TEST(test_MockRegEdit, RegEdit_SetRegisterExpectedCallPasses)
 {
-
+    uint8_t  a;
-    uint8_t a;
     uint8_t *b = &a;
 
-    mock().expectOneCall("RegEdit_SetRegister")
+    mock().expectOneCall("RegEdit_SetRegister").withPointerParameter("reg", b);
-        .withPointerParameter("reg", b);
+
-    
     RegEdit_SetRegister(b);
-    
+
     mock().checkExpectations();
 }
 
-
 TEST(test_MockRegEdit, RegEdit_SetBitExpectedCallPasses)
 {
-
+    uint8_t  a;
-    uint8_t a;
     uint8_t *b = &a;
 
-    mock().expectOneCall("RegEdit_SetBit")
+    mock().expectOneCall("RegEdit_SetBit").withPointerParameter("reg", b).withUnsignedIntParameter("bit_num", 5);
-        .withPointerParameter("reg", b)
+
-        .withUnsignedIntParameter("bit_num", 5);
-    
     RegEdit_SetBit(b, 5);
-    
+
     mock().checkExpectations();
 }
 
-
 TEST(test_MockRegEdit, RegEdit_ClearBitExpectedCallPasses)
 {
-
+    uint8_t  a;
-    uint8_t a;
     uint8_t *b = &a;
 
-    mock().expectOneCall("RegEdit_ClearBit")
+    mock().expectOneCall("RegEdit_ClearBit").withPointerParameter("reg", b).withUnsignedIntParameter("bit_num", 5);
-        .withPointerParameter("reg", b)
+
-        .withUnsignedIntParameter("bit_num", 5);
-    
     RegEdit_ClearBit(b, 5);
-    
+
     mock().checkExpectations();
 }
 
 TEST(test_MockRegEdit, RegEdit_IsBitSetExpectedCallPasses)
 {
-    uint8_t a = 0xFF;
+    uint8_t  a = 0xFF;
     uint8_t *b = &a;
 
-    mock().expectOneCall("RegEdit_IsBitSet")
+    mock().expectOneCall("RegEdit_IsBitSet").withPointerParameter("reg", b).withUnsignedIntParameter("bit_num", 5).andReturnValue(true);
-        .withPointerParameter("reg", b)
+
-        .withUnsignedIntParameter("bit_num", 5)
-        .andReturnValue(true);
-    
     CHECK_TRUE(RegEdit_IsBitSet(b, 5));
-    
+
     mock().checkExpectations();
 }
 
-
 TEST(test_MockRegEdit, RegEdit_IsBitSetExpectedCallPassesWithFalse)
 {
-    uint8_t a = 0xFF;
+    uint8_t  a = 0xFF;
     uint8_t *b = &a;
 
-    mock().expectOneCall("RegEdit_IsBitSet")
+    mock().expectOneCall("RegEdit_IsBitSet").withPointerParameter("reg", b).withUnsignedIntParameter("bit_num", 5).andReturnValue(false);
-        .withPointerParameter("reg", b)
+
-        .withUnsignedIntParameter("bit_num", 5)
-        .andReturnValue(false);
-    
     CHECK_FALSE(RegEdit_IsBitSet(b, 5));
-    
+
     mock().checkExpectations();
 }
 
 TEST(test_MockRegEdit, RegEdit_OR_NumExpectedWorks)
 {
-    uint8_t a = 0xFF;
+    uint8_t  a = 0xFF;
     uint8_t *b = &a;
 
-    mock().expectOneCall("RegEdit_OR_Num")
+    mock().expectOneCall("RegEdit_OR_Num").withPointerParameter("reg", b).withUnsignedIntParameter("num", 0x4).andReturnValue(false);
-        .withPointerParameter("reg", b)
+
-        .withUnsignedIntParameter("num", 0x4)
-        .andReturnValue(false);
-    
     RegEdit_OR_Num(b, 0x4);
-    
+
     mock().checkExpectations();
-
-
 }
 
 TEST(test_MockRegEdit, RegEdit_SetNumPasses)
 {
-    uint32_t a = 0xFFFFFFFF;
+    uint32_t  a = 0xFFFFFFFF;
     uint32_t *b = &a;
 
-    mock().expectOneCall("RegEdit_SetNum")
+    mock().expectOneCall("RegEdit_SetNum").withPointerParameter("reg", b).withUnsignedIntParameter("num", 0x4).andReturnValue(false);
-        .withPointerParameter("reg", b)
+
-        .withUnsignedIntParameter("num", 0x4)
-        .andReturnValue(false);
-    
     RegEdit_SetNum(b, 0x4);
-    
+
     mock().checkExpectations();
 }
 
 TEST(test_MockRegEdit, RegEdit_ReadRegPasses)
 {
-    uint8_t a = 0xFF;
+    uint8_t  a = 0xFF;
     uint8_t *b = &a;
 
-    mock().expectOneCall("RegEdit_ReadReg")
+    mock().expectOneCall("RegEdit_ReadReg").withPointerParameter("reg", b).andReturnValue(0xFF);
-        .withPointerParameter("reg", b)
+
-        .andReturnValue(0xFF);
-   
     uint8_t reg_val = RegEdit_ReadReg(b);
-    LONGS_EQUAL(0xFF, reg_val); 
+    LONGS_EQUAL(0xFF, reg_val);
-    
+
     mock().checkExpectations();
 }

tests/MockTests.cpp

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

tests/RegEdit/test_RegEdit.cpp

@@ -1,32 +1,26 @@
 /*
  * Author: username
- * Date: todays_date 
+ * Date: todays_date
  * filename: test_RegEdit.c
  * description: module_purpose
  */
 
 #include "CppUTest/CommandLineTestRunner.h"
 
-extern "C" 
+extern "C"
 {
 #include "RegEdit.h"
 }
 
-TEST_GROUP(test_RegEdit)
+TEST_GROUP(test_RegEdit){
-{
+    void   setup(){
-    void setup()
-    {
 
-    }
+    } void teardown(){
-    void teardown()
-    {
 
-    }
+    }};
-};
 
 TEST(test_RegEdit, FirstTest)
 {
-   //FAIL("Fail me!");
+    // FAIL("Fail me!");
-   CHECK(true);
+    CHECK(true);
 }
-

tests/blink/test_blink.cpp

@@ -1,40 +1,37 @@
 /*
  * Author: username
- * Date: todays_date 
+ * Date: todays_date
  * filename: test_blink.c
  * description: module_purpose
  */
 
 #include "CppUTest/CommandLineTestRunner.h"
 
-extern "C" 
+extern "C"
 {
 #include "blink.h"
 }
 
-volatile uint32_t fake_bshr_reg = 0;
+volatile uint32_t  fake_bshr_reg  = 0;
-volatile uint32_t* GPIO_PORT_BSHR = &fake_bshr_reg;
+volatile uint32_t *GPIO_PORT_BSHR = &fake_bshr_reg;
 
-unsigned int called;
+unsigned int       called;
-void fake_delay(unsigned int ms)
+void               fake_delay(unsigned int ms)
 {
     called += 1;
     return;
 }
 
-TEST_GROUP(test_blink)
+TEST_GROUP(test_blink){
-{
+    void setup(){
-    void setup()
-    {
         fake_bshr_reg = 0;
-        called = 0;
+called = 0;
-    }
+}
-    void teardown()
+void teardown()
-    {
+{
-
+}
-    }
+}
-};
+;
-
 
 TEST(test_blink, UninitializedFuncPointer)
 {
@@ -44,18 +41,16 @@ TEST(test_blink, UninitializedFuncPointer)
 
 TEST(test_blink, BlinkChangesReg)
 {
-    //Set the function pointer.
+    // Set the function pointer.
     delay_ms = fake_delay;
 
     blink_led(1);
 
     CHECK_EQUAL_TEXT(2, called, "Delay function not called expeced number of times");
 
-    CHECK(fake_bshr_reg & (1<<0));
+    CHECK(fake_bshr_reg & (1 << 0));
-    CHECK(fake_bshr_reg & (1<<(0+16)));
+    CHECK(fake_bshr_reg & (1 << (0 + 16)));
 
-    //Unset function pointer
+    // Unset function pointer
     delay_ms = 0;
 }
-
-

tests/shared/mocks/MockADC/MockADC.c

@@ -1,6 +1,6 @@
 /*
  * Author: username
- * Date: 2024 
+ * Date: 2024
  * filename: MockADC.c
  * description: module_purpose
  */
@@ -10,14 +10,12 @@
 
 #define FAKESIZE 256
 
-uint16_t fake_data[FAKESIZE];
+uint16_t    fake_data[FAKESIZE];
-int fake_index = 0;
+int         fake_index = 0;
 
-static bool is_setup = false;
+static bool is_setup   = false;
 
-
+void        ADC_SetPin(uint8_t pin_num)
-
-void ADC_SetPin(uint8_t pin_num)
 {
     return;
 }
@@ -30,8 +28,7 @@ void ADC_Setup(void)
 
 void ADC_Init(uint8_t pin_num)
 {
-    mock_c()->actualCall("ADC_Init")
+    mock_c()->actualCall("ADC_Init")->withUnsignedIntParameters("pin_num", pin_num);
-        ->withUnsignedIntParameters("pin_num", pin_num);
 }
 
 void ADC_Enable(void)
@@ -41,15 +38,15 @@ void ADC_Enable(void)
 
 void ADC_Disable(void)
 {
-    mock_c()->actualCall("ADC_Disable"); 
+    mock_c()->actualCall("ADC_Disable");
 }
 
 uint16_t ADC_ReadValue_Impl(uint8_t pin_num)
 {
-    mock_c()->actualCall("ADC_ReadValue_Impl")
+    mock_c()->actualCall("ADC_ReadValue_Impl")->withUnsignedIntParameters("pin_num", pin_num);
-        ->withUnsignedIntParameters("pin_num", pin_num);
 
-    if(fake_index == 0){
+    if (fake_index == 0)
+    {
         return 0;
     }
     return fake_data[--fake_index];
@@ -57,27 +54,25 @@ uint16_t ADC_ReadValue_Impl(uint8_t pin_num)
 
 uint16_t (*ADC_ReadValue)(uint8_t pin_num) = ADC_ReadValue_Impl;
 
-
+void MockADC_PushValue(uint16_t value)
-void MockADC_PushValue(uint16_t value){
+{
-    if(fake_index >= FAKESIZE - 1){
+    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

@@ -10,9 +10,8 @@
 #ifndef MOCKADC_H
 #define MOCKADC_H
 
-#include <stdint.h>
 #include <stdbool.h>
-
+#include <stdint.h>
 
 void ADC_Setup(void);
 void ADC_SetPin(uint8_t pin_num);
@@ -24,7 +23,7 @@ extern uint16_t (*ADC_ReadValue)(uint8_t pin_num);
 
 void MockADC_PushValue(uint16_t value);
 void MockADC_ZeroIndex(void);
-int MockADC_GetIndex(void);
+int  MockADC_GetIndex(void);
 bool MockADC_IsSetup(void);
 
-#endif //MOCKADC_H
+#endif // MOCKADC_H

tests/shared/mocks/MockRegEdit/MockRegEdit.c

@@ -1,6 +1,6 @@
 /*
  * Author: username
- * Date: 2024 
+ * Date: 2024
  * filename: MockRegEdit.c
  * description: module_purpose
  */
@@ -8,78 +8,52 @@
 #include "MockRegEdit.h"
 #include "CppUTestExt/MockSupport_c.h"
 
-
 void RegEdit_SetRegister(void *reg)
 {
-    mock_c()->actualCall("RegEdit_SetRegister")
+    mock_c()->actualCall("RegEdit_SetRegister")->withPointerParameters("reg", reg);
-        ->withPointerParameters("reg", reg);
 }
 
 void RegEdit_ClearRegister(void *reg)
 {
-    mock_c()->actualCall("RegEdit_ClearRegister")
+    mock_c()->actualCall("RegEdit_ClearRegister")->withPointerParameters("reg", reg);
-        ->withPointerParameters("reg", reg);
 }
 
-
 void RegEdit_SetBit(void *reg, uint8_t bit_num)
 {
-    mock_c()->actualCall("RegEdit_SetBit")
+    mock_c()->actualCall("RegEdit_SetBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
-        ->withPointerParameters("reg", reg)
-        ->withUnsignedIntParameters("bit_num", bit_num);
 }
 
-
 void RegEdit_ClearBit(void *reg, uint8_t bit_num)
 {
-    mock_c()->actualCall("RegEdit_ClearBit")
+    mock_c()->actualCall("RegEdit_ClearBit")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num);
-        ->withPointerParameters("reg", reg)
-        ->withUnsignedIntParameters("bit_num", bit_num);
 }
 
-
 bool RegEdit_IsBitSet(void *reg, uint8_t bit_num)
 {
-
+    return mock_c()->actualCall("RegEdit_IsBitSet")->withPointerParameters("reg", reg)->withUnsignedIntParameters("bit_num", bit_num)->returnBoolValueOrDefault(true);
-    return mock_c()->actualCall("RegEdit_IsBitSet")
+    // return mock_c()->returnBoolValueOrDefault(true);
-        ->withPointerParameters("reg", reg)
-        ->withUnsignedIntParameters("bit_num", bit_num)
-        ->returnBoolValueOrDefault(true);
-    //return mock_c()->returnBoolValueOrDefault(true);
 }
 
 void RegEdit_OR_Num(void *reg, uint32_t num)
 {
-    mock_c()->actualCall("RegEdit_OR_Num")
+    mock_c()->actualCall("RegEdit_OR_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
-        ->withPointerParameters("reg", reg)
-        ->withUnsignedIntParameters("num", num);
 }
 
-
 void RegEdit_AND_Num(void *reg, uint32_t num)
 {
-    mock_c()->actualCall("RegEdit_AND_Num")
+    mock_c()->actualCall("RegEdit_AND_Num")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
-        ->withPointerParameters("reg", reg)
-        ->withUnsignedIntParameters("num", num);
 }
 
-
-
 void RegEdit_SetNum(void *reg, uint32_t num)
 {
-    mock_c()->actualCall("RegEdit_SetNum")
+    mock_c()->actualCall("RegEdit_SetNum")->withPointerParameters("reg", reg)->withUnsignedIntParameters("num", num);
-        ->withPointerParameters("reg", reg)
-        ->withUnsignedIntParameters("num", num);
 }
 
-
 uint8_t RegEdit_ReadReg(void *reg)
 {
-    uint8_t value = *(uint8_t *)reg;    
+    uint8_t value = *(uint8_t *)reg;
+
+    mock_c()->actualCall("RegEdit_ReadReg")->withPointerParameters("reg", reg)->returnUnsignedIntValueOrDefault(value);
 
-    mock_c()->actualCall("RegEdit_ReadReg")
-        ->withPointerParameters("reg", reg)
-        ->returnUnsignedIntValueOrDefault(value);
-    
     return value;
 }

tests/shared/mocks/MockRegEdit/MockRegEdit.h

@@ -10,21 +10,20 @@
 #ifndef MOCKREGEDIT_H
 #define MOCKREGEDIT_H
 
-
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 
-void RegEdit_SetRegister(void *reg);
+void    RegEdit_SetRegister(void *reg);
-void RegEdit_ClearRegister(void *reg);
+void    RegEdit_ClearRegister(void *reg);
-void RegEdit_SetBit(void *reg, uint8_t bit_num);
+void    RegEdit_SetBit(void *reg, uint8_t bit_num);
-void RegEdit_ClearBit(void *reg, uint8_t bit_num);
+void    RegEdit_ClearBit(void *reg, uint8_t bit_num);
-bool RegEdit_IsBitSet(void *reg, uint8_t bit_num);
+bool    RegEdit_IsBitSet(void *reg, uint8_t bit_num);
 
-void RegEdit_OR_Num(void *reg, uint32_t num);
+void    RegEdit_OR_Num(void *reg, uint32_t num);
-void RegEdit_AND_Num(void *reg, uint32_t num);
+void    RegEdit_AND_Num(void *reg, uint32_t num);
 
-void RegEdit_SetNum(void *reg, uint32_t num);
+void    RegEdit_SetNum(void *reg, uint32_t num);
 
 uint8_t RegEdit_ReadReg(void *reg);
 
-#endif //MOCKREGEDIT_H
+#endif // MOCKREGEDIT_H

tests/shared/mocks/MockRegEdit/u8_comparator.cpp

@@ -16,14 +16,16 @@ public:
 };
 */
 
-bool UInt8PointerComparator::isEqual(const void* object1, const void* object2) {
+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);
+    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) {
+SimpleString UInt8PointerComparator::valueToString(const void *object)
-    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(object);
+{
+    const uint8_t *ptr = reinterpret_cast<const uint8_t *>(object);
     return StringFromFormat("0x%02x", *ptr);
 }
 
@@ -40,12 +42,14 @@ SimpleString UInt8PointerComparator::valueToString(const void* object) const {
 }
 */
 
-bool UInt8Comparator::isEqual(const void* object1, const void* object2) {
+bool UInt8Comparator::isEqual(const void *object1, const void *object2)
-    return (uint8_t*)object1 == (uint8_t *)object2;
+{
+    return (uint8_t *)object1 == (uint8_t *)object2;
 }
 
-SimpleString UInt8Comparator::valueToString(const void* object) {
+SimpleString UInt8Comparator::valueToString(const void *object)
-    //uint8_t value = reinterpret_cast<uint8_t>(object);
+{
-    const uint8_t *ptr = reinterpret_cast<const uint8_t*>(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/TimerMock/TimerMock.c

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

tests/shared/mocks/TimerMock/TimerMock.h

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

tests/simple_test/simple_test.cpp

@@ -1,24 +1,18 @@
 #include "CppUTest/TestHarness.h"
 
 /*
-extern C 
+extern C
 {
 #include "simple.h"
 }
 */
 
+TEST_GROUP(simple_test){
+    void   setup(){
 
-TEST_GROUP(simple_test)
+    } void teardown(){
-{
-    void setup()
-    {
 
-    }
+    }};
-    void teardown()
-    {
-
-    }
-};
 
 TEST(simple_test, passing_test)
 {