void testBlock_getInstanceNumber(CuTest* testCase) {
cactusBlockTestSetup();
CuAssertTrue(testCase, block_getInstanceNumber(block) == 3);
Block *block2 = block_construct(1, flower);
CuAssertTrue(testCase, block_getInstanceNumber(block2) == 0);
cactusBlockTestTeardown();
}
void testFlower_getEndNumber(CuTest *testCase) {
/*
* Tests the different end number functions.
*/
cactusFlowerTestSetup();
CuAssertTrue(testCase, flower_getEndNumber(flower) == 0);
CuAssertTrue(testCase, flower_getBlockEndNumber(flower) == 0);
CuAssertTrue(testCase, flower_getStubEndNumber(flower) == 0);
CuAssertTrue(testCase, flower_getFreeStubEndNumber(flower) == 0);
CuAssertTrue(testCase, flower_getAttachedStubEndNumber(flower) == 0);
int64_t blockNumber = 10;
int64_t freeStubEndNumber = 5;
int64_t attachedStubEndNumber = 3;
int64_t i;
for (i = 0; i < blockNumber; i++) {
block_construct(1, flower);
}
for (i = 0; i < freeStubEndNumber; i++) {
end_construct(0, flower);
}
for (i = 0; i < attachedStubEndNumber; i++) {
end_construct(1, flower);
}
CuAssertTrue(testCase, flower_getEndNumber(flower) == blockNumber*2 + freeStubEndNumber + attachedStubEndNumber);
CuAssertTrue(testCase, flower_getBlockEndNumber(flower) == blockNumber*2);
CuAssertTrue(testCase, flower_getStubEndNumber(flower) == freeStubEndNumber + attachedStubEndNumber);
CuAssertTrue(testCase, flower_getFreeStubEndNumber(flower) == freeStubEndNumber);
CuAssertTrue(testCase, flower_getAttachedStubEndNumber(flower) == attachedStubEndNumber);
cactusFlowerTestTeardown();
}
void testCap_segmentCoordinatesReverseStrand(CuTest* testCase) {
/*
* Tests the coordinates of an segment and its 5 and 3 prime caps.
*/
cactusCapTestSetup();
Block *block = block_construct(3, flower);
Segment *segment = segment_construct2(block, 2, 0, sequence);
Cap *_5Cap = segment_get5Cap(segment);
Cap *_3Cap = segment_get3Cap(segment);
CuAssertTrue(testCase, cap_getSide(_5Cap));
CuAssertTrue(testCase, !cap_getSide(_3Cap));
CuAssertTrue(testCase, !cap_getStrand(_5Cap));
CuAssertTrue(testCase, !cap_getStrand(_3Cap));
CuAssertIntEquals(testCase, 4, cap_getCoordinate(_5Cap));
CuAssertIntEquals(testCase, 2, cap_getCoordinate(_3Cap));
CuAssertTrue(testCase, !segment_getStrand(segment));
CuAssertIntEquals(testCase, 4, segment_getStart(segment));
CuAssertIntEquals(testCase, 3, segment_getLength(segment));
CuAssertTrue(testCase, !cap_getSide(cap_getReverse(_5Cap)));
CuAssertTrue(testCase, cap_getSide(cap_getReverse(_3Cap)));
CuAssertTrue(testCase, cap_getStrand(cap_getReverse(_5Cap)));
CuAssertTrue(testCase, cap_getStrand(cap_getReverse(_3Cap)));
CuAssertIntEquals(testCase, 4, cap_getCoordinate(cap_getReverse(_5Cap)));
CuAssertIntEquals(testCase, 2, cap_getCoordinate(cap_getReverse(_3Cap)));
CuAssertTrue(testCase, segment_getStrand(segment_getReverse(segment)));
CuAssertIntEquals(testCase, 2, segment_getStart(segment_getReverse(segment)));
CuAssertIntEquals(testCase, 3, segment_getLength(segment_getReverse(segment)));
cactusCapTestTeardown();
}
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 testBlock_getFirst(CuTest* testCase) {
cactusBlockTestSetup();
CuAssertTrue(testCase, block_getFirst(block) == segment_getReverse(rootSegment));
CuAssertTrue(testCase, block_getFirst(block_getReverse(block)) == rootSegment);
Block *block2 = block_construct(1, flower);
CuAssertTrue(testCase, block_getFirst(block2) == NULL);
CuAssertTrue(testCase, block_getFirst(block_getReverse(block2)) == NULL);
cactusBlockTestTeardown();
}
void block_split(Block *block, int64_t splitPoint, Block **leftBlock, Block **rightBlock) {
assert(splitPoint > 0);
assert(splitPoint < block_getLength(block));
*leftBlock = block_construct(splitPoint, block_getFlower(block));
*rightBlock = block_construct(block_getLength(block) - splitPoint, block_getFlower(block));
Segment *segment = block_getRootInstance(block);
if(segment != NULL) {
block_splitP2(segment, NULL, NULL, *leftBlock, *rightBlock);
}
else {
Block_InstanceIterator *instanceIterator = block_getInstanceIterator(block);
while((segment = block_getNext(instanceIterator)) != NULL) {
block_splitP(segment, *leftBlock, *rightBlock);
}
block_destructInstanceIterator(instanceIterator);
}
block_destruct(block);
}
void testBlock_getSetRootInstance(CuTest *testCase) {
cactusBlockTestSetup();
Block *block2 = block_construct(1, flower);
CuAssertTrue(testCase, block_getRootInstance(block2) == NULL);
block_destruct(block2);
//block_setRootInstance(block, segment_getReverse(rootSegment)); //set in the constructor code of the test.
CuAssertTrue(testCase, block_getRootInstance(block) == segment_getReverse(rootSegment));
CuAssertTrue(testCase, end_getRootInstance(block_get5End(block)) == segment_get5Cap(segment_getReverse(rootSegment)));
CuAssertTrue(testCase, end_getRootInstance(block_get3End(block)) == segment_get3Cap(segment_getReverse(rootSegment)));
cactusBlockTestTeardown();
}
void testFlower_isTerminal(CuTest *testCase) {
cactusFlowerTestSetup();
CuAssertTrue(testCase, flower_isTerminal(flower));
group_construct2(flower);
CuAssertTrue(testCase, flower_isTerminal(flower));
end_construct(0, flower);
CuAssertTrue(testCase, flower_isTerminal(flower));
block_construct(1, flower);
CuAssertTrue(testCase, !flower_isTerminal(flower));
cactusFlowerTestTeardown();
}
void testBlock_isTrivialChain(CuTest *testCase) {
cactusBlockTestSetup();
Group *group = group_construct2(flower);
end_setGroup(block_get5End(block), group);
end_setGroup(block_get3End(block), group);
Chain *chain = chain_construct(flower);
Group *group2 = group_construct2(flower);
CuAssertTrue(testCase, block_isTrivialChain(block));
Block *block1 = block_construct(1, flower);
Block *block2 = block_construct(1, flower);
end_setGroup(block_get5End(block2), group2);
end_setGroup(block_get3End(block1), group2);
link_construct(block_get3End(block1), block_get5End(block2), group2, chain);
end_setGroup(block_get5End(block1), group);
end_setGroup(block_get3End(block2), group);
CuAssertTrue(testCase, block_isTrivialChain(block));
CuAssertTrue(testCase, !block_isTrivialChain(block1));
CuAssertTrue(testCase, !block_isTrivialChain(block2));
cactusBlockTestTeardown();
}
void testCap_getSegment(CuTest* testCase) {
cactusCapTestSetup();
Block *block = block_construct(2, flower);
Segment *segment = segment_construct(block, rootEvent);
CuAssertTrue(testCase, cap_getSegment(segment_get5Cap(segment)) == segment);
CuAssertTrue(testCase, cap_getSegment(segment_get3Cap(segment)) == segment);
CuAssertTrue(testCase, cap_getOrientation(segment_get5Cap(segment)) == segment_getOrientation(segment));
CuAssertTrue(testCase, cap_getOrientation(segment_get3Cap(segment)) == segment_getOrientation(segment));
CuAssertTrue(testCase, cap_getSegment(cap_getReverse(segment_get5Cap(segment))) == segment_getReverse(segment));
CuAssertTrue(testCase, cap_getSegment(cap_getReverse(segment_get3Cap(segment))) == segment_getReverse(segment));
cactusCapTestTeardown();
}
void testEnd_isBlockOrStubEnd(CuTest* testCase) {
cactusEndTestSetup();
CuAssertTrue(testCase, end_isStubEnd(end));
CuAssertTrue(testCase, !end_isBlockEnd(end));
Block *block = block_construct(2, flower);
End *leftEnd = block_get5End(block);
End *rightEnd = block_get3End(block);
CuAssertTrue(testCase, end_isBlockEnd(leftEnd));
CuAssertTrue(testCase, end_isBlockEnd(rightEnd));
CuAssertTrue(testCase, !end_isStubEnd(leftEnd));
CuAssertTrue(testCase, !end_isStubEnd(rightEnd));
cactusEndTestTeardown();
}
void testFlower_getTrivialChainNumber(CuTest* testCase) {
cactusFlowerTestSetup();
CuAssertIntEquals(testCase, 0, flower_getTrivialChainNumber(flower));
chain = chain_construct(flower);
chain2 = chain_construct(flower);
CuAssertIntEquals(testCase, 0, flower_getTrivialChainNumber(flower));
group = group_construct2(flower);
group2 = group_construct2(flower);
block = block_construct(1, flower);
end_setGroup(block_get5End(block), group);
end_setGroup(block_get3End(block), group2);
CuAssertIntEquals(testCase, 1, flower_getTrivialChainNumber(flower));
block2 = block_construct(1, flower);
end_setGroup(block_get5End(block2), group2);
end_setGroup(block_get3End(block2), group);
CuAssertIntEquals(testCase, 2, flower_getTrivialChainNumber(flower));
link_construct(block_get3End(block), block_get5End(block2), group2, chain);
CuAssertIntEquals(testCase, 0, flower_getTrivialChainNumber(flower));
link_construct(block_get3End(block2), block_get5End(block), group, chain);
CuAssertIntEquals(testCase, 0, flower_getTrivialChainNumber(flower));
cactusFlowerTestTeardown();
}
void testEnd_getSide(CuTest *testCase) {
cactusEndTestSetup();
Block *block = block_construct(10, flower);
End *_5End = block_get5End(block);
End *_3End = block_get3End(block);
CuAssertTrue(testCase, end_getSide(end));
CuAssertTrue(testCase, !end_getSide(end_getReverse(end)));
CuAssertTrue(testCase, end_getSide(_5End));
CuAssertTrue(testCase, !end_getSide(_3End));
CuAssertTrue(testCase, end_getSide(end_getReverse(_3End)));
CuAssertTrue(testCase, !end_getSide(end_getReverse(_5End)));
cactusEndTestTeardown();
}
void testEnd_getOtherBlockEnd(CuTest *testCase) {
cactusEndTestSetup();
Block *block = block_construct(10, flower);
End *leftEnd = block_get5End(block);
End *rightEnd = block_get3End(block);
CuAssertTrue(testCase, end_getOtherBlockEnd(end) == NULL);
CuAssertTrue(testCase, end_getOtherBlockEnd(end_getReverse(end)) == NULL);
CuAssertTrue(testCase, end_getOtherBlockEnd(leftEnd) == rightEnd);
CuAssertTrue(testCase, end_getOtherBlockEnd(rightEnd) == leftEnd);
CuAssertTrue(testCase, end_getOtherBlockEnd(end_getReverse(leftEnd)) == end_getReverse(rightEnd));
CuAssertTrue(testCase, end_getOtherBlockEnd(end_getReverse(rightEnd)) == end_getReverse(leftEnd));
cactusEndTestTeardown();
}
void testEnd_isAttachedOrFree(CuTest* testCase) {
cactusEndTestSetup();
End *end2 = end_construct(1, flower);
End *end3 = end_construct(0, flower);
Block *block = block_construct(2, flower);
End *end4 = block_get5End(block);
End *end5 = block_get3End(block);
CuAssertTrue(testCase, end_isAttached(end2));
CuAssertTrue(testCase, !end_isAttached(end3));
CuAssertTrue(testCase, !end_isFree(end2));
CuAssertTrue(testCase, end_isFree(end3));
CuAssertTrue(testCase, !end_isAttached(end4));
CuAssertTrue(testCase, !end_isAttached(end5));
CuAssertTrue(testCase, end_isFree(end4));
CuAssertTrue(testCase, end_isFree(end5));
cactusEndTestTeardown();
}
void testCap_getOtherSegmentCap(CuTest *testCase) {
cactusCapTestSetup();
Block *block = block_construct(3, flower);
Segment *segment = segment_construct2(block, 2, 1, sequence);
Cap *_5Cap = segment_get5Cap(segment);
Cap *_3Cap = segment_get3Cap(segment);
CuAssertTrue(testCase, cap_getOtherSegmentCap(leaf1Cap) == NULL);
CuAssertTrue(testCase, cap_getOtherSegmentCap(cap_getReverse(leaf1Cap)) == NULL);
CuAssertTrue(testCase, cap_getOtherSegmentCap(_5Cap) == _3Cap);
CuAssertTrue(testCase, cap_getOtherSegmentCap(_3Cap) == _5Cap);
CuAssertTrue(testCase, cap_getOtherSegmentCap(cap_getReverse(_5Cap)) == cap_getReverse(_3Cap));
CuAssertTrue(testCase, cap_getOtherSegmentCap(cap_getReverse(_3Cap)) == cap_getReverse(_5Cap));
cactusCapTestTeardown();
}
void testEnd_getBlock(CuTest* testCase) {
cactusEndTestSetup();
Block *block = block_construct(10, flower);
End *leftEnd = block_get5End(block);
End *rightEnd = block_get3End(block);
CuAssertTrue(testCase, end_getBlock(end) == NULL);
CuAssertTrue(testCase, end_getBlock(end_getReverse(end)) == NULL);
CuAssertTrue(testCase, end_getBlock(leftEnd) == block);
CuAssertTrue(testCase, end_getBlock(end_getReverse(leftEnd)) == block_getReverse(block));
CuAssertTrue(testCase, block_getOrientation(block) == end_getOrientation(leftEnd));
CuAssertTrue(testCase, end_getBlock(rightEnd) == block);
CuAssertTrue(testCase, end_getBlock(end_getReverse(rightEnd)) == block_getReverse(block));
CuAssertTrue(testCase, block_getOrientation(block) == end_getOrientation(rightEnd));
cactusEndTestTeardown();
}
void testGroup_getAttachedStubAndBlockEndNumber(CuTest* testCase) {
cactusGroupTestSetup();
CuAssertTrue(testCase, group_getAttachedStubEndNumber(group) == 0);
CuAssertTrue(testCase, group_getBlockEndNumber(group) == 0);
CuAssertIntEquals(testCase, 2, group_getStubEndNumber(group));
CuAssertIntEquals(testCase, 2, group_getFreeStubEndNumber(group));
end_setGroup(end_construct(1, flower), group);
end_setGroup(end_construct(0, flower), group);
end_setGroup(end_construct(1, flower), group);
CuAssertTrue(testCase, group_getAttachedStubEndNumber(group) == 2);
CuAssertTrue(testCase, group_getBlockEndNumber(group) == 0);
CuAssertTrue(testCase, group_getStubEndNumber(group) == 5);
CuAssertTrue(testCase, group_getFreeStubEndNumber(group) == 3);
Block *block = block_construct(1, flower);
end_setGroup(block_get5End(block), group);
end_setGroup(block_get3End(block), group);
CuAssertTrue(testCase, group_getAttachedStubEndNumber(group) == 2);
CuAssertTrue(testCase, group_getBlockEndNumber(group) == 2);
CuAssertTrue(testCase, group_getStubEndNumber(group) == 5);
CuAssertTrue(testCase, group_getFreeStubEndNumber(group) == 3);
cactusGroupTestTeardown();
}
static void blocksSetup() {
block = block_construct(1, flower);
block2 = block_construct(2, flower);
}
