void listAdd(List* list, int data) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_listAdd_CALL_INSTANCE* cmock_call_instance = (CMOCK_listAdd_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.listAdd_CallInstance); Mock.listAdd_CallInstance = CMock_Guts_MemNext(Mock.listAdd_CallInstance); if (Mock.listAdd_IgnoreBool) { return; } if (Mock.listAdd_CallbackFunctionPointer != NULL) { Mock.listAdd_CallbackFunctionPointer(list, data, Mock.listAdd_CallbackCalls++); return; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'listAdd' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'listAdd' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'listAdd' called later than expected."); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_list), (void*)(list), sizeof(List), cmock_line, "Function 'listAdd' called with unexpected value for argument 'list'."); UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_data, data, cmock_line, "Function 'listAdd' called with unexpected value for argument 'data'."); if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE) { Throw(cmock_call_instance->ExceptionToThrow); } }
Stack* Stack_create(void) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_Stack_create_CALL_INSTANCE* cmock_call_instance = (CMOCK_Stack_create_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Stack_create_CallInstance); Mock.Stack_create_CallInstance = CMock_Guts_MemNext(Mock.Stack_create_CallInstance); if (Mock.Stack_create_IgnoreBool) { if (cmock_call_instance == NULL) return Mock.Stack_create_FinalReturn; Mock.Stack_create_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } if (Mock.Stack_create_CallbackFunctionPointer != NULL) { return Mock.Stack_create_CallbackFunctionPointer(Mock.Stack_create_CallbackCalls++); } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'Stack_create' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'Stack_create' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'Stack_create' called later than expected."); if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE) { Throw(cmock_call_instance->ExceptionToThrow); } return cmock_call_instance->ReturnVal; }
void stringCopy(char* source, char* destination, int startLocation, int length) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_stringCopy_CALL_INSTANCE* cmock_call_instance = (CMOCK_stringCopy_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.stringCopy_CallInstance); Mock.stringCopy_CallInstance = CMock_Guts_MemNext(Mock.stringCopy_CallInstance); if (Mock.stringCopy_IgnoreBool) { return; } if (Mock.stringCopy_CallbackFunctionPointer != NULL) { Mock.stringCopy_CallbackFunctionPointer(source, destination, startLocation, length, Mock.stringCopy_CallbackCalls++); return; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'stringCopy' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'stringCopy' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'stringCopy' called later than expected."); UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_source, source, cmock_line, "Function 'stringCopy' called with unexpected value for argument 'source'."); UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_destination, destination, cmock_line, "Function 'stringCopy' called with unexpected value for argument 'destination'."); UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_startLocation, startLocation, cmock_line, "Function 'stringCopy' called with unexpected value for argument 'startLocation'."); UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_length, length, cmock_line, "Function 'stringCopy' called with unexpected value for argument 'length'."); if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE) { Throw(cmock_call_instance->ExceptionToThrow); } }
void stringRightTrim(String* string) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_stringRightTrim_CALL_INSTANCE* cmock_call_instance = (CMOCK_stringRightTrim_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.stringRightTrim_CallInstance); Mock.stringRightTrim_CallInstance = CMock_Guts_MemNext(Mock.stringRightTrim_CallInstance); if (Mock.stringRightTrim_IgnoreBool) { return; } if (Mock.stringRightTrim_CallbackFunctionPointer != NULL) { Mock.stringRightTrim_CallbackFunctionPointer(string, Mock.stringRightTrim_CallbackCalls++); return; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'stringRightTrim' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'stringRightTrim' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'stringRightTrim' called later than expected."); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_string), (void*)(string), sizeof(String), cmock_line, "Function 'stringRightTrim' called with unexpected value for argument 'string'."); if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE) { Throw(cmock_call_instance->ExceptionToThrow); } }
Token* calculate(Operator* opeToken, Number* first, Number* second) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_calculate_CALL_INSTANCE* cmock_call_instance = (CMOCK_calculate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.calculate_CallInstance); Mock.calculate_CallInstance = CMock_Guts_MemNext(Mock.calculate_CallInstance); if (Mock.calculate_IgnoreBool) { if (cmock_call_instance == NULL) return Mock.calculate_FinalReturn; Mock.calculate_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } if (Mock.calculate_CallbackFunctionPointer != NULL) { return Mock.calculate_CallbackFunctionPointer(opeToken, first, second, Mock.calculate_CallbackCalls++); } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'calculate' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'calculate' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'calculate' called later than expected."); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_opeToken), (void*)(opeToken), sizeof(Operator), cmock_line, "Function 'calculate' called with unexpected value for argument 'opeToken'."); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_first), (void*)(first), sizeof(Number), cmock_line, "Function 'calculate' called with unexpected value for argument 'first'."); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_second), (void*)(second), sizeof(Number), cmock_line, "Function 'calculate' called with unexpected value for argument 'second'."); return cmock_call_instance->ReturnVal; }
int isNumber(Token* unknownToken) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_isNumber_CALL_INSTANCE* cmock_call_instance = (CMOCK_isNumber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.isNumber_CallInstance); Mock.isNumber_CallInstance = CMock_Guts_MemNext(Mock.isNumber_CallInstance); if (Mock.isNumber_IgnoreBool) { if (cmock_call_instance == NULL) return Mock.isNumber_FinalReturn; Mock.isNumber_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } if (Mock.isNumber_CallbackFunctionPointer != NULL) { return Mock.isNumber_CallbackFunctionPointer(unknownToken, Mock.isNumber_CallbackCalls++); } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'isNumber' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'isNumber' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'isNumber' called later than expected."); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_unknownToken), (void*)(unknownToken), sizeof(Token), cmock_line, "Function 'isNumber' called with unexpected value for argument 'unknownToken'."); if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE) { Throw(cmock_call_instance->ExceptionToThrow); } return cmock_call_instance->ReturnVal; }
String* getWordAndUpdate(String* line, char* delimiter) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_getWordAndUpdate_CALL_INSTANCE* cmock_call_instance = (CMOCK_getWordAndUpdate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.getWordAndUpdate_CallInstance); Mock.getWordAndUpdate_CallInstance = CMock_Guts_MemNext(Mock.getWordAndUpdate_CallInstance); if (Mock.getWordAndUpdate_IgnoreBool) { if (cmock_call_instance == NULL) return Mock.getWordAndUpdate_FinalReturn; Mock.getWordAndUpdate_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } if (Mock.getWordAndUpdate_CallbackFunctionPointer != NULL) { return Mock.getWordAndUpdate_CallbackFunctionPointer(line, delimiter, Mock.getWordAndUpdate_CallbackCalls++); } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'getWordAndUpdate' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'getWordAndUpdate' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'getWordAndUpdate' called later than expected."); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_line), (void*)(line), sizeof(String), cmock_line, "Function 'getWordAndUpdate' called with unexpected value for argument 'line'."); UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_delimiter, delimiter, cmock_line, "Function 'getWordAndUpdate' called with unexpected value for argument 'delimiter'."); if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE) { Throw(cmock_call_instance->ExceptionToThrow); } return cmock_call_instance->ReturnVal; }
String* stringCreate(char* expression) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_stringCreate_CALL_INSTANCE* cmock_call_instance = (CMOCK_stringCreate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.stringCreate_CallInstance); Mock.stringCreate_CallInstance = CMock_Guts_MemNext(Mock.stringCreate_CallInstance); if (Mock.stringCreate_IgnoreBool) { if (cmock_call_instance == NULL) return Mock.stringCreate_FinalReturn; Mock.stringCreate_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } if (Mock.stringCreate_CallbackFunctionPointer != NULL) { return Mock.stringCreate_CallbackFunctionPointer(expression, Mock.stringCreate_CallbackCalls++); } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'stringCreate' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'stringCreate' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'stringCreate' called later than expected."); UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_expression, expression, cmock_line, "Function 'stringCreate' called with unexpected value for argument 'expression'."); if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE) { Throw(cmock_call_instance->ExceptionToThrow); } return cmock_call_instance->ReturnVal; }
List* ListNew(int length) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_ListNew_CALL_INSTANCE* cmock_call_instance = (CMOCK_ListNew_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ListNew_CallInstance); Mock.ListNew_CallInstance = CMock_Guts_MemNext(Mock.ListNew_CallInstance); if (Mock.ListNew_IgnoreBool) { if (cmock_call_instance == NULL) return Mock.ListNew_FinalReturn; Mock.ListNew_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } if (Mock.ListNew_CallbackFunctionPointer != NULL) { return Mock.ListNew_CallbackFunctionPointer(length, Mock.ListNew_CallbackCalls++); } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'ListNew' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'ListNew' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'ListNew' called later than expected."); UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_length, length, cmock_line, "Function 'ListNew' called with unexpected value for argument 'length'."); if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE) { Throw(cmock_call_instance->ExceptionToThrow); } return cmock_call_instance->ReturnVal; }
void assertStringEqual(const char *expected, String *actual, int line, const char *msg) { int i; const char *str = &actual->text->string[actual->start]; if(strlen(expected) != actual->length) UNITY_TEST_FAIL(line, "Both strings are not of the same length."); for(i = 0; expected[i] != 0 && expected[i] == str[i]; i++); if(expected[i] != 0) UNITY_TEST_FAIL(line, "Both strings are not the same."); }
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 UnityMalloc_EndTest(void) { malloc_fail_countdown = MALLOC_DONT_FAIL; if (malloc_count != 0) { UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!"); } }
void assertAvlNode(const Node* expectedLeftChild, const Node* expectedRightChild, const int balanceFactor, const Node *actual, const UNITY_LINE_TYPE lineNumber){ if(actual == NULL) UNITY_TEST_FAIL(lineNumber, "The 'actual' node is NULL."); UNITY_TEST_ASSERT_EQUAL_PTR(expectedLeftChild, actual->leftChild, lineNumber,"The leftChild is not the same."); UNITY_TEST_ASSERT_EQUAL_PTR(expectedRightChild, actual->rightChild, lineNumber,"The rightChild is not the same."); UNITY_TEST_ASSERT_EQUAL_INT(balanceFactor, actual->balance, lineNumber,"Balance factor is not the same.");}
char _RS232_ReadByte(int comport_number, int line){ char data = -1; int count = 0; while(RS232_PollComport(comport_number, &data, 1) == 0 && count < MAX_TRIES) count++; if(count >= MAX_TRIES){ RS232_CloseComport(COMPORT); UNITY_TEST_FAIL(line,"Attempt to read byte but comport seems not responsive"); } return data; }
int System_AbortRequested(void) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_System_AbortRequested_CALL_INSTANCE* cmock_call_instance = (CMOCK_System_AbortRequested_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.System_AbortRequested_CallInstance); Mock.System_AbortRequested_CallInstance = CMock_Guts_MemNext(Mock.System_AbortRequested_CallInstance); if (Mock.System_AbortRequested_IgnoreBool) { if (cmock_call_instance == NULL) return Mock.System_AbortRequested_FinalReturn; Mock.System_AbortRequested_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'System_AbortRequested' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'System_AbortRequested' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'System_AbortRequested' called later than expected."); return cmock_call_instance->ReturnVal; }
void I2CWriteInit(void) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_I2CWriteInit_CALL_INSTANCE* cmock_call_instance = (CMOCK_I2CWriteInit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.I2CWriteInit_CallInstance); Mock.I2CWriteInit_CallInstance = CMock_Guts_MemNext(Mock.I2CWriteInit_CallInstance); if (Mock.I2CWriteInit_IgnoreBool) { return; } if (Mock.I2CWriteInit_CallbackFunctionPointer != NULL) { Mock.I2CWriteInit_CallbackFunctionPointer(Mock.I2CWriteInit_CallbackCalls++); return; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'I2CWriteInit' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'I2CWriteInit' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'I2CWriteInit' called later than expected."); }
void InitI2C(uint8_t address) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_InitI2C_CALL_INSTANCE* cmock_call_instance = (CMOCK_InitI2C_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.InitI2C_CallInstance); Mock.InitI2C_CallInstance = CMock_Guts_MemNext(Mock.InitI2C_CallInstance); if (Mock.InitI2C_IgnoreBool) { return; } if (Mock.InitI2C_CallbackFunctionPointer != NULL) { Mock.InitI2C_CallbackFunctionPointer(address, Mock.InitI2C_CallbackCalls++); return; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'InitI2C' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'InitI2C' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'InitI2C' called later than expected."); UNITY_TEST_ASSERT_EQUAL_HEX8(cmock_call_instance->Expected_address, address, cmock_line, "Function 'InitI2C' called with unexpected value for argument 'address'."); }
void evaluate3(char* expression) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_evaluate3_CALL_INSTANCE* cmock_call_instance = (CMOCK_evaluate3_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.evaluate3_CallInstance); Mock.evaluate3_CallInstance = CMock_Guts_MemNext(Mock.evaluate3_CallInstance); if (Mock.evaluate3_IgnoreBool) { return; } if (Mock.evaluate3_CallbackFunctionPointer != NULL) { Mock.evaluate3_CallbackFunctionPointer(expression, Mock.evaluate3_CallbackCalls++); return; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'evaluate3' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'evaluate3' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'evaluate3' called later than expected."); UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_expression, expression, cmock_line, "Function 'evaluate3' called with unexpected value for argument 'expression'."); }
void operatorPush(Token* token) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_operatorPush_CALL_INSTANCE* cmock_call_instance = (CMOCK_operatorPush_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.operatorPush_CallInstance); Mock.operatorPush_CallInstance = CMock_Guts_MemNext(Mock.operatorPush_CallInstance); if (Mock.operatorPush_IgnoreBool) { return; } if (Mock.operatorPush_CallbackFunctionPointer != NULL) { Mock.operatorPush_CallbackFunctionPointer(token, Mock.operatorPush_CallbackCalls++); return; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'operatorPush' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'operatorPush' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'operatorPush' called later than expected."); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_token), (void*)(token), sizeof(Token), cmock_line, "Function 'operatorPush' called with unexpected value for argument 'token'."); }
void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line) { if (pointer_index >= MAX_POINTERS) { UNITY_TEST_FAIL(line, "Too many pointers set"); } else { pointer_store[pointer_index].pointer = pointer; pointer_store[pointer_index].old_value = *pointer; *pointer = newValue; pointer_index++; } }
void Draw_Int(int cmock_arg1) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_Draw_Int_CALL_INSTANCE* cmock_call_instance = (CMOCK_Draw_Int_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Draw_Int_CallInstance); Mock.Draw_Int_CallInstance = CMock_Guts_MemNext(Mock.Draw_Int_CallInstance); if (Mock.Draw_Int_IgnoreBool) { return; } if (Mock.Draw_Int_CallbackFunctionPointer != NULL) { Mock.Draw_Int_CallbackFunctionPointer(cmock_arg1, Mock.Draw_Int_CallbackCalls++); return; } UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'Draw_Int' called more times than expected."); cmock_line = cmock_call_instance->LineNumber; if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'Draw_Int' called earlier than expected."); if (cmock_call_instance->CallOrder < GlobalVerifyOrder) UNITY_TEST_FAIL(cmock_line, "Function 'Draw_Int' called later than expected."); { UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_cmock_arg1, cmock_arg1, cmock_line, "Function 'Draw_Int' called with unexpected value for argument 'cmock_arg1'."); } }
void unity_free(void* mem) { int overrun; if (mem == NULL) { return; } overrun = isOverrun(mem); release_memory(mem); if (overrun) { UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()"); } }
void* unity_realloc(void* oldMem, size_t size) { Guard* guard = (Guard*)oldMem; void* newMem; if (oldMem == NULL) return unity_malloc(size); guard--; if (isOverrun(oldMem)) { release_memory(oldMem); UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()"); } if (size == 0) { release_memory(oldMem); return NULL; } if (guard->size >= size) return oldMem; #ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */ if (oldMem == unity_heap + heap_index - guard->size - sizeof(end) && heap_index + size - guard->size <= UNITY_INTERNAL_HEAP_SIZE_BYTES) { release_memory(oldMem); /* Not thread-safe, like unity_heap generally */ return unity_malloc(size); /* No memcpy since data is in place */ } #endif newMem = unity_malloc(size); if (newMem == NULL) return NULL; /* Do not release old memory */ memcpy(newMem, oldMem, guard->size); release_memory(oldMem); return newMem; }