void testEnd_getGroup(CuTest* testCase) { cactusEndTestSetup(); Flower *flower2 = flower_construct(cactusDisk); eventTree_copyConstruct(eventTree, flower2, testEnd_copyConstructP); sequence_construct(metaSequence, flower2); End *end2 = end_copyConstruct(end, flower2); CuAssertTrue(testCase, end_getGroup(end) == NULL); Group *group = group_construct(flower, flower2); CuAssertTrue(testCase, end_getGroup(end) == group); CuAssertTrue(testCase, end_getGroup(end2) == NULL); cactusEndTestTeardown(); }
static void cactusGroupTestSetup() { cactusGroupTestTeardown(); cactusDisk = testCommon_getTemporaryCactusDisk(); flower = flower_construct(cactusDisk); nestedFlower = flower_construct(cactusDisk); end1 = end_construct2(0, 0, flower); end2 = end_construct(0, flower); end3 = end_construct(0, flower); nestedEnd1 = end_copyConstruct(end1, nestedFlower); nestedEnd2 = end_copyConstruct(end2, nestedFlower); group = group_construct(flower, nestedFlower); group2 = group_construct2(flower); end4 = end_construct(0, flower); }
bool flower_removeIfRedundant(Flower *flower) { if (!flower_isLeaf(flower) && flower_getParentGroup(flower) != NULL && flower_getBlockNumber(flower) == 0) { //We will remove this flower.. Group *parentGroup = flower_getParentGroup(flower); //This group will be destructed //Deal with any parent chain.. if (group_isLink(parentGroup)) { link_split(group_getLink(parentGroup)); } Flower *parentFlower = group_getFlower(parentGroup); //We will add the groups in the flower to the parent /* * For each group in the flower we take its nested flower and attach it to the parent. */ Group *group; Flower_GroupIterator *groupIt = flower_getGroupIterator(flower); while ((group = flower_getNextGroup(groupIt)) != NULL) { if (!group_isLeaf(group)) { //Copy the group into the parent.. Flower *nestedFlower = group_getNestedFlower(group); assert(nestedFlower != NULL); Group *newParentGroup = group_construct(parentFlower, nestedFlower); flower_setParentGroup(nestedFlower, newParentGroup); group_constructChainForLink(newParentGroup); } else { Group *newParentGroup = group_construct2(parentFlower); End *end; Group_EndIterator *endIt = group_getEndIterator(group); while ((end = group_getNextEnd(endIt)) != NULL) { End *parentEnd = flower_getEnd(parentFlower, end_getName(end)); assert(parentEnd != NULL); end_setGroup(parentEnd, newParentGroup); } group_destructEndIterator(endIt); group_constructChainForLink(newParentGroup); } } flower_destructGroupIterator(groupIt); //The group attached to the flower should now be empty assert(group_getEndNumber(parentGroup) == 0); group_destruct(parentGroup); //Now wipe the flower out.. cactusDisk_deleteFlowerFromDisk(flower_getCactusDisk(flower), flower); flower_destruct(flower, 0); return 1; } return 0; }
void testBlock_getChain(CuTest* testCase) { cactusBlockTestSetup(); Block *block2 = block_construct(2, flower); Flower *flower2 = flower_construct(cactusDisk); eventTree_copyConstruct(flower_getEventTree(flower), flower2, NULL); end_copyConstruct(block_get3End(block), flower2); end_copyConstruct(block_get5End(block2), flower2); Group *group = group_construct(flower, flower2); Chain *chain = chain_construct(flower); link_construct(block_get3End(block), block_get5End(block2), group, chain); CuAssertTrue(testCase, block_getChain(block_construct(2, flower)) == NULL); CuAssertTrue(testCase, block_getChain(block) == chain); CuAssertTrue(testCase, block_getChain(block2) == chain); cactusBlockTestTeardown(); }
group_t *group_add_selects(group_t *group, select_t *newsels) { // add selects to group //select_t *scurr = newsels; //select_t *glast; //select_t *select_new = NULL; //int sindex, gindex; if (!group) group = group_construct(); select_add_multiple_dots(group->selects, newsels); /* while (scurr && glast) { // merge selection and group selects in order //if (scurr->index < glast->index) sindex = select_get_dot(scurr); gindex = select_get_dot(glast); if (sindex < gindex) { // selection goes next select_new = select_add_index(select_new, sindex, false); //scurr = scurr->next; scurr = select_get_next(scurr); } else if (sindex > gindex) { // group goes next select_new = select_add_index(select_new, gindex, false); //glast = glast->next; glast = select_get_next(glast); } else { // duplicate //scurr = scurr->next; scurr = select_get_next(scurr); } } // clean up while (scurr) { //select_new = select_add_index(select_new, scurr->index, false); //scurr = scurr->next; select_new = select_add_index(select_new, select_get_dot(scurr), false); scurr = select_get_next(scurr); } while (glast) { //select_new = select_add_index(select_new, glast->index, false); //glast = glast->next; select_new = select_add_index(select_new, select_get_dot(glast), false); glast = select_get_next(glast); } // add new selection to group select_discard(group->selects); group->selects = select_new; */ return group; }
static void groupsSetup() { group = group_construct(flower, flower_construct(cactusDisk)); group2 = group_construct(flower, flower_construct(cactusDisk)); }
void testFlower_removeIfRedundant(CuTest *testCase) { /* * Do a simple test to see if function can remove a redundant flower. */ cactusFlowerTestSetup(); endsSetup(); //First construct a redundant flower from the root. Flower *flower2 = flower_construct(cactusDisk); Group *group = group_construct(flower, flower2); end_setGroup(end, group); end_setGroup(end2, group); //Now hang another couple of flowers of that. Flower *flower3 = flower_construct(cactusDisk); group_construct(flower2, flower3); //Now hang another flower of that. Group *group3b = group_construct2(flower2); //Finally hang one more flower on the end.. Flower *flower4 = flower_construct(cactusDisk); group_construct(flower3, flower4); //Copy the ends into the flowers. end_copyConstruct(end, flower2); end_copyConstruct(end2, flower2); end_copyConstruct(end, flower3); end_setGroup(flower_getEnd(flower2, end_getName(end2)), group3b); end_copyConstruct(end, flower4); //st_uglyf("I got %" PRIi64 " %" PRIi64 " %" PRIi64 " %" PRIi64 "\n", flower_getName(flower), flower_getName(flower2), flower_getName(flower3), flower_getName(flower4)); //Write the mess to disk. cactusDisk_write(cactusDisk); //Now test the removal function (check we get a negative on this leaf). CuAssertTrue(testCase, !flower_removeIfRedundant(flower4)); //Check we can't remove the root.. CuAssertTrue(testCase, !flower_removeIfRedundant(flower)); //We will remove flower2 //Before CuAssertTrue(testCase, flower_getGroupNumber(flower) == 1); CuAssertTrue(testCase, group_getFlower(flower_getParentGroup(flower2)) == flower); CuAssertTrue(testCase, flower_removeIfRedundant(flower2)); //After, check the flower/group connections CuAssertTrue(testCase, flower_getGroupNumber(flower) == 2); CuAssertTrue(testCase, !flower_isLeaf(flower)); CuAssertTrue(testCase, group_getFlower(flower_getParentGroup(flower3)) == flower); group3b = end_getGroup(end2); CuAssertTrue(testCase, group_getFlower(group3b) == flower); CuAssertTrue(testCase, group_isLeaf(group3b)); CuAssertTrue(testCase, flower_getGroup(flower, flower_getName(flower3)) == flower_getParentGroup(flower3)); //Check the ends.. CuAssertTrue(testCase, flower_getEndNumber(flower) == 2); CuAssertTrue(testCase, flower_getEndNumber(flower3) == 1); CuAssertTrue(testCase, group_getEndNumber(group3b) == 1); CuAssertTrue(testCase, end_getGroup(end) == flower_getParentGroup(flower3)); CuAssertTrue(testCase, end_getGroup(end2) == group3b); CuAssertTrue(testCase, flower_getEnd(flower3, end_getName(end)) != NULL); //Check the child of 3 is still okay.. CuAssertTrue(testCase, group_getFlower(flower_getParentGroup(flower4)) == flower3); //Now do removal of flower3 CuAssertTrue(testCase, !flower_removeIfRedundant(flower)); CuAssertTrue(testCase, !flower_removeIfRedundant(flower4)); CuAssertTrue(testCase, flower_removeIfRedundant(flower3)); //Check groups again CuAssertTrue(testCase, flower_getGroupNumber(flower) == 2); CuAssertTrue(testCase, !flower_isLeaf(flower)); CuAssertTrue(testCase, group_getFlower(flower_getParentGroup(flower4)) == flower); CuAssertTrue(testCase, group_getFlower(group3b) == flower); CuAssertTrue(testCase, flower_getGroup(flower, flower_getName(flower4)) == flower_getParentGroup(flower4)); //Check the ends again.. CuAssertTrue(testCase, flower_getEndNumber(flower) == 2); CuAssertTrue(testCase, flower_getEndNumber(flower4) == 1); CuAssertTrue(testCase, group_getEndNumber(group3b) == 1); CuAssertTrue(testCase, end_getGroup(end) == flower_getParentGroup(flower4)); CuAssertTrue(testCase, end_getGroup(end2) == group3b); CuAssertTrue(testCase, flower_getEnd(flower4, end_getName(end)) != NULL); cactusFlowerTestTeardown(); }