ceedling 0.30.0 → 0.31.0

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

@@ -0,0 +1,46 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#ifndef _MOCKEXECUTOR_H
+#define _MOCKEXECUTOR_H
+
+#include "unity.h"
+#include "Executor.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 MockExecutor_Init(void);
+void MockExecutor_Destroy(void);
+void MockExecutor_Verify(void);
+
+
+
+
+#define Executor_Init_Ignore() Executor_Init_CMockIgnore()
+void Executor_Init_CMockIgnore(void);
+#define Executor_Init_StopIgnore() Executor_Init_CMockStopIgnore()
+void Executor_Init_CMockStopIgnore(void);
+#define Executor_Init_Expect() Executor_Init_CMockExpect(__LINE__)
+void Executor_Init_CMockExpect(UNITY_LINE_TYPE cmock_line);
+#define Executor_Run_IgnoreAndReturn(cmock_retval) Executor_Run_CMockIgnoreAndReturn(__LINE__, cmock_retval)
+void Executor_Run_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+#define Executor_Run_StopIgnore() Executor_Run_CMockStopIgnore()
+void Executor_Run_CMockStopIgnore(void);
+#define Executor_Run_ExpectAndReturn(cmock_retval) Executor_Run_CMockExpectAndReturn(__LINE__, cmock_retval)
+void Executor_Run_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+
+#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/MockIntrinsicsWrapper.c

@@ -0,0 +1,157 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include <string.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include "cmock.h"
+#include "MockIntrinsicsWrapper.h"
+
+static const char* CMockString_Interrupt_Disable = "Interrupt_Disable";
+static const char* CMockString_Interrupt_Enable = "Interrupt_Enable";
+
+typedef struct _CMOCK_Interrupt_Enable_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Interrupt_Enable_CALL_INSTANCE;
+
+typedef struct _CMOCK_Interrupt_Disable_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Interrupt_Disable_CALL_INSTANCE;
+
+static struct MockIntrinsicsWrapperInstance
+{
+  char Interrupt_Enable_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Interrupt_Enable_CallInstance;
+  char Interrupt_Disable_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Interrupt_Disable_CallInstance;
+} Mock;
+
+extern jmp_buf AbortFrame;
+extern int GlobalExpectCount;
+extern int GlobalVerifyOrder;
+
+void MockIntrinsicsWrapper_Verify(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_MEM_INDEX_TYPE call_instance;
+  call_instance = Mock.Interrupt_Enable_CallInstance;
+  if (Mock.Interrupt_Enable_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Interrupt_Enable);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Interrupt_Disable_CallInstance;
+  if (Mock.Interrupt_Disable_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Interrupt_Disable);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+}
+
+void MockIntrinsicsWrapper_Init(void)
+{
+  MockIntrinsicsWrapper_Destroy();
+}
+
+void MockIntrinsicsWrapper_Destroy(void)
+{
+  CMock_Guts_MemFreeAll();
+  memset(&Mock, 0, sizeof(Mock));
+  GlobalExpectCount = 0;
+  GlobalVerifyOrder = 0;
+}
+
+void Interrupt_Enable(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Interrupt_Enable_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Interrupt_Enable);
+  cmock_call_instance = (CMOCK_Interrupt_Enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Interrupt_Enable_CallInstance);
+  Mock.Interrupt_Enable_CallInstance = CMock_Guts_MemNext(Mock.Interrupt_Enable_CallInstance);
+  if (Mock.Interrupt_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 Interrupt_Enable_CMockIgnore(void)
+{
+  Mock.Interrupt_Enable_IgnoreBool = (char)1;
+}
+
+void Interrupt_Enable_CMockStopIgnore(void)
+{
+  Mock.Interrupt_Enable_IgnoreBool = (char)0;
+}
+
+void Interrupt_Enable_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Interrupt_Enable_CALL_INSTANCE));
+  CMOCK_Interrupt_Enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_Interrupt_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.Interrupt_Enable_CallInstance = CMock_Guts_MemChain(Mock.Interrupt_Enable_CallInstance, cmock_guts_index);
+  Mock.Interrupt_Enable_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Interrupt_Disable(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Interrupt_Disable_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Interrupt_Disable);
+  cmock_call_instance = (CMOCK_Interrupt_Disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Interrupt_Disable_CallInstance);
+  Mock.Interrupt_Disable_CallInstance = CMock_Guts_MemNext(Mock.Interrupt_Disable_CallInstance);
+  if (Mock.Interrupt_Disable_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 Interrupt_Disable_CMockIgnore(void)
+{
+  Mock.Interrupt_Disable_IgnoreBool = (char)1;
+}
+
+void Interrupt_Disable_CMockStopIgnore(void)
+{
+  Mock.Interrupt_Disable_IgnoreBool = (char)0;
+}
+
+void Interrupt_Disable_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Interrupt_Disable_CALL_INSTANCE));
+  CMOCK_Interrupt_Disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_Interrupt_Disable_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.Interrupt_Disable_CallInstance = CMock_Guts_MemChain(Mock.Interrupt_Disable_CallInstance, cmock_guts_index);
+  Mock.Interrupt_Disable_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+

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

