ceedling 0.30.0 → 0.31.0

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

@@ -0,0 +1,64 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#ifndef _MOCKADCCONDUCTOR_H
+#define _MOCKADCCONDUCTOR_H
+
+#include "unity.h"
+#include "AdcConductor.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 MockAdcConductor_Init(void);
+void MockAdcConductor_Destroy(void);
+void MockAdcConductor_Verify(void);
+
+
+
+
+#define AdcConductor_Init_Ignore() AdcConductor_Init_CMockIgnore()
+void AdcConductor_Init_CMockIgnore(void);
+#define AdcConductor_Init_StopIgnore() AdcConductor_Init_CMockStopIgnore()
+void AdcConductor_Init_CMockStopIgnore(void);
+#define AdcConductor_Init_Expect() AdcConductor_Init_CMockExpect(__LINE__)
+void AdcConductor_Init_CMockExpect(UNITY_LINE_TYPE cmock_line);
+#define AdcConductor_Run_Ignore() AdcConductor_Run_CMockIgnore()
+void AdcConductor_Run_CMockIgnore(void);
+#define AdcConductor_Run_StopIgnore() AdcConductor_Run_CMockStopIgnore()
+void AdcConductor_Run_CMockStopIgnore(void);
+#define AdcConductor_Run_Expect() AdcConductor_Run_CMockExpect(__LINE__)
+void AdcConductor_Run_CMockExpect(UNITY_LINE_TYPE cmock_line);
+#define AdcConductor_JustHereToTest_IgnoreAndReturn(cmock_retval) AdcConductor_JustHereToTest_CMockIgnoreAndReturn(__LINE__, cmock_retval)
+void AdcConductor_JustHereToTest_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+#define AdcConductor_JustHereToTest_StopIgnore() AdcConductor_JustHereToTest_CMockStopIgnore()
+void AdcConductor_JustHereToTest_CMockStopIgnore(void);
+#define AdcConductor_JustHereToTest_ExpectAndReturn(cmock_retval) AdcConductor_JustHereToTest_CMockExpectAndReturn(__LINE__, cmock_retval)
+void AdcConductor_JustHereToTest_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+#define AdcConductor_AlsoHereToTest_IgnoreAndReturn(cmock_retval) AdcConductor_AlsoHereToTest_CMockIgnoreAndReturn(__LINE__, cmock_retval)
+void AdcConductor_AlsoHereToTest_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+#define AdcConductor_AlsoHereToTest_StopIgnore() AdcConductor_AlsoHereToTest_CMockStopIgnore()
+void AdcConductor_AlsoHereToTest_CMockStopIgnore(void);
+#define AdcConductor_AlsoHereToTest_ExpectAndReturn(cmock_retval) AdcConductor_AlsoHereToTest_CMockExpectAndReturn(__LINE__, cmock_retval)
+void AdcConductor_AlsoHereToTest_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+#define AdcConductor_YetAnotherTest_IgnoreAndReturn(cmock_retval) AdcConductor_YetAnotherTest_CMockIgnoreAndReturn(__LINE__, cmock_retval)
+void AdcConductor_YetAnotherTest_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+#define AdcConductor_YetAnotherTest_StopIgnore() AdcConductor_YetAnotherTest_CMockStopIgnore()
+void AdcConductor_YetAnotherTest_CMockStopIgnore(void);
+#define AdcConductor_YetAnotherTest_ExpectAndReturn(cmock_retval) AdcConductor_YetAnotherTest_CMockExpectAndReturn(__LINE__, cmock_retval)
+void AdcConductor_YetAnotherTest_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/MockAdcHardware.c

