ceedling 0.30.0 → 0.31.0

data/examples/temp_sensor/build/test/mocks/MockTemperatureFilter.h

@@ -0,0 +1,52 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#ifndef _MOCKTEMPERATUREFILTER_H
+#define _MOCKTEMPERATUREFILTER_H
+
+#include "unity.h"
+#include "TemperatureFilter.h"
+
+/* Ignore the following warnings, since we are copying code */
+#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))
+#pragma GCC diagnostic push
+#endif
+#if !defined(__clang__)
+#pragma GCC diagnostic ignored "-Wpragmas"
+#endif
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier"
+#endif
+
+void MockTemperatureFilter_Init(void);
+void MockTemperatureFilter_Destroy(void);
+void MockTemperatureFilter_Verify(void);
+
+
+
+
+#define TemperatureFilter_Init_Ignore() TemperatureFilter_Init_CMockIgnore()
+void TemperatureFilter_Init_CMockIgnore(void);
+#define TemperatureFilter_Init_StopIgnore() TemperatureFilter_Init_CMockStopIgnore()
+void TemperatureFilter_Init_CMockStopIgnore(void);
+#define TemperatureFilter_Init_Expect() TemperatureFilter_Init_CMockExpect(__LINE__)
+void TemperatureFilter_Init_CMockExpect(UNITY_LINE_TYPE cmock_line);
+#define TemperatureFilter_GetTemperatureInCelcius_IgnoreAndReturn(cmock_retval) TemperatureFilter_GetTemperatureInCelcius_CMockIgnoreAndReturn(__LINE__, cmock_retval)
+void TemperatureFilter_GetTemperatureInCelcius_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, float cmock_to_return);
+#define TemperatureFilter_GetTemperatureInCelcius_StopIgnore() TemperatureFilter_GetTemperatureInCelcius_CMockStopIgnore()
+void TemperatureFilter_GetTemperatureInCelcius_CMockStopIgnore(void);
+#define TemperatureFilter_GetTemperatureInCelcius_ExpectAndReturn(cmock_retval) TemperatureFilter_GetTemperatureInCelcius_CMockExpectAndReturn(__LINE__, cmock_retval)
+void TemperatureFilter_GetTemperatureInCelcius_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, float cmock_to_return);
+#define TemperatureFilter_ProcessInput_Ignore() TemperatureFilter_ProcessInput_CMockIgnore()
+void TemperatureFilter_ProcessInput_CMockIgnore(void);
+#define TemperatureFilter_ProcessInput_StopIgnore() TemperatureFilter_ProcessInput_CMockStopIgnore()
+void TemperatureFilter_ProcessInput_CMockStopIgnore(void);
+#define TemperatureFilter_ProcessInput_Expect(temperature) TemperatureFilter_ProcessInput_CMockExpect(__LINE__, temperature)
+void TemperatureFilter_ProcessInput_CMockExpect(UNITY_LINE_TYPE cmock_line, float temperature);
+
+#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))
+#pragma GCC diagnostic pop
+#endif
+#endif
+
+#endif

data/examples/temp_sensor/build/test/mocks/MockTimerConductor.c

