void testEvent_getChild(CuTest* testCase) {
cactusEventTestSetup();
CuAssertTrue(testCase, event_getChild(rootEvent, 0) == internalEvent);
CuAssertTrue(testCase, event_getChild(internalEvent, 0) == leafEvent1);
CuAssertTrue(testCase, event_getChild(internalEvent, 1) == leafEvent2);
cactusEventTestTeardown();
}
void testEvent_serialisation(CuTest* testCase) {
cactusEventTestSetup();
int64_t i;
void *vA = binaryRepresentation_makeBinaryRepresentation(leafEvent1,
(void (*)(void *, void (*)(const void *, size_t, size_t)))event_writeBinaryRepresentation, &i);
CuAssertTrue(testCase, i > 0);
event_destruct(leafEvent1);
void *vA2 = vA;
leafEvent1 = event_loadFromBinaryRepresentation(&vA2, eventTree);
free(vA);
nestedTest = 1;
testEvent_getParent(testCase);
testEvent_getName(testCase);
testEvent_getHeader(testCase);
testEvent_getBranchLength(testCase);
testEvent_getSubTreeBranchLength(testCase);
testEvent_getSubTreeEventNumber(testCase);
testEvent_getChildNumber(testCase);
//testEvent_getChild(testCase); -- won't work as doesn't preserve order of leaves, which is okay -- here's a replacement.
CuAssertTrue(testCase, event_getChild(rootEvent, 0) == internalEvent);
CuAssertTrue(testCase, event_getChild(internalEvent, 0) == leafEvent2);
CuAssertTrue(testCase, event_getChild(internalEvent, 1) == leafEvent1);
testEvent_getEventTree(testCase);
testEvent_isAncestor(testCase);
testEvent_isDescendant(testCase);
testEvent_isSibling(testCase);
testEvent_isOutgroup(testCase);
nestedTest = 0;
cactusEventTestTeardown();
}
void testEventTree_serialisation(CuTest* testCase) {
cactusEventTreeTestSetup();
int64_t i;
void *vA = binaryRepresentation_makeBinaryRepresentation(eventTree,
(void (*)(void *, void (*)(const void *, size_t, size_t)))eventTree_writeBinaryRepresentation, &i);
CuAssertTrue(testCase, i > 0);
eventTree_destruct(eventTree);
void *vA2 = vA;
eventTree = eventTree_loadFromBinaryRepresentation(&vA2, flower);
rootEvent = eventTree_getRootEvent(eventTree);
internalEvent = event_getChild(rootEvent, 0);
leafEvent1 = event_getChild(internalEvent, 0);
leafEvent2 = event_getChild(internalEvent, 1);
free(vA);
nestedTest = 1;
testEventTree_copyConstruct(testCase);
testEventTree_getRootEvent(testCase);
testEventTree_getEvent(testCase);
testEventTree_getCommonAncestor(testCase);
testEventTree_getFlower(testCase);
testEventTree_getEventNumber(testCase);
testEventTree_getFirst(testCase);
testEventTree_makeNewickString(testCase);
testEventTree_iterator(testCase);
testEventTree_addSiblingUnaryEvent(testCase);
nestedTest = 0;
cactusEventTreeTestTeardown();
}
void eventTree_copyConstructP(EventTree *eventTree, Event *event,
int64_t (unaryEventFilterFn)(Event *event)) {
int64_t i;
Event *event2;
for(i=0; i<event_getChildNumber(event); i++) {
event2 = event_getChild(event, i);
while(event_getChildNumber(event2) == 1 && unaryEventFilterFn != NULL && !unaryEventFilterFn(event2)) {
//skip the event
event2 = event_getChild(event2, 0);
}
event_setOutgroupStatus(event_construct(event_getName(event2), event_getHeader(event2), event_getBranchLength(event2),
eventTree_getEvent(eventTree, event_getName(event)), eventTree), event_isOutgroup(event2));
eventTree_copyConstructP(eventTree, event2, unaryEventFilterFn);
}
}
void eventTree_writeBinaryRepresentationP(Event *event, void (*writeFn)(const void * ptr, size_t size, size_t count)) {
int64_t i;
event_writeBinaryRepresentation(event, writeFn);
for(i=0; i<event_getChildNumber(event); i++) {
eventTree_writeBinaryRepresentationP(event_getChild(event, i), writeFn);
}
}
static char *eventTree_makeNewickStringP(Event *event) {
int64_t i;
char *cA = NULL;
char *cA3;
if(event_getChildNumber(event) > 0) {
for(i=0;i<event_getChildNumber(event); i++) {
char *cA2 = eventTree_makeNewickStringP(event_getChild(event, i));
if(i > 0) {
cA3 = st_malloc(sizeof(char)*(strlen(cA)+strlen(cA2)+2));
sprintf(cA3, "%s,%s", cA, cA2);
free(cA);
cA = cA3;
}
else {
cA = st_malloc(sizeof(char)*(strlen(cA2)+2));
sprintf(cA, "(%s", cA2);
}
free(cA2);
}
cA3 = st_malloc(sizeof(char)*(strlen(cA) + strlen(event_getHeader(event)) + 30));
sprintf(cA3, "%s)%s:%g", cA, event_getHeader(event), event_getBranchLength(event));
free(cA);
cA = cA3;
}
else {
cA = st_malloc(sizeof(char)*(strlen(event_getHeader(event)) + 30));
sprintf(cA, "%s:%g", event_getHeader(event), event_getBranchLength(event));
}
return cA;
}
// Get species tree from event tree (labeled by the event Names),
// which requires ignoring the root event.
stTree *eventTree_getStTree(EventTree *eventTree) {
Event *rootEvent = eventTree_getRootEvent(eventTree);
// Need to skip the root event, since it is added onto the real
// species tree.
assert(event_getChildNumber(rootEvent) == 1);
Event *speciesRoot = event_getChild(rootEvent, 0);
return eventTree_getStTree_R(speciesRoot);
}
static stTree *eventTree_getStTree_R(Event *event) {
stTree *ret = stTree_construct();
stTree_setLabel(ret, stString_print("%" PRIi64, event_getName(event)));
stTree_setBranchLength(ret, event_getBranchLength(event));
for(int64_t i = 0; i < event_getChildNumber(event); i++) {
Event *child = event_getChild(event, i);
stTree *childStTree = eventTree_getStTree_R(child);
stTree_setParent(childStTree, ret);
}
return ret;
}
void eventTree_writeBinaryRepresentation(EventTree *eventTree, void (*writeFn)(const void * ptr, size_t size, size_t count)) {
int64_t i;
Event *event;
event = eventTree_getRootEvent(eventTree);
binaryRepresentation_writeElementType(CODE_EVENT_TREE, writeFn);
binaryRepresentation_writeName(event_getName(event), writeFn);
for(i=0; i<event_getChildNumber(event); i++) {
eventTree_writeBinaryRepresentationP(event_getChild(event, i), writeFn);
}
binaryRepresentation_writeElementType(CODE_EVENT_TREE, writeFn);
}
int64_t event_getSubTreeEventNumber(Event *event) {
assert(event != NULL);
int64_t i, j;
Event *childEvent;
j = 0.0;
for (i = 0; i < event_getChildNumber(event); i++) {
childEvent = event_getChild(event, i);
j += event_getSubTreeEventNumber(childEvent) + 1;
}
return j;
}
float event_getSubTreeBranchLength(Event *event) {
assert(event != NULL);
int64_t i;
Event *childEvent;
float branchLength;
branchLength = 0.0;
for (i = 0; i < event_getChildNumber(event); i++) {
childEvent = event_getChild(event, i);
branchLength += event_getSubTreeBranchLength(childEvent)
+ event_getBranchLength(childEvent);
}
return branchLength;
}
void event_check(Event *event) {
EventTree *eventTree = event_getEventTree(event);
Event *ancestorEvent = event_getParent(event);
//Check event and eventree properly linked
cactusCheck(eventTree_getEvent(event_getEventTree(event), event_getName(event)) == event);
//Event has parent, unless it is root.
if (eventTree_getRootEvent(eventTree) == event) {
cactusCheck(ancestorEvent == NULL);
} else { //not root, so must have ancestor.
cactusCheck(ancestorEvent != NULL);
}
//Each child event has event as parent.
int64_t i = 0;
for (i = 0; i < event_getChildNumber(event); i++) {
Event *childEvent = event_getChild(event, i);
cactusCheck(event_getParent(childEvent) == event);
}
//Ancestor-event --> event edge is consistent with any event tree that is in the parent of the containing flower.
Group *parentGroup = flower_getParentGroup(eventTree_getFlower(
event_getEventTree(event)));
if (parentGroup != NULL) {
EventTree *parentEventTree = flower_getEventTree(group_getFlower(
parentGroup));
Event *parentEvent = eventTree_getEvent(parentEventTree, event_getName(
event));
if (parentEvent != NULL) {
if (ancestorEvent == NULL) { //the case where they are both root.
cactusCheck(eventTree_getRootEvent(parentEventTree) == parentEvent);
} else {
//Check edge ancestorEvent --> event is in parent event tree.
while (1) {
Event *parentAncestorEvent = eventTree_getEvent(
parentEventTree, event_getName(ancestorEvent));
if (parentAncestorEvent != NULL) {
cactusCheck(event_isAncestor(parentEvent, parentAncestorEvent));
break;
}
ancestorEvent = event_getParent(ancestorEvent);
cactusCheck(ancestorEvent != NULL);
}
}
}
}
}
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();
}