@@ -0,0 +1,313 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include <string.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include "cmock.h"
+#include "MockAdcHardware.h"
+
+static const char* CMockString_AdcHardware_GetSample = "AdcHardware_GetSample";
+static const char* CMockString_AdcHardware_GetSampleComplete = "AdcHardware_GetSampleComplete";
+static const char* CMockString_AdcHardware_Init = "AdcHardware_Init";
+static const char* CMockString_AdcHardware_StartConversion = "AdcHardware_StartConversion";
+
+typedef struct _CMOCK_AdcHardware_Init_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_AdcHardware_Init_CALL_INSTANCE;
+
+typedef struct _CMOCK_AdcHardware_StartConversion_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_AdcHardware_StartConversion_CALL_INSTANCE;
+
+typedef struct _CMOCK_AdcHardware_GetSampleComplete_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  bool ReturnVal;
+  int CallOrder;
+
+} CMOCK_AdcHardware_GetSampleComplete_CALL_INSTANCE;
+
+typedef struct _CMOCK_AdcHardware_GetSample_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  uint16 ReturnVal;
+  int CallOrder;
+
+} CMOCK_AdcHardware_GetSample_CALL_INSTANCE;
+
+static struct MockAdcHardwareInstance
+{
+  char AdcHardware_Init_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE AdcHardware_Init_CallInstance;
+  char AdcHardware_StartConversion_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE AdcHardware_StartConversion_CallInstance;
+  char AdcHardware_GetSampleComplete_IgnoreBool;
+  bool AdcHardware_GetSampleComplete_FinalReturn;
+  CMOCK_MEM_INDEX_TYPE AdcHardware_GetSampleComplete_CallInstance;
+  char AdcHardware_GetSample_IgnoreBool;
+  uint16 AdcHardware_GetSample_FinalReturn;
+  CMOCK_MEM_INDEX_TYPE AdcHardware_GetSample_CallInstance;
+} Mock;
+
+extern jmp_buf AbortFrame;
+extern int GlobalExpectCount;
+extern int GlobalVerifyOrder;
+
+void MockAdcHardware_Verify(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_MEM_INDEX_TYPE call_instance;
+  call_instance = Mock.AdcHardware_Init_CallInstance;
+  if (Mock.AdcHardware_Init_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_AdcHardware_Init);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.AdcHardware_StartConversion_CallInstance;
+  if (Mock.AdcHardware_StartConversion_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_AdcHardware_StartConversion);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.AdcHardware_GetSampleComplete_CallInstance;
+  if (Mock.AdcHardware_GetSampleComplete_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_AdcHardware_GetSampleComplete);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.AdcHardware_GetSample_CallInstance;
+  if (Mock.AdcHardware_GetSample_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_AdcHardware_GetSample);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+}
+
+void MockAdcHardware_Init(void)
+{
+  MockAdcHardware_Destroy();
+}
+
+void MockAdcHardware_Destroy(void)
+{
+  CMock_Guts_MemFreeAll();
+  memset(&Mock, 0, sizeof(Mock));
+  GlobalExpectCount = 0;
+  GlobalVerifyOrder = 0;
+}
+
+void AdcHardware_Init(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_AdcHardware_Init_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_AdcHardware_Init);
+  cmock_call_instance = (CMOCK_AdcHardware_Init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.AdcHardware_Init_CallInstance);
+  Mock.AdcHardware_Init_CallInstance = CMock_Guts_MemNext(Mock.AdcHardware_Init_CallInstance);
+  if (Mock.AdcHardware_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 AdcHardware_Init_CMockIgnore(void)
+{
+  Mock.AdcHardware_Init_IgnoreBool = (char)1;
+}
+
+void AdcHardware_Init_CMockStopIgnore(void)
+{
+  Mock.AdcHardware_Init_IgnoreBool = (char)0;
+}
+
+void AdcHardware_Init_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_AdcHardware_Init_CALL_INSTANCE));
+  CMOCK_AdcHardware_Init_CALL_INSTANCE* cmock_call_instance = (CMOCK_AdcHardware_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.AdcHardware_Init_CallInstance = CMock_Guts_MemChain(Mock.AdcHardware_Init_CallInstance, cmock_guts_index);
+  Mock.AdcHardware_Init_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void AdcHardware_StartConversion(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_AdcHardware_StartConversion_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_AdcHardware_StartConversion);
+  cmock_call_instance = (CMOCK_AdcHardware_StartConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.AdcHardware_StartConversion_CallInstance);
+  Mock.AdcHardware_StartConversion_CallInstance = CMock_Guts_MemNext(Mock.AdcHardware_StartConversion_CallInstance);
+  if (Mock.AdcHardware_StartConversion_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 AdcHardware_StartConversion_CMockIgnore(void)
+{
+  Mock.AdcHardware_StartConversion_IgnoreBool = (char)1;
+}
+
+void AdcHardware_StartConversion_CMockStopIgnore(void)
+{
+  Mock.AdcHardware_StartConversion_IgnoreBool = (char)0;
+}
+
+void AdcHardware_StartConversion_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_AdcHardware_StartConversion_CALL_INSTANCE));
+  CMOCK_AdcHardware_StartConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_AdcHardware_StartConversion_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.AdcHardware_StartConversion_CallInstance = CMock_Guts_MemChain(Mock.AdcHardware_StartConversion_CallInstance, cmock_guts_index);
+  Mock.AdcHardware_StartConversion_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+bool AdcHardware_GetSampleComplete(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_AdcHardware_GetSampleComplete_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_AdcHardware_GetSampleComplete);
+  cmock_call_instance = (CMOCK_AdcHardware_GetSampleComplete_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.AdcHardware_GetSampleComplete_CallInstance);
+  Mock.AdcHardware_GetSampleComplete_CallInstance = CMock_Guts_MemNext(Mock.AdcHardware_GetSampleComplete_CallInstance);
+  if (Mock.AdcHardware_GetSampleComplete_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    if (cmock_call_instance == NULL)
+      return Mock.AdcHardware_GetSampleComplete_FinalReturn;
+    Mock.AdcHardware_GetSampleComplete_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 AdcHardware_GetSampleComplete_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_AdcHardware_GetSampleComplete_CALL_INSTANCE));
+  CMOCK_AdcHardware_GetSampleComplete_CALL_INSTANCE* cmock_call_instance = (CMOCK_AdcHardware_GetSampleComplete_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.AdcHardware_GetSampleComplete_CallInstance = CMock_Guts_MemChain(Mock.AdcHardware_GetSampleComplete_CallInstance, cmock_guts_index);
+  Mock.AdcHardware_GetSampleComplete_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->ReturnVal = cmock_to_return;
+  Mock.AdcHardware_GetSampleComplete_IgnoreBool = (char)1;
+}
+
+void AdcHardware_GetSampleComplete_CMockStopIgnore(void)
+{
+  if(Mock.AdcHardware_GetSampleComplete_IgnoreBool)
+    Mock.AdcHardware_GetSampleComplete_CallInstance = CMock_Guts_MemNext(Mock.AdcHardware_GetSampleComplete_CallInstance);
+  Mock.AdcHardware_GetSampleComplete_IgnoreBool = (char)0;
+}
+
+void AdcHardware_GetSampleComplete_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_AdcHardware_GetSampleComplete_CALL_INSTANCE));
+  CMOCK_AdcHardware_GetSampleComplete_CALL_INSTANCE* cmock_call_instance = (CMOCK_AdcHardware_GetSampleComplete_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.AdcHardware_GetSampleComplete_CallInstance = CMock_Guts_MemChain(Mock.AdcHardware_GetSampleComplete_CallInstance, cmock_guts_index);
+  Mock.AdcHardware_GetSampleComplete_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+  cmock_call_instance->ReturnVal = cmock_to_return;
+}
+
+uint16 AdcHardware_GetSample(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_AdcHardware_GetSample_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_AdcHardware_GetSample);
+  cmock_call_instance = (CMOCK_AdcHardware_GetSample_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.AdcHardware_GetSample_CallInstance);
+  Mock.AdcHardware_GetSample_CallInstance = CMock_Guts_MemNext(Mock.AdcHardware_GetSample_CallInstance);
+  if (Mock.AdcHardware_GetSample_IgnoreBool)
+  {
+    UNITY_CLR_DETAILS();
+    if (cmock_call_instance == NULL)
+      return Mock.AdcHardware_GetSample_FinalReturn;
+    Mock.AdcHardware_GetSample_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 AdcHardware_GetSample_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint16 cmock_to_return)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_AdcHardware_GetSample_CALL_INSTANCE));
+  CMOCK_AdcHardware_GetSample_CALL_INSTANCE* cmock_call_instance = (CMOCK_AdcHardware_GetSample_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.AdcHardware_GetSample_CallInstance = CMock_Guts_MemChain(Mock.AdcHardware_GetSample_CallInstance, cmock_guts_index);
+  Mock.AdcHardware_GetSample_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->ReturnVal = cmock_to_return;
+  Mock.AdcHardware_GetSample_IgnoreBool = (char)1;
+}
+
+void AdcHardware_GetSample_CMockStopIgnore(void)
+{
+  if(Mock.AdcHardware_GetSample_IgnoreBool)
+    Mock.AdcHardware_GetSample_CallInstance = CMock_Guts_MemNext(Mock.AdcHardware_GetSample_CallInstance);
+  Mock.AdcHardware_GetSample_IgnoreBool = (char)0;
+}
+
+void AdcHardware_GetSample_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16 cmock_to_return)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_AdcHardware_GetSample_CALL_INSTANCE));
+  CMOCK_AdcHardware_GetSample_CALL_INSTANCE* cmock_call_instance = (CMOCK_AdcHardware_GetSample_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.AdcHardware_GetSample_CallInstance = CMock_Guts_MemChain(Mock.AdcHardware_GetSample_CallInstance, cmock_guts_index);
+  Mock.AdcHardware_GetSample_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+  cmock_call_instance->ReturnVal = cmock_to_return;
+}
+

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

