/**
* Custom assertion of red black tree node
**/
void assertNode(Node *left,Node *right,char color,Node *actualNode,int lineNumber){
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
// Expected contents Actual content
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
UNITY_TEST_ASSERT_EQUAL_INT8(color,actualNode->color,lineNumber,"Wrong color");
UNITY_TEST_ASSERT_EQUAL_PTR(left,actualNode->left,lineNumber,"Wrong left node");
UNITY_TEST_ASSERT_EQUAL_PTR(right,actualNode->right,lineNumber,"Wrong right node");
}
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.");}
void Stack_push(Stack* stack, void* element)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_Stack_push_CALL_INSTANCE* cmock_call_instance = (CMOCK_Stack_push_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.Stack_push_CallInstance);
Mock.Stack_push_CallInstance = CMock_Guts_MemNext(Mock.Stack_push_CallInstance);
if (Mock.Stack_push_IgnoreBool)
{
return;
}
if (Mock.Stack_push_CallbackFunctionPointer != NULL)
{
Mock.Stack_push_CallbackFunctionPointer(stack, element, Mock.Stack_push_CallbackCalls++);
return;
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'Stack_push' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)
UNITY_TEST_FAIL(cmock_line, "Function 'Stack_push' called earlier than expected.");
if (cmock_call_instance->CallOrder < GlobalVerifyOrder)
UNITY_TEST_FAIL(cmock_line, "Function 'Stack_push' called later than expected.");
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_stack), (void*)(stack), sizeof(Stack), cmock_line, "Function 'Stack_push' called with unexpected value for argument 'stack'.");
UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_element, element, cmock_line, "Function 'Stack_push' called with unexpected value for argument 'element'.");
if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE)
{
Throw(cmock_call_instance->ExceptionToThrow);
}
}
S_DATA mock_system_read_impl(S_DATA* src)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
UNITY_SET_DETAIL(CMockString_system_read);
CMOCK_system_read_CALL_INSTANCE* cmock_call_instance = (CMOCK_system_read_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.system_read_CallInstance);
Mock.system_read_CallInstance = CMock_Guts_MemNext(Mock.system_read_CallInstance);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
cmock_line = cmock_call_instance->LineNumber;
{
UNITY_SET_DETAILS(CMockString_system_read,CMockString_src);
UNITY_TEST_ASSERT_EQUAL_PTR((void*)(cmock_call_instance->Expected_src), (void*)(src), cmock_line, CMockStringMismatch);
}
UNITY_CLR_DETAILS();
return cmock_call_instance->ReturnVal;
}
void mock_system_write_impl(S_DATA* dest, S_DATA value)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
UNITY_SET_DETAIL(CMockString_system_write);
CMOCK_system_write_CALL_INSTANCE* cmock_call_instance = (CMOCK_system_write_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.system_write_CallInstance);
Mock.system_write_CallInstance = CMock_Guts_MemNext(Mock.system_write_CallInstance);
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
cmock_line = cmock_call_instance->LineNumber;
{
UNITY_SET_DETAILS(CMockString_system_write,CMockString_dest);
UNITY_TEST_ASSERT_EQUAL_PTR((void*)(cmock_call_instance->Expected_dest), (void*)(dest), cmock_line, CMockStringMismatch);
}
{
UNITY_SET_DETAILS(CMockString_system_write,CMockString_value);
UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_value, value, cmock_line, CMockStringMismatch);
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_value), (void*)(&value), sizeof(S_DATA), cmock_line, CMockStringMismatch);
}
UNITY_CLR_DETAILS();
// Actually write value
*dest = value;
}
qeo_retcode_t data_set_member(qeocore_data_t* data, qeocore_member_id_t id, const void* value)
{
UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
CMOCK_data_set_member_CALL_INSTANCE* cmock_call_instance = (CMOCK_data_set_member_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.data_set_member_CallInstance);
Mock.data_set_member_CallInstance = CMock_Guts_MemNext(Mock.data_set_member_CallInstance);
if (Mock.data_set_member_IgnoreBool)
{
if (cmock_call_instance == NULL)
return Mock.data_set_member_FinalReturn;
memcpy(&Mock.data_set_member_FinalReturn, &cmock_call_instance->ReturnVal, sizeof(qeo_retcode_t));
return cmock_call_instance->ReturnVal;
}
if (Mock.data_set_member_CallbackFunctionPointer != NULL)
{
return Mock.data_set_member_CallbackFunctionPointer(data, id, value, Mock.data_set_member_CallbackCalls++);
}
UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, "Function 'data_set_member' called more times than expected.");
cmock_line = cmock_call_instance->LineNumber;
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_data), (void*)(data), sizeof(qeocore_data_t), cmock_line, "Function 'data_set_member' called with unexpected value for argument 'data'.");
UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(qeocore_member_id_t), cmock_line, "Function 'data_set_member' called with unexpected value for argument 'id'.");
UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_value, value, cmock_line, "Function 'data_set_member' called with unexpected value for argument 'value'.");
return cmock_call_instance->ReturnVal;
}
