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); }
void testCactusDisk_write(CuTest* testCase) { assert(testCase != NULL); cactusDiskTestSetup(); flower_construct(cactusDisk); cactusDisk_write(cactusDisk); cactusDiskTestTeardown(); }
void testEnd_setGroup(CuTest* testCase) { cactusEndTestSetup(); Flower *flower2 = flower_construct(cactusDisk); Group *group2 = group_construct2(flower2); End *end2 = end_construct(1, flower2); End *end3 = end_construct(1, flower2); CuAssertTrue(testCase, group_getEndNumber(group2) == 0); CuAssertTrue(testCase, end_getGroup(end2) == NULL); CuAssertTrue(testCase, end_getGroup(end3) == NULL); end_setGroup(end2, group2); CuAssertTrue(testCase, group_getEndNumber(group2) == 1); CuAssertTrue(testCase, end_getGroup(end2) == group2); CuAssertTrue(testCase, group_getEnd(group2, end_getName(end2)) == end2); CuAssertTrue(testCase, end_getGroup(end3) == NULL); end_setGroup(end3, group2); CuAssertTrue(testCase, group_getEndNumber(group2) == 2); CuAssertTrue(testCase, end_getGroup(end2) == group2); CuAssertTrue(testCase, group_getEnd(group2, end_getName(end2)) == end2); CuAssertTrue(testCase, end_getGroup(end3) == group2); CuAssertTrue(testCase, group_getEnd(group2, end_getName(end3)) == end3); end_setGroup(end3, NULL); end_setGroup(end2, group2); CuAssertTrue(testCase, group_getEndNumber(group2) == 1); CuAssertTrue(testCase, end_getGroup(end2) == group2); CuAssertTrue(testCase, group_getEnd(group2, end_getName(end2)) == end2); CuAssertTrue(testCase, end_getGroup(end3) == NULL); cactusEndTestTeardown(); }
void testCactusDisk_getFlower(CuTest* testCase) { cactusDiskTestSetup(); Flower *flower = flower_construct(cactusDisk); Flower *flower2 = flower_construct(cactusDisk); CuAssertTrue(testCase, cactusDisk_getFlower(cactusDisk, flower_getName(flower)) == flower); CuAssertTrue(testCase, cactusDisk_getFlower(cactusDisk, flower_getName(flower2)) == flower2); //now try closing the disk, then reloading it, to see if we get the same result. Name name1 = flower_getName(flower); Name name2 = flower_getName(flower2); cactusDisk_write(cactusDisk); cactusDisk_destruct(cactusDisk); cactusDisk = cactusDisk_construct(conf, 0); flower = cactusDisk_getFlower(cactusDisk, name1); flower2 = cactusDisk_getFlower(cactusDisk, name2); CuAssertTrue(testCase, flower != NULL); CuAssertTrue(testCase, flower2 != NULL); CuAssertTrue(testCase, flower_getName(flower) == name1); CuAssertTrue(testCase, flower_getName(flower2) == name2); cactusDiskTestTeardown(); }
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(); }
void testEventTree_copyConstruct(CuTest* testCase) { cactusEventTreeTestSetup(); Flower *flower2 = flower_construct(cactusDisk); EventTree *eventTree2 = eventTree_copyConstruct(eventTree, flower2, unaryEventFunction); CuAssertIntEquals(testCase, eventTree_getEventNumber(eventTree), eventTree_getEventNumber(eventTree2)); CuAssertTrue(testCase, event_getName(eventTree_getEvent(eventTree2, event_getName(rootEvent))) == event_getName(rootEvent)); CuAssertTrue(testCase, event_getName(eventTree_getEvent(eventTree2, event_getName(internalEvent))) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getName(eventTree_getEvent(eventTree2, event_getName(leafEvent1))) == event_getName(leafEvent1)); CuAssertTrue(testCase, event_getName(eventTree_getEvent(eventTree2, event_getName(leafEvent2))) == event_getName(leafEvent2)); CuAssertTrue(testCase, event_isOutgroup(eventTree_getEvent(eventTree2, event_getName(leafEvent1)))); CuAssertTrue(testCase, !event_isOutgroup(eventTree_getEvent(eventTree2, event_getName(leafEvent2)))); cactusEventTreeTestTeardown(); }
static void cactusEventTreeTestSetup() { if(!nestedTest) { cactusEventTreeTestTeardown(); cactusDisk = testCommon_getTemporaryCactusDisk(); flower = flower_construct(cactusDisk); eventTree = eventTree_construct2(flower); rootEvent = eventTree_getRootEvent(eventTree); internalEvent = event_construct3("INTERNAL", 0.5, rootEvent, eventTree); leafEvent1 = event_construct3("LEAF1", 0.2, internalEvent, eventTree); leafEvent2 = event_construct3("LEAF2", 1.3, internalEvent, eventTree); event_setOutgroupStatus(leafEvent1, 1); } }
void testEnd_copyConstruct(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_getName(end2) != NULL_NAME); CuAssertTrue(testCase, end_getName(end2) == end_getName(end)); CuAssertTrue(testCase, flower_getEnd(flower2, end_getName(end2)) == end2); CuAssertTrue(testCase, cap_getName(end_getInstance(end2, cap_getName(rootCap))) == cap_getName(rootCap)); CuAssertTrue(testCase, cap_getName(end_getInstance(end2, cap_getName(leaf1Cap))) == cap_getName(leaf1Cap)); CuAssertTrue(testCase, cap_getName(end_getInstance(end2, cap_getName(leaf2Cap))) == cap_getName(leaf2Cap)); cactusEndTestTeardown(); }
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(); }
void testEventTree_addSiblingUnaryEvent(CuTest *testCase) { cactusEventTreeTestSetup(); //Create two sibling flowers with the basic event tree.. //then try adding events from on into the other. Group *group1 = group_construct2(flower); Group *group2 = group_construct2(flower); Flower *flower2 = flower_construct(cactusDisk); Flower *flower3 = flower_construct(cactusDisk); flower_setParentGroup(flower2, group1); flower_setParentGroup(flower3, group2); EventTree *eventTree2 = eventTree_copyConstruct(flower_getEventTree(flower), flower2, NULL); Event *parentUnaryEvent1 = event_construct4("UNARY1", 0.1, internalEvent, leafEvent1, eventTree); Event *parentUnaryEvent2 = event_construct4("UNARY2", 0.1, parentUnaryEvent1, leafEvent1, eventTree); Event *parentUnaryEvent3 = event_construct4("UNARY3", 0.1, internalEvent, leafEvent2, eventTree); //now event tree contains the added unary events. EventTree *eventTree3 = eventTree_copyConstruct(flower_getEventTree(flower), flower3, NULL); //add a couple of denovo events into the new event tree Event *internalEventChild = eventTree_getEvent(eventTree3, event_getName(internalEvent)); Event *unaryEvent1 = eventTree_getEvent(eventTree3, event_getName(parentUnaryEvent1)); Event *unaryEvent2 = eventTree_getEvent(eventTree3, event_getName(parentUnaryEvent2)); Event *unaryEvent3 = eventTree_getEvent(eventTree3, event_getName(parentUnaryEvent3)); Event *unaryEvent4 = event_construct4("UNARY4", 0.1, internalEventChild, unaryEvent3, eventTree3); Event *unaryEvent5 = event_construct4("UNARY5", 0.1, internalEventChild, unaryEvent4, eventTree3); //Now event-tree 2 does not contain the unary events but event-tree 3 does.. CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent1)) == NULL); CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent2)) == NULL); CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent3)) == NULL); CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent4)) == NULL); CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent5)) == NULL); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent1); Event *unaryEvent12 = eventTree_getEvent(eventTree2, event_getName(unaryEvent1)); CuAssertTrue(testCase, unaryEvent12 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent12)) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent12) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent12, 0)) == event_getName(leafEvent1)); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent2); Event *unaryEvent22 = eventTree_getEvent(eventTree2, event_getName(unaryEvent2)); CuAssertTrue(testCase, unaryEvent22 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent22)) == event_getName(unaryEvent1)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent22) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent22, 0)) == event_getName(leafEvent1)); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent3); Event *unaryEvent32 = eventTree_getEvent(eventTree2, event_getName(unaryEvent3)); CuAssertTrue(testCase, unaryEvent32 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent32)) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent32) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent32, 0)) == event_getName(leafEvent2)); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent4); Event *unaryEvent42 = eventTree_getEvent(eventTree2, event_getName(unaryEvent4)); CuAssertTrue(testCase, unaryEvent42 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent42)) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent42) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent42, 0)) == event_getName(unaryEvent3)); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent5); Event *unaryEvent52 = eventTree_getEvent(eventTree2, event_getName(unaryEvent5)); CuAssertTrue(testCase, unaryEvent52 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent52)) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent52) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent52, 0)) == event_getName(unaryEvent4)); //uglyf("Event-tree-1 %s\n", eventTree_makeNewickString(eventTree)); //uglyf("Event-tree-2 %s\n", eventTree_makeNewickString(eventTree3)); //uglyf("Event-tree-3 %s\n", eventTree_makeNewickString(eventTree2)); cactusEventTreeTestTeardown(); }
static void groupsSetup() { group = group_construct(flower, flower_construct(cactusDisk)); group2 = group_construct(flower, flower_construct(cactusDisk)); }
static void cactusFlowerTestSetup() { cactusFlowerTestTeardown(); cactusDisk = testCommon_getTemporaryCactusDisk(); flower = flower_construct(cactusDisk); eventTree = eventTree_construct2(flower); }
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(); }