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); }