int isOperator(Token* unknownToken)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_isOperator_CALL_INSTANCE* cmock_call_instance = (CMOCK_isOperator_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.isOperator_CallInstance);
Mock.isOperator_CallInstance = CMock_Guts_MemNext(Mock.isOperator_CallInstance);
if (Mock.isOperator_IgnoreBool)
{
if (cmock_call_instance == NULL)
return Mock.isOperator_FinalReturn;
Mock.isOperator_FinalReturn = cmock_call_instance->ReturnVal;
return cmock_call_instance->ReturnVal;
}
if (Mock.isOperator_CallbackFunctionPointer != NULL)
{
return Mock.isOperator_CallbackFunctionPointer(unknownToken, Mock.isOperator_CallbackCalls++);
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'isOperator' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
UNITY_TEST_FAIL(cmock_line, "Function 'isOperator' called earlier than expected.");
if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
UNITY_TEST_FAIL(cmock_line, "Function 'isOperator' called later than expected.");
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_unknownToken), (void*)(unknownToken), sizeof(Token), cmock_line, "Function 'isOperator' called with unexpected value for argument 'unknownToken'.");
if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE)
{
Throw(cmock_call_instance->ExceptionToThrow);
}
return cmock_call_instance->ReturnVal;
}
void isOperator_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_isOperator_CALL_INSTANCE));
CMOCK_isOperator_CALL_INSTANCE* cmock_call_instance = (CMOCK_isOperator_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.isOperator_CallInstance = CMock_Guts_MemChain(Mock.isOperator_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;
cmock_call_instance->ReturnVal = cmock_to_return;
Mock.isOperator_IgnoreBool = (int)1;
}
void test_ThatWeCanClaimAndChainAFewElementsTogether(void)
{
unsigned int i;
CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE;
CMOCK_MEM_INDEX_TYPE next;
CMOCK_MEM_INDEX_TYPE element[4];
//verify we're cleared first
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(StartingSize, CMock_Guts_MemBytesFree());
//first element
element[0] = CMock_Guts_MemNew(sizeof(unsigned int));
TEST_ASSERT_MESSAGE(element[0] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
first = CMock_Guts_MemChain(first, element[0]);
TEST_ASSERT_EQUAL(element[0], first);
*((unsigned int*)CMock_Guts_GetAddressFor(element[0])) = 0;
//verify we're using the right amount of memory
TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(StartingSize - 1 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
//second element
element[1] = CMock_Guts_MemNew(sizeof(unsigned int));
TEST_ASSERT_MESSAGE(element[1] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
TEST_ASSERT_NOT_EQUAL(element[0], element[1]);
TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[1]));
*((unsigned int*)CMock_Guts_GetAddressFor(element[1])) = 1;
//verify we're using the right amount of memory
TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(StartingSize - 2 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
//third element
element[2] = CMock_Guts_MemNew(sizeof(unsigned int));
TEST_ASSERT_MESSAGE(element[2] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
TEST_ASSERT_NOT_EQUAL(element[0], element[2]);
TEST_ASSERT_NOT_EQUAL(element[1], element[2]);
TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[2]));
*((unsigned int*)CMock_Guts_GetAddressFor(element[2])) = 2;
//verify we're using the right amount of memory
TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(StartingSize - 3 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
//fourth element
element[3] = CMock_Guts_MemNew(sizeof(unsigned int));
TEST_ASSERT_MESSAGE(element[3] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
TEST_ASSERT_NOT_EQUAL(element[0], element[3]);
TEST_ASSERT_NOT_EQUAL(element[1], element[3]);
TEST_ASSERT_NOT_EQUAL(element[2], element[3]);
TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[3]));
*((unsigned int*)CMock_Guts_GetAddressFor(element[3])) = 3;
//verify we're using the right amount of memory
TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(StartingSize - 4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
//traverse list
next = first;
for (i = 0; i < 4; i++)
{
TEST_ASSERT_EQUAL(element[i], next);
TEST_ASSERT_EQUAL(i, *((unsigned int*)CMock_Guts_GetAddressFor(element[i])));
next = CMock_Guts_MemNext(next);
}
//verify we get a null at the end of the list
TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, next);
//verify we're using the right amount of memory
TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(StartingSize - 4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree());
//Free it all
CMock_Guts_MemFreeAll();
//verify we're cleared
TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
TEST_ASSERT_EQUAL(StartingSize, CMock_Guts_MemBytesFree());
}
void nextToken_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, Tokenizer* tokenizer, Token* cmock_to_return)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_nextToken_CALL_INSTANCE));
CMOCK_nextToken_CALL_INSTANCE* cmock_call_instance = (CMOCK_nextToken_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.nextToken_CallInstance = CMock_Guts_MemChain(Mock.nextToken_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
cmock_call_instance->CallOrder = ++GlobalExpectCount;
cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;
CMockExpectParameters_nextToken(cmock_call_instance, tokenizer);
cmock_call_instance->ReturnVal = cmock_to_return;
}
void qeo_remote_registration_construct_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, qeo_retcode_t cmock_to_return)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_qeo_remote_registration_construct_CALL_INSTANCE));
CMOCK_qeo_remote_registration_construct_CALL_INSTANCE* cmock_call_instance = (CMOCK_qeo_remote_registration_construct_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.qeo_remote_registration_construct_CallInstance = CMock_Guts_MemChain(Mock.qeo_remote_registration_construct_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
cmock_call_instance->ReturnVal = cmock_to_return;
Mock.qeo_remote_registration_construct_IgnoreBool = (int)1;
}
void Adc_StartTemperatureSensorConversion_CMockExpect(UNITY_LINE_TYPE cmock_line)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Adc_StartTemperatureSensorConversion_CALL_INSTANCE));
CMOCK_Adc_StartTemperatureSensorConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_Adc_StartTemperatureSensorConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.Adc_StartTemperatureSensorConversion_CallInstance = CMock_Guts_MemChain(Mock.Adc_StartTemperatureSensorConversion_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
}
void LED_Toggle(void)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_LED_Toggle_CALL_INSTANCE* cmock_call_instance = (CMOCK_LED_Toggle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.LED_Toggle_CallInstance);
Mock.LED_Toggle_CallInstance = CMock_Guts_MemNext(Mock.LED_Toggle_CallInstance);
if (Mock.LED_Toggle_IgnoreBool)
{
return;
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'LED_Toggle' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
UNITY_TEST_FAIL(cmock_line, "Function 'LED_Toggle' called earlier than expected.");
if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
UNITY_TEST_FAIL(cmock_line, "Function 'LED_Toggle' called later than expected.");
}
void qeo_remote_registration_destroy_CMockExpect(UNITY_LINE_TYPE cmock_line)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_qeo_remote_registration_destroy_CALL_INSTANCE));
CMOCK_qeo_remote_registration_destroy_CALL_INSTANCE* cmock_call_instance = (CMOCK_qeo_remote_registration_destroy_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.qeo_remote_registration_destroy_CallInstance = CMock_Guts_MemChain(Mock.qeo_remote_registration_destroy_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
}
void qeo_deviceinfo_publish(qeo_factory_t* factory)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_qeo_deviceinfo_publish_CALL_INSTANCE* cmock_call_instance = (CMOCK_qeo_deviceinfo_publish_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.qeo_deviceinfo_publish_CallInstance);
Mock.qeo_deviceinfo_publish_CallInstance = CMock_Guts_MemNext(Mock.qeo_deviceinfo_publish_CallInstance);
if (Mock.qeo_deviceinfo_publish_IgnoreBool)
{
return;
}
if (Mock.qeo_deviceinfo_publish_CallbackFunctionPointer != NULL)
{
Mock.qeo_deviceinfo_publish_CallbackFunctionPointer(factory, Mock.qeo_deviceinfo_publish_CallbackCalls++);
return;
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'qeo_deviceinfo_publish' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_factory), (void*)(factory), sizeof(qeo_factory_t), cmock_line, "Function 'qeo_deviceinfo_publish' called with unexpected value for argument 'factory'.");
}
void LED_Toggle_CMockExpect(UNITY_LINE_TYPE cmock_line)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_LED_Toggle_CALL_INSTANCE));
CMOCK_LED_Toggle_CALL_INSTANCE* cmock_call_instance = (CMOCK_LED_Toggle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.LED_Toggle_CallInstance = CMock_Guts_MemChain(Mock.LED_Toggle_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
cmock_call_instance->CallOrder = ++GlobalExpectCount;
}
void qeo_deviceinfo_destruct_CMockExpect(UNITY_LINE_TYPE cmock_line, qeo_factory_t* factory)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_qeo_deviceinfo_destruct_CALL_INSTANCE));
CMOCK_qeo_deviceinfo_destruct_CALL_INSTANCE* cmock_call_instance = (CMOCK_qeo_deviceinfo_destruct_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.qeo_deviceinfo_destruct_CallInstance = CMock_Guts_MemChain(Mock.qeo_deviceinfo_destruct_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
CMockExpectParameters_qeo_deviceinfo_destruct(cmock_call_instance, factory);
}
uint16 Adc_ReadTemperatureSensor(void)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_Adc_ReadTemperatureSensor_CALL_INSTANCE* cmock_call_instance = (CMOCK_Adc_ReadTemperatureSensor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Adc_ReadTemperatureSensor_CallInstance);
Mock.Adc_ReadTemperatureSensor_CallInstance = CMock_Guts_MemNext(Mock.Adc_ReadTemperatureSensor_CallInstance);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'Adc_ReadTemperatureSensor' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
return cmock_call_instance->ReturnVal;
}
void Adc_TemperatureSensorSampleReady_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Adc_TemperatureSensorSampleReady_CALL_INSTANCE));
CMOCK_Adc_TemperatureSensorSampleReady_CALL_INSTANCE* cmock_call_instance = (CMOCK_Adc_TemperatureSensorSampleReady_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.Adc_TemperatureSensorSampleReady_CallInstance = CMock_Guts_MemChain(Mock.Adc_TemperatureSensorSampleReady_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
cmock_call_instance->ReturnVal = cmock_to_return;
}
void isOperator_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, Token* unknownToken, CEXCEPTION_T cmock_to_throw)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_isOperator_CALL_INSTANCE));
CMOCK_isOperator_CALL_INSTANCE* cmock_call_instance = (CMOCK_isOperator_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.isOperator_CallInstance = CMock_Guts_MemChain(Mock.isOperator_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
cmock_call_instance->CallOrder = ++GlobalExpectCount;
cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;
CMockExpectParameters_isOperator(cmock_call_instance, unknownToken);
cmock_call_instance->ExceptionToThrow = cmock_to_throw;
}
{
Mockmgmt_cert_parser_Destroy();
}
void Mockmgmt_cert_parser_Destroy(void)
{
CMock_Guts_MemFreeAll();
memset(&Mock, 0, sizeof(Mock));
Mock.qeo_mgmt_cert_parse_CallbackFunctionPointer = NULL;
Mock.qeo_mgmt_cert_parse_CallbackCalls = 0;
}
qeo_mgmt_cert_retcode_t qeo_mgmt_cert_parse(STACK_OF(X509)* chain, qeo_mgmt_cert_contents* contents)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_qeo_mgmt_cert_parse_CALL_INSTANCE* cmock_call_instance = (CMOCK_qeo_mgmt_cert_parse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.qeo_mgmt_cert_parse_CallInstance);
Mock.qeo_mgmt_cert_parse_CallInstance = CMock_Guts_MemNext(Mock.qeo_mgmt_cert_parse_CallInstance);
if (Mock.qeo_mgmt_cert_parse_IgnoreBool)
{
if (cmock_call_instance == NULL)
return Mock.qeo_mgmt_cert_parse_FinalReturn;
memcpy(&Mock.qeo_mgmt_cert_parse_FinalReturn, &cmock_call_instance->ReturnVal, sizeof(qeo_mgmt_cert_retcode_t));
return cmock_call_instance->ReturnVal;
}
if (Mock.qeo_mgmt_cert_parse_CallbackFunctionPointer != NULL)
{
return Mock.qeo_mgmt_cert_parse_CallbackFunctionPointer(chain, contents, Mock.qeo_mgmt_cert_parse_CallbackCalls++);
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'qeo_mgmt_cert_parse' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_chain), (void*)(chain), sizeof(STACK_OF(X509)), cmock_line, "Function 'qeo_mgmt_cert_parse' called with unexpected value for argument 'chain'.");
void qeo_remote_registration_destroy(void)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_qeo_remote_registration_destroy_CALL_INSTANCE* cmock_call_instance = (CMOCK_qeo_remote_registration_destroy_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.qeo_remote_registration_destroy_CallInstance);
Mock.qeo_remote_registration_destroy_CallInstance = CMock_Guts_MemNext(Mock.qeo_remote_registration_destroy_CallInstance);
if (Mock.qeo_remote_registration_destroy_IgnoreBool)
{
return;
}
if (Mock.qeo_remote_registration_destroy_CallbackFunctionPointer != NULL)
{
Mock.qeo_remote_registration_destroy_CallbackFunctionPointer(Mock.qeo_remote_registration_destroy_CallbackCalls++);
return;
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'qeo_remote_registration_destroy' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
}
void operatorEvaluate(Stack* numberStack, Stack* operatorStack)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_operatorEvaluate_CALL_INSTANCE* cmock_call_instance = (CMOCK_operatorEvaluate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.operatorEvaluate_CallInstance);
Mock.operatorEvaluate_CallInstance = CMock_Guts_MemNext(Mock.operatorEvaluate_CallInstance);
if (Mock.operatorEvaluate_IgnoreBool)
{
return;
}
if (Mock.operatorEvaluate_CallbackFunctionPointer != NULL)
{
Mock.operatorEvaluate_CallbackFunctionPointer(numberStack, operatorStack, Mock.operatorEvaluate_CallbackCalls++);
return;
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'operatorEvaluate' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
UNITY_TEST_FAIL(cmock_line, "Function 'operatorEvaluate' called earlier than expected.");
if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
UNITY_TEST_FAIL(cmock_line, "Function 'operatorEvaluate' called later than expected.");
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_numberStack), (void*)(numberStack), sizeof(Stack), cmock_line, "Function 'operatorEvaluate' called with unexpected value for argument 'numberStack'.");
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_operatorStack), (void*)(operatorStack), sizeof(Stack), cmock_line, "Function 'operatorEvaluate' called with unexpected value for argument 'operatorStack'.");
}
qeo_retcode_t qeo_remote_registration_construct(const qeo_remote_registration_cfg_t* cfg, qeo_remote_registration_hndl_t* remote_reg)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_qeo_remote_registration_construct_CALL_INSTANCE* cmock_call_instance = (CMOCK_qeo_remote_registration_construct_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.qeo_remote_registration_construct_CallInstance);
Mock.qeo_remote_registration_construct_CallInstance = CMock_Guts_MemNext(Mock.qeo_remote_registration_construct_CallInstance);
if (Mock.qeo_remote_registration_construct_IgnoreBool)
{
if (cmock_call_instance == NULL)
return Mock.qeo_remote_registration_construct_FinalReturn;
memcpy(&Mock.qeo_remote_registration_construct_FinalReturn, &cmock_call_instance->ReturnVal, sizeof(qeo_retcode_t));
return cmock_call_instance->ReturnVal;
}
if (Mock.qeo_remote_registration_construct_CallbackFunctionPointer != NULL)
{
return Mock.qeo_remote_registration_construct_CallbackFunctionPointer(cfg, remote_reg, Mock.qeo_remote_registration_construct_CallbackCalls++);
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'qeo_remote_registration_construct' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_cfg), (void*)(cfg), sizeof(qeo_remote_registration_cfg_t), cmock_line, "Function 'qeo_remote_registration_construct' called with unexpected value for argument 'cfg'.");
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_remote_reg), (void*)(remote_reg), sizeof(qeo_remote_registration_hndl_t), cmock_line, "Function 'qeo_remote_registration_construct' called with unexpected value for argument 'remote_reg'.");
return cmock_call_instance->ReturnVal;
}
void operatorEvaluate_CMockExpect(UNITY_LINE_TYPE cmock_line, Stack* numberStack, Stack* operatorStack)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_operatorEvaluate_CALL_INSTANCE));
CMOCK_operatorEvaluate_CALL_INSTANCE* cmock_call_instance = (CMOCK_operatorEvaluate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.operatorEvaluate_CallInstance = CMock_Guts_MemChain(Mock.operatorEvaluate_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
cmock_call_instance->CallOrder = ++GlobalExpectCount;
CMockExpectParameters_operatorEvaluate(cmock_call_instance, numberStack, operatorStack);
}
void qeo_remote_registration_construct_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const qeo_remote_registration_cfg_t* cfg, qeo_remote_registration_hndl_t* remote_reg, qeo_retcode_t cmock_to_return)
{
CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_qeo_remote_registration_construct_CALL_INSTANCE));
CMOCK_qeo_remote_registration_construct_CALL_INSTANCE* cmock_call_instance = (CMOCK_qeo_remote_registration_construct_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "CMock has run out of memory. Please allocate more.");
Mock.qeo_remote_registration_construct_CallInstance = CMock_Guts_MemChain(Mock.qeo_remote_registration_construct_CallInstance, cmock_guts_index);
cmock_call_instance->LineNumber = cmock_line;
CMockExpectParameters_qeo_remote_registration_construct(cmock_call_instance, cfg, remote_reg);
memcpy(&cmock_call_instance->ReturnVal, &cmock_to_return, sizeof(qeo_retcode_t));
}
void Adc_EnableTemperatureChannel(void)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_Adc_EnableTemperatureChannel_CALL_INSTANCE* 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);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'Adc_EnableTemperatureChannel' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
}
