void test_ByteArray_GetSlice_should_return_a_subarray_of_the_ByteArray(void)
{
uint8_t data[] = {0x1u, 0x2u, 0x3u, 0x4u};
size_t len = sizeof(data);
ByteArray array = {.data = data, .len = len};
size_t sliceLen;
// Validate slice of full array
ByteArray slice0 = ByteArray_GetSlice(array, 0, len);
TEST_ASSERT_EQUAL_PTR(data, slice0.data);
TEST_ASSERT_EQUAL(len, slice0.len);
TEST_ASSERT_EQUAL_HEX8_ARRAY(data, slice0.data, len);
// Validate slice from beginning of array
sliceLen = len - 1;
ByteArray slice1 = ByteArray_GetSlice(array, 0, sliceLen);
TEST_ASSERT_EQUAL_PTR(data, slice1.data);
TEST_ASSERT_EQUAL(sliceLen, slice1.len);
TEST_ASSERT_EQUAL_HEX8_ARRAY(data, slice1.data, sliceLen);
// Validate slice from non-start to the end of the array
sliceLen = len - 1;
ByteArray slice2 = ByteArray_GetSlice(array, 1, sliceLen);
TEST_ASSERT_EQUAL_PTR(&data[1], slice2.data);
TEST_ASSERT_EQUAL(sliceLen, slice2.len);
TEST_ASSERT_EQUAL_HEX8_ARRAY(&data[1], slice2.data, sliceLen);
// Validate slice from middle of the array
sliceLen = len - 2;
ByteArray slice3 = ByteArray_GetSlice(array, 1, sliceLen);
TEST_ASSERT_EQUAL_PTR(&data[1], slice3.data);
TEST_ASSERT_EQUAL(sliceLen, slice3.len);
TEST_ASSERT_EQUAL_HEX8_ARRAY(&data[1], slice3.data, sliceLen);
}
/** Encounter case 3 on the left child after remove successor (with case 1a appear after rotate)
*
* parent's left parent's left parent's left parent's left
* | | | |
* v v v v
* 10(b) 10(b) 10(b) 10(b)
* / \ successor 1 / \ / \ / \
* 4(b) 15(b) ------------> 4(b) 15(b) ------------> 7(b) 15(b) ------------> 7(b) 15(b)
* / \ / \ // \ / \ / \ / \ / \ / \
* 1(b) 7(r) 13(b) 20(b) NULL 7(r) 13(b) 20(b) 4(r) 8(b) 13(b) 20(b) 5(r) 8(b) 13(b) 20(b)
* / \ / \ // \ / \
* 5(b) 8(b) 5(b) 8(b) NULL 5(b) 4(b) 6(b)
* \ \ \
* 6(r) 6(r) 6(r)
*/
void test_removeNextLargerSuccessor_given_nodes_1_4_5_6_7_8_10_13_15_20_should_remove_successor_1(void)
{
setNode(&node6, NULL, NULL, 'r');
setNode(&node5, NULL, &node6, 'b');
setNode(&node8, NULL, NULL, 'b');
setNode(&node7, &node5, &node8, 'r');
setNode(&node13, NULL, NULL, 'b');
setNode(&node20, NULL, NULL, 'b');
setNode(&node1, NULL, NULL, 'b');
setNode(&node4, &node1, &node7, 'b');
setNode(&node15, &node13, &node20, 'b');
setNode(&node10, &node4, &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', &node4);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node6);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'b', &node8);
TEST_ASSERT_EQUAL_NODE(&node4, &node6, 'r', &node5);
TEST_ASSERT_EQUAL_NODE(&node5, &node8, 'b', &node7);
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(&node7, &node15, 'b', &node10);
}
/** listA has p1 , p3 and p5 no conflict to listA
* studentNum in p3,p5 are 50, sum toggether are 100 , is within ratio of targetNum
* so will take out p3 and p5
* ****************************************************************
* ( targetNum = 100 )
*
* listA : p1
* c1, c2
*
* listB : p3(50) p4(50) p5(50)
* c3, c4 c1,c2 c5,c6
* * *
* ---------------------OUTPUT----------------------------
*
* truePapers = p5,p3
* ListB = p4;
*/
void test_getTruePapersFromListB_given_p3_p5_no_conflict_but_p4_has_should_take_out_p3_p5(void){
setPaperTakersNum(&p1 ,"p1", 50);
addProgrammeToPaper(&p1, &c1);
addProgrammeToPaper(&p1, &c2);
setPaperTakersNum(&p3 ,"p3", 50);
addProgrammeToPaper(&p3, &c3);
addProgrammeToPaper(&p3, &c4);
setPaperTakersNum(&p4 ,"p4", 50);
addProgrammeToPaper(&p4, &c1);
addProgrammeToPaper(&p4, &c2);
setPaperTakersNum(&p5 ,"p3", 50);
addProgrammeToPaper(&p5, &c5);
addProgrammeToPaper(&p5, &c6);
listA = linkListNew(&p1);
listB = linkListNew(&p5);
addDataToHead(&listB, &p4);
addDataToHead(&listB, &p3);
//--------------------------------THE ABOVE ARE THE ELEMENT INITIALIZATION---------------------------------------
truePapers = getTruePapersFromListB(listA, listB, 100);
TEST_ASSERT_EQUAL_PTR( &p5, TAKEN_PAPER1->data);
TEST_ASSERT_EQUAL_PTR( &p3, TAKEN_PAPER2->data);
TEST_ASSERT_NULL(TAKEN_PAPER3);
CLEAR_ALL_LIST;
}
/**
*
* Session1 : p1 p2
* c1,c2 c3,c4
*
* Session2 : p3 p4
* c2,c3 c4,c1
*
* Session1 and Session2 all elements are confict with each other, their programmes element already exist in other session,
* so no matter how exchange will just only cause confict, therefore should not do mutation
*/
void test_mutateTwoSession_given_the_2session_all_element_conflict_with_other_should_not_do_Mutation(void){
setPaperTakersNum(&p1, "p1", 50);
addProgrammeToPaper(&p1, &c1);
addProgrammeToPaper(&p1, &c2);
setPaperTakersNum(&p2, "p2", 50);
addProgrammeToPaper(&p2, &c3);
addProgrammeToPaper(&p2, &c4);
setPaperTakersNum(&p3, "p3", 50);
addProgrammeToPaper(&p3, &c2);
addProgrammeToPaper(&p3, &c3);
setPaperTakersNum(&p4, "p4", 50);
addProgrammeToPaper(&p4, &c4);
addProgrammeToPaper(&p4, &c1);
addPaperToSession(&s1, &p2);
addPaperToSession(&s1, &p1);
addPaperToSession(&s2, &p4);
addPaperToSession(&s2, &p3);
//----------------------------------------------------------------------------------------
mutateTwoSession(&s1, &s2);
TEST_ASSERT_EQUAL_PTR( &p1,S1_HEAD->data);
TEST_ASSERT_EQUAL_PTR( &p2,S1_HEAD1->data);
TEST_ASSERT_NULL(S1_HEAD2);
TEST_ASSERT_EQUAL_PTR( &p3,S2_HEAD->data);
TEST_ASSERT_EQUAL_PTR( &p4,S2_HEAD1->data);
TEST_ASSERT_NULL(S2_HEAD2);
CLEAR_ALL_LIST;
}
void test_createdXorModule_given_TRI_3_INPUT_type_should_create_module_for_XOR_gate(void)
{
Module *XOR;
int i, inputType = TRI_3_INPUT;
XOR = createdXorModule(inputType);
TEST_ASSERT_NOT_NULL(XOR);
TEST_ASSERT_EQUAL_STRING("XOR", XOR->name);
TEST_ASSERT_EQUAL_PTR(&xorEvent, XOR->event);
TEST_ASSERT_EQUAL_PTR(&setXor, XOR->set);
TEST_ASSERT_EQUAL_PTR(&configureInputOutput, XOR->configure);
TEST_ASSERT_EQUAL(inputType, XOR->typeOfInput);
TEST_ASSERT_EQUAL(TOTAL_PIN, XOR->totalPin);
for(i = 0; i < TOTAL_PIN; i++)
{
if(i < 9)
TEST_ASSERT_EQUAL(INPUT_PIN, (XOR->pin[i]).type);
else if(i > 8 && i < 12)
TEST_ASSERT_EQUAL(OUTPUT_PIN, (XOR->pin[i]).type);
else
TEST_ASSERT_EQUAL(UNUSED_PIN, (XOR->pin[i]).type);
TEST_ASSERT_EQUAL(i, (XOR->pin[i]).pinNumber);
TEST_ASSERT_EQUAL(LOW, (XOR->pin[i]).state);
TEST_ASSERT_EQUAL_PTR(NULL, (XOR->pin[i]).pipe);
}
destroyModule(XOR);
}
void test_createdNotModule_given_HEX_INV_type_should_create_module_for_NOT_gate(void)
{
Module *NOT;
int i, inputType = HEX_INV;
NOT = createdNotModule(inputType);
TEST_ASSERT_NOT_NULL(NOT);
TEST_ASSERT_EQUAL_STRING("NOT", NOT->name);
TEST_ASSERT_EQUAL_PTR(¬Event, NOT->event);
TEST_ASSERT_EQUAL_PTR(&setNot, NOT->set);
TEST_ASSERT_EQUAL_PTR(&configureInputOutput, NOT->configure);
TEST_ASSERT_EQUAL(inputType, NOT->typeOfInput);
TEST_ASSERT_EQUAL(TOTAL_PIN, NOT->totalPin);
for(i = 0; i < TOTAL_PIN; i++)
{
if(i < 6)
TEST_ASSERT_EQUAL(INPUT_PIN, (NOT->pin[i]).type);
else if(i > 5 && i < 12)
TEST_ASSERT_EQUAL(OUTPUT_PIN, (NOT->pin[i]).type);
else
TEST_ASSERT_EQUAL(UNUSED_PIN, (NOT->pin[i]).type);
TEST_ASSERT_EQUAL(i, (NOT->pin[i]).pinNumber);
TEST_ASSERT_EQUAL(LOW, (NOT->pin[i]).state);
TEST_ASSERT_EQUAL_PTR(NULL, (NOT->pin[i]).pipe);
}
destroyModule(NOT);
}
void test_createdNorModule_given_DUAL_4_INPUT_type_should_create_module_for_MOR_gate(void)
{
Module *NOR;
int i, inputType = DUAL_4_INPUT;
NOR = createdNorModule(inputType);
TEST_ASSERT_NOT_NULL(NOR);
TEST_ASSERT_EQUAL_STRING("NOR", NOR->name);
TEST_ASSERT_EQUAL_PTR(&norEvent, NOR->event);
TEST_ASSERT_EQUAL_PTR(&setNor, NOR->set);
TEST_ASSERT_EQUAL_PTR(&configureInputOutput, NOR->configure);
TEST_ASSERT_EQUAL(inputType, NOR->typeOfInput);
TEST_ASSERT_EQUAL(TOTAL_PIN, NOR->totalPin);
for(i = 0; i < TOTAL_PIN; i++)
{
if(i < 8)
TEST_ASSERT_EQUAL(INPUT_PIN, (NOR->pin[i]).type);
else if(i > 7 && i < 10)
TEST_ASSERT_EQUAL(OUTPUT_PIN, (NOR->pin[i]).type);
else
TEST_ASSERT_EQUAL(UNUSED_PIN, (NOR->pin[i]).type);
TEST_ASSERT_EQUAL(i, (NOR->pin[i]).pinNumber);
TEST_ASSERT_EQUAL(LOW, (NOR->pin[i]).state);
TEST_ASSERT_EQUAL_PTR(NULL, (NOR->pin[i]).pipe);
}
destroyModule(NOR);
}
void test_createdNandModule_given_TRI_3_INPUT_type_should_create_module_for_NAND_gate(void)
{
Module *NAND;
int i, inputType = TRI_3_INPUT;
NAND = createdNandModule(inputType);
TEST_ASSERT_NOT_NULL(NAND);
TEST_ASSERT_EQUAL_STRING("NAND", NAND->name);
TEST_ASSERT_EQUAL_PTR(&nandEvent, NAND->event);
TEST_ASSERT_EQUAL_PTR(&setNand, NAND->set);
TEST_ASSERT_EQUAL_PTR(&configureInputOutput, NAND->configure);
TEST_ASSERT_EQUAL(inputType, NAND->typeOfInput);
TEST_ASSERT_EQUAL(TOTAL_PIN, NAND->totalPin);
for(i = 0; i < TOTAL_PIN; i++)
{
if(i < 9)
TEST_ASSERT_EQUAL(INPUT_PIN, (NAND->pin[i]).type);
else if(i > 8 && i < 12)
TEST_ASSERT_EQUAL(OUTPUT_PIN, (NAND->pin[i]).type);
else
TEST_ASSERT_EQUAL(UNUSED_PIN, (NAND->pin[i]).type);
TEST_ASSERT_EQUAL(i, (NAND->pin[i]).pinNumber);
TEST_ASSERT_EQUAL(LOW, (NAND->pin[i]).state);
TEST_ASSERT_EQUAL_PTR(NULL, (NAND->pin[i]).pipe);
}
destroyModule(NAND);
}
void test_createdAndModule_given_DUAL_4_INPUT_type_should_create_module_for_AND_gate(void)
{
Module *AND;
int i, inputType = DUAL_4_INPUT;
AND = createdAndModule(inputType);
TEST_ASSERT_NOT_NULL(AND);
TEST_ASSERT_EQUAL_STRING("AND", AND->name);
TEST_ASSERT_EQUAL_PTR(&andEvent, AND->event);
TEST_ASSERT_EQUAL_PTR(&setAnd, AND->set);
TEST_ASSERT_EQUAL_PTR(&configureInputOutput, AND->configure);
TEST_ASSERT_EQUAL(inputType, AND->typeOfInput);
TEST_ASSERT_EQUAL(TOTAL_PIN, AND->totalPin);
for(i = 0; i < TOTAL_PIN; i++)
{
if(i < 8)
TEST_ASSERT_EQUAL(INPUT_PIN, (AND->pin[i]).type);
else if(i > 7 && i < 10)
TEST_ASSERT_EQUAL(OUTPUT_PIN, (AND->pin[i]).type);
else
TEST_ASSERT_EQUAL(UNUSED_PIN, (AND->pin[i]).type);
TEST_ASSERT_EQUAL(i, (AND->pin[i]).pinNumber);
TEST_ASSERT_EQUAL(LOW, (AND->pin[i]).state);
TEST_ASSERT_EQUAL_PTR(NULL, (AND->pin[i]).pipe);
}
destroyModule(AND);
}
/**
*
* Session1 : p1 p2(100)
* c1,c2 c5,c6
* *
*
* Session2 : p3(10) p4(10)
* c7,c8 c9,c10
*
*
* p2 is no confict to session2, but session2 can not return a papers combo having close number to p2, so do nothing
*/
void test_mutateTwoSession_given_the_session2_cannot_return_papers_combo_having_close_number_to_p2_should_do_nothing(void){
setPaperTakersNum(&p1, "p1", 50);
addProgrammeToPaper(&p1, &c1);
addProgrammeToPaper(&p1, &c2);
setPaperTakersNum(&p2, "p2", 100);
addProgrammeToPaper(&p2, &c5);
addProgrammeToPaper(&p2, &c6);
setPaperTakersNum(&p3, "p3", 10);
addProgrammeToPaper(&p3, &c7);
addProgrammeToPaper(&p3, &c8);
setPaperTakersNum(&p4, "p4", 10);
addProgrammeToPaper(&p4, &c9);
addProgrammeToPaper(&p4, &c10);
addPaperToSession(&s1, &p2);
addPaperToSession(&s1, &p1);
addPaperToSession(&s2, &p4);
addPaperToSession(&s2, &p3);
//----------------------------------------------------------------------------------------
mutateTwoSession(&s1, &s2);
TEST_ASSERT_EQUAL_PTR( &p1,S1_HEAD->data);
TEST_ASSERT_EQUAL_PTR( &p2,S1_HEAD1->data);
TEST_ASSERT_NULL(S1_HEAD2);
TEST_ASSERT_EQUAL_PTR( &p3,S2_HEAD->data);
TEST_ASSERT_EQUAL_PTR( &p4,S2_HEAD1->data);
TEST_ASSERT_NULL(S2_HEAD2);
CLEAR_ALL_LIST;
}
/**
*
* Session1 : p1 p2(100)
* c1,c2 c5,c6
* *
*
* Session2 : p3(50) p4(50)
* c7,c8 c8,c1
*
* (p3 and p4 having c8 )
* p2 is no confict to session2, p3 and p4 together can meet p2 studentNum, but p3 p4 them selves has confict, so do nothing
*/
void test_mutateTwoSession_given_the_p3_p4_having_c8_cause_conflict_so_do_nothing(void){
setPaperTakersNum(&p1, "p1", 50);
addProgrammeToPaper(&p1, &c1);
addProgrammeToPaper(&p1, &c2);
setPaperTakersNum(&p2, "p2", 100);
addProgrammeToPaper(&p2, &c5);
addProgrammeToPaper(&p2, &c6);
setPaperTakersNum(&p3, "p3", 50);
addProgrammeToPaper(&p3, &c7);
addProgrammeToPaper(&p3, &c8);
setPaperTakersNum(&p4, "p4", 50);
addProgrammeToPaper(&p4, &c8);
addProgrammeToPaper(&p4, &c1);
addPaperToSession(&s1, &p2);
addPaperToSession(&s1, &p1);
addPaperToSession(&s2, &p4);
addPaperToSession(&s2, &p3);
//----------------------------------------------------------------------------------------
mutateTwoSession(&s1, &s2);
TEST_ASSERT_EQUAL_PTR( &p1,S1_HEAD->data);
TEST_ASSERT_EQUAL_PTR( &p2,S1_HEAD1->data);
TEST_ASSERT_NULL(S1_HEAD2);
TEST_ASSERT_EQUAL_PTR( &p3,S2_HEAD->data);
TEST_ASSERT_EQUAL_PTR( &p4,S2_HEAD1->data);
TEST_ASSERT_NULL(S2_HEAD2);
CLEAR_ALL_LIST;
}
void test_createdOrModule_given_QUAD_2_INPUT_type_should_create_module_for_OR_gate(void)
{
Module *OR;
int i, inputType = QUAD_2_INPUT;
OR = createdOrModule(inputType);
TEST_ASSERT_NOT_NULL(OR);
TEST_ASSERT_EQUAL_STRING("OR", OR->name);
TEST_ASSERT_EQUAL_PTR(&orEvent, OR->event);
TEST_ASSERT_EQUAL_PTR(&setOr, OR->set);
TEST_ASSERT_EQUAL_PTR(&configureInputOutput, OR->configure);
TEST_ASSERT_EQUAL(inputType, OR->typeOfInput);
TEST_ASSERT_EQUAL(TOTAL_PIN, OR->totalPin);
for(i = 0; i < TOTAL_PIN; i++)
{
if(i < 8)
TEST_ASSERT_EQUAL(INPUT_PIN, (OR->pin[i]).type);
else if(i > 7 && i < 12)
TEST_ASSERT_EQUAL(OUTPUT_PIN, (OR->pin[i]).type);
else
TEST_ASSERT_EQUAL(UNUSED_PIN, (OR->pin[i]).type);
TEST_ASSERT_EQUAL(i, (OR->pin[i]).pinNumber);
TEST_ASSERT_EQUAL(LOW, (OR->pin[i]).state);
TEST_ASSERT_EQUAL_PTR(NULL, (OR->pin[i]).pipe);
}
destroyModule(OR);
}
void test_configureInputOutput_given_AND_and_OR_that_connected_to_pipe_should_connect_output_from_pipe_to_AND_module_and_add_data_to_pipe(void)
{
Module *AND, *OR;
Pipe *pipe;
ModuleAndPin *moduleAndPin;
int inputType = QUAD_2_INPUT;
OR = createdOrModule(inputType);
AND = createdAndModule(inputType);
pipe = createdPipeModule();
(OR->pin[9]).pipe = pipe;
OR->configure((void *)OR, (void *)&OR->pin[9], (void *)AND, (void *)&AND->pin[0]);
moduleAndPin = (OR->pin[9]).pipe->data->dataPtr;
TEST_ASSERT_NOT_NULL(AND);
TEST_ASSERT_NOT_NULL(OR);
TEST_ASSERT_NOT_NULL((OR->pin[9]).pipe);
TEST_ASSERT_EQUAL_PTR((OR->pin[9]).pipe, (AND->pin[0]).pipe);
TEST_ASSERT_EQUAL_PTR(AND, moduleAndPin->module);
TEST_ASSERT_EQUAL_PTR(&AND->pin[0], moduleAndPin->pin);
destroyModule(AND);
destroyModule(OR);
}
void test_add_SHOULD_NOT_ADD_IF_BUFFER_IS_FULL()
{
CircularBuffer *CB = CreateBuffer(SIZE_OF_BUFFER);
CB->length = CB-> size;
CB ->buffer[0] = NUMBER+1; //Fake the original number.
add(CB,NUMBER);
//The number in slot 0 still be the same
TEST_ASSERT_EQUAL( NUMBER+1, CB->buffer[0]);
// Add should fail to size buffer is full (0 indicates failures)
TEST_ASSERT_EQUAL(0,add(CB,NUMBER));
CB=CreateBuffer(SIZE_OF_BUFFER);
add(CB,1);
add(CB,2);
add(CB,3);
add(CB,4);
add(CB,5);
//Add should fail size buffer is full (0indicates failures)
TEST_ASSERT_EQUAL(0,add(CB,6));
TEST_ASSERT_EQUAL(1,CB->buffer[0]);
TEST_ASSERT_EQUAL(2,CB->buffer[1]);
TEST_ASSERT_EQUAL(3,CB->buffer[2]);
TEST_ASSERT_EQUAL(4,CB->buffer[3]);
TEST_ASSERT_EQUAL(5,CB->buffer[4]);
TEST_ASSERT_EQUAL_PTR(&(CB->buffer[0]),CB->head);
TEST_ASSERT_EQUAL_PTR(CB->tail,CB->head);
}
void test_KineticBuilder_BuildSetPin_should_build_a_SECURITY_operation_to_set_new_ERASE_PIN(void)
{
char oldPinData[] = "1234";
char newPinData[] = "5678";
ByteArray oldPin = ByteArray_Create(oldPinData, sizeof(oldPinData));
ByteArray newPin = ByteArray_Create(newPinData, sizeof(newPinData));
KineticOperation_ValidateOperation_Expect(&Operation);
KineticBuilder_BuildSetPin(&Operation, oldPin, newPin, false);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(KineticOperation_TimeoutSetPin, Operation.timeoutSeconds);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__SECURITY,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(&Request.message.body, Request.command->body);
TEST_ASSERT_EQUAL_PTR(&Request.message.security, Request.command->body->security);
TEST_ASSERT_TRUE(Request.command->body->security->has_olderasepin);
TEST_ASSERT_EQUAL_PTR(oldPinData, Request.command->body->security->olderasepin.data);
TEST_ASSERT_EQUAL(oldPin.len, Request.command->body->security->olderasepin.len);
TEST_ASSERT_TRUE(Request.command->body->security->has_newerasepin);
TEST_ASSERT_EQUAL_PTR(newPinData, Request.command->body->security->newerasepin.data);
TEST_ASSERT_EQUAL(newPin.len, Request.command->body->security->newerasepin.len);
TEST_ASSERT_NULL(Request.command->body->pinop);
TEST_ASSERT_EQUAL_PTR(&KineticCallbacks_Basic, Operation.opCallback);
TEST_ASSERT_NULL(Operation.response);
}
/** 2-node case
* remove 2
* root -> 2(b) ----------> NULL
*/
void test_genericDelRedBlackTree_remove_node2_from_tree_with_only_node2(void)
{
setNode(&node2, NULL, NULL, 'b');
Node *root = &node2, *removeNode;
removeNode = genericDelRedBlackTree(&root, &node2, compareEventInfo);
TEST_ASSERT_EQUAL_PTR(NULL, root);
TEST_ASSERT_EQUAL_PTR(&node2, removeNode);
}
/** plist = p1,p2,p3,p4,p5,p6,p7,p8,p9
*
* population = 600
*
* 9 paper, each paper has 50 person, 9*50 = 540
* session can have all paper, then for build 1 session wit all element
*
*----------------output-------------------
*
* Table: s1
* p1p2p3p4p5p6p7p8p9
*
*/
void test_buildTable_given_9paper_populatoin_is_600_should_create_1_session(void){
pList = linkListNew(&p9);
addDataToHead(&pList, &p8);
addDataToHead(&pList, &p7);
addDataToHead(&pList, &p6);
addDataToHead(&pList, &p5);
addDataToHead(&pList, &p4);
addDataToHead(&pList, &p3);
addDataToHead(&pList, &p2);
addDataToHead(&pList, &p1);
//-------------------------------------------------------------------------------------------
table = buildTable( pList, 600);
//printfTable( table);
TEST_ASSERT_NOT_NULL(S1);
TEST_ASSERT_NULL(S2);
TEST_ASSERT_EQUAL_PTR(&p1, S1_1->data);
TEST_ASSERT_EQUAL_PTR(&p2, S1_2->data);
TEST_ASSERT_EQUAL_PTR(&p3, S1_3->data);
TEST_ASSERT_EQUAL_PTR(&p4, S1_4->data);
TEST_ASSERT_EQUAL_PTR(&p5, S1_5->data);
TEST_ASSERT_EQUAL_PTR(&p6, S1_6->data);
TEST_ASSERT_EQUAL_PTR(&p7, S1_7->data);
TEST_ASSERT_EQUAL_PTR(&p8, S1_8->data);
TEST_ASSERT_EQUAL_PTR(&p9, S1_9->data);
TEST_ASSERT_NULL(S1_10);
}
void test_circularBufferNew_should_create_new_CircularBuffer_object_of_integer_type() {
CircularBuffer *cb = circularBufferNew(7, sizeof(int));
TEST_ASSERT_NOT_NULL(cb);
TEST_ASSERT_NOT_NULL(cb->buffer);
TEST_ASSERT_EQUAL_PTR(cb->buffer, cb->head);
TEST_ASSERT_EQUAL_PTR(cb->buffer, cb->tail);
TEST_ASSERT_EQUAL(0, cb->size);
TEST_ASSERT_EQUAL(7, cb->length);
TEST_ASSERT_EQUAL(sizeof(int), cb->sizeOfType);
circularBufferDel(cb);
}
void test_SwaleInit_sets_head_and_tail_to_null(void) {
swale_t swale;
SwaleInit(&swale);
TEST_ASSERT_EQUAL_PTR(NULL, swale.head);
TEST_ASSERT_EQUAL_PTR(NULL, swale.tail);
TEST_ASSERT_EQUAL_PTR(NULL, swale.next_task);
TEST_ASSERT_EQUAL(24, sizeof(swale_t));
}
void test_addPaperToSession_given_session_add_p1_p2_should_have_population_equal_300(void){
Session s = createSession();
addPaperToSession(&s, &p1);
addPaperToSession(&s, &p2);
TEST_ASSERT_EQUAL(300, s.size);
TEST_ASSERT_EQUAL_PTR(&p2, s.papers->data);
TEST_ASSERT_EQUAL_PTR(&p1, s.papers->next->data);
TEST_ASSERT_NULL(s.papers->next->next);
clearLinkList(&(s.papers));
}
void test_createdEventInfo_should_create_EventInfo_with_moduleAndPin_and_pipe(void)
{
ModuleAndPin moduleAndPin;
Pipe pipe;
EventInfo *eventInfo = createdEventInfo(&moduleAndPin, &pipe);
TEST_ASSERT_NOT_NULL(eventInfo);
TEST_ASSERT_EQUAL_PTR(&moduleAndPin, eventInfo->moduleAndPin);
TEST_ASSERT_EQUAL_PTR(&pipe, eventInfo->pipe);
destroyEventInfo(eventInfo);
}
/** 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);
}
void test_SwaleTaskInit_fills_in_a_task(void) {
swale_task_t task;
uint32_t a_param = 99;
SwaleTaskInit(&task, task_entry_0, (void*)&a_param);
TEST_ASSERT_EQUAL_PTR(NULL, task.next);
TEST_ASSERT_EQUAL_PTR(task_entry_0, task.entry);
TEST_ASSERT_EQUAL_PTR((void*)&a_param, task.param);
/* Ensure we catch when the size of swale_task_t changes. */
TEST_ASSERT_EQUAL(24, sizeof(swale_task_t));
}
void test_circularBufferNew_should_create_new_CircularBuffer_object_of_double_type(void)
{
CircularBuffer *cb = circularBufferNew(13, sizeof(double));
TEST_ASSERT_NOT_NULL(cb);
TEST_ASSERT_NOT_NULL(cb->buffer);
TEST_ASSERT_EQUAL_PTR(cb->buffer,cb->head);
TEST_ASSERT_EQUAL_PTR(cb->buffer,cb->tail);
TEST_ASSERT_EQUAL(0,cb->size);
TEST_ASSERT_EQUAL(13,cb->length);
TEST_ASSERT_EQUAL(sizeof(double), cb->sizeOfType);
circularBufferDel(cb);
}
void test_SwaleRegisterTask_should_set_head_and_tail_if_no_head(void) {
swale_t swale;
swale_task_t task;
SwaleInit(&swale);
SwaleTaskInit(&task, task_entry_0, NULL);
task.next = &task; // initialize to invalid value
SwaleRegisterTask(&swale, &task);
TEST_ASSERT_EQUAL_PTR(&task, swale.head);
TEST_ASSERT_EQUAL_PTR(&task, swale.tail);
TEST_ASSERT_EQUAL_PTR(NULL, task.next);
}
void test_createdModuleAndPin_given_AND_module_and_its_pin_should_return_moduleAndPin(void)
{
Module *AND;
ModuleAndPin *moduleAndPin;
int inputType = QUAD_2_INPUT;
AND = createdAndModule(inputType);
moduleAndPin = createdModuleAndPin(AND, AND->pin[0].pinNumber);
TEST_ASSERT_EQUAL_PTR(AND, moduleAndPin->module);
TEST_ASSERT_EQUAL_PTR(&AND->pin[0], moduleAndPin->pin);
destroyModuleAndPin(moduleAndPin);
}
void test_ByteBuffer_CreateWithArray_should_create_an_empty_ByteBuffer_with_specified_ByteArray(void)
{
uint8_t data[] = {0x1u, 0x2u, 0x3u, 0x4u};
size_t len = sizeof(data);
ByteArray array = {.data = data, .len = len};
ByteBuffer buffer = ByteBuffer_CreateWithArray(array);
TEST_ASSERT_EQUAL_PTR(data, buffer.array.data);
TEST_ASSERT_EQUAL(len, buffer.array.len);
TEST_ASSERT_EQUAL_PTR(array.data, buffer.array.data);
TEST_ASSERT_EQUAL(array.len, buffer.array.len);
TEST_ASSERT_EQUAL_HEX8_ARRAY(data, buffer.array.data, len);
TEST_ASSERT_EQUAL(0, buffer.bytesUsed);
}
/**
* root root
* | |
* v v
* 2(b) remove 1 2(b)
* / \ ------------> \
* 1(b) 3(b) 3(r)
*/
void test__delRedBlackTree_remove_one_from_tree_with_1_2_3_nodes(void)
{
setNode(&node1, NULL, NULL, 'b');
setNode(&node3, NULL, NULL, 'b');
setNode(&node2, &node1, &node3, 'r');
Node *root = &node2;
Node *result;
result = _delRedBlackTree(&root, &node1);
TEST_ASSERT_EQUAL_PTR(root, &node2);
TEST_ASSERT_EQUAL_PTR(result, &node1);
TEST_ASSERT_EQUAL_NODE(NULL, NULL, 'r', &node3);
TEST_ASSERT_EQUAL_NODE(NULL, &node3, 'b', &node2);
}
void
test_OneElementQueue(void) {
queue* q = create_queue();
TEST_ASSERT_NOT_NULL(q);
element e = {"string", 3};
element* e_ptr = debug_get_node(sizeof(element));
enqueue(q, e_ptr);
*e_ptr = e;
TEST_ASSERT_FALSE(empty(q));
TEST_ASSERT_NOT_NULL(queue_head(q));
TEST_ASSERT_EQUAL(1, get_no_of_elements(q));
element* e_ptr_returned = dequeue(q);
TEST_ASSERT_NOT_NULL(e_ptr_returned);
TEST_ASSERT_EQUAL_STRING(e_ptr_returned->str, "string");
TEST_ASSERT_EQUAL_PTR(e_ptr_returned, e_ptr);
TEST_ASSERT_EQUAL(0, get_no_of_elements(q));
TEST_ASSERT_TRUE(empty(q));
TEST_ASSERT_NULL(dequeue(q));
destroy_queue(q);
}