@@ -0,0 +1,157 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include <string.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include "cmock.h"
+#include "MockTimerConductor.h"
+
+static const char* CMockString_TimerConductor_Init = "TimerConductor_Init";
+static const char* CMockString_TimerConductor_Run = "TimerConductor_Run";
+
+typedef struct _CMOCK_TimerConductor_Init_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_TimerConductor_Init_CALL_INSTANCE;
+
+typedef struct _CMOCK_TimerConductor_Run_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_TimerConductor_Run_CALL_INSTANCE;
+
+static struct MockTimerConductorInstance
+{
+  char TimerConductor_Init_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE TimerConductor_Init_CallInstance;
+  char TimerConductor_Run_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE TimerConductor_Run_CallInstance;
+} Mock;
+
+extern jmp_buf AbortFrame;
+extern int GlobalExpectCount;
+extern int GlobalVerifyOrder;
+
+void MockTimerConductor_Verify(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_MEM_INDEX_TYPE call_instance;
+  call_instance = Mock.TimerConductor_Init_CallInstance;
+  if (Mock.TimerConductor_Init_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_TimerConductor_Init);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.TimerConductor_Run_CallInstance;
+  if (Mock.TimerConductor_Run_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_TimerConductor_Run);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+}
+
+void MockTimerConductor_Init(void)
+{
+  MockTimerConductor_Destroy();
+}
+
+void MockTimerConductor_Destroy(void)
+{
+  CMock_Guts_MemFreeAll();
+  memset(&Mock, 0, sizeof(Mock));
+  GlobalExpectCount = 0;
+  GlobalVerifyOrder = 0;
+}
+
+void TimerConductor_Init(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_TimerConductor_Init_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_TimerConductor_Init);
+  cmock_call_instance = (CMOCK_TimerConductor_Init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.TimerConductor_Init_CallInstance);
+  Mock.TimerConductor_Init_CallInstance = CMock_Guts_MemNext(Mock.TimerConductor_Init_CallInstance);
+  if (Mock.TimerConductor_Init_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void TimerConductor_Init_CMockIgnore(void)
+{
+  Mock.TimerConductor_Init_IgnoreBool = (char)1;
+}
+
+void TimerConductor_Init_CMockStopIgnore(void)
+{
+  Mock.TimerConductor_Init_IgnoreBool = (char)0;
+}
+
+void TimerConductor_Init_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_TimerConductor_Init_CALL_INSTANCE));
+  CMOCK_TimerConductor_Init_CALL_INSTANCE* cmock_call_instance = (CMOCK_TimerConductor_Init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.TimerConductor_Init_CallInstance = CMock_Guts_MemChain(Mock.TimerConductor_Init_CallInstance, cmock_guts_index);
+  Mock.TimerConductor_Init_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void TimerConductor_Run(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_TimerConductor_Run_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_TimerConductor_Run);
+  cmock_call_instance = (CMOCK_TimerConductor_Run_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.TimerConductor_Run_CallInstance);
+  Mock.TimerConductor_Run_CallInstance = CMock_Guts_MemNext(Mock.TimerConductor_Run_CallInstance);
+  if (Mock.TimerConductor_Run_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void TimerConductor_Run_CMockIgnore(void)
+{
+  Mock.TimerConductor_Run_IgnoreBool = (char)1;
+}
+
+void TimerConductor_Run_CMockStopIgnore(void)
+{
+  Mock.TimerConductor_Run_IgnoreBool = (char)0;
+}
+
+void TimerConductor_Run_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_TimerConductor_Run_CALL_INSTANCE));
+  CMOCK_TimerConductor_Run_CALL_INSTANCE* cmock_call_instance = (CMOCK_TimerConductor_Run_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.TimerConductor_Run_CallInstance = CMock_Guts_MemChain(Mock.TimerConductor_Run_CallInstance, cmock_guts_index);
+  Mock.TimerConductor_Run_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+

data/examples/temp_sensor/build/test/mocks/MockTimerConductor.h

@@ -0,0 +1,46 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#ifndef _MOCKTIMERCONDUCTOR_H
+#define _MOCKTIMERCONDUCTOR_H
+
+#include "unity.h"
+#include "TimerConductor.h"
+
+/* Ignore the following warnings, since we are copying code */
+#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))
+#pragma GCC diagnostic push
+#endif
+#if !defined(__clang__)
+#pragma GCC diagnostic ignored "-Wpragmas"
+#endif
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier"
+#endif
+
+void MockTimerConductor_Init(void);
+void MockTimerConductor_Destroy(void);
+void MockTimerConductor_Verify(void);
+
+
+
+
+#define TimerConductor_Init_Ignore() TimerConductor_Init_CMockIgnore()
+void TimerConductor_Init_CMockIgnore(void);
+#define TimerConductor_Init_StopIgnore() TimerConductor_Init_CMockStopIgnore()
+void TimerConductor_Init_CMockStopIgnore(void);
+#define TimerConductor_Init_Expect() TimerConductor_Init_CMockExpect(__LINE__)
+void TimerConductor_Init_CMockExpect(UNITY_LINE_TYPE cmock_line);
+#define TimerConductor_Run_Ignore() TimerConductor_Run_CMockIgnore()
+void TimerConductor_Run_CMockIgnore(void);
+#define TimerConductor_Run_StopIgnore() TimerConductor_Run_CMockStopIgnore()
+void TimerConductor_Run_CMockStopIgnore(void);
+#define TimerConductor_Run_Expect() TimerConductor_Run_CMockExpect(__LINE__)
+void TimerConductor_Run_CMockExpect(UNITY_LINE_TYPE cmock_line);
+
+#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))
+#pragma GCC diagnostic pop
+#endif
+#endif
+
+#endif

data/examples/temp_sensor/build/test/mocks/MockTimerConfigurator.c

@@ -0,0 +1,523 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include <string.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include "cmock.h"
+#include "MockTimerConfigurator.h"
+
+static const char* CMockString_Timer_ConfigureInterruptHandler = "Timer_ConfigureInterruptHandler";
+static const char* CMockString_Timer_ConfigureMode = "Timer_ConfigureMode";
+static const char* CMockString_Timer_ConfigurePeriod = "Timer_ConfigurePeriod";
+static const char* CMockString_Timer_Enable = "Timer_Enable";
+static const char* CMockString_Timer_EnableOutputPin = "Timer_EnableOutputPin";
+static const char* CMockString_Timer_EnablePeripheralClocks = "Timer_EnablePeripheralClocks";
+static const char* CMockString_Timer_Reset = "Timer_Reset";
+static const char* CMockString_Timer_Start = "Timer_Start";
+
+typedef struct _CMOCK_Timer_EnablePeripheralClocks_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Timer_EnablePeripheralClocks_CALL_INSTANCE;
+
+typedef struct _CMOCK_Timer_Reset_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Timer_Reset_CALL_INSTANCE;
+
+typedef struct _CMOCK_Timer_ConfigureMode_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Timer_ConfigureMode_CALL_INSTANCE;
+
+typedef struct _CMOCK_Timer_ConfigurePeriod_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Timer_ConfigurePeriod_CALL_INSTANCE;
+
+typedef struct _CMOCK_Timer_EnableOutputPin_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Timer_EnableOutputPin_CALL_INSTANCE;
+
+typedef struct _CMOCK_Timer_Enable_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Timer_Enable_CALL_INSTANCE;
+
+typedef struct _CMOCK_Timer_ConfigureInterruptHandler_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Timer_ConfigureInterruptHandler_CALL_INSTANCE;
+
+typedef struct _CMOCK_Timer_Start_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Timer_Start_CALL_INSTANCE;
+
+static struct MockTimerConfiguratorInstance
+{
+  char Timer_EnablePeripheralClocks_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Timer_EnablePeripheralClocks_CallInstance;
+  char Timer_Reset_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Timer_Reset_CallInstance;
+  char Timer_ConfigureMode_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Timer_ConfigureMode_CallInstance;
+  char Timer_ConfigurePeriod_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Timer_ConfigurePeriod_CallInstance;
+  char Timer_EnableOutputPin_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Timer_EnableOutputPin_CallInstance;
+  char Timer_Enable_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Timer_Enable_CallInstance;
+  char Timer_ConfigureInterruptHandler_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Timer_ConfigureInterruptHandler_CallInstance;
+  char Timer_Start_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Timer_Start_CallInstance;
+} Mock;
+
+extern jmp_buf AbortFrame;
+extern int GlobalExpectCount;
+extern int GlobalVerifyOrder;
+
+void MockTimerConfigurator_Verify(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_MEM_INDEX_TYPE call_instance;
+  call_instance = Mock.Timer_EnablePeripheralClocks_CallInstance;
+  if (Mock.Timer_EnablePeripheralClocks_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Timer_EnablePeripheralClocks);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Timer_Reset_CallInstance;
+  if (Mock.Timer_Reset_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Timer_Reset);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Timer_ConfigureMode_CallInstance;
+  if (Mock.Timer_ConfigureMode_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Timer_ConfigureMode);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Timer_ConfigurePeriod_CallInstance;
+  if (Mock.Timer_ConfigurePeriod_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Timer_ConfigurePeriod);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Timer_EnableOutputPin_CallInstance;
+  if (Mock.Timer_EnableOutputPin_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Timer_EnableOutputPin);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Timer_Enable_CallInstance;
+  if (Mock.Timer_Enable_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Timer_Enable);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Timer_ConfigureInterruptHandler_CallInstance;
+  if (Mock.Timer_ConfigureInterruptHandler_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Timer_ConfigureInterruptHandler);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Timer_Start_CallInstance;
+  if (Mock.Timer_Start_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Timer_Start);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+}
+
+void MockTimerConfigurator_Init(void)
+{
+  MockTimerConfigurator_Destroy();
+}
+
+void MockTimerConfigurator_Destroy(void)
+{
+  CMock_Guts_MemFreeAll();
+  memset(&Mock, 0, sizeof(Mock));
+  GlobalExpectCount = 0;
+  GlobalVerifyOrder = 0;
+}
+
+void Timer_EnablePeripheralClocks(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Timer_EnablePeripheralClocks_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Timer_EnablePeripheralClocks);
+  cmock_call_instance = (CMOCK_Timer_EnablePeripheralClocks_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Timer_EnablePeripheralClocks_CallInstance);
+  Mock.Timer_EnablePeripheralClocks_CallInstance = CMock_Guts_MemNext(Mock.Timer_EnablePeripheralClocks_CallInstance);
+  if (Mock.Timer_EnablePeripheralClocks_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void Timer_EnablePeripheralClocks_CMockIgnore(void)
+{
+  Mock.Timer_EnablePeripheralClocks_IgnoreBool = (char)1;
+}
+
+void Timer_EnablePeripheralClocks_CMockStopIgnore(void)
+{
+  Mock.Timer_EnablePeripheralClocks_IgnoreBool = (char)0;
+}
+
+void Timer_EnablePeripheralClocks_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Timer_EnablePeripheralClocks_CALL_INSTANCE));
+  CMOCK_Timer_EnablePeripheralClocks_CALL_INSTANCE* cmock_call_instance = (CMOCK_Timer_EnablePeripheralClocks_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.Timer_EnablePeripheralClocks_CallInstance = CMock_Guts_MemChain(Mock.Timer_EnablePeripheralClocks_CallInstance, cmock_guts_index);
+  Mock.Timer_EnablePeripheralClocks_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Timer_Reset(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Timer_Reset_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Timer_Reset);
+  cmock_call_instance = (CMOCK_Timer_Reset_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Timer_Reset_CallInstance);
+  Mock.Timer_Reset_CallInstance = CMock_Guts_MemNext(Mock.Timer_Reset_CallInstance);
+  if (Mock.Timer_Reset_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void Timer_Reset_CMockIgnore(void)
+{
+  Mock.Timer_Reset_IgnoreBool = (char)1;
+}
+
+void Timer_Reset_CMockStopIgnore(void)
+{
+  Mock.Timer_Reset_IgnoreBool = (char)0;
+}
+
+void Timer_Reset_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Timer_Reset_CALL_INSTANCE));
+  CMOCK_Timer_Reset_CALL_INSTANCE* cmock_call_instance = (CMOCK_Timer_Reset_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.Timer_Reset_CallInstance = CMock_Guts_MemChain(Mock.Timer_Reset_CallInstance, cmock_guts_index);
+  Mock.Timer_Reset_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Timer_ConfigureMode(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Timer_ConfigureMode_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Timer_ConfigureMode);
+  cmock_call_instance = (CMOCK_Timer_ConfigureMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Timer_ConfigureMode_CallInstance);
+  Mock.Timer_ConfigureMode_CallInstance = CMock_Guts_MemNext(Mock.Timer_ConfigureMode_CallInstance);
+  if (Mock.Timer_ConfigureMode_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void Timer_ConfigureMode_CMockIgnore(void)
+{
+  Mock.Timer_ConfigureMode_IgnoreBool = (char)1;
+}
+
+void Timer_ConfigureMode_CMockStopIgnore(void)
+{
+  Mock.Timer_ConfigureMode_IgnoreBool = (char)0;
+}
+
+void Timer_ConfigureMode_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Timer_ConfigureMode_CALL_INSTANCE));
+  CMOCK_Timer_ConfigureMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_Timer_ConfigureMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.Timer_ConfigureMode_CallInstance = CMock_Guts_MemChain(Mock.Timer_ConfigureMode_CallInstance, cmock_guts_index);
+  Mock.Timer_ConfigureMode_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Timer_ConfigurePeriod(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Timer_ConfigurePeriod_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Timer_ConfigurePeriod);
+  cmock_call_instance = (CMOCK_Timer_ConfigurePeriod_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Timer_ConfigurePeriod_CallInstance);
+  Mock.Timer_ConfigurePeriod_CallInstance = CMock_Guts_MemNext(Mock.Timer_ConfigurePeriod_CallInstance);
+  if (Mock.Timer_ConfigurePeriod_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void Timer_ConfigurePeriod_CMockIgnore(void)
+{
+  Mock.Timer_ConfigurePeriod_IgnoreBool = (char)1;
+}
+
+void Timer_ConfigurePeriod_CMockStopIgnore(void)
+{
+  Mock.Timer_ConfigurePeriod_IgnoreBool = (char)0;
+}
+
+void Timer_ConfigurePeriod_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Timer_ConfigurePeriod_CALL_INSTANCE));
+  CMOCK_Timer_ConfigurePeriod_CALL_INSTANCE* cmock_call_instance = (CMOCK_Timer_ConfigurePeriod_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.Timer_ConfigurePeriod_CallInstance = CMock_Guts_MemChain(Mock.Timer_ConfigurePeriod_CallInstance, cmock_guts_index);
+  Mock.Timer_ConfigurePeriod_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Timer_EnableOutputPin(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Timer_EnableOutputPin_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Timer_EnableOutputPin);
+  cmock_call_instance = (CMOCK_Timer_EnableOutputPin_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Timer_EnableOutputPin_CallInstance);
+  Mock.Timer_EnableOutputPin_CallInstance = CMock_Guts_MemNext(Mock.Timer_EnableOutputPin_CallInstance);
+  if (Mock.Timer_EnableOutputPin_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void Timer_EnableOutputPin_CMockIgnore(void)
+{
+  Mock.Timer_EnableOutputPin_IgnoreBool = (char)1;
+}
+
+void Timer_EnableOutputPin_CMockStopIgnore(void)
+{
+  Mock.Timer_EnableOutputPin_IgnoreBool = (char)0;
+}
+
+void Timer_EnableOutputPin_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Timer_EnableOutputPin_CALL_INSTANCE));
+  CMOCK_Timer_EnableOutputPin_CALL_INSTANCE* cmock_call_instance = (CMOCK_Timer_EnableOutputPin_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.Timer_EnableOutputPin_CallInstance = CMock_Guts_MemChain(Mock.Timer_EnableOutputPin_CallInstance, cmock_guts_index);
+  Mock.Timer_EnableOutputPin_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Timer_Enable(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Timer_Enable_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Timer_Enable);
+  cmock_call_instance = (CMOCK_Timer_Enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Timer_Enable_CallInstance);
+  Mock.Timer_Enable_CallInstance = CMock_Guts_MemNext(Mock.Timer_Enable_CallInstance);
+  if (Mock.Timer_Enable_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void Timer_Enable_CMockIgnore(void)
+{
+  Mock.Timer_Enable_IgnoreBool = (char)1;
+}
+
+void Timer_Enable_CMockStopIgnore(void)
+{
+  Mock.Timer_Enable_IgnoreBool = (char)0;
+}
+
+void Timer_Enable_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Timer_Enable_CALL_INSTANCE));
+  CMOCK_Timer_Enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_Timer_Enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.Timer_Enable_CallInstance = CMock_Guts_MemChain(Mock.Timer_Enable_CallInstance, cmock_guts_index);
+  Mock.Timer_Enable_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Timer_ConfigureInterruptHandler(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Timer_ConfigureInterruptHandler_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Timer_ConfigureInterruptHandler);
+  cmock_call_instance = (CMOCK_Timer_ConfigureInterruptHandler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Timer_ConfigureInterruptHandler_CallInstance);
+  Mock.Timer_ConfigureInterruptHandler_CallInstance = CMock_Guts_MemNext(Mock.Timer_ConfigureInterruptHandler_CallInstance);
+  if (Mock.Timer_ConfigureInterruptHandler_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void Timer_ConfigureInterruptHandler_CMockIgnore(void)
+{
+  Mock.Timer_ConfigureInterruptHandler_IgnoreBool = (char)1;
+}
+
+void Timer_ConfigureInterruptHandler_CMockStopIgnore(void)
+{
+  Mock.Timer_ConfigureInterruptHandler_IgnoreBool = (char)0;
+}
+
+void Timer_ConfigureInterruptHandler_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Timer_ConfigureInterruptHandler_CALL_INSTANCE));
+  CMOCK_Timer_ConfigureInterruptHandler_CALL_INSTANCE* cmock_call_instance = (CMOCK_Timer_ConfigureInterruptHandler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.Timer_ConfigureInterruptHandler_CallInstance = CMock_Guts_MemChain(Mock.Timer_ConfigureInterruptHandler_CallInstance, cmock_guts_index);
+  Mock.Timer_ConfigureInterruptHandler_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Timer_Start(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Timer_Start_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Timer_Start);
+  cmock_call_instance = (CMOCK_Timer_Start_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Timer_Start_CallInstance);
+  Mock.Timer_Start_CallInstance = CMock_Guts_MemNext(Mock.Timer_Start_CallInstance);
+  if (Mock.Timer_Start_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    return;
+  }
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
+  cmock_line = cmock_call_instance->LineNumber;
+  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);
+  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);
+  UNITY_CLR_DETAILS();
+}
+
+void Timer_Start_CMockIgnore(void)
+{
+  Mock.Timer_Start_IgnoreBool = (char)1;
+}
+
+void Timer_Start_CMockStopIgnore(void)
+{
+  Mock.Timer_Start_IgnoreBool = (char)0;
+}
+
+void Timer_Start_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Timer_Start_CALL_INSTANCE));
+  CMOCK_Timer_Start_CALL_INSTANCE* cmock_call_instance = (CMOCK_Timer_Start_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
+  memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
+  Mock.Timer_Start_CallInstance = CMock_Guts_MemChain(Mock.Timer_Start_CallInstance, cmock_guts_index);
+  Mock.Timer_Start_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+