void test_avlRemove_remove_node80_and_The_BF_of_node60_is_(void){
Node *root = &node100;
int cState = avlAdd(&root,&node60);
cState =avlAdd(&root,&node130);
cState =avlAdd(&root,&node140);
cState =avlAdd(&root,&node110);
int heightChange;
Node *temp = avlRemove(&root,110,&heightChange);
TEST_ASSERT_EQUAL(0,heightChange);
TEST_ASSERT_EQUAL_PTR(&node110,temp);
TEST_ASSERT_EQUAL_NODE(root,&node60,&node130,1);
TEST_ASSERT_EQUAL_NODE(&node60,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node130,NULL,&node140,1);
}
/**
* parent parent
* | |
* v v
* 12(b) successor 12(b)
* / \ 1 / \
* 5(b) 18(b) ----------> 5(b) 18(b)
* / \ / \ / \ / \
* 1(r) - 13(r) - - - 13(r) -
*/
void test_removeNextLargerSuccessor_remove_1_from_the_tree_with_1_5_12_13_18_nodes(void)
{
setNode(&node1, NULL, NULL, 'r');
setNode(&node13, NULL, NULL, 'r');
setNode(&node5, &node1, NULL, 'b');
setNode(&node18, &node13, NULL, 'b');
setNode(&node12, &node5, &node18, 'b');
Node *parent = &node12;
Node *removeNode;
removeNode = removeNextLargerSuccessor(&parent);
TEST_ASSERT_EQUAL_PTR(&node1, removeNode);
TEST_ASSERT_EQUAL_PTR(parent, &node12);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'r', &node13);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node5);
TEST_ASSERT_EQUAL_NODE(&node13, NULL, 'b', &node18);
TEST_ASSERT_EQUAL_NODE(&node5, &node18, 'b', &node12);
}
/** 2-node case
* add 1
* root -> NULL --------> 1(b)
*/
void test_genericAddRedBlackTree_add_node1_to_empty_tree(void)
{
setNode(&node1, NULL, NULL, 'r');
Node *root = NULL;
genericAddRedBlackTree(&root, &node1, compareEventInfo);
TEST_ASSERT_EQUAL_PTR(&node1, root);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1);
}
/**
* root root root
* | | |
* v v v
* 5(b) 5(b) rotate 3(b)
* / \ remove 6 / right / \
* 3(r) 6(b) ---------------> 3(r) --------------> 2(b) 5(b)
* / \ / \ /
* 2(b) 4(b) 2(b) 4(b) 4(r)
*/
void test__delRedBlackTree_remove_6_from_tree_with_2_3_4_5_6_nodes(void)
{
setNode(&node2, NULL, NULL, 'b');
setNode(&node4, NULL, NULL, 'b');
setNode(&node6, NULL, NULL, 'b');
setNode(&node3, &node2, &node4, 'r');
setNode(&node5, &node3, &node6, 'b');
Node *root = &node5;
Node *result;
result = delRedBlackTree(&root, &node6);
TEST_ASSERT_EQUAL_PTR(root, &node3);
TEST_ASSERT_EQUAL_PTR(result, &node6);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'r', &node4);
TEST_ASSERT_EQUAL_NODE(&node4, NULL, 'b', &node5);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node2);
TEST_ASSERT_EQUAL_NODE(&node2, &node5, 'b', &node3);
}
/** 2-node case
* add A
* root -> NULL --------> A(b)
*/
void test_genericAddRedBlackTree_add_nodeA_to_empty_tree(void)
{
setNode(&nodeA, NULL, NULL, 'r');
Node *root = NULL;
genericAddRedBlackTree(&root, &nodeA, compareModuleAndPin);
TEST_ASSERT_EQUAL_PTR(&nodeA, root);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &nodeA);
}
/** 30(+1)60(+1) -> 30(0)60(0)
* 30(+1) -5 30(+2) 60(0)
* / \ ------> / \ -----> / \
* 10 60(+1) 10 60(0) (0)30 70
* / / \ / \ / \ \
* 5 50 70 50 70 10 50 80
* \ \
* 80 80
*
*
**/
void test_avlRemove_remove_node5_and_given_the_bal_factor_of_node60_is_1_and_given_extra_node80(void){
Node *root = &node30;
int cState = avlAdd(&root,&node10);
cState =avlAdd(&root,&node60);
cState =avlAdd(&root,&node5);
cState =avlAdd(&root,&node50);
cState =avlAdd(&root,&node70);
cState =avlAdd(&root,&node80);
int heightChange;
Node *temp = avlRemove(&root,5,&heightChange);
TEST_ASSERT_EQUAL(1,heightChange);
TEST_ASSERT_EQUAL_PTR(&node5,temp);
TEST_ASSERT_EQUAL_NODE(root,&node30,&node70,0);
TEST_ASSERT_EQUAL_NODE(&node30,&node10,&node50,0);
TEST_ASSERT_EQUAL_NODE(&node70,NULL,&node80,1);
TEST_ASSERT_EQUAL_NODE(&node80,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node50,NULL,NULL,0);
}
/** 2-node case
* root root
* | |
* v remove 2 v
* 1(b) ------------> 1(b)
* \
* 2(r)
*/
void test_delRedBlackTree_remove_2_from_tree_with_1_2_nodes(void)
{
setNode(&node2, NULL, NULL, 'r');
setNode(&node1, NULL, &node2, 'b');
Node *root = &node1;
delRedBlackTree(&root, &node2);
TEST_ASSERT_EQUAL_PTR(root, &node1);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1);
}
void test_avlRemove_remove_node5_in_tree(void){
Node *root = &node30;
int cState = avlAdd(&root,&node10);
cState =avlAdd(&root,&node60);
cState =avlAdd(&root,&node5);
int heightChange;
Node *temp = avlRemove(&root,5,&heightChange);
TEST_ASSERT_EQUAL(1,heightChange);
TEST_ASSERT_EQUAL_PTR(&node5,temp);
TEST_ASSERT_EQUAL_NODE(&node30,&node10,&node60,0);
}
/** 2-node case
*
* root -> 2(b) remove 1
* / ----------> 2(b) <- root
* 1(r)
*/
void test_genericDelRedBlackTree_remove_node1_from_tree_with_node_1_2(void)
{
setNode(&node1, NULL, NULL, 'r');
setNode(&node2, &node1, NULL, 'b');
Node *root = &node2, *removeNode;
removeNode = genericDelRedBlackTree(&root, &node1, compareEventInfo);
TEST_ASSERT_EQUAL_PTR(&node2, root);
TEST_ASSERT_EQUAL_PTR(&node1, removeNode);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node2);
}
/**
* parent parent
* | |
* v successor v
* 2(b) 2 3(b)
* \ -------------->
* 3(r)
*/
void test_removeNextLargerSuccessor_remove_3_from_the_tree_with_2_3_nodes(void)
{
setNode(&node3, NULL, NULL, 'r');
setNode(&node2, NULL, &node3, 'b');
Node *parent = &node2;
Node *removeNode;
removeNode = removeNextLargerSuccessor(&parent);
TEST_ASSERT_EQUAL_PTR(&node2, removeNode);
TEST_ASSERT_EQUAL_PTR(parent, &node3);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node3);
}
/*
*
* root root root
* | remove 20 | rotate left |
* v -----> v ---------> v
* 15(b) 15(b) 5(b)
* / \ / \\ / \
* 5(r) 20(b) 5(r) NULL 2(b) 15(b)
* / \ / \ /
* 2(b) 7(b) 2(b) 7(b) 7(r)
*/
void test_delRedBlackTree_3_node_remove_20_from_tree_with_root_15_root_should_point_to_5()
{
setNode(&node2, NULL, NULL, 'b');
setNode(&node7, NULL, NULL, 'b');
setNode(&node20, NULL, NULL, 'b');
setNode(&node5, &node2, &node7, 'r');
setNode(&node15, &node5, &node20, 'b');
Node *root = &node15;
Node *node;
node = delRedBlackTree(&root, &node20);
TEST_ASSERT_EQUAL(20 , node->data);
TEST_ASSERT_EQUAL_NODE(NULL , NULL, 'b', &node2);
TEST_ASSERT_EQUAL_NODE(NULL , NULL, 'r', &node7);
TEST_ASSERT_EQUAL(root->data,5);
TEST_ASSERT_EQUAL_NODE(&node7, NULL, 'b', &node15);
TEST_ASSERT_EQUAL_NODE(&node2, &node15 , 'b', &node5);
}
/**
* root root root root
* | | | |
* v v v v
* 2(b) 2(b) 5(b) 5(b)
* / \ remove 1 // \ case 3 / \ case 1 / \
* 1(b) 5(r) ------------> 5(r) --------------> 2(r) 6(b) ------------> 3(r) 6(b)
* / \ / \ // \ / \
* 3(b) 6(b) 3(b) 6(b) 3(b) 2(b) 4(b)
* \ \ \
* 4(r) 4(r) 4(r)
*/
void test__delRedBlackTree_remove_1_from_tree_with_1_2_3_4_5_6_nodes_by_using_case_3_and_1(void)
{
setNode(&node4, NULL, NULL, 'r');
setNode(&node6, NULL, NULL, 'b');
setNode(&node1, NULL, NULL, 'b');
setNode(&node3, NULL, &node4, 'b');
setNode(&node5, &node3, &node6, 'r');
setNode(&node2, &node1, &node5, 'b');
Node *root = &node2;
Node *result;
result = delRedBlackTree(&root, &node1);
TEST_ASSERT_EQUAL_PTR(root, &node5);
TEST_ASSERT_EQUAL_PTR(result, &node1);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node2);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node4);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node6);
TEST_ASSERT_EQUAL_NODE(&node2, &node4, 'r', &node3);
TEST_ASSERT_EQUAL_NODE(&node3, &node6, 'b', &node5);
}
void test_avlGetReplace_expected_BF_of_node60_is_0(void){
Node *root = &node30;
int cState = avlAdd(&root,&node20);
cState =avlAdd(&root,&node60);
cState =avlAdd(&root,&node10);
cState =avlAdd(&root,&node40);
cState =avlAdd(&root,&node70);
cState =avlAdd(&root,&node50);
int heightChange;
Node *temp = avlGetReplace( &root->right ,&heightChange);
printf(" heightChange = %d\n", heightChange);
TEST_ASSERT_EQUAL(1,heightChange);
TEST_ASSERT_EQUAL_PTR(&node40,temp);
TEST_ASSERT_EQUAL_NODE(&node60,&node50,&node70,0);
TEST_ASSERT_EQUAL_NODE(&node50,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node70,NULL,NULL,0);
}
/**
* 30(+1) 30(+1)
* / \ ------> / \ heightChange = 1;
* 20 60(-1) 20 60(-1)
* / / \ / / \
* 10 (-1)40 70 10 (0)40 70
* /
* 35
**/
void xtest_avlGetReplace_expected_BF_of_node60_is_negative_1_and_heightChange_is_1(void){
Node *root = &node30;
int cState = avlAdd(&root,&node20);
cState =avlAdd(&root,&node60);
cState =avlAdd(&root,&node10);
cState =avlAdd(&root,&node40);
cState =avlAdd(&root,&node35);
cState =avlAdd(&root,&node70);
int heightChange;
Node *temp = avlGetReplace( &root->right ,&heightChange);
printf(" heightChange = %d\n", heightChange);
TEST_ASSERT_EQUAL(0,heightChange);
printf("temp->data = %d",temp->data);
TEST_ASSERT_EQUAL_PTR(&node35,temp);
TEST_ASSERT_EQUAL_NODE(&node60,&node40,&node70,0);
TEST_ASSERT_EQUAL_NODE(&node40,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node70,NULL,NULL,0);
}
/** 2-node case
* root
* | remove 2
* v -------------> Throw ERR_NODE_UNAVAILABLE
* 1(b)
*/
void test_delRedBlackTree_remove_2_from_tree_with_root_1_should_throw_ERR_NODE_UNAVAILABLE(void)
{
CEXCEPTION_T err;
setNode(&node1, NULL, NULL, 'b');
Node *root = &node1;
Try
{
delRedBlackTree(&root, &node2);
TEST_FAIL_MESSAGE("Expected ERR_NODE_UNAVAILABLE to be thrown");
}
Catch(err)
{
TEST_ASSERT_EQUAL_PTR(root, &node1);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1);
}
}
/** n = 9, m = 2^[Floor(log2 (9+1))] - 1
* = 7
*
* c1(2) c2(3) c2(1)
* 1(R) 2(R) 4(R) 6
* \ / \ / \ / \
* 2 -----> 1 4 -----> 2 6 -----> 4 8
* \ / \ / \ / \ / \ / \
* 3(R) 3 5(R) 1 3 5 8 2 5 7 9
* \ \ / \ / \
* 4 6 7 9 1 3
* \ \
* 5 7(R)
* \ \
* 6 8
* \ \
* 7 9
* \
* 8
* \
* 9
*
*/
void test_rightVineToTree_given_Vine_has_9_node_should_do_c1_and_c2_two_times(void){
setNode(&node1, NULL, &node2, 'b');
setNode(&node2, NULL, &node3, 'b');
setNode(&node3, NULL, &node4, 'b');
setNode(&node4, NULL, &node5, 'b');
setNode(&node5, NULL, &node6, 'b');
setNode(&node6, NULL, &node7, 'b');
setNode(&node7, NULL, &node8, 'b');
setNode(&node8, NULL, &node9, 'b');
setNode(&node9, NULL, NULL, 'b');
Node *vine = &node1;
rightVineToTree(&vine);
TEST_ASSERT_EQUAL_PTR(&node6, vine);
TEST_ASSERT_EQUAL_NODE(&node4, &node8, 'b', &node6);
TEST_ASSERT_EQUAL_NODE(&node2, &node5, 'b', &node4);
TEST_ASSERT_EQUAL_NODE(&node7, &node9 , 'b', &node8);
TEST_ASSERT_EQUAL_NODE(&node1, &node3 , 'b', &node2);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node3);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node5);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node7);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node9);
}
/** n = 6, m = 2^[Floor(log2 (6+1))] - 1
* = 3
*
* c1(3) c2(1)
* 1(R) 2(R) 4
* \ / \ / \
* 2 ----> 1 4 ----> 2 6
* \ / \ / \ /
* 3(R) 3 6 1 3 5
* \ /
* 4 5
* \
* 5(R)
* \
* 6
*/
void test_rightVineToTree_given_Vine_has_6_node_should_form_tree_and_do_c1_and_c2(void){
setNode(&node1, NULL, &node2, 'b');
setNode(&node2, NULL, &node3, 'b');
setNode(&node3, NULL, &node4, 'b');
setNode(&node4, NULL, &node5, 'b');
setNode(&node5, NULL, &node6, 'b');
setNode(&node6, NULL, NULL, 'b');
Node *vine = &node1;
rightVineToTree(&vine);
TEST_ASSERT_EQUAL_PTR(&node4, vine);
TEST_ASSERT_EQUAL_NODE(&node2, &node6, 'b', &node4);
TEST_ASSERT_EQUAL_NODE(&node1, &node3, 'b', &node2);
TEST_ASSERT_EQUAL_NODE(&node5, NULL , 'b', &node6);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node3);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node5);
}
/** 30(+1)60(-1)40(0) -> 30(0)60(0)50(0)
* 30(+1) 30(+2) 40(0)
* / \ ------> / \ -----> / \
* 20 60(-1) 20 60(-1) (0)30 60(0)
* / / \ / \ / \ / \
* 10 (0)40 70 (0)40 70 20 35 50 70
* / \ / \
* 35 50 35 50
**/
void test_avlRemove_remove_node10_and_given_the_bal_factor_of_node40_is_0(void){
Node *root = &node30;
int cState = avlAdd(&root,&node20);
cState =avlAdd(&root,&node60);
cState =avlAdd(&root,&node10);
cState =avlAdd(&root,&node40);
cState =avlAdd(&root,&node70);
cState =avlAdd(&root,&node35);
cState =avlAdd(&root,&node50);
int heightChange;
Node *temp = avlRemove(&root,10,&heightChange);
TEST_ASSERT_EQUAL(1,heightChange);
TEST_ASSERT_EQUAL_PTR(&node10,temp);
TEST_ASSERT_EQUAL_NODE(root,&node30,&node60,0);
TEST_ASSERT_EQUAL_NODE(root->left,&node20,&node35,0);
TEST_ASSERT_EQUAL_NODE(root->right,&node50,&node70,0);
TEST_ASSERT_EQUAL_NODE(&node20,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node35,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node50,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node70,NULL,NULL,0);
}
void test_avlRemove_remove_node130_and_given_the_bal_factor_of_node80_is_0(void){
Node *root = &node100;
int cState = avlAdd(&root,&node60);
cState =avlAdd(&root,&node130);
cState =avlAdd(&root,&node40);
cState =avlAdd(&root,&node80);
cState =avlAdd(&root,&node140);
cState =avlAdd(&root,&node70);
cState =avlAdd(&root,&node90);
int heightChange;
Node *temp = avlRemove(&root,140,&heightChange);
TEST_ASSERT_EQUAL(1,heightChange);
TEST_ASSERT_EQUAL_PTR(&node140,temp);
TEST_ASSERT_EQUAL_NODE(root,&node60,&node100,0);
TEST_ASSERT_EQUAL_NODE(&node100,&node90,&node130,0);
TEST_ASSERT_EQUAL_NODE(&node60,&node40,&node70,0);
TEST_ASSERT_EQUAL_NODE(&node40,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node70,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node90,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node130,NULL,NULL,0);
}
/** Encounter case 1b on the left child after remove successor
*
* parent's left parent's left parent's left
* | | |
* v v v
* 10(b) 10(b) 10(b)
* / \ successor 1 / \ / \
* 5(b) 15(b) ------------> 5(b) 15(b) ------------> 6(b) 15(b)
* / \ / \ // \ / \ / \ / \
* 1(b) 7(b) 13(b) 20(b) NULL 7(b) 13(b) 20(b) 5(b) 7(b) 13(b) 20(b)
* / /
* 6(r) 6(r)
*/
void test_removeNextLargerSuccessor_given_nodes_1_5_6_7_10_13_15_20_should_remove_successor_1(void)
{
setNode(&node6, NULL, NULL, 'r');
setNode(&node7, &node6, NULL, 'b');
setNode(&node13, NULL, NULL, 'b');
setNode(&node20, NULL, NULL, 'b');
setNode(&node1, NULL, NULL, 'b');
setNode(&node5, &node1, &node7, 'b');
setNode(&node15, &node13, &node20, 'b');
setNode(&node10, &node5, &node15, 'b');
Node *parent = &node10, *removeNode;
removeNode = removeNextLargerSuccessor(&parent);
TEST_ASSERT_EQUAL_PTR(&node10, parent);
TEST_ASSERT_EQUAL_PTR(&node1, removeNode);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node5);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node7);
TEST_ASSERT_EQUAL_NODE(&node5, &node7, 'b', &node6);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node13);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node20);
TEST_ASSERT_EQUAL_NODE(&node13, &node20, 'b', &node15);
TEST_ASSERT_EQUAL_NODE(&node6, &node15, 'b', &node10);
}
/**
* root root
* | |
* v v
* 4(b) 4(b)
* / \ remove 7 / \
* 2(r) 6(r) -----------> 2(r) 6(b)
* / \ / \ / \ /
* 1(b) 3(b) 5(b) 7(b) 1(b) 3(b) 5(r)
*/
void test_delRedBlackTree_remove_7_from_tree_with_4_2_1_3_6_5_7_nodes(void)
{
setNode(&node1, NULL, NULL, 'b');
setNode(&node3, NULL, NULL, 'b');
setNode(&node5, NULL, NULL, 'b');
setNode(&node7, NULL, NULL, 'b');
setNode(&node2, &node1, &node3, 'r');
setNode(&node6, &node5, &node7, 'r');
setNode(&node4, &node2, &node6, 'b');
Node *root = &node4;
delRedBlackTree(&root, &node7);
TEST_ASSERT_EQUAL_PTR(root, &node4);
TEST_ASSERT_EQUAL_NODE(&node1, &node3, 'r', &node2);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'r', &node5);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node1);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node3);
TEST_ASSERT_EQUAL_NODE(&node5, NULL, 'b', &node6);
TEST_ASSERT_EQUAL_NODE(&node2, &node6, 'b', &node4);
}
void test_safeMallocTest_allocate_size_100_should_create_record_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory;
MemoryBlock1 ptrBlock = {.header[49] = "##########" , .memory[99] = "abcdef", .footer[49] = "$$$$$$$$$$"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock.memory))-50);
allocatedMemory =(char*)safeMallocTest(100);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(50,allocatedMemory-50);
TEST_ASSERT_EQUAL(100,allocatedMemory);
TEST_ASSERT_EQUAL(200,allocatedMemory+100);
TEST_ASSERT_EQUAL(100,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',allocatedPool);
_free_Expect(allocatedMemory);
freeMemory(allocatedMemory);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_100_and_200_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory100,*allocatedMemory200;
MemoryBlock1 ptrBlock1 = {.header[49] = "##########" , .memory[99] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock2 ptrBlock2 = {.header[49] = "@@@@@@@@@@" , .memory[199] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock1.memory))-50);
allocatedMemory100 = (char*)safeMallocTest(100);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(100,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory100,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(200,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(rightPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightPool);
TEST_ASSERT_EQUAL_NODE(NULL,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory100);
freeMemory(allocatedMemory100);
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_200_and_100_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory100,*allocatedMemory200;
MemoryBlock1 ptrBlock1 = {.header[49] = "@@@@@@@@@@" , .memory[99] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock2 ptrBlock2 = {.header[49] = "##########" , .memory[199] = "abcdef", .footer[49] = "$$$$$$$$$$"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock1.memory))-50);
allocatedMemory100 = (char*)safeMallocTest(100);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(200,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(100,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory100,memoryAddr(leftPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftPool);
TEST_ASSERT_EQUAL_NODE(leftPool,NULL,'b',allocatedPool);
_free_Expect(allocatedMemory100);
freeMemory(allocatedMemory100);
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_200_and_100_and_300_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory100,*allocatedMemory200,*allocatedMemory300;
MemoryBlock2 ptrBlock2 = {.header[49] = "##########" , .memory[199] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock1 ptrBlock1 = {.header[49] = "@@@@@@@@@@" , .memory[99] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock3 ptrBlock3 = {.header[49] = "%%%%%%%%%%" , .memory[299] = "abcdef123456", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock1.memory))-50);
allocatedMemory100 = (char*)safeMallocTest(100);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+300+FOOTER_SIZE)),((char*)sizeof(ptrBlock3.memory))-50);
allocatedMemory300 = (char*)safeMallocTest(300);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(200,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(100,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory100,memoryAddr(leftPool));
TEST_ASSERT_EQUAL(300,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory300,memoryAddr(rightPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightPool);
TEST_ASSERT_EQUAL_NODE(leftPool,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory100);
freeMemory(allocatedMemory100);
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedMemory300);
freeMemory(allocatedMemory300);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_200_and_300_and_100_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory100,*allocatedMemory200,*allocatedMemory300;
MemoryBlock1 ptrBlock1 = {.header[49] = "##########" , .memory[99] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock2 ptrBlock2 = {.header[49] = "@@@@@@@@@@" , .memory[199] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock3 ptrBlock3 = {.header[49] = "%%%%%%%%%%" , .memory[299] = "abcdef123456", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+300+FOOTER_SIZE)),((char*)sizeof(ptrBlock3.memory))-50);
allocatedMemory300 = (char*)safeMallocTest(300);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock1.memory))-50);
allocatedMemory100 = (char*)safeMallocTest(100);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(200,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(100,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory100,memoryAddr(leftPool));
TEST_ASSERT_EQUAL(300,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory300,memoryAddr(rightPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightPool);
TEST_ASSERT_EQUAL_NODE(leftPool,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory100);
freeMemory(allocatedMemory100);
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedMemory300);
freeMemory(allocatedMemory300);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_200_and_300_and_400_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory200,*allocatedMemory300,*allocatedMemory400;
MemoryBlock2 ptrBlock2 = {.header[49] = "##########" , .memory[199] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock3 ptrBlock3 = {.header[49] = "@@@@@@@@@@" , .memory[299] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock4 ptrBlock4 = {.header[49] = "%%%%%%%%%%" , .memory[399] = "abcdef123456", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+300+FOOTER_SIZE)),((char*)sizeof(ptrBlock3.memory))-50);
allocatedMemory300 = (char*)safeMallocTest(300);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock4.memory))-50);
allocatedMemory400 = (char*)safeMallocTest(400);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(300,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory300,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(200,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(leftPool));
TEST_ASSERT_EQUAL(400,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory400,memoryAddr(rightPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightPool);
TEST_ASSERT_EQUAL_NODE(leftPool,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedMemory300);
freeMemory(allocatedMemory300);
_free_Expect(allocatedMemory400);
freeMemory(allocatedMemory400);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_400_and_300_and_200_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory200,*allocatedMemory300,*allocatedMemory400;
MemoryBlock2 ptrBlock2 = {.header[49] = "##########" , .memory[199] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock3 ptrBlock3 = {.header[49] = "@@@@@@@@@@" , .memory[299] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock4 ptrBlock4 = {.header[49] = "%%%%%%%%%%" , .memory[399] = "abcdef123456", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+400+FOOTER_SIZE)),((char*)sizeof(ptrBlock4.memory))-50);
allocatedMemory400 = (char*)safeMallocTest(400);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+300+FOOTER_SIZE)),((char*)sizeof(ptrBlock3.memory))-50);
allocatedMemory300 = (char*)safeMallocTest(300);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(300,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory300,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(200,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(leftPool));
TEST_ASSERT_EQUAL(400,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory400,memoryAddr(rightPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightPool);
TEST_ASSERT_EQUAL_NODE(leftPool,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedMemory300);
freeMemory(allocatedMemory300);
_free_Expect(allocatedMemory400);
freeMemory(allocatedMemory400);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_300_and_100_and_200_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory100,*allocatedMemory200,*allocatedMemory300;
MemoryBlock1 ptrBlock1 = {.header[49] = "##########" , .memory[99] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock2 ptrBlock2 = {.header[49] = "@@@@@@@@@@" , .memory[199] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock3 ptrBlock3 = {.header[49] = "%%%%%%%%%%" , .memory[299] = "abcdef123456", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+300+FOOTER_SIZE)),((char*)sizeof(ptrBlock3.memory))-50);
allocatedMemory300 = (char*)safeMallocTest(300);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock1.memory))-50);
allocatedMemory100 = (char*)safeMallocTest(100);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(200,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(100,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory100,memoryAddr(leftPool));
TEST_ASSERT_EQUAL(300,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory300,memoryAddr(rightPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightPool);
TEST_ASSERT_EQUAL_NODE(leftPool,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory100);
freeMemory(allocatedMemory100);
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedMemory300);
freeMemory(allocatedMemory300);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_100_and_400_and_200_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory100,*allocatedMemory200,*allocatedMemory400;
MemoryBlock1 ptrBlock1 = {.header[49] = "##########" , .memory[99] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock2 ptrBlock2 = {.header[49] = "@@@@@@@@@@" , .memory[199] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock4 ptrBlock4 = {.header[49] = "%%%%%%%%%%" , .memory[399] = "abcdef123456", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock1.memory))-50);
allocatedMemory100 = (char*)safeMallocTest(100);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+400+FOOTER_SIZE)),((char*)sizeof(ptrBlock4.memory))-50);
allocatedMemory400 = (char*)safeMallocTest(400);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(200,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(100,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory100,memoryAddr(leftPool));
TEST_ASSERT_EQUAL(400,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory400,memoryAddr(rightPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightPool);
TEST_ASSERT_EQUAL_NODE(leftPool,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory100);
freeMemory(allocatedMemory100);
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedMemory400);
freeMemory(allocatedMemory400);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_400_and_200_and_300_and_100_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory100,*allocatedMemory200,*allocatedMemory300,*allocatedMemory400;
MemoryBlock1 ptrBlock1 = {.header[49] = "##########" , .memory[99] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock2 ptrBlock2 = {.header[49] = "@@@@@@@@@@" , .memory[199] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock3 ptrBlock3 = {.header[49] = "@@@@@@@@@@" , .memory[299] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock4 ptrBlock4 = {.header[49] = "%%%%%%%%%%" , .memory[399] = "abcdef123456", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+400+FOOTER_SIZE)),((char*)sizeof(ptrBlock4.memory))-50);
allocatedMemory400 = (char*)safeMallocTest(400);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+300+FOOTER_SIZE)),((char*)sizeof(ptrBlock3.memory))-50);
allocatedMemory300 = (char*)safeMallocTest(300);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock1.memory))-50);
allocatedMemory100 = (char*)safeMallocTest(100);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(300,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory300,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(200,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(leftPool));
TEST_ASSERT_EQUAL(400,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory400,memoryAddr(rightPool));
TEST_ASSERT_EQUAL(100,memorySize(leftChildPool));
TEST_ASSERT_EQUAL(allocatedMemory100,memoryAddr(leftChildPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftChildPool);
TEST_ASSERT_EQUAL_NODE(allocatedPool->left->left,NULL,'b',leftPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'b',rightPool);
TEST_ASSERT_EQUAL_NODE(leftPool,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory100);
freeMemory(allocatedMemory100);
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedMemory300);
freeMemory(allocatedMemory300);
_free_Expect(allocatedMemory400);
freeMemory(allocatedMemory400);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
void test_safeMallocTest_allocate_size_500_400_and_200_and_300_and_100_should_create_descriptor_and_add_into_allocated_pool(void){
initializePool();
char *allocatedMemory100,*allocatedMemory200,*allocatedMemory300,*allocatedMemory400,*allocatedMemory500;
MemoryBlock1 ptrBlock1 = {.header[49] = "##########" , .memory[99] = "abcdef", .footer[49] = "$$$$$$$$$$"};
MemoryBlock2 ptrBlock2 = {.header[49] = "@@@@@@@@@@" , .memory[199] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock3 ptrBlock3 = {.header[49] = "@@@@@@@@@@" , .memory[299] = "abcdef123", .footer[49] = "&&&&&&&&&&"};
MemoryBlock4 ptrBlock4 = {.header[49] = "%%%%%%%%%%" , .memory[399] = "abcdef123456", .footer[49] = "&&&&&&&&&&"};
MemoryBlock5 ptrBlock5 = {.header[49] = "%%%%%%%%%%" , .memory[499] = "abcdef123456789", .footer[49] = "&&&&&&&&&&"};
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+500+FOOTER_SIZE)),((char*)sizeof(ptrBlock5.memory))-50);
allocatedMemory500 = (char*)safeMallocTest(500);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+400+FOOTER_SIZE)),((char*)sizeof(ptrBlock4.memory))-50);
allocatedMemory400 = (char*)safeMallocTest(400);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+300+FOOTER_SIZE)),((char*)sizeof(ptrBlock3.memory))-50);
allocatedMemory300 = (char*)safeMallocTest(300);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+200+FOOTER_SIZE)),((char*)sizeof(ptrBlock2.memory))-50);
allocatedMemory200 = (char*)safeMallocTest(200);
_malloc_ExpectAndReturn((sizeof(HEADER_SIZE+100+FOOTER_SIZE)),((char*)sizeof(ptrBlock1.memory))-50);
allocatedMemory100 = (char*)safeMallocTest(100);
TEST_ASSERT_NOT_NULL(allocatedPool);
TEST_ASSERT_EQUAL(200,memorySize(allocatedPool));
TEST_ASSERT_EQUAL(allocatedMemory200,memoryAddr(allocatedPool));
TEST_ASSERT_EQUAL(100,memorySize(leftPool));
TEST_ASSERT_EQUAL(allocatedMemory100,memoryAddr(leftPool));
TEST_ASSERT_EQUAL(400,memorySize(rightPool));
TEST_ASSERT_EQUAL(allocatedMemory400,memoryAddr(rightPool));
TEST_ASSERT_EQUAL(300,memorySize(rightLeftChildPool));
TEST_ASSERT_EQUAL(allocatedMemory300,memoryAddr(rightLeftChildPool));
TEST_ASSERT_EQUAL(500,memorySize(rightChildPool));
TEST_ASSERT_EQUAL(allocatedMemory500,memoryAddr(rightChildPool));
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightChildPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',rightLeftChildPool);
TEST_ASSERT_EQUAL_NODE(NULL,NULL,'r',leftPool);
TEST_ASSERT_EQUAL_NODE(rightLeftChildPool,rightChildPool,'b',rightPool);
TEST_ASSERT_EQUAL_NODE(leftPool,rightPool,'b',allocatedPool);
//Free memory and pool
_free_Expect(allocatedMemory100);
freeMemory(allocatedMemory100);
_free_Expect(allocatedMemory200);
freeMemory(allocatedMemory200);
_free_Expect(allocatedMemory300);
freeMemory(allocatedMemory300);
_free_Expect(allocatedMemory400);
freeMemory(allocatedMemory400);
_free_Expect(allocatedMemory500);
freeMemory(allocatedMemory500);
_free_Expect(allocatedPool);
freeMemory(allocatedPool);
}
/**
* 80(+1) 80(+1) 80(0) HC = 1;
* / \ ------> / \ -----> / \
* 50 140(-1) 50 140(-1) 50 140(-1)
* / \ / \ / \ / \ / \ / \
* 40 70 (+1)100 150 40 70 (+2)100 150 40 70 (0)110 150
* / / \ \ / \ \ / / \ \
* 30 90 110 160 30 110 160 30 100 120 160
* / \ / \ \
* 105 120 105 120 105
**/
void test_avlGetReplace_expected_get_node90_BF_of_node_is_0(void){
Node *root = &node80;
int cState = avlAdd(&root,&node50);
cState =avlAdd(&root,&node140);
cState =avlAdd(&root,&node40);
cState =avlAdd(&root,&node70);
cState =avlAdd(&root,&node100);
cState =avlAdd(&root,&node150);
cState =avlAdd(&root,&node30);
cState =avlAdd(&root,&node90);
cState =avlAdd(&root,&node110);
cState =avlAdd(&root,&node160);
cState =avlAdd(&root,&node105);
cState =avlAdd(&root,&node120);
TEST_ASSERT_EQUAL_NODE(root,&node50,&node140,1);
TEST_ASSERT_EQUAL_NODE(&node50,&node40,&node70,-1);
TEST_ASSERT_EQUAL_NODE(&node40,&node30,NULL,-1);
TEST_ASSERT_EQUAL_NODE(&node140,&node100,&node150,-1);
TEST_ASSERT_EQUAL_NODE(&node90,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node110,&node105,&node120,0);
TEST_ASSERT_EQUAL_NODE(&node100,&node90,&node110,1);
TEST_ASSERT_EQUAL_NODE(&node150,NULL,&node160,1);
int heightChange;
Node *temp = avlGetReplace( &root->right ,&heightChange);
printf(" heightChange = %d\n", heightChange);
TEST_ASSERT_EQUAL(0,heightChange);
TEST_ASSERT_EQUAL_PTR(&node90,temp);
TEST_ASSERT_EQUAL_NODE(&node110,&node100,&node120,-1);
TEST_ASSERT_EQUAL_NODE(&node80,&node50,&node140,1);
TEST_ASSERT_EQUAL_NODE(&node50,&node40,&node70,-1);
TEST_ASSERT_EQUAL_NODE(&node40,&node30,NULL,-1);
TEST_ASSERT_EQUAL_NODE(&node70,NULL,NULL,0);
TEST_ASSERT_EQUAL_NODE(&node140,&node110,&node150,-1);
TEST_ASSERT_EQUAL_NODE(&node150,NULL,&node160,1);
}