@@ -0,0 +1,46 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#ifndef _MOCKINTRINSICSWRAPPER_H
+#define _MOCKINTRINSICSWRAPPER_H
+
+#include "unity.h"
+#include "IntrinsicsWrapper.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 MockIntrinsicsWrapper_Init(void);
+void MockIntrinsicsWrapper_Destroy(void);
+void MockIntrinsicsWrapper_Verify(void);
+
+
+
+
+#define Interrupt_Enable_Ignore() Interrupt_Enable_CMockIgnore()
+void Interrupt_Enable_CMockIgnore(void);
+#define Interrupt_Enable_StopIgnore() Interrupt_Enable_CMockStopIgnore()
+void Interrupt_Enable_CMockStopIgnore(void);
+#define Interrupt_Enable_Expect() Interrupt_Enable_CMockExpect(__LINE__)
+void Interrupt_Enable_CMockExpect(UNITY_LINE_TYPE cmock_line);
+#define Interrupt_Disable_Ignore() Interrupt_Disable_CMockIgnore()
+void Interrupt_Disable_CMockIgnore(void);
+#define Interrupt_Disable_StopIgnore() Interrupt_Disable_CMockStopIgnore()
+void Interrupt_Disable_CMockStopIgnore(void);
+#define Interrupt_Disable_Expect() Interrupt_Disable_CMockExpect(__LINE__)
+void Interrupt_Disable_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/MockModel.c

