static void test_st_randomInt(CuTest *testCase) { /* * Exercises the random int function. */ int32_t min = INT32_MIN; int32_t max = INT32_MAX; int32_t v; for (int32_t i = -9; i < 10; ++i) { CuAssertTrue(testCase, st_randomInt(i, i + 1) == i); } for(int64_t i = 0; i < 100000; i++) { v = st_randomInt(min, max); CuAssertTrue(testCase, v >= min); CuAssertTrue(testCase, v < max); } min = -1; max = 10; for(int64_t i = 0; i < 100000; i++) { v = st_randomInt(min, max); CuAssertTrue(testCase, v >= min); CuAssertTrue(testCase, v < max); } stTry { st_randomInt(1, 1); } stCatch(except) { CuAssertTrue(testCase, stExcept_getId(except) == RANDOM_EXCEPTION_ID); } stTryEnd }
static void test_stSortedSet_searchGreaterThan(CuTest* testCase) { sonLibSortedSetTestSetup(); for(int32_t i=0; i<size; i++) { stSortedSet_insert(sortedSet, stIntTuple_construct(1, input[i])); } //static int32_t sortedInput[] = { -10, -1, 1, 3, 5, 10, 12 }; CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet, stIntTuple_construct(1, -11)) == stSortedSet_search(sortedSet, stIntTuple_construct(1, -10))); CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet, stIntTuple_construct(1, -10)) == stSortedSet_search(sortedSet, stIntTuple_construct(1, -1))); CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet, stIntTuple_construct(1, -5)) == stSortedSet_search(sortedSet, stIntTuple_construct(1, -1))); CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet, stIntTuple_construct(1, 1)) == stSortedSet_search(sortedSet, stIntTuple_construct(1, 3))); CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet, stIntTuple_construct(1, 13)) == NULL); CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet, stIntTuple_construct(1, 12)) == NULL); for(int32_t i=0; i<100; i++) { stSortedSet_insert(sortedSet, stIntTuple_construct(1, st_randomInt(-1000, 1000))); } stList *list = stSortedSet_getList(sortedSet); for(int32_t i=1; i<stList_length(list); i++) { stIntTuple *p = stList_get(list, i-1); stIntTuple *j = stList_get(list, i); stIntTuple *k = stIntTuple_construct(1, st_randomInt(stIntTuple_getPosition(p, 0), stIntTuple_getPosition(j, 0))); CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet, k) == j); stIntTuple_destruct(k); } stList_destruct(list); sonLibSortedSetTestTeardown(); }
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 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 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 void test_st_randomInt_distribution_0(CuTest *testCase) { /* * check the distribution of the randomInt function */ double med, var, mu = 0.0; uint32_t n = 1000000; uint32_t reps = 50; int32_t min = 0; int32_t max = 101; int32_t *array = NULL; for (uint32_t j = 0; j < reps; ++j) { array = (int32_t *) st_malloc(sizeof(*array) * n); for (int32_t i = 0; i < n; i++) { array[i] = st_randomInt(min, max); mu = runningMean32(mu, array[i], i); } var = sv32(array, n, mu); med = median32(array, n); // median() will sort array CuAssertTrue(testCase, array[0] <= array[n - 1]); CuAssertTrue(testCase, array[0] < max); CuAssertTrue(testCase, array[n - 1] < max); // median of discrete uniform is // median = (a + b) / 2 CuAssertTrue(testCase, med == 50.0); // mean of discrete uniform is // mu = (a + b) / 2 CuAssertTrue(testCase, mu > 0.9 * (max - 1) / 2.0); CuAssertTrue(testCase, mu < 1.1 * (max - 1) / 2.0); // variance of discrete uniform is // var = ((b - a + 1)^2 - 1) / 12 CuAssertTrue(testCase, var < 1.1 * (((max - min + 1) * (max - min + 1) - 1) / 12.0)); CuAssertTrue(testCase, var > 0.9 * (((max - min + 1) * (max - min + 1) - 1) / 12.0)); free(array); } }
/* * Retrieves really long records from the database. */ static void bigRecordRetrieval(CuTest *testCase) { setup(); for (int32_t i = 0; i < 10; i++) { int32_t size = st_randomInt(5000000, 10000000); char *randomRecord = st_malloc(size * sizeof(char)); for (int32_t j = 0; j < size; j++) { randomRecord[j] = (char) st_randomInt(0, 100); } //st_uglyf("I am inserting record %i %i\n", i, size); stKVDatabase_insertRecord(database, i, randomRecord, size * sizeof(char)); //st_uglyf("I am creating the record %i %i\n", i, size); //Check they are equivalent. int64_t size2; char *randomRecord2 = stKVDatabase_getRecord2(database, i, &size2); CuAssertTrue(testCase, size == size2); for (int32_t j = 0; j < size; j++) { CuAssertTrue(testCase, randomRecord[j] == randomRecord2[j]); } } teardown(); }
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 test_stPosetAlignment_addAndIsPossible(CuTest *testCase) { for(int64_t trial=0; trial<100; trial++) { setup(); //Make random number of sequences. stList *sequenceLengths = stList_construct3(0, (void (*)(void *))stIntTuple_destruct); for(int64_t i=0; i<sequenceNumber; i++) { stList_append(sequenceLengths, stIntTuple_construct1( st_randomInt(0, MAX_SEQUENCE_SIZE))); } //Propose random alignment pairs... stList *pairs = stList_construct3(0, (void(*)(void *))stIntTuple_destruct); int64_t maxAlignedPairs = st_randomInt(0, MAX_ALIGNMENTS); if(sequenceNumber > 0) { for(int64_t i=0; i<maxAlignedPairs; i++) { int64_t seq1 = st_randomInt(0, sequenceNumber); int64_t seqLength1 = stIntTuple_get(stList_get(sequenceLengths, seq1), 0); if(seqLength1 == 0) { continue; } int64_t position1 = st_randomInt(0, seqLength1); int64_t seq2 = st_randomInt(0, sequenceNumber); int64_t seqLength2 = stIntTuple_get(stList_get(sequenceLengths, seq1), 0); if(seqLength2 == 0) { continue; } int64_t position2 = st_randomInt(0, seqLength2); if(seq1 != seq2) { stList_append(pairs, stIntTuple_construct4( seq1, position1, seq2, position2)); if(stPosetAlignment_isPossible(posetAlignment, seq1, position1, seq2, position2)) { st_logInfo("In %" PRIi64 " %" PRIi64 " %" PRIi64 " %" PRIi64 " \n", seq1, position1, seq2, position2); //For each accepted pair check it doesn't create a cycle. CuAssertTrue(testCase, !containsACycle(pairs, sequenceNumber)); CuAssertTrue(testCase, stPosetAlignment_add(posetAlignment, seq1, position1, seq2, position2)); } else { st_logInfo("Out %" PRIi64 " %" PRIi64 " %" PRIi64 " %" PRIi64 " \n", seq1, position1, seq2, position2); //For each rejected pair check it creates a cycle.. CuAssertTrue(testCase, containsACycle(pairs, sequenceNumber)); CuAssertTrue(testCase, !stPosetAlignment_isPossible(posetAlignment, seq1, position1, seq2, position2)); stIntTuple_destruct(stList_pop(pairs)); //remove the pair which created the cycle. CuAssertTrue(testCase, !containsACycle(pairs, sequenceNumber)); //Check we're back to being okay.. } } } } //Cleanup stList_destruct(sequenceLengths); stList_destruct(pairs); teardown(); st_logInfo("Passed a random ordering test with %" PRIi64 " sequences and %" PRIi64 " aligned pairs\n", sequenceNumber, maxAlignedPairs); } }
void testCactusDisk_getUniqueID_UniqueIntervals(CuTest* testCase) { cactusDiskTestSetup(); stSortedSet *uniqueNames = stSortedSet_construct3(testCactusDisk_getUniqueID_UniqueP, free); for (int64_t i = 0; i < 10; i++) { //Gets a billion ids, checks we are good. int64_t intervalSize = st_randomInt(0, 100000); Name uniqueName = cactusDisk_getUniqueIDInterval(cactusDisk, intervalSize); for(int64_t j=0; j<intervalSize; j++) { CuAssertTrue(testCase, uniqueName > 0); CuAssertTrue(testCase, uniqueName < INT64_MAX); CuAssertTrue(testCase, uniqueName != NULL_NAME); char *cA = cactusMisc_nameToString(uniqueName); CuAssertTrue(testCase, stSortedSet_search(uniqueNames, cA) == NULL); CuAssertTrue(testCase, cactusMisc_stringToName(cA) == uniqueName); stSortedSet_insert(uniqueNames, cA); uniqueName++; } } stSortedSet_destruct(uniqueNames); cactusDiskTestTeardown(); }
static void testGibbsSamplingWithSimulatedAnnealing(CuTest *testCase, double(*temperatureFn)(double), bool pureGreedy, int64_t maxNumberOfChainsBeforeSwitchingToFast) { for (int64_t i = 0; i < 100; i++) { setup(); double totalScore; time_t startTime = time(NULL); bool fast = maxNumberOfChainsBeforeSwitchingToFast > nodeNumber; stList *reference = makeReferenceGreedily(stubs, chains, zMatrix, nodeNumber, &totalScore, fast); checkIsValidReference(testCase, reference, totalScore); time_t totalTime = time(NULL) - startTime; char *cA = stString_print("Pre-annealing greedy (fast:%" PRIi64 "), %" PRIi64 " nodes, it took %" PRIi64 " seconds, score: %f\n", fast, nodeNumber, totalTime, totalScore); st_logInfo(cA); logReference(reference, nodeNumber, zMatrix, totalScore, cA); free(cA); startTime = time(NULL); int64_t permutations = st_randomInt(0, 100); if(pureGreedy) { greedyImprovement(reference, chains, zMatrix, permutations); } else { gibbsSamplingWithSimulatedAnnealing(reference, chains, zMatrix, permutations, temperatureFn); } double totalScoreAfterAnnealing = calculateZScoreOfReference(reference, nodeNumber, zMatrix); checkIsValidReference(testCase, reference, totalScoreAfterAnnealing); totalTime = time(NULL) - startTime; cA = stString_print("Post-annealing permutations:%" PRIi64 ", %" PRIi64 " nodes, it took %" PRIi64 " seconds, score: %f\n", permutations, nodeNumber, totalTime, totalScore); st_logInfo(cA); logReference(reference, nodeNumber, zMatrix, totalScoreAfterAnnealing, cA); if(pureGreedy) { CuAssertTrue(testCase, totalScoreAfterAnnealing + 0.001 >= totalScore); } teardown(); } }
static void readWriteAndRemoveRecordsLotsIteration(CuTest *testCase, int numRecords, bool reopenDatabase) { //Make a big old list of records.. stSortedSet *set = stSortedSet_construct3((int(*)(const void *, const void *)) stIntTuple_cmpFn, (void(*)(void *)) stIntTuple_destruct); while (stSortedSet_size(set) < numRecords) { int32_t key = st_randomInt(0, 100 * numRecords); stIntTuple *tuple = stIntTuple_construct(1, key); if (stSortedSet_search(set, tuple) == NULL) { CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, key)); stSortedSet_insert(set, tuple); stKVDatabase_insertRecord(database, key, &key, sizeof(int32_t)); CuAssertTrue(testCase, stKVDatabase_containsRecord(database, key)); } else { CuAssertTrue(testCase, stKVDatabase_containsRecord(database, key)); stIntTuple_destruct(tuple); // already in db } } readWriteAndRemoveRecordsLotsCheck(testCase, set, 1); //Update all records to negate values stSortedSetIterator *it = stSortedSet_getIterator(set); stIntTuple *tuple; while ((tuple = stSortedSet_getNext(it)) != NULL) { int32_t *value = (int32_t *) stKVDatabase_getRecord(database, stIntTuple_getPosition(tuple, 0)); *value *= -1; stKVDatabase_updateRecord(database, stIntTuple_getPosition(tuple, 0), value, sizeof(int32_t)); CuAssertTrue(testCase, stKVDatabase_containsRecord(database, stIntTuple_getPosition(tuple, 0))); free(value); } stSortedSet_destructIterator(it); readWriteAndRemoveRecordsLotsCheck(testCase, set, -1); //Try optionally committing the transaction and reloading the database.. if (reopenDatabase) { //stKVDatabase_commitTransaction(database); stKVDatabase_destruct(database); database = stKVDatabase_construct(conf, false); //stKVDatabase_startTransaction(database); } //Now remove each one.. it = stSortedSet_getIterator(set); while ((tuple = stSortedSet_getNext(it)) != NULL) { CuAssertTrue(testCase, stKVDatabase_containsRecord(database, stIntTuple_getPosition(tuple, 0))); stKVDatabase_removeRecord(database, stIntTuple_getPosition(tuple, 0)); CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, stIntTuple_getPosition(tuple, 0))); //Test we get exception if we remove twice. stTry { stKVDatabase_removeRecord(database, stIntTuple_getPosition(tuple, 0)); CuAssertTrue(testCase, 0); } stCatch(except) { CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID); }stTryEnd; } stSortedSet_destructIterator(it); CuAssertIntEquals(testCase, 0, stKVDatabase_getNumberOfRecords(database)); stSortedSet_destruct(set); }
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(); }
static void setup() { teardown(); sequenceNumber = st_randomInt(0, MAX_SEQUENCE_NUMBER); posetAlignment = stPosetAlignment_construct(sequenceNumber); }