static void setup() {
teardown();
assert(nodeNumber == -1);
while(nodeNumber % 2 != 0) {
nodeNumber = st_randomInt(0, 100);
}
assert(nodeNumber >= 0);
assert(nodeNumber % 2 == 0);
stubs = stList_construct3(0, (void (*)(void *))stIntTuple_destruct);
chains = stList_construct3(0, (void (*)(void *))stIntTuple_destruct);
for(int64_t i=0; i<nodeNumber/2; i++) {
assert(nodeNumber/2 > 0);
stIntTuple *edge = stIntTuple_construct2(i, nodeNumber/2 + i);
if(stList_length(stubs) == 0 || st_random() > 0.9) {
stList_append(stubs, edge);
}
else {
stList_append(chains, edge);
}
}
zMatrix = st_calloc(nodeNumber*nodeNumber, sizeof(float));
for(int64_t i=0; i<nodeNumber; i++) {
for(int64_t j=i+1; j<nodeNumber; j++) {
double score = st_random();
zMatrix[i * nodeNumber + j] = score;
zMatrix[j * nodeNumber + i] = score;
}
}
st_logDebug("To test the adjacency problem we've created a problem with %" PRIi64 " nodes %" PRIi64 " stubs and %" PRIi64 " chains\n", nodeNumber, stList_length(stubs), stList_length(chains));
}
static stList *getRandomPairwiseAlignments() {
stList *pairwiseAlignments = stList_construct3(0, (void(*)(void *)) destructPairwiseAlignment);
int64_t randomAlignmentNumber = st_randomInt(0, 10);
for (int64_t i = 0; i < randomAlignmentNumber; i++) {
char *contig1 = stString_print("%" PRIi64 "", i);
char *contig2 = stString_print("%" PRIi64 "", i * 10);
int64_t start1 = st_randomInt(100000, 1000000);
int64_t start2 = st_randomInt(100000, 1000000);
int64_t strand1 = st_random() > 0.5;
int64_t strand2 = st_random() > 0.5;
int64_t end1 = start1;
int64_t end2 = start2;
struct List *operationList = constructEmptyList(0, NULL);
while (st_random() > 0.1) {
int64_t length = st_randomInt(0, 10);
int64_t type = st_randomInt(0, 3);
assert(type < 3);
listAppend(operationList, constructAlignmentOperation(type, length, 0));
if (type != PAIRWISE_INDEL_Y) {
end1 += strand1 ? length : -length;
}
if (type != PAIRWISE_INDEL_X) {
end2 += strand2 ? length : -length;
}
}
stList_append(pairwiseAlignments,
constructPairwiseAlignment(contig1, start1, end1, strand1, contig2, start2, end2, strand2, 0.0, operationList));
free(contig1);
free(contig2);
}
return pairwiseAlignments;
}
static void test_st_random(CuTest *testCase) {
/*
* Excercies the random int function.
*/
for(int32_t i = 0; i < 10000; i++) {
CuAssertTrue(testCase, st_random() >= 0);
CuAssertTrue(testCase, st_random() < 1.0);
}
}
static void testCalculateZScore(CuTest *testCase) {
for(int64_t i=0; i<100; i++) {
int64_t n = st_randomInt(0, 100);
int64_t m = st_randomInt(0, 100);
int64_t k = st_randomInt(1, 10000);
double theta = st_random() > 0.05 ? st_random() : 0.0;
double zScore = calculateZScore(n, m, k, theta);
double zScoreSlow = calculateZScoreSlow(n, m, k, theta);
st_logDebug("The slow computed score: %f the fast computed score: %f, n: %" PRIi64 " m: %" PRIi64 " k: %" PRIi64 ", theta: %lf\n", zScoreSlow, zScore, n, m, k, theta);
CuAssertDblEquals(testCase, zScoreSlow, zScore, 0.000001);
}
}
static void testBreakUpPinchGraphAdjacencyComponentsGreedily(CuTest *testCase) {
//return;
for (int64_t test = 0; test < 10000; test++) {
st_logInfo("Starting break up giant pinch graph components random test %" PRIi64 "\n", test);
stPinchThreadSet *threadSet = stPinchThreadSet_getRandomGraph();
int64_t totalNodes = 2 * stPinchThreadSet_getTotalBlockNumber(threadSet);
float maximumAdjacencyComponentSizeRatio = st_random() * 10;
int64_t maximumAdjacencyComponentSize = log(maximumAdjacencyComponentSizeRatio) * totalNodes;
if (maximumAdjacencyComponentSize < 2) {
maximumAdjacencyComponentSize = 2;
}
stList *adjacencyComponents = stPinchThreadSet_getAdjacencyComponents(threadSet);
int64_t largestAdjacencyComponentSizeInGraph = getSizeOfLargestAdjacencyComponent(adjacencyComponents);
st_logInfo(
"We have a random pinch graph with %" PRIi64 " nodes and %" PRIi64 " adjacency components, the largest adjacency component has %" PRIi64 " nodes, with a ratio of %f we will break up adjacency components larger than %" PRIi64 " in size, this will result in a breakup: %" PRIi64 "\n",
totalNodes, stList_length(adjacencyComponents), largestAdjacencyComponentSizeInGraph, maximumAdjacencyComponentSizeRatio,
maximumAdjacencyComponentSize, largestAdjacencyComponentSizeInGraph > maximumAdjacencyComponentSize);
stList_destruct(adjacencyComponents);
//Now do the actual breaking up
stCaf_breakupComponentsGreedily(threadSet, maximumAdjacencyComponentSizeRatio);
adjacencyComponents = stPinchThreadSet_getAdjacencyComponents(threadSet);
int64_t largestAdjacencyComponentSizeInGraphAfterBreakup = getSizeOfLargestAdjacencyComponent(adjacencyComponents);
totalNodes = 2 * stPinchThreadSet_getTotalBlockNumber(threadSet);
st_logInfo(
"After splitting we have a pinch graph with %" PRIi64 " nodes and %" PRIi64 " adjacency components, the largest adjacency component has %" PRIi64 " nodes, with a ratio of %f that broke up adjacency components larger than %" PRIi64 " in size\n",
totalNodes, stList_length(adjacencyComponents), largestAdjacencyComponentSizeInGraphAfterBreakup,
maximumAdjacencyComponentSizeRatio, maximumAdjacencyComponentSize);
//Cleanup
stList_destruct(adjacencyComponents);
stPinchThreadSet_destruct(threadSet);
}
}
void hmm_randomise(Hmm *hmm) {
//Transitions
for (int64_t from = 0; from < hmm->stateNumber; from++) {
for (int64_t to = 0; to < hmm->stateNumber; to++) {
hmm_setTransition(hmm, from, to, st_random());
}
}
//Emissions
for (int64_t state = 0; state < hmm->stateNumber; state++) {
for (int64_t x = 0; x < SYMBOL_NUMBER_NO_N; x++) {
for (int64_t y = 0; y < SYMBOL_NUMBER_NO_N; y++) {
hmm_setEmissionsExpectation(hmm, state, x, y, st_random());
}
}
}
hmm_normalise(hmm);
}
static void setup() {
teardown();
//Make nodes
nodes = stList_construct3(0, (void(*)(void *)) stIntTuple_destruct);
int64_t nodeNumber = st_randomInt(0, 1000);
for (int64_t i = 0; i < nodeNumber; i++) {
stList_append(nodes, stIntTuple_construct1( i));
}
//Make edges
edges = stList_construct3(0, (void(*)(void *)) stIntTuple_destruct);
float edgeProb = st_random();
for (int64_t i = 0; i < nodeNumber; i++) {
for (int64_t j = i; j < nodeNumber; j++) {
if (st_random() <= edgeProb) {
stList_append(edges, stIntTuple_construct3( st_randomInt(1, 100), i, j));
}
}
}
//Max component size
maxComponentSize = 1 + log(nodeNumber) * 10; //(st_randomInt(0, nodeNumber+1);
}
static void partialRecordRetrieval(CuTest *testCase) {
setup();
//Make some number of large records
stList *records = stList_construct3(0, free);
stList *recordSizes = stList_construct3(0, (void(*)(void *)) stIntTuple_destruct);
for (int32_t i = 0; i < 300; i++) {
int32_t size = st_randomInt(0, 80);
size = size * size * size; //Use cubic size distribution
char *randomRecord = st_malloc(size * sizeof(char));
for (int32_t j = 0; j < size; j++) {
randomRecord[j] = (char) st_randomInt(0, 100);
}
stList_append(records, randomRecord);
stList_append(recordSizes, stIntTuple_construct(1, size));
CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, i));
stKVDatabase_insertRecord(database, i, randomRecord, size * sizeof(char));
CuAssertTrue(testCase, stKVDatabase_containsRecord(database, i));
//st_uglyf("I am creating the record %i %i\n", i, size);
}
while (st_random() > 0.001) {
int32_t recordKey = st_randomInt(0, stList_length(records));
CuAssertTrue(testCase, stKVDatabase_containsRecord(database, recordKey));
char *record = stList_get(records, recordKey);
int32_t size = stIntTuple_getPosition(stList_get(recordSizes, recordKey), 0);
//Get partial record
int32_t start = size > 0 ? st_randomInt(0, size) : 0;
int32_t partialSize = size - start > 0 ? st_randomInt(start, size) - start : 0;
assert(start >= 0);
assert(partialSize >= 0);
assert(partialSize + start <= size);
//st_uglyf("I am getting record %i %i %i %i\n", recordKey, start, partialSize, size);
char *partialRecord = stKVDatabase_getPartialRecord(database, recordKey, start * sizeof(char),
partialSize * sizeof(char), size * sizeof(char));
//Check they are equivalent..
for (int32_t i = 0; i < partialSize; i++) {
if (record[start + i] != partialRecord[i]) {
st_uglyf("There was a difference %i %i for record %i %i\n", record[start + i], partialRecord[i], i,
partialSize);
}
//CuAssertTrue(testCase, record[start + i] == partialRecord[i]);
}
//Check we can not get out of bounds.. (start less than zero)
stTry {
stKVDatabase_getPartialRecord(database, recordKey, -1, 1, size * sizeof(char));
}stCatch(except)
{
CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID);
}stTryEnd;
//Check we can not get out of bounds.. (start greater than index start)
stTry {
stKVDatabase_getPartialRecord(database, recordKey, size, 1, size * sizeof(char));
}stCatch(except)
{
CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID);
}stTryEnd;
//Check we can not get out of bounds.. (total size if greater than record length)
stTry {
stKVDatabase_getPartialRecord(database, recordKey, 0, size + 1, size * sizeof(char));
}stCatch(except)
{
CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID);
}stTryEnd;
//Check we can not get non existent record
stTry {
stKVDatabase_getPartialRecord(database, 1000000, 0, size, size * sizeof(char));
}stCatch(except)
{
CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID);
}stTryEnd;
}
stList_destruct(records);
stList_destruct(recordSizes);
teardown();
}
