test/mocks/Mockmod_metrics_analyzer_extra.c

/* AUTOGENERATED FILE. DO NOT EDIT. */
#include <string.h>
#include <stdlib.h>
#include <setjmp.h>
#include "cmock.h"
#include "Mockmod_metrics_analyzer_extra.h"

static const char* CMockString_get_limit = "get_limit";
static const char* CMockString_id = "id";
static const char* CMockString_power_limit = "power_limit";
static const char* CMockString_set_limit = "set_limit";

typedef struct _CMOCK_get_limit_CALL_INSTANCE
{
  UNITY_LINE_TYPE LineNumber;
  char ExpectAnyArgsBool;
  int ReturnVal;
  fwk_id_t Expected_id;
  uint32_t* Expected_power_limit;
  int Expected_power_limit_Depth;
  char ReturnThruPtr_power_limit_Used;
  uint32_t* ReturnThruPtr_power_limit_Val;
  size_t ReturnThruPtr_power_limit_Size;
  char IgnoreArg_id;
  char IgnoreArg_power_limit;

} CMOCK_get_limit_CALL_INSTANCE;

typedef struct _CMOCK_set_limit_CALL_INSTANCE
{
  UNITY_LINE_TYPE LineNumber;
  char ExpectAnyArgsBool;
  int ReturnVal;
  fwk_id_t Expected_id;
  uint32_t Expected_power_limit;
  char IgnoreArg_id;
  char IgnoreArg_power_limit;

} CMOCK_set_limit_CALL_INSTANCE;

static struct Mockmod_metrics_analyzer_extraInstance
{
  char get_limit_IgnoreBool;
  int get_limit_FinalReturn;
  char get_limit_CallbackBool;
  CMOCK_get_limit_CALLBACK get_limit_CallbackFunctionPointer;
  int get_limit_CallbackCalls;
  CMOCK_MEM_INDEX_TYPE get_limit_CallInstance;
  char set_limit_IgnoreBool;
  int set_limit_FinalReturn;
  char set_limit_CallbackBool;
  CMOCK_set_limit_CALLBACK set_limit_CallbackFunctionPointer;
  int set_limit_CallbackCalls;
  CMOCK_MEM_INDEX_TYPE set_limit_CallInstance;
} Mock;

extern jmp_buf AbortFrame;

void Mockmod_metrics_analyzer_extra_Verify(void)
{
  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
  CMOCK_MEM_INDEX_TYPE call_instance;
  call_instance = Mock.get_limit_CallInstance;
  if (Mock.get_limit_IgnoreBool)
    call_instance = CMOCK_GUTS_NONE;
  if (CMOCK_GUTS_NONE != call_instance)
  {
    UNITY_SET_DETAIL(CMockString_get_limit);
    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
  }
  if (Mock.get_limit_CallbackFunctionPointer != NULL)
  {
    call_instance = CMOCK_GUTS_NONE;
    (void)call_instance;
  }
  call_instance = Mock.set_limit_CallInstance;
  if (Mock.set_limit_IgnoreBool)
    call_instance = CMOCK_GUTS_NONE;
  if (CMOCK_GUTS_NONE != call_instance)
  {
    UNITY_SET_DETAIL(CMockString_set_limit);
    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
  }
  if (Mock.set_limit_CallbackFunctionPointer != NULL)
  {
    call_instance = CMOCK_GUTS_NONE;
    (void)call_instance;
  }
}

void Mockmod_metrics_analyzer_extra_Init(void)
{
  Mockmod_metrics_analyzer_extra_Destroy();
}

void Mockmod_metrics_analyzer_extra_Destroy(void)
{
  CMock_Guts_MemFreeAll();
  memset(&Mock, 0, sizeof(Mock));
}

