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; }