@@ -0,0 +1,58 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#ifndef _MOCKADCHARDWARE_H
+#define _MOCKADCHARDWARE_H
+
+#include "unity.h"
+#include "AdcHardware.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 MockAdcHardware_Init(void);
+void MockAdcHardware_Destroy(void);
+void MockAdcHardware_Verify(void);
+
+
+
+
+#define AdcHardware_Init_Ignore() AdcHardware_Init_CMockIgnore()
+void AdcHardware_Init_CMockIgnore(void);
+#define AdcHardware_Init_StopIgnore() AdcHardware_Init_CMockStopIgnore()
+void AdcHardware_Init_CMockStopIgnore(void);
+#define AdcHardware_Init_Expect() AdcHardware_Init_CMockExpect(__LINE__)
+void AdcHardware_Init_CMockExpect(UNITY_LINE_TYPE cmock_line);
+#define AdcHardware_StartConversion_Ignore() AdcHardware_StartConversion_CMockIgnore()
+void AdcHardware_StartConversion_CMockIgnore(void);
+#define AdcHardware_StartConversion_StopIgnore() AdcHardware_StartConversion_CMockStopIgnore()
+void AdcHardware_StartConversion_CMockStopIgnore(void);
+#define AdcHardware_StartConversion_Expect() AdcHardware_StartConversion_CMockExpect(__LINE__)
+void AdcHardware_StartConversion_CMockExpect(UNITY_LINE_TYPE cmock_line);
+#define AdcHardware_GetSampleComplete_IgnoreAndReturn(cmock_retval) AdcHardware_GetSampleComplete_CMockIgnoreAndReturn(__LINE__, cmock_retval)
+void AdcHardware_GetSampleComplete_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+#define AdcHardware_GetSampleComplete_StopIgnore() AdcHardware_GetSampleComplete_CMockStopIgnore()
+void AdcHardware_GetSampleComplete_CMockStopIgnore(void);
+#define AdcHardware_GetSampleComplete_ExpectAndReturn(cmock_retval) AdcHardware_GetSampleComplete_CMockExpectAndReturn(__LINE__, cmock_retval)
+void AdcHardware_GetSampleComplete_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return);
+#define AdcHardware_GetSample_IgnoreAndReturn(cmock_retval) AdcHardware_GetSample_CMockIgnoreAndReturn(__LINE__, cmock_retval)
+void AdcHardware_GetSample_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint16 cmock_to_return);
+#define AdcHardware_GetSample_StopIgnore() AdcHardware_GetSample_CMockStopIgnore()
+void AdcHardware_GetSample_CMockStopIgnore(void);
+#define AdcHardware_GetSample_ExpectAndReturn(cmock_retval) AdcHardware_GetSample_CMockExpectAndReturn(__LINE__, cmock_retval)
+void AdcHardware_GetSample_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16 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/MockAdcHardwareConfigurator.c