int get_limit(fwk_id_t id, uint32_t* power_limit)
{
  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
  CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance;
  UNITY_SET_DETAIL(CMockString_get_limit);
  cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_limit_CallInstance);
  Mock.get_limit_CallInstance = CMock_Guts_MemNext(Mock.get_limit_CallInstance);
  if (Mock.get_limit_IgnoreBool)
  {
    UNITY_CLR_DETAILS();
    if (cmock_call_instance == NULL)
      return Mock.get_limit_FinalReturn;
    Mock.get_limit_FinalReturn = cmock_call_instance->ReturnVal;
    return cmock_call_instance->ReturnVal;
  }
  if (!Mock.get_limit_CallbackBool &&
      Mock.get_limit_CallbackFunctionPointer != NULL)
  {
    int cmock_cb_ret = Mock.get_limit_CallbackFunctionPointer(id, power_limit, Mock.get_limit_CallbackCalls++);
    UNITY_CLR_DETAILS();
    return cmock_cb_ret;
  }
  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
  cmock_line = cmock_call_instance->LineNumber;
  if (!cmock_call_instance->ExpectAnyArgsBool)
  {
  if (!cmock_call_instance->IgnoreArg_id)
  {
    UNITY_SET_DETAILS(CMockString_get_limit,CMockString_id);
    UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch);
  }
  if (!cmock_call_instance->IgnoreArg_power_limit)
  {
    UNITY_SET_DETAILS(CMockString_get_limit,CMockString_power_limit);
    if (cmock_call_instance->Expected_power_limit == NULL)
      { UNITY_TEST_ASSERT_NULL(power_limit, cmock_line, CMockStringExpNULL); }
    else
      { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_power_limit, power_limit, cmock_call_instance->Expected_power_limit_Depth, cmock_line, CMockStringMismatch); }
  }
  }
  if (Mock.get_limit_CallbackFunctionPointer != NULL)
  {
    cmock_call_instance->ReturnVal = Mock.get_limit_CallbackFunctionPointer(id, power_limit, Mock.get_limit_CallbackCalls++);
  }
  if (cmock_call_instance->ReturnThruPtr_power_limit_Used)
  {
    UNITY_TEST_ASSERT_NOT_NULL(power_limit, cmock_line, CMockStringPtrIsNULL);
    memcpy((void*)power_limit, (void*)cmock_call_instance->ReturnThruPtr_power_limit_Val,
      cmock_call_instance->ReturnThruPtr_power_limit_Size);
  }
  UNITY_CLR_DETAILS();
  return cmock_call_instance->ReturnVal;
}

void CMockExpectParameters_get_limit(CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth);
void CMockExpectParameters_get_limit(CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth)
{
  memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id),
         sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */
  cmock_call_instance->IgnoreArg_id = 0;
  cmock_call_instance->Expected_power_limit = power_limit;
  cmock_call_instance->Expected_power_limit_Depth = power_limit_Depth;
  cmock_call_instance->IgnoreArg_power_limit = 0;
  cmock_call_instance->ReturnThruPtr_power_limit_Used = 0;
}

void get_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
{
  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE));
  CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_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.get_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index);
  Mock.get_limit_IgnoreBool = (char)0;
  cmock_call_instance->LineNumber = cmock_line;
  cmock_call_instance->ExpectAnyArgsBool = (char)0;
  cmock_call_instance->ReturnVal = cmock_to_return;
  Mock.get_limit_IgnoreBool = (char)1;
}

void get_limit_CMockStopIgnore(void)
{
  if(Mock.get_limit_IgnoreBool)
    Mock.get_limit_CallInstance = CMock_Guts_MemNext(Mock.get_limit_CallInstance);
  Mock.get_limit_IgnoreBool = (char)0;
}

void get_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
{
  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE));
  CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_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.get_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index);
  Mock.get_limit_IgnoreBool = (char)0;
  cmock_call_instance->LineNumber = cmock_line;
  cmock_call_instance->ExpectAnyArgsBool = (char)0;
  cmock_call_instance->ReturnVal = cmock_to_return;
  cmock_call_instance->ExpectAnyArgsBool = (char)1;
}

void get_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return)
{
  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE));
  CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_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.get_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index);
  Mock.get_limit_IgnoreBool = (char)0;
  cmock_call_instance->LineNumber = cmock_line;
  cmock_call_instance->ExpectAnyArgsBool = (char)0;
  CMockExpectParameters_get_limit(cmock_call_instance, id, power_limit, 1);
  cmock_call_instance->ReturnVal = cmock_to_return;
}

void get_limit_AddCallback(CMOCK_get_limit_CALLBACK Callback)
{
  Mock.get_limit_IgnoreBool = (char)0;
  Mock.get_limit_CallbackBool = (char)1;
  Mock.get_limit_CallbackFunctionPointer = Callback;
}

void get_limit_Stub(CMOCK_get_limit_CALLBACK Callback)
{
  Mock.get_limit_IgnoreBool = (char)0;
  Mock.get_limit_CallbackBool = (char)0;
  Mock.get_limit_CallbackFunctionPointer = Callback;
}

void get_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return)
{
  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE));
  CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_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.get_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index);
  Mock.get_limit_IgnoreBool = (char)0;
  cmock_call_instance->LineNumber = cmock_line;
  cmock_call_instance->ExpectAnyArgsBool = (char)0;
  CMockExpectParameters_get_limit(cmock_call_instance, id, power_limit, power_limit_Depth);
  cmock_call_instance->ReturnVal = cmock_to_return;
}

void get_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size)
{
  CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance));
  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp);
  cmock_call_instance->ReturnThruPtr_power_limit_Used = 1;
  cmock_call_instance->ReturnThruPtr_power_limit_Val = power_limit;
  cmock_call_instance->ReturnThruPtr_power_limit_Size = cmock_size;
}

void get_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line)
{
  CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance));
  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
  cmock_call_instance->IgnoreArg_id = 1;
}

void get_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line)
{
  CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance));
  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
  cmock_call_instance->IgnoreArg_power_limit = 1;
}