@@ -0,0 +1,96 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include <string.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include "cmock.h"
+#include "MockModel.h"
+
+static const char* CMockString_Model_Init = "Model_Init";
+
+typedef struct _CMOCK_Model_Init_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Model_Init_CALL_INSTANCE;
+
+static struct MockModelInstance
+{
+  char Model_Init_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Model_Init_CallInstance;
+} Mock;
+
+extern jmp_buf AbortFrame;
+extern int GlobalExpectCount;
+extern int GlobalVerifyOrder;
+
+void MockModel_Verify(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_MEM_INDEX_TYPE call_instance;
+  call_instance = Mock.Model_Init_CallInstance;
+  if (Mock.Model_Init_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Model_Init);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+}
+
+void MockModel_Init(void)
+{
+  MockModel_Destroy();
+}
+
+void MockModel_Destroy(void)
+{
+  CMock_Guts_MemFreeAll();
+  memset(&Mock, 0, sizeof(Mock));
+  GlobalExpectCount = 0;
+  GlobalVerifyOrder = 0;
+}
+
+void Model_Init(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Model_Init_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Model_Init);
+  cmock_call_instance = (CMOCK_Model_Init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Model_Init_CallInstance);
+  Mock.Model_Init_CallInstance = CMock_Guts_MemNext(Mock.Model_Init_CallInstance);
+  if (Mock.Model_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 Model_Init_CMockIgnore(void)
+{
+  Mock.Model_Init_IgnoreBool = (char)1;
+}
+
+void Model_Init_CMockStopIgnore(void)
+{
+  Mock.Model_Init_IgnoreBool = (char)0;
+}
+
+void Model_Init_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Model_Init_CALL_INSTANCE));
+  CMOCK_Model_Init_CALL_INSTANCE* cmock_call_instance = (CMOCK_Model_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.Model_Init_CallInstance = CMock_Guts_MemChain(Mock.Model_Init_CallInstance, cmock_guts_index);
+  Mock.Model_Init_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+

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

@@ -0,0 +1,40 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#ifndef _MOCKMODEL_H
+#define _MOCKMODEL_H
+
+#include "unity.h"
+#include "Model.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 MockModel_Init(void);
+void MockModel_Destroy(void);
+void MockModel_Verify(void);
+
+
+
+
+#define Model_Init_Ignore() Model_Init_CMockIgnore()
+void Model_Init_CMockIgnore(void);
+#define Model_Init_StopIgnore() Model_Init_CMockStopIgnore()
+void Model_Init_CMockStopIgnore(void);
+#define Model_Init_Expect() Model_Init_CMockExpect(__LINE__)
+void Model_Init_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/MockTaskScheduler.c

@@ -0,0 +1,326 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include <string.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include "cmock.h"
+#include "MockTaskScheduler.h"
+
+static const char* CMockString_TaskScheduler_DoAdc = "TaskScheduler_DoAdc";
+static const char* CMockString_TaskScheduler_DoUsart = "TaskScheduler_DoUsart";
+static const char* CMockString_TaskScheduler_Init = "TaskScheduler_Init";
+static const char* CMockString_TaskScheduler_Update = "TaskScheduler_Update";
+static const char* CMockString_time = "time";
+
+typedef struct _CMOCK_TaskScheduler_Init_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_TaskScheduler_Init_CALL_INSTANCE;
+
+typedef struct _CMOCK_TaskScheduler_Update_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+  uint32 Expected_time;
+
+} CMOCK_TaskScheduler_Update_CALL_INSTANCE;
+
+typedef struct _CMOCK_TaskScheduler_DoUsart_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  bool ReturnVal;
+  int CallOrder;
+
+} CMOCK_TaskScheduler_DoUsart_CALL_INSTANCE;
+
+typedef struct _CMOCK_TaskScheduler_DoAdc_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  bool ReturnVal;
+  int CallOrder;
+
+} CMOCK_TaskScheduler_DoAdc_CALL_INSTANCE;
+
+static struct MockTaskSchedulerInstance
+{
+  char TaskScheduler_Init_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE TaskScheduler_Init_CallInstance;
+  char TaskScheduler_Update_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE TaskScheduler_Update_CallInstance;
+  char TaskScheduler_DoUsart_IgnoreBool;
+  bool TaskScheduler_DoUsart_FinalReturn;
+  CMOCK_MEM_INDEX_TYPE TaskScheduler_DoUsart_CallInstance;
+  char TaskScheduler_DoAdc_IgnoreBool;
+  bool TaskScheduler_DoAdc_FinalReturn;
+  CMOCK_MEM_INDEX_TYPE TaskScheduler_DoAdc_CallInstance;
+} Mock;
+
+extern jmp_buf AbortFrame;
+extern int GlobalExpectCount;
+extern int GlobalVerifyOrder;
+
+void MockTaskScheduler_Verify(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_MEM_INDEX_TYPE call_instance;
+  call_instance = Mock.TaskScheduler_Init_CallInstance;
+  if (Mock.TaskScheduler_Init_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_TaskScheduler_Init);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.TaskScheduler_Update_CallInstance;
+  if (Mock.TaskScheduler_Update_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_TaskScheduler_Update);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.TaskScheduler_DoUsart_CallInstance;
+  if (Mock.TaskScheduler_DoUsart_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_TaskScheduler_DoUsart);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.TaskScheduler_DoAdc_CallInstance;
+  if (Mock.TaskScheduler_DoAdc_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_TaskScheduler_DoAdc);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+}
+
+void MockTaskScheduler_Init(void)
+{
+  MockTaskScheduler_Destroy();
+}
+
+void MockTaskScheduler_Destroy(void)
+{
+  CMock_Guts_MemFreeAll();
+  memset(&Mock, 0, sizeof(Mock));
+  GlobalExpectCount = 0;
+  GlobalVerifyOrder = 0;
+}
+
+void TaskScheduler_Init(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_TaskScheduler_Init_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_TaskScheduler_Init);
+  cmock_call_instance = (CMOCK_TaskScheduler_Init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.TaskScheduler_Init_CallInstance);
+  Mock.TaskScheduler_Init_CallInstance = CMock_Guts_MemNext(Mock.TaskScheduler_Init_CallInstance);
+  if (Mock.TaskScheduler_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 TaskScheduler_Init_CMockIgnore(void)
+{
+  Mock.TaskScheduler_Init_IgnoreBool = (char)1;
+}
+
+void TaskScheduler_Init_CMockStopIgnore(void)
+{
+  Mock.TaskScheduler_Init_IgnoreBool = (char)0;
+}
+
+void TaskScheduler_Init_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_TaskScheduler_Init_CALL_INSTANCE));
+  CMOCK_TaskScheduler_Init_CALL_INSTANCE* cmock_call_instance = (CMOCK_TaskScheduler_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.TaskScheduler_Init_CallInstance = CMock_Guts_MemChain(Mock.TaskScheduler_Init_CallInstance, cmock_guts_index);
+  Mock.TaskScheduler_Init_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void TaskScheduler_Update(uint32 time)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_TaskScheduler_Update_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_TaskScheduler_Update);
+  cmock_call_instance = (CMOCK_TaskScheduler_Update_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.TaskScheduler_Update_CallInstance);
+  Mock.TaskScheduler_Update_CallInstance = CMock_Guts_MemNext(Mock.TaskScheduler_Update_CallInstance);
+  if (Mock.TaskScheduler_Update_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_SET_DETAILS(CMockString_TaskScheduler_Update,CMockString_time);
+    UNITY_TEST_ASSERT_EQUAL_UINT32(cmock_call_instance->Expected_time, time, cmock_line, CMockStringMismatch);
+  }
+  UNITY_CLR_DETAILS();
+}
+
+void CMockExpectParameters_TaskScheduler_Update(CMOCK_TaskScheduler_Update_CALL_INSTANCE* cmock_call_instance, uint32 time);
+void CMockExpectParameters_TaskScheduler_Update(CMOCK_TaskScheduler_Update_CALL_INSTANCE* cmock_call_instance, uint32 time)
+{
+  cmock_call_instance->Expected_time = time;
+}
+
+void TaskScheduler_Update_CMockIgnore(void)
+{
+  Mock.TaskScheduler_Update_IgnoreBool = (char)1;
+}
+
+void TaskScheduler_Update_CMockStopIgnore(void)
+{
+  Mock.TaskScheduler_Update_IgnoreBool = (char)0;
+}
+
+void TaskScheduler_Update_CMockExpect(UNITY_LINE_TYPE cmock_line, uint32 time)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_TaskScheduler_Update_CALL_INSTANCE));
+  CMOCK_TaskScheduler_Update_CALL_INSTANCE* cmock_call_instance = (CMOCK_TaskScheduler_Update_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.TaskScheduler_Update_CallInstance = CMock_Guts_MemChain(Mock.TaskScheduler_Update_CallInstance, cmock_guts_index);
+  Mock.TaskScheduler_Update_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+  CMockExpectParameters_TaskScheduler_Update(cmock_call_instance, time);
+}
+
+bool TaskScheduler_DoUsart(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_TaskScheduler_DoUsart_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_TaskScheduler_DoUsart);
+  cmock_call_instance = (CMOCK_TaskScheduler_DoUsart_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.TaskScheduler_DoUsart_CallInstance);
+  Mock.TaskScheduler_DoUsart_CallInstance = CMock_Guts_MemNext(Mock.TaskScheduler_DoUsart_CallInstance);
+  if (Mock.TaskScheduler_DoUsart_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    if (cmock_call_instance == NULL)
+      return Mock.TaskScheduler_DoUsart_FinalReturn;
+    Mock.TaskScheduler_DoUsart_FinalReturn = cmock_call_instance->ReturnVal;
+    return cmock_call_instance->ReturnVal;
+  }
+  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();
+  return cmock_call_instance->ReturnVal;
+}
+
+void TaskScheduler_DoUsart_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_TaskScheduler_DoUsart_CALL_INSTANCE));
+  CMOCK_TaskScheduler_DoUsart_CALL_INSTANCE* cmock_call_instance = (CMOCK_TaskScheduler_DoUsart_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.TaskScheduler_DoUsart_CallInstance = CMock_Guts_MemChain(Mock.TaskScheduler_DoUsart_CallInstance, cmock_guts_index);
+  Mock.TaskScheduler_DoUsart_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->ReturnVal = cmock_to_return;
+  Mock.TaskScheduler_DoUsart_IgnoreBool = (char)1;
+}
+
+void TaskScheduler_DoUsart_CMockStopIgnore(void)
+{
+  if(Mock.TaskScheduler_DoUsart_IgnoreBool)
+    Mock.TaskScheduler_DoUsart_CallInstance = CMock_Guts_MemNext(Mock.TaskScheduler_DoUsart_CallInstance);
+  Mock.TaskScheduler_DoUsart_IgnoreBool = (char)0;
+}
+
+void TaskScheduler_DoUsart_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_TaskScheduler_DoUsart_CALL_INSTANCE));
+  CMOCK_TaskScheduler_DoUsart_CALL_INSTANCE* cmock_call_instance = (CMOCK_TaskScheduler_DoUsart_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.TaskScheduler_DoUsart_CallInstance = CMock_Guts_MemChain(Mock.TaskScheduler_DoUsart_CallInstance, cmock_guts_index);
+  Mock.TaskScheduler_DoUsart_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+  cmock_call_instance->ReturnVal = cmock_to_return;
+}
+
+bool TaskScheduler_DoAdc(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_TaskScheduler_DoAdc_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_TaskScheduler_DoAdc);
+  cmock_call_instance = (CMOCK_TaskScheduler_DoAdc_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.TaskScheduler_DoAdc_CallInstance);
+  Mock.TaskScheduler_DoAdc_CallInstance = CMock_Guts_MemNext(Mock.TaskScheduler_DoAdc_CallInstance);
+  if (Mock.TaskScheduler_DoAdc_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    if (cmock_call_instance == NULL)
+      return Mock.TaskScheduler_DoAdc_FinalReturn;
+    Mock.TaskScheduler_DoAdc_FinalReturn = cmock_call_instance->ReturnVal;
+    return cmock_call_instance->ReturnVal;
+  }
+  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();
+  return cmock_call_instance->ReturnVal;
+}
+
+void TaskScheduler_DoAdc_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_TaskScheduler_DoAdc_CALL_INSTANCE));
+  CMOCK_TaskScheduler_DoAdc_CALL_INSTANCE* cmock_call_instance = (CMOCK_TaskScheduler_DoAdc_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.TaskScheduler_DoAdc_CallInstance = CMock_Guts_MemChain(Mock.TaskScheduler_DoAdc_CallInstance, cmock_guts_index);
+  Mock.TaskScheduler_DoAdc_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->ReturnVal = cmock_to_return;
+  Mock.TaskScheduler_DoAdc_IgnoreBool = (char)1;
+}
+
+void TaskScheduler_DoAdc_CMockStopIgnore(void)
+{
+  if(Mock.TaskScheduler_DoAdc_IgnoreBool)
+    Mock.TaskScheduler_DoAdc_CallInstance = CMock_Guts_MemNext(Mock.TaskScheduler_DoAdc_CallInstance);
+  Mock.TaskScheduler_DoAdc_IgnoreBool = (char)0;
+}
+
+void TaskScheduler_DoAdc_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_TaskScheduler_DoAdc_CALL_INSTANCE));
+  CMOCK_TaskScheduler_DoAdc_CALL_INSTANCE* cmock_call_instance = (CMOCK_TaskScheduler_DoAdc_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.TaskScheduler_DoAdc_CallInstance = CMock_Guts_MemChain(Mock.TaskScheduler_DoAdc_CallInstance, cmock_guts_index);
+  Mock.TaskScheduler_DoAdc_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+  cmock_call_instance->ReturnVal = cmock_to_return;
+}
+