@@ -0,0 +1,218 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include <string.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include "cmock.h"
+#include "MockAdcHardwareConfigurator.h"
+
+static const char* CMockString_Adc_ConfigureMode = "Adc_ConfigureMode";
+static const char* CMockString_Adc_EnableTemperatureChannel = "Adc_EnableTemperatureChannel";
+static const char* CMockString_Adc_Reset = "Adc_Reset";
+
+typedef struct _CMOCK_Adc_Reset_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Adc_Reset_CALL_INSTANCE;
+
+typedef struct _CMOCK_Adc_ConfigureMode_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Adc_ConfigureMode_CALL_INSTANCE;
+
+typedef struct _CMOCK_Adc_EnableTemperatureChannel_CALL_INSTANCE
+{
+  UNITY_LINE_TYPE LineNumber;
+  int CallOrder;
+
+} CMOCK_Adc_EnableTemperatureChannel_CALL_INSTANCE;
+
+static struct MockAdcHardwareConfiguratorInstance
+{
+  char Adc_Reset_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Adc_Reset_CallInstance;
+  char Adc_ConfigureMode_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Adc_ConfigureMode_CallInstance;
+  char Adc_EnableTemperatureChannel_IgnoreBool;
+  CMOCK_MEM_INDEX_TYPE Adc_EnableTemperatureChannel_CallInstance;
+} Mock;
+
+extern jmp_buf AbortFrame;
+extern int GlobalExpectCount;
+extern int GlobalVerifyOrder;
+
+void MockAdcHardwareConfigurator_Verify(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_MEM_INDEX_TYPE call_instance;
+  call_instance = Mock.Adc_Reset_CallInstance;
+  if (Mock.Adc_Reset_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Adc_Reset);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Adc_ConfigureMode_CallInstance;
+  if (Mock.Adc_ConfigureMode_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Adc_ConfigureMode);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+  call_instance = Mock.Adc_EnableTemperatureChannel_CallInstance;
+  if (Mock.Adc_EnableTemperatureChannel_IgnoreBool)
+    call_instance = CMOCK_GUTS_NONE;
+  if (CMOCK_GUTS_NONE != call_instance)
+  {
+    UNITY_SET_DETAIL(CMockString_Adc_EnableTemperatureChannel);
+    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
+  }
+}
+
+void MockAdcHardwareConfigurator_Init(void)
+{
+  MockAdcHardwareConfigurator_Destroy();
+}
+
+void MockAdcHardwareConfigurator_Destroy(void)
+{
+  CMock_Guts_MemFreeAll();
+  memset(&Mock, 0, sizeof(Mock));
+  GlobalExpectCount = 0;
+  GlobalVerifyOrder = 0;
+}
+
+void Adc_Reset(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Adc_Reset_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Adc_Reset);
+  cmock_call_instance = (CMOCK_Adc_Reset_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Adc_Reset_CallInstance);
+  Mock.Adc_Reset_CallInstance = CMock_Guts_MemNext(Mock.Adc_Reset_CallInstance);
+  if (Mock.Adc_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 Adc_Reset_CMockIgnore(void)
+{
+  Mock.Adc_Reset_IgnoreBool = (char)1;
+}
+
+void Adc_Reset_CMockStopIgnore(void)
+{
+  Mock.Adc_Reset_IgnoreBool = (char)0;
+}
+
+void Adc_Reset_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Adc_Reset_CALL_INSTANCE));
+  CMOCK_Adc_Reset_CALL_INSTANCE* cmock_call_instance = (CMOCK_Adc_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.Adc_Reset_CallInstance = CMock_Guts_MemChain(Mock.Adc_Reset_CallInstance, cmock_guts_index);
+  Mock.Adc_Reset_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Adc_ConfigureMode(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Adc_ConfigureMode_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Adc_ConfigureMode);
+  cmock_call_instance = (CMOCK_Adc_ConfigureMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Adc_ConfigureMode_CallInstance);
+  Mock.Adc_ConfigureMode_CallInstance = CMock_Guts_MemNext(Mock.Adc_ConfigureMode_CallInstance);
+  if (Mock.Adc_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 Adc_ConfigureMode_CMockIgnore(void)
+{
+  Mock.Adc_ConfigureMode_IgnoreBool = (char)1;
+}
+
+void Adc_ConfigureMode_CMockStopIgnore(void)
+{
+  Mock.Adc_ConfigureMode_IgnoreBool = (char)0;
+}
+
+void Adc_ConfigureMode_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Adc_ConfigureMode_CALL_INSTANCE));
+  CMOCK_Adc_ConfigureMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_Adc_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.Adc_ConfigureMode_CallInstance = CMock_Guts_MemChain(Mock.Adc_ConfigureMode_CallInstance, cmock_guts_index);
+  Mock.Adc_ConfigureMode_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+
+void Adc_EnableTemperatureChannel(void)
+{
+  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
+  CMOCK_Adc_EnableTemperatureChannel_CALL_INSTANCE* cmock_call_instance;
+  UNITY_SET_DETAIL(CMockString_Adc_EnableTemperatureChannel);
+  cmock_call_instance = (CMOCK_Adc_EnableTemperatureChannel_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Adc_EnableTemperatureChannel_CallInstance);
+  Mock.Adc_EnableTemperatureChannel_CallInstance = CMock_Guts_MemNext(Mock.Adc_EnableTemperatureChannel_CallInstance);
+  if (Mock.Adc_EnableTemperatureChannel_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 Adc_EnableTemperatureChannel_CMockIgnore(void)
+{
+  Mock.Adc_EnableTemperatureChannel_IgnoreBool = (char)1;
+}
+
+void Adc_EnableTemperatureChannel_CMockStopIgnore(void)
+{
+  Mock.Adc_EnableTemperatureChannel_IgnoreBool = (char)0;
+}
+
+void Adc_EnableTemperatureChannel_CMockExpect(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Adc_EnableTemperatureChannel_CALL_INSTANCE));
+  CMOCK_Adc_EnableTemperatureChannel_CALL_INSTANCE* cmock_call_instance = (CMOCK_Adc_EnableTemperatureChannel_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.Adc_EnableTemperatureChannel_CallInstance = CMock_Guts_MemChain(Mock.Adc_EnableTemperatureChannel_CallInstance, cmock_guts_index);
+  Mock.Adc_EnableTemperatureChannel_IgnoreBool = (char)0;
+  cmock_call_instance->LineNumber = cmock_line;
+  cmock_call_instance->CallOrder = ++GlobalExpectCount;
+}
+