int set_limit(fwk_id_t id, uint32_t power_limit)
{
  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
  CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance;
  UNITY_SET_DETAIL(CMockString_set_limit);
  cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_limit_CallInstance);
  Mock.set_limit_CallInstance = CMock_Guts_MemNext(Mock.set_limit_CallInstance);
  if (Mock.set_limit_IgnoreBool)
  {
    UNITY_CLR_DETAILS();
    if (cmock_call_instance == NULL)
      return Mock.set_limit_FinalReturn;
    Mock.set_limit_FinalReturn = cmock_call_instance->ReturnVal;
    return cmock_call_instance->ReturnVal;
  }
  if (!Mock.set_limit_CallbackBool &&
      Mock.set_limit_CallbackFunctionPointer != NULL)
  {
    int cmock_cb_ret = Mock.set_limit_CallbackFunctionPointer(id, power_limit, Mock.set_limit_CallbackCalls++);
    UNITY_CLR_DETAILS();
    return cmock_cb_ret;
  }
  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
  cmock_line = cmock_call_instance->LineNumber;
  if (!cmock_call_instance->ExpectAnyArgsBool)
  {
  if (!cmock_call_instance->IgnoreArg_id)
  {
    UNITY_SET_DETAILS(CMockString_set_limit,CMockString_id);
    UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch);
  }
  if (!cmock_call_instance->IgnoreArg_power_limit)
  {
    UNITY_SET_DETAILS(CMockString_set_limit,CMockString_power_limit);
    UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_power_limit, power_limit, cmock_line, CMockStringMismatch);
  }
  }
  if (Mock.set_limit_CallbackFunctionPointer != NULL)
  {
    cmock_call_instance->ReturnVal = Mock.set_limit_CallbackFunctionPointer(id, power_limit, Mock.set_limit_CallbackCalls++);
  }
  UNITY_CLR_DETAILS();
  return cmock_call_instance->ReturnVal;
}

void CMockExpectParameters_set_limit(CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_limit);
void CMockExpectParameters_set_limit(CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_limit)
{
  memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id),
         sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */
  cmock_call_instance->IgnoreArg_id = 0;
  cmock_call_instance->Expected_power_limit = power_limit;
  cmock_call_instance->IgnoreArg_power_limit = 0;
}

void set_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
{
  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_limit_CALL_INSTANCE));
  CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_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.set_limit_CallInstance = CMock_Guts_MemChain(Mock.set_limit_CallInstance, cmock_guts_index);
  Mock.set_limit_IgnoreBool = (char)0;
  cmock_call_instance->LineNumber = cmock_line;
  cmock_call_instance->ExpectAnyArgsBool = (char)0;
  cmock_call_instance->ReturnVal = cmock_to_return;
  Mock.set_limit_IgnoreBool = (char)1;
}

void set_limit_CMockStopIgnore(void)
{
  if(Mock.set_limit_IgnoreBool)
    Mock.set_limit_CallInstance = CMock_Guts_MemNext(Mock.set_limit_CallInstance);
  Mock.set_limit_IgnoreBool = (char)0;
}

void set_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
{
  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_limit_CALL_INSTANCE));
  CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_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.set_limit_CallInstance = CMock_Guts_MemChain(Mock.set_limit_CallInstance, cmock_guts_index);
  Mock.set_limit_IgnoreBool = (char)0;
  cmock_call_instance->LineNumber = cmock_line;
  cmock_call_instance->ExpectAnyArgsBool = (char)0;
  cmock_call_instance->ReturnVal = cmock_to_return;
  cmock_call_instance->ExpectAnyArgsBool = (char)1;
}

void set_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_limit, int cmock_to_return)
{
  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_limit_CALL_INSTANCE));
  CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_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.set_limit_CallInstance = CMock_Guts_MemChain(Mock.set_limit_CallInstance, cmock_guts_index);
  Mock.set_limit_IgnoreBool = (char)0;
  cmock_call_instance->LineNumber = cmock_line;
  cmock_call_instance->ExpectAnyArgsBool = (char)0;
  CMockExpectParameters_set_limit(cmock_call_instance, id, power_limit);
  cmock_call_instance->ReturnVal = cmock_to_return;
}

void set_limit_AddCallback(CMOCK_set_limit_CALLBACK Callback)
{
  Mock.set_limit_IgnoreBool = (char)0;
  Mock.set_limit_CallbackBool = (char)1;
  Mock.set_limit_CallbackFunctionPointer = Callback;
}

void set_limit_Stub(CMOCK_set_limit_CALLBACK Callback)
{
  Mock.set_limit_IgnoreBool = (char)0;
  Mock.set_limit_CallbackBool = (char)0;
  Mock.set_limit_CallbackFunctionPointer = Callback;
}

void set_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line)
{
  CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_limit_CallInstance));
  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
  cmock_call_instance->IgnoreArg_id = 1;
}

void set_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line)
{
  CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_limit_CallInstance));
  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
  cmock_call_instance->IgnoreArg_power_limit = 1;
}