static int gt_codon_iterator_encseq_single_test(GtEncseq *encseq,
const char *testseq,
const char *testseq_cmp,
GtReadmode readmode,
GT_UNUSED GtError *err)
{
unsigned long j, k, i;
GtCodonIterator *ci;
char n1, n2, n3;
int had_err = 0;
unsigned int frame;
gt_error_check(err);
for (j = 0; !had_err && j < strlen(testseq); j++) {
for (k = j; !had_err && k < strlen(testseq); k++) {
GtCodonIteratorStatus s;
ci = gt_codon_iterator_encseq_new_with_readmode(encseq, j,
strlen(testseq) - k,
readmode,
NULL);
i = j;
while (!had_err && !(s = gt_codon_iterator_next(ci, &n1, &n2, &n3,
&frame, NULL))) {
gt_ensure(had_err, n1 == testseq_cmp[i]);
gt_ensure(had_err, n2 == testseq_cmp[i+1]);
gt_ensure(had_err, n3 == testseq_cmp[i+2]);
i++;
}
gt_codon_iterator_delete(ci);
}
}
return had_err;
}
int gt_codon_iterator_encseq_unit_test(GtError *err)
{
int had_err = 0,
i, j;
const char *testseq = "gctgatcgactgaacatagctagcacggccgcgcgatcgtacgatg",
*testseq_rc = "catcgtacgatcgcgcggccgtgctagctatgttcagtcgatcagc",
*testseq_rv = "gtagcatgctagcgcgccggcacgatcgatacaagtcagctagtcg",
*testseq_cm = "cgactagctgacttgtatcgatcgtgccggcgcgctagcatgctac";
GtEncseq *encseq;
GtEncseqBuilder *eb;
GtCodonIterator *ci;
GtAlphabet *alpha;
char n1, n2, n3;
unsigned int frame;
gt_error_check(err);
alpha = gt_alphabet_new_dna();
eb = gt_encseq_builder_new(alpha);
gt_encseq_builder_add_cstr(eb, testseq, strlen(testseq), "foo");
encseq = gt_encseq_builder_build(eb, NULL);
/* forward tests */
had_err = gt_codon_iterator_encseq_single_test(encseq, testseq, testseq,
GT_READMODE_FORWARD, err);
/* complement tests */
had_err = gt_codon_iterator_encseq_single_test(encseq, testseq, testseq_cm,
GT_READMODE_COMPL, err);
/* revcompl tests */
had_err = gt_codon_iterator_encseq_single_test(encseq, testseq, testseq_rc,
GT_READMODE_REVCOMPL, err);
/* reverse tests */
had_err = gt_codon_iterator_encseq_single_test(encseq, testseq, testseq_rv,
GT_READMODE_REVERSE, err);
/* lengths < 3 */
for (j = 0; !had_err && j < 3; j++) {
ci = gt_codon_iterator_encseq_new_with_readmode(encseq, 10, j,
GT_READMODE_REVCOMPL, NULL);
i = 10;
while (!(gt_codon_iterator_next(ci, &n1, &n2, &n3, &frame, NULL))) {
gt_ensure(had_err, false);
}
gt_ensure(had_err, i == 10);
gt_codon_iterator_delete(ci);
}
gt_encseq_delete(encseq);
gt_encseq_builder_delete(eb);
gt_alphabet_delete(alpha);
return had_err;
}
int gt_priority_queue_unit_test(GtError *err)
{
int had_err = 0;
unsigned long idx,
maxsize = 10000UL,
trials = 1000UL,
*numbers = gt_malloc(sizeof *numbers * maxsize),
*numbers_copy = gt_malloc(sizeof *numbers_copy * maxsize);
unsigned long arr[] = {76UL, 132UL, 136UL, 538UL, 545UL, 401UL};
gt_error_check (err);
gt_priority_sort(arr,(unsigned long) sizeof arr/sizeof arr[0]);
for (idx = 0; idx < trials; idx++)
{
unsigned long j,
size = gt_rand_max(maxsize),
maximal_value = 1 + gt_rand_max(1000UL);
GtPriorityQueue *pq = gt_priority_queue_new(cmpUlong,size);
void *elem;
for (j = 0; j< size; j++)
{
numbers_copy[j] = numbers[j] = gt_rand_max(maximal_value);
gt_priority_queue_add(pq, numbers_copy + j);
}
gt_ensure(had_err,gt_priority_queue_is_full(pq));
qsort(numbers,(size_t) size,sizeof *numbers,cmpUlong);
for (j = 0; j < size; j++)
{
elem = gt_priority_queue_extract_min(pq);
if (*((unsigned long *) elem) != numbers[j])
{
fprintf(stderr,"elem=%lu != %lu = numbers[%lu]\n",
*((unsigned long *) elem),numbers[j],j);
exit(EXIT_FAILURE);
}
gt_ensure(had_err,*((unsigned long *) elem) == numbers[j]);
}
gt_ensure(had_err,gt_priority_queue_is_empty(pq));
gt_priority_queue_delete(pq);
}
gt_free(numbers);
gt_free(numbers_copy);
if (had_err == -1)
{
exit(EXIT_FAILURE);
}
return had_err;
}
int gt_diagram_unit_test(GtError *err)
{
int had_err = 0;
GtGenomeNode *gn;
GtDiagramTestShared sh;
GtRange testrng = {100, 10000};
gt_error_check(err);
gn = gt_feature_node_new_standard_gene();
sh.fi = gt_feature_index_memory_new();
sh.sty = gt_style_new(err);
sh.err = err;
sh.errstatus = 0;
gt_feature_index_add_feature_node(sh.fi, gt_feature_node_cast(gn), err);
gt_genome_node_delete(gn);
sh.d = gt_diagram_new(sh.fi, "ctg123", &testrng, sh.sty, err);
/* removed the multithreading test for now until it is fixed */
gt_diagram_unit_test_sketch_func(&sh);
gt_ensure(sh.errstatus == 0);
gt_style_delete(sh.sty);
gt_diagram_delete(sh.d);
gt_feature_index_delete(sh.fi);
return had_err;
}
int gt_uint64hashtable_unit_test(GtError *err)
{
int had_err = 0;
GtUint64hashtable *table = NULL;
bool found;
size_t i, nof_elements;
gt_error_check(err);
table = gt_uint64hashtable_new(0);
gt_ensure(had_err, table != NULL);
found = gt_uint64hashtable_search(table, (uint64_t)7, false);
gt_ensure(had_err, !found);
found = gt_uint64hashtable_search(table, (uint64_t)7, true);
gt_ensure(had_err, !found);
found = gt_uint64hashtable_search(table, (uint64_t)7, true);
gt_ensure(had_err, found);
gt_uint64hashtable_delete(table);
nof_elements = (size_t)10000;
table = gt_uint64hashtable_new(nof_elements);
gt_ensure(had_err, table != NULL);
for (i = 0; i < nof_elements; i++)
{
found = gt_uint64hashtable_search(table, (uint64_t)i, true);
gt_ensure(had_err, !found);
}
for (i = 0; i < nof_elements; i++)
{
found = gt_uint64hashtable_search(table, (uint64_t)i, true);
gt_ensure(had_err, found);
}
gt_uint64hashtable_delete(table);
return had_err;
}
static int check_queue_reverse(void **elem, void *info, GtError *err)
{
long *check_counter_reverse = info;
int had_err = 0;
gt_error_check(err);
gt_assert(check_counter_reverse);
gt_ensure(had_err, *check_counter_reverse == *(long*) elem);
if (!had_err)
(*check_counter_reverse)--;
return had_err;
}
int gt_kmp_preproc_unit_test(GtError *err)
{
int had_err = 0;
int i;
gt_kmp_t *pi, expected_pi[10] = {(gt_kmp_t)0, (gt_kmp_t)0, (gt_kmp_t)1,
(gt_kmp_t)2, (gt_kmp_t)3, (gt_kmp_t)4, (gt_kmp_t)5, (gt_kmp_t)6,
(gt_kmp_t)0, (gt_kmp_t)1};
pi = gt_kmp_preproc("ababababca", 10UL);
for (i = 0; i < 10; i++)
gt_ensure(had_err, pi[i] == expected_pi[i]);
gt_free(pi);
return had_err;
}
int gt_codon_iterator_simple_unit_test(GtError *err)
{
int had_err = 0,
i;
const char *testseq = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
GtCodonIterator *ci;
char n1, n2, n3;
unsigned int frame;
gt_error_check(err);
ci = gt_codon_iterator_simple_new(testseq, 26, NULL);
i = 0;
while (!gt_codon_iterator_next(ci, &n1, &n2, &n3, &frame, NULL)) {
gt_ensure(had_err, n1 == testseq[i]);
gt_ensure(had_err, n2 == testseq[i+1]);
gt_ensure(had_err, n3 == testseq[i+2]);
i++;
}
gt_ensure(had_err, i == 24);
gt_codon_iterator_delete(ci);
return had_err;
}
int gt_alphabet_unit_test(GtError *err)
{
int had_err = 0;
GtAlphabet *a, *b, *c;
gt_error_check(err);
a = gt_alphabet_new_dna();
b = gt_alphabet_new_protein();
c = gt_alphabet_clone(a);
gt_ensure(had_err, gt_alphabet_equals(a, a));
gt_ensure(had_err, gt_alphabet_equals(b, b));
gt_ensure(had_err, gt_alphabet_equals(c, c));
gt_ensure(had_err, !gt_alphabet_equals(a, b));
gt_ensure(had_err, gt_alphabet_equals(a, c));
gt_alphabet_delete(a);
gt_alphabet_delete(b);
gt_alphabet_delete(c);
return had_err;
}
int gt_countingsort_unit_test(GtError *err)
{
unsigned int numbers[] = { 1, 2, 1, 2, 0 }, numbers_out[5],
sorted_numbers[] = { 0, 1, 1, 2, 2 };
int had_err = 0;
gt_error_check(err);
gt_countingsort(numbers_out, numbers, sizeof (unsigned int), 5,
gt_countingsort_get_max(numbers, sizeof (unsigned int), 5,
NULL, get_int),
NULL, get_int);
gt_ensure(
!memcmp(sorted_numbers, numbers_out, sizeof (unsigned int) * 5));
return had_err;
}
int gt_trans_table_unit_test(GtError *err)
{
int had_err = 0;
GtStrArray *schemes;
gt_error_check(err);
/* check retrieval of table descriptions */
schemes = gt_trans_table_get_scheme_descriptions();
gt_ensure(
gt_str_array_size(schemes) == (GtUword) GT_NUMOFTRANSSCHEMES);
/* check switching translation scheme */
/* test_errnum = gt_translator_set_translation_scheme(tr, 3, test_err);
gt_ensure(!test_errnum && !gt_error_is_set(test_err)); */
/* check switching to invalid translation scheme */
/* test_errnum = gt_translator_set_translation_scheme(tr, 7, test_err);
gt_ensure(test_errnum && gt_error_is_set(test_err)); */
/* switch back to default translation scheme */
/* gt_error_unset(test_err);
test_errnum = gt_translator_set_translation_scheme(tr, 1, test_err);
gt_ensure(!test_errnum && !gt_error_is_set(test_err)); */
/* check single codon translation */
/*
* char *bases = "AaCcGgTt";
* gt_error_unset(test_err);
for (i=0; i<8; i++) {
char c1 = bases[i];
for (j=0; j<8; j++) {
char c2 = bases[j];
for (k=0; k<8; k++) {
char c3 = bases[k], ret1, ret2;
test_errnum = gt_translator_codon2amino(tr, c1, c2, c3, &ret1,
test_err);
gt_ensure(!test_errnum && !gt_error_is_set(test_err));
ret2 = gt_transa(tr->scheme->aminos, true, c1, c2, c3, NULL,
test_err);
gt_ensure(ret1 == ret2);
}
}
} */
return had_err;
}
int gt_alignment_unit_test(GtError *err)
{
static char u[] = "acgtagatatatagat",
v[] = "agaaagaggtaagaggga";
GtAlignment *alignment;
int had_err = 0;
gt_error_check(err);
/* construct the following alignment (backwards):
acgtaga--tatata-gat
| ||| || | | | [R 7,I 2,R 2,D 1,R 3,I 1,R 3]
agaaagaggta-agaggga
*/
alignment = gt_alignment_new_with_seqs((const GtUchar *) u,
(GtUword) strlen(u),
(const GtUchar *) v,
(GtUword) strlen(v));
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_insertion(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_deletion(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_insertion(alignment);
gt_alignment_add_insertion(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_alignment_add_replacement(alignment);
gt_ensure(gt_alignment_eval(alignment) == 10UL);
gt_alignment_delete(alignment);
return had_err;
}
static int check_splicedseq(Splicedseq *ss, GtError *err)
{ /*0123456789*/
static char *origseq = "aaccaagtga", *splicedseq = "ccgtg";
int had_err = 0;
gt_error_check(err);
gt_splicedseq_add(ss, 2, 3, origseq + 2);
gt_splicedseq_add(ss, 6, 8, origseq + 6);
gt_ensure(had_err, strcmp(gt_splicedseq_get(ss), splicedseq) == 0);
gt_ensure(had_err, !gt_splicedseq_pos_is_border(ss, 0));
gt_ensure(had_err, gt_splicedseq_pos_is_border(ss, 1));
gt_ensure(had_err, !gt_splicedseq_pos_is_border(ss, 2));
gt_ensure(had_err, !gt_splicedseq_pos_is_border(ss, 3));
gt_ensure(had_err, !gt_splicedseq_pos_is_border(ss, 4));
return had_err;
}
int gt_cstr_unit_test(GtError *err)
{
int had_err = 0;
char **res;
const char *foo = "foo bar baz";
gt_error_check(err);
res = gt_cstr_split(foo, ' ');
gt_ensure(strcmp(res[0], "foo") == 0);
gt_ensure(strcmp(res[1], "") == 0);
gt_ensure(strcmp(res[2], "bar") == 0);
gt_ensure(strcmp(res[3], "baz") == 0);
gt_ensure(res[4] == NULL);
gt_cstr_array_delete(res);
res = gt_cstr_split("", ' ');
gt_ensure(res[0] == NULL);
gt_cstr_array_delete(res);
return had_err;
}
int gt_block_unit_test(GtError *err)
{
GtRange r1, r2, r_temp, b_range;
GtStrand s;
GtGenomeNode *gn1, *gn2;
GtElement *e1, *e2;
double height;
GtBlock *b;
GtStr *seqid, *caption1, *caption2;
int had_err = 0;
GtStyle *sty;
GtError *testerr;
gt_error_check(err);
seqid = gt_str_new_cstr("seqid");
caption1 = gt_str_new_cstr("foo");
caption2 = gt_str_new_cstr("bar");
testerr = gt_error_new();
r1.start = 10UL;
r1.end = 50UL;
r2.start = 40UL;
r2.end = 50UL;
gn1 = gt_feature_node_new(seqid, gt_ft_gene, r1.start, r1.end,
GT_STRAND_FORWARD);
gn2 = gt_feature_node_new(seqid, gt_ft_exon, r2.start, r2.end,
GT_STRAND_FORWARD);
e1 = gt_element_new((GtFeatureNode*) gn1);
e2 = gt_element_new((GtFeatureNode*) gn2);
b = gt_block_new();
/* test gt_block_insert_elements */
gt_ensure((0UL == gt_block_get_size(b)));
gt_block_insert_element(b, (GtFeatureNode*) gn1);
gt_ensure((1UL == gt_block_get_size(b)));
gt_block_insert_element(b, (GtFeatureNode*) gn2);
gt_ensure((2UL == gt_block_get_size(b)));
/* test gt_block_set_range & gt_block_get_range */
r_temp = gt_range_join(&r1, &r2);
gt_block_set_range(b, r_temp);
b_range = gt_block_get_range(b);
gt_ensure((0 == gt_range_compare(&b_range, &r_temp)));
gt_ensure((1 == gt_range_compare(&r2, &r_temp)));
/* tests gt_block_set_caption & gt_block_get_caption */
gt_block_set_caption(b, caption1);
gt_ensure((0 == gt_str_cmp(gt_block_get_caption(b), caption1)));
gt_ensure((0 != gt_str_cmp(gt_block_get_caption(b), caption2)));
/* tests gt_block_set_strand & gt_block_get_range */
s = gt_block_get_strand(b);
gt_ensure((GT_STRAND_UNKNOWN == s));
gt_block_set_strand(b, GT_STRAND_FORWARD);
s = gt_block_get_strand(b);
gt_ensure((GT_STRAND_FORWARD == s));
/* test gt_block_get_max_height() */
sty = gt_style_new(err);
gt_ensure(gt_block_get_max_height(b, &height, sty, err) == 0);
gt_ensure(!gt_error_is_set(testerr));
gt_ensure(height == BAR_HEIGHT_DEFAULT);
gt_style_set_num(sty, "exon", "bar_height", 42);
gt_ensure(gt_block_get_max_height(b, &height, sty, err) == 0);
gt_ensure(!gt_error_is_set(testerr));
gt_ensure(height == 42);
gt_style_set_num(sty, "gene", "bar_height", 23);
gt_ensure(gt_block_get_max_height(b, &height, sty, err) == 0);
gt_ensure(!gt_error_is_set(testerr));
gt_ensure(height == 42);
gt_style_unset(sty, "exon", "bar_height");
gt_ensure(gt_block_get_max_height(b, &height, sty, err) == 0);
gt_ensure(!gt_error_is_set(testerr));
gt_ensure(height == 23);
gt_str_delete(caption2);
gt_str_delete(seqid);
gt_element_delete(e1);
gt_element_delete(e2);
gt_block_delete(b);
gt_style_delete(sty);
gt_error_delete(testerr);
gt_genome_node_delete(gn1);
gt_genome_node_delete(gn2);
return had_err;
}
int gt_bitpackarray_unit_test(GtError *err)
{
struct BitPackArray *bitStore = NULL;
int had_err = 0;
{
uint32_t *randSrc = NULL; /*< create random ints here for input as bit
* store */
uint32_t *randCmp = NULL, /*< used for random ints read back */
mask;
size_t i, numRnd;
unsigned bits;
numRnd = random() % MAX_RND_NUMS + 1;
bits = random() % (sizeof (randSrc[0]) * CHAR_BIT + 1);
if (bits == 32)
mask = ~(uint32_t)0;
else
mask = ~((~(uint32_t)0)<<bits);
gt_log_log("numRnd="GT_WU"\n", (GtUword)numRnd);
randSrc = gt_malloc(sizeof (uint32_t)*numRnd);
bitStore = bitpackarray_new(bits, numRnd,true);
randCmp = gt_malloc(sizeof (uint32_t)*numRnd);
for (i = 0; i < numRnd; ++i)
{
uint32_t v = randSrc[i] = random();
bitpackarray_store_uint32(bitStore, i, v);
}
for (i = 0; i < numRnd; ++i)
{
uint32_t v = randSrc[i];
uint32_t r = bitpackarray_get_uint32(bitStore, i);
gt_ensure((v & mask) == r);
if (had_err)
{
gt_log_log("gt_bsStoreUInt32/bitpackarray_get_uint32: "
"Expected %"PRIu32", got %"PRIu32", i = "GT_WU", bits=%u\n",
v & mask, r, (GtUword)i, bits);
gt_free(randSrc);
gt_free(randCmp);
bitpackarray_delete(bitStore);
return had_err;
}
}
gt_free(randSrc);
gt_free(randCmp);
bitpackarray_delete(bitStore);
}
gt_log_log("bitpackarray_store_uint32/bitpackarray_get_uint32: passed\n");
{
uint64_t *randSrc = NULL; /*< create random ints here for input as bit
* store */
uint64_t *randCmp = NULL, /*< used for random ints read back */
mask;
size_t i, numRnd;
unsigned bits;
numRnd = random() % MAX_RND_NUMS + 1;
bits = random() % (sizeof (randSrc[0]) * CHAR_BIT + 1);
if (bits == (sizeof (randSrc[0]) * CHAR_BIT))
mask = ~(uint64_t)0;
else
mask = ~((~(uint64_t)0)<<bits);
gt_ensure((randSrc = gt_malloc(sizeof (uint64_t)*numRnd))
&& (bitStore = bitpackarray_new(bits, numRnd,true))
&& (randCmp = gt_malloc(sizeof (uint64_t)*numRnd)));
if (had_err)
{
perror("Storage allocations failed");
if (randSrc)
gt_free(randSrc);
if (randCmp)
gt_free(randCmp);
if (bitStore)
bitpackarray_delete(bitStore);
return had_err;
}
for (i = 0; i < numRnd; ++i)
{
uint64_t v = randSrc[i] = ((uint64_t)random() << 32 | random());
bitpackarray_store_uint64(bitStore, i, v);
}
for (i = 0; i < numRnd; ++i)
{
uint64_t v = randSrc[i];
uint64_t r = bitpackarray_get_uint64(bitStore, i);
gt_ensure((v & mask) == r);
if (had_err)
{
gt_log_log("gt_bsStoreUInt64/bitpackarray_get_uint64: "
"Expected "GT_LLU", got "GT_LLU", i = "GT_WU", bits=%u\n",
(GtUint64)(v & mask),
(GtUint64)r, (GtUword)i, bits);
gt_free(randSrc);
gt_free(randCmp);
bitpackarray_delete(bitStore);
return had_err;
}
}
gt_free(randSrc);
gt_free(randCmp);
bitpackarray_delete(bitStore);
}
gt_log_log("bitpackarray_store_uint64/bitpackarray_get_uint64: passed\n");
return had_err;
}
int gt_interval_tree_unit_test(GT_UNUSED GtError *err)
{
GtIntervalTree *it = NULL;
GtIntervalTreeNode *res = NULL;
unsigned long i = 0;
int had_err = 0, num_testranges = 3000,
num_samples = 300000, num_find_all_samples = 10000,
gt_range_max_basepos = 90000, width = 700,
query_width = 5000;
GtRange *res_rng = NULL, qrange;
GtArray *arr = NULL, *narr = NULL;
arr = gt_array_new(sizeof (GtRange*));
/* generate test ranges */
for (i = 0;i<num_testranges;i++)
{
unsigned long start;
GtRange *rng;
rng = gt_calloc(1, sizeof (GtRange));
start = gt_rand_max(gt_range_max_basepos);
rng->start = start;
rng->end = start + gt_rand_max(width);
gt_array_add(arr, rng);
}
it = gt_interval_tree_new(gt_free_func);
/* insert ranges */
for (i = 0; i < num_testranges && !had_err; i++)
{
GtIntervalTreeNode *new_node;
GtRange *rng;
rng = *(GtRange**) gt_array_get(arr, i);
new_node = gt_interval_tree_node_new(rng, rng->start, rng->end);
gt_interval_tree_insert(it, new_node);
}
gt_ensure(had_err, gt_interval_tree_size(it) == num_testranges);
/* perform test queries */
for (i = 0; i < num_samples && !had_err; i++)
{
unsigned long start = gt_rand_max(gt_range_max_basepos);
qrange.start = start;
qrange.end = start + gt_rand_max(width);
res = gt_interval_tree_find_first_overlapping(it, qrange.start, qrange.end);
if (res)
{
/* we have a hit, check if really overlapping */
res_rng = (GtRange*) gt_interval_tree_node_get_data(res);
gt_ensure(had_err, gt_range_overlap(&qrange, res_rng));
} else {
/* no hit, check whether there really is no overlapping
interval in tree */
GtRange *this_rng;
unsigned long j;
bool found = false;
for (j = 0; j < gt_array_size(arr); j++)
{
this_rng = *(GtRange**) gt_array_get(arr, j);
if (gt_range_overlap(this_rng, &qrange))
{
found = true;
break;
}
}
gt_ensure(had_err, !found);
}
}
/* test searching for all overlapping intervals */
for (i = 0; i < num_find_all_samples && !had_err; i++)
{
unsigned long start = gt_rand_max(gt_range_max_basepos);
qrange.start = start;
qrange.end = start + gt_rand_max(query_width);
GtArray *res = gt_array_new(sizeof (GtRange*));
gt_interval_tree_find_all_overlapping(it, qrange.start, qrange.end, res);
if (res)
{
/* generate reference overlapping interval list by linear search */
GtArray *ref;
unsigned long j;
ref = gt_array_new(sizeof (GtRange*));
for (j = 0; j < gt_array_size(arr); j++)
{
GtRange *this_rng;
this_rng = *(GtRange**) gt_array_get(arr, j);
if (gt_range_overlap(this_rng, &qrange))
{
gt_array_add(ref, this_rng);
}
}
/* compare reference with interval tree query result */
gt_array_sort_stable(ref, range_ptr_compare);
gt_array_sort_stable(res, range_ptr_compare);
/* must be equal */
gt_ensure(had_err, gt_array_cmp(ref, res)==0);
gt_array_delete(ref);
}
gt_array_delete(res);
}
gt_interval_tree_delete(it);
it = gt_interval_tree_new(NULL);
gt_array_reset(arr);
/* generate test ranges */
for (i = 0;i<num_testranges && !had_err;i++)
{
unsigned long start;
GtIntervalTreeNode *new_node;
start = gt_rand_max(gt_range_max_basepos);
new_node = gt_interval_tree_node_new((void*) i, start,
start + gt_rand_max(width));
gt_interval_tree_insert(it, new_node);
}
gt_ensure(had_err, gt_interval_tree_size(it) == num_testranges);
narr = gt_array_new(sizeof (GtIntervalTreeNode*));
for (i = 0; i < num_testranges && !had_err; i++) {
unsigned long idx, n, val;
GtIntervalTreeNode *node = NULL;
/* get all nodes referenced by the interval tree */
interval_tree_find_all_internal(it, it->root, itree_test_get_node, 0,
gt_range_max_basepos+width, narr);
/* remove a random node */
idx = gt_rand_max(gt_array_size(narr)-1);
node = *(GtIntervalTreeNode**) gt_array_get(narr, idx);
gt_ensure(had_err, node != NULL);
val = (unsigned long) gt_interval_tree_node_get_data(node);
gt_interval_tree_remove(it, node);
gt_array_reset(narr);
/* make sure that the node has disappeared */
gt_ensure(had_err, gt_interval_tree_size(it) == num_testranges - (i+1));
interval_tree_find_all_internal(it, it->root, itree_test_get_node, 0,
gt_range_max_basepos+width, narr);
gt_ensure(had_err, gt_array_size(narr) == num_testranges - (i+1));
for (n = 0; !had_err && n < gt_array_size(narr); n++) {
GtIntervalTreeNode *onode = *(GtIntervalTreeNode**) gt_array_get(narr, n);
gt_ensure(had_err, (unsigned long) gt_interval_tree_node_get_data(onode)
!= val);
}
}
gt_array_delete(arr);
gt_array_delete(narr);
gt_interval_tree_delete(it);
return had_err;
}
int gt_splitter_unit_test(GtError *err)
{
static char string_1[] = "a bb ccc dddd eeeee",
string_2[] = "a\tbb\tccc\tdddd\teeeee",
string_3[] = "",
string_4[] = "a b",
string_5[] = "ac bc ",
string_6[] = "test";
GtSplitter *s;
int had_err = 0;
gt_error_check(err);
s = gt_splitter_new();
/* string_1 */
gt_ensure(!gt_splitter_size(s));
gt_splitter_split(s, string_1, strlen(string_1), ' ');
gt_ensure(gt_splitter_size(s) == 5);
gt_ensure(strcmp(gt_splitter_get_token(s, 0), "a") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 1), "bb") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 2), "ccc") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 3), "dddd") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 4), "eeeee") == 0);
gt_splitter_reset(s);
/* string_2 */
gt_ensure(!gt_splitter_size(s));
gt_splitter_split(s, string_2, strlen(string_2), '\t');
gt_ensure(gt_splitter_size(s) == 5);
gt_ensure(strcmp(gt_splitter_get_token(s, 0), "a") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 1), "bb") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 2), "ccc") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 3), "dddd") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 4), "eeeee") == 0);
gt_splitter_reset(s);
/* string_3 */
gt_ensure(!gt_splitter_size(s));
gt_splitter_split(s, string_3, strlen(string_3), '\t');
gt_ensure(gt_splitter_size(s) == 1);
gt_ensure(strcmp(gt_splitter_get_token(s, 0), "") == 0);
gt_splitter_reset(s);
/* string_4 */
gt_ensure(!gt_splitter_size(s));
gt_splitter_split(s, string_4, strlen(string_4), ' ');
gt_ensure(gt_splitter_size(s) == 3);
gt_ensure(strcmp(gt_splitter_get_token(s, 0), "a") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 1), "") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 2), "b") == 0);
gt_splitter_reset(s);
/* string_5 */
gt_ensure(!gt_splitter_size(s));
gt_splitter_split(s, string_5, strlen(string_5), ' ');
gt_ensure(gt_splitter_size(s) == 3);
gt_ensure(strcmp(gt_splitter_get_token(s, 0), "ac") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 1), "bc") == 0);
gt_ensure(strcmp(gt_splitter_get_token(s, 2), "") == 0);
gt_splitter_reset(s);
/* string_6 */
gt_ensure(!gt_splitter_size(s));
gt_splitter_split(s, string_6, strlen(string_6), ';');
gt_ensure(gt_splitter_size(s) == 1);
gt_ensure(strcmp(gt_splitter_get_token(s, 0), "test") == 0);
/* free */
gt_splitter_delete(s);
return had_err;
}
int gt_rbtree_unit_test(GtError *err)
{
int had_err = 0;
GtRBTree *tree = NULL;
GtUword i, j, k, *v;
gt_error_check (err);
gt_rbtree_xtab = gt_malloc(GT_RBTREE_SIZE * sizeof (*gt_rbtree_xtab));
gt_rbtree_ytab = gt_malloc(2*GT_RBTREE_SIZE * sizeof (*gt_rbtree_ytab));
gt_rbtree_ztab = gt_malloc(GT_RBTREE_SIZE * sizeof (*gt_rbtree_ztab));
gt_rbtree_depths = gt_malloc(GT_RBTREE_SIZE * sizeof (*gt_rbtree_depths));
tree = gt_rbtree_new(nrbt_cmp_fn, NULL, NULL);
gt_ensure(tree != NULL);
for (i = 0; i < (GtUword) GT_RBTREE_SIZE; ++i) {
gt_rbtree_xtab[i] = i;
}
/* Do this loop several times to get different permutations for the random
case. */
for (i = 0; i < (GtUword) GT_RBTREE_PASSES; ++i) {
NRBT_MANGLECHECK(GT_RBTREE_ASCENDING, GtRBTreeBuild, 0);
NRBT_MANGLECHECK(GT_RBTREE_ASCENDING, GtRBTreeFind, 0);
NRBT_MANGLECHECK(GT_RBTREE_DESCENDING, GtRBTreeFind, 0);
NRBT_MANGLECHECK(GT_RBTREE_RANDOMORDER, GtRBTreeFind, 0);
NRBT_WALKCHECK;
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeDelete, 0);
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeBuild, 0);
NRBT_WALKCHECK;
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeDelete, 0);
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeBuild, 0);
NRBT_WALKCHECK;
NRBT_MANGLECHECK (GT_RBTREE_RANDOMORDER, GtRBTreeDelete, 0);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeBuild, 0);
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeFind, 0);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeFind, 0);
NRBT_MANGLECHECK (GT_RBTREE_RANDOMORDER, GtRBTreeFind, 0);
NRBT_WALKCHECK;
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeDelete, 0);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING,GtRBTreeBuild, 0);
NRBT_WALKCHECK;
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeDelete, 0);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeBuild, 0);
NRBT_WALKCHECK;
NRBT_MANGLECHECK (GT_RBTREE_RANDOMORDER, GtRBTreeDelete, 0);
NRBT_MANGLECHECK (GT_RBTREE_RANDOMORDER, GtRBTreeBuild, 0);
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeFind, 0);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeFind, 0);
NRBT_MANGLECHECK (GT_RBTREE_RANDOMORDER, GtRBTreeFind, 0);
NRBT_WALKCHECK;
NRBT_MANGLECHECK (GT_RBTREE_RANDOMORDER, GtRBTreeDelete, 0);
for (j = 1UL; j < (GtUword) GT_RBTREE_SIZE; j *= 2) {
NRBT_MANGLECHECK (GT_RBTREE_RANDOMORDER, GtRBTreeBuildDelete, j);
}
}
for (i = 1UL; i < (GtUword) GT_RBTREE_SIZE; i *= 2) {
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeBuildDelete, i);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeBuildDelete, i);
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeBuildDelete, i);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeBuildDelete, i);
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeBuildDelete, i);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeBuildDelete, i);
NRBT_MANGLECHECK (GT_RBTREE_ASCENDING, GtRBTreeBuildDelete, i);
NRBT_MANGLECHECK (GT_RBTREE_DESCENDING, GtRBTreeBuildDelete, i);
}
gt_rbtree_delete(tree);
gt_free(gt_rbtree_xtab);
gt_free(gt_rbtree_ytab);
gt_free(gt_rbtree_ztab);
gt_free(gt_rbtree_depths);
i = 0; j = 1UL, k = 2UL;
tree = gt_rbtree_new(nrbt_cmp_fn, NULL, NULL);
v = gt_rbtree_root_key(tree);
gt_ensure(!v);
(void) gt_rbtree_insert(tree, &i);
v = gt_rbtree_root_key(tree);
gt_ensure(v == &i);
gt_ensure(*v == i);
(void) gt_rbtree_insert(tree, &j);
(void) gt_rbtree_insert(tree, &k);
v = gt_rbtree_root_key(tree);
gt_ensure(v == &j);
gt_ensure(*v == j);
gt_rbtree_delete(tree);
return had_err;
}
int gt_ovlfind_kmp_unit_test(GtError *err)
{
int had_err = 0;
GtArray *a;
struct GtOvlfindKmpResult *r;
GtContfind retval;
gt_kmp_t *u_pi, *v_pi;
/*@i1@*/ gt_error_check(err);
had_err = gt_kmp_preproc_unit_test(err);
if (had_err != 0)
return had_err;
a = gt_array_new(sizeof (struct GtOvlfindKmpResult));
/* u suffix == v prefix */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("aacgcacctg", 10UL);
v_pi = gt_kmp_preproc("acctgatttc", 10UL);
retval = gt_ovlfind_kmp("aacgcacctg", 10UL, u_pi, "acctgatttc", 10UL, v_pi,
GT_OVLFIND_PROPER_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_NO);
gt_ensure(had_err, gt_array_size(a) == 1UL);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, true, 5UL);
gt_free(u_pi);
gt_free(v_pi);
}
/* v suffix == u prefix */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("atccgtgacgtg", 12UL);
v_pi = gt_kmp_preproc("aagaagaatccg", 12UL);
retval = gt_ovlfind_kmp("atccgtgacgtg", 12UL, u_pi, "aagaagaatccg", 12UL,
v_pi, GT_OVLFIND_ALL, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_NO);
gt_ensure(had_err, gt_array_size(a) == 1UL);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, false, 5UL);
gt_free(u_pi);
gt_free(v_pi);
}
/* no overlap */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("aac", 3UL);
v_pi = gt_kmp_preproc("tgc", 3UL);
retval = gt_ovlfind_kmp("aac", 3UL, u_pi, "tgc", 3UL, v_pi,
GT_OVLFIND_PROPER_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_NO);
gt_ensure(had_err, gt_array_size(a) == 0UL);
gt_free(u_pi);
gt_free(v_pi);
}
/* u suffix of v */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("acagc", 5UL);
v_pi = gt_kmp_preproc("gtacagc", 7UL);
retval = gt_ovlfind_kmp("acagc", 5UL, u_pi, "gtacagc", 7UL, v_pi,
GT_OVLFIND_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, gt_array_size(a) == 1UL);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, false, 5UL);
gt_array_reset(a);
retval = gt_ovlfind_kmp("acagc", 5UL, u_pi, "gtacagc", 7UL, v_pi,
GT_OVLFIND_PROPER_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_U);
gt_ensure(had_err, gt_array_size(a) == 0UL);
gt_array_reset(a);
retval = gt_ovlfind_kmp("acagc", 5UL, u_pi, "gtacagc", 7UL, v_pi,
GT_OVLFIND_CNT, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, gt_array_size(a) == 0UL);
gt_ensure(had_err, retval == GT_CONTFIND_U);
gt_array_reset(a);
retval = gt_ovlfind_kmp("acagc", 5UL, u_pi, "gtacagc", 7UL, v_pi,
GT_OVLFIND_ALL, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, gt_array_size(a) == 1UL);
gt_ensure(had_err, retval == GT_CONTFIND_U);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, false, 5UL);
gt_free(u_pi);
gt_free(v_pi);
}
/* v suffix of u */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("gtacagc", 7UL);
v_pi = gt_kmp_preproc("acagc", 5UL);
retval = gt_ovlfind_kmp("gtacagc", 7UL, u_pi, "acagc", 5UL, v_pi,
GT_OVLFIND_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
gt_ensure(had_err, gt_array_size(a) == 1UL);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, true, 5UL);
gt_array_reset(a);
retval = gt_ovlfind_kmp("gtacagc", 7UL, u_pi, "acagc", 5UL, v_pi,
GT_OVLFIND_PROPER_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_V);
gt_ensure(had_err, gt_array_size(a) == 0UL);
gt_free(u_pi);
gt_free(v_pi);
}
/* u prefix of v */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("ctat", 4UL);
v_pi = gt_kmp_preproc("ctatacagg", 9UL);
retval = gt_ovlfind_kmp("ctat", 4UL, u_pi, "ctatacagg", 9UL, v_pi,
GT_OVLFIND_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
gt_ensure(had_err, gt_array_size(a) == 1UL);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, true, 4UL);
gt_array_reset(a);
retval = gt_ovlfind_kmp("ctat", 4UL, u_pi, "ctatacagg", 9UL, v_pi,
GT_OVLFIND_PROPER_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_U);
gt_ensure(had_err, gt_array_size(a) == 0UL);
gt_free(u_pi);
gt_free(v_pi);
}
/* v prefix of u */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("ctatacagg", 9UL);
v_pi = gt_kmp_preproc("ctat", 4UL);
retval = gt_ovlfind_kmp("ctatacagg", 9UL, u_pi, "ctat", 4UL, v_pi,
GT_OVLFIND_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
gt_ensure(had_err, gt_array_size(a) == 1UL);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, false, 4UL);
gt_array_reset(a);
retval = gt_ovlfind_kmp("ctatacagg", 9UL, u_pi, "ctat", 4UL, v_pi,
GT_OVLFIND_PROPER_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_V);
gt_ensure(had_err, gt_array_size(a) == 0UL);
gt_free(u_pi);
gt_free(v_pi);
}
/* identical sequences */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("acagc", 5UL);
retval = gt_ovlfind_kmp("acagc", 5UL, u_pi, "acagc", 5UL, u_pi,
GT_OVLFIND_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
gt_ensure(had_err, gt_array_size(a) == 2UL);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, true, 5UL);
GT_OVLFIND_KMP_EXPECT_RESULT(1UL, false, 5UL);
gt_array_reset(a);
retval = gt_ovlfind_kmp("acagc", 5UL, u_pi, "acagc", 5UL, u_pi,
GT_OVLFIND_PROPER_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_EQ);
gt_ensure(had_err, gt_array_size(a) == 0UL);
gt_free(u_pi);
}
/* find_nonmaximal */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("aacagtagtagt", 12UL);
v_pi = gt_kmp_preproc("agtagtagttaa", 12UL);
retval = gt_ovlfind_kmp("aacagtagtagt", 12UL, u_pi, "agtagtagttaa", 12UL,
v_pi, GT_OVLFIND_SPM, 1UL, false, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
gt_ensure(had_err, gt_array_size(a) == 2UL);
GT_OVLFIND_KMP_EXPECT_RESULT(0UL, true, 9UL);
GT_OVLFIND_KMP_EXPECT_RESULT(1UL, false, 2UL);
gt_array_reset(a);
retval = gt_ovlfind_kmp("aacagtagtagt", 12UL, u_pi, "agtagtagttaa", 12UL,
v_pi, GT_OVLFIND_SPM, 1UL, true, ovlfind_kmp_test_save, a);
gt_ensure(had_err, gt_array_size(a) == 5UL);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
gt_free(u_pi);
gt_free(v_pi);
}
/* min_length */
if (!had_err)
{
gt_array_reset(a);
u_pi = gt_kmp_preproc("aggaccagtagt", 12UL);
v_pi = gt_kmp_preproc("agtagttactac", 12UL);
retval = gt_ovlfind_kmp("aggaccagtagt", 12UL, u_pi, "agtagttactac", 12UL,
v_pi, GT_OVLFIND_SPM, 1UL, true, ovlfind_kmp_test_save, a);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
gt_ensure(had_err, gt_array_size(a) == 2UL);
gt_array_reset(a);
retval = gt_ovlfind_kmp("aggaccagtagt", 12UL, u_pi, "agtagttactac", 12UL,
v_pi, GT_OVLFIND_SPM, 4UL, true, ovlfind_kmp_test_save, a);
gt_ensure(had_err, gt_array_size(a) == 1UL);
gt_ensure(had_err, retval == GT_CONTFIND_OFF);
gt_free(u_pi);
gt_free(v_pi);
}
gt_array_delete(a);
return had_err;
}
int gt_intset_16_unit_test(GtError *err)
{
int had_err = 0;
GtIntset *is;
GtUword num_of_elems = gt_rand_max(((GtUword) 1) << 10) + 1,
*arr = gt_malloc(sizeof (*arr) * num_of_elems),
stepsize = GT_DIV2(num_of_elems <<4 / num_of_elems),
idx;
size_t is_size;
gt_error_check(err);
arr[0] = gt_rand_max(stepsize) + 1;
for (idx = (GtUword) 1; idx < num_of_elems; ++idx) {
arr[idx] = arr[idx - 1] + gt_rand_max(stepsize) + 1;
}
is_size = gt_intset_16_size_of_rep(arr[num_of_elems - 1], num_of_elems);
if (!had_err) {
if (is_size < (size_t) UINT_MAX) {
is = gt_intset_16_new(arr[num_of_elems - 1], num_of_elems);
for (idx = 0; idx < num_of_elems; idx++) {
gt_intset_16_add(is, arr[idx]);
gt_ensure(idx + 1 == gt_intset_16_size(is));
if (idx < num_of_elems - 1)
gt_ensure(gt_intset_16_get_idx_smallest_geq(is,
arr[idx] + 1) ==
num_of_elems);
}
gt_ensure(gt_intset_16_elems_is_valid(is));
gt_ensure(gt_intset_16_secstart_is_valid(is));
for (idx = 0; !had_err && idx < num_of_elems; idx++) {
if (arr[idx] != 0 && arr[idx - 1] != (arr[idx] - 1)) {
gt_ensure(
gt_intset_16_get_idx_smallest_geq_test(is, arr[idx] - 1) ==
idx);
gt_ensure(
gt_intset_16_get_idx_smallest_geq(is, arr[idx] - 1) ==
idx);
}
gt_ensure(gt_intset_16_get_test(is, idx) == arr[idx]);
gt_ensure(gt_intset_16_get(is, idx) == arr[idx]);
gt_ensure(
gt_intset_16_get_idx_smallest_geq_test(is, arr[idx] + 1) ==
idx + 1);
gt_ensure(
gt_intset_16_get_idx_smallest_geq(is, arr[idx] + 1) ==
idx + 1);
}
if (!had_err)
had_err = gt_intset_unit_test_notinset(is, 0, arr[0] - 1, err);
if (!had_err)
had_err = gt_intset_unit_test_check_seqnum(is, 0, arr[0] - 1, 0, err);
for (idx = (GtUword) 1; !had_err && idx < num_of_elems; idx++) {
had_err = gt_intset_unit_test_notinset(is, arr[idx - 1] + 1,
arr[idx] - 1, err);
if (!had_err)
had_err = gt_intset_unit_test_check_seqnum(is, arr[idx - 1] + 1,
arr[idx] - 1, idx, err);
}
gt_intset_delete(is);
}
}
gt_free(arr);
return had_err;
}
int gt_ranked_list_unit_test(GtError *err)
{
int had_err = 0;
GtRankedList *rl;
GtRankedListIter *iter;
GtArray *arr;
const GtUword nof_best = 30UL, nof_tests = 100UL;
GtRankedListTestStruct *mystr;
int values[8] = {-3, 4, 1, 545, 24, 33, 22, 42},
i, j;
gt_error_check(err);
rl = gt_ranked_list_new(5UL, gt_ranked_list_cmp_numbers, NULL, NULL);
gt_ensure(rl != NULL);
gt_ensure(gt_ranked_list_size(rl) == 0);
iter = gt_ranked_list_iter_new_from_first(rl);
mystr = gt_ranked_list_iter_next(iter);
gt_ensure(mystr == NULL);
mystr = gt_ranked_list_iter_next(iter);
gt_ensure(mystr == NULL);
gt_ranked_list_iter_delete(iter);
iter = gt_ranked_list_iter_new_from_last(rl);
mystr = gt_ranked_list_iter_prev(iter);
gt_ensure(mystr == NULL);
mystr = gt_ranked_list_iter_prev(iter);
gt_ensure(mystr == NULL);
gt_ranked_list_iter_delete(iter);
for (i = 0; i < 8; i++) {
gt_ranked_list_insert(rl, values+i);
if (i < 5)
gt_ensure(gt_ranked_list_size(rl) == (GtUword) i + 1UL);
else
gt_ensure(gt_ranked_list_size(rl) == 5UL);
}
gt_ensure((*(int*) gt_ranked_list_first(rl)) == 545);
gt_ensure((*(int*) gt_ranked_list_last(rl)) == 22);
gt_ranked_list_delete(rl);
for (j = 0; (GtUword) j < nof_tests; j++) {
rl = gt_ranked_list_new(30UL, gt_ranked_list_cmp_teststructs, gt_free_func,
NULL);
arr = gt_array_new(sizeof (GtRankedListTestStruct));
for (i = 0; i < 200; i++) {
GtRankedListTestStruct newstr,
*ptr;
newstr.id = (GtUword) i;
newstr.score = (GtUword) (random() % (2*nof_best));
gt_array_add(arr, newstr);
ptr = gt_malloc(sizeof (*ptr));
ptr->id = newstr.id;
ptr->score = newstr.score;
gt_ranked_list_insert(rl, ptr);
if ((GtUword) i < nof_best)
gt_ensure(gt_ranked_list_size(rl) == (GtUword) i + 1UL);
else
gt_ensure(gt_ranked_list_size(rl) == nof_best);
}
gt_array_sort_stable_with_data(arr, gt_ranked_list_cmp_teststructs, NULL);
gt_array_reverse(arr);
gt_ensure(gt_ranked_list_size(rl) == nof_best);
iter = gt_ranked_list_iter_new_from_first(rl);
i = 0;
for (mystr = gt_ranked_list_iter_next(iter);
mystr != NULL;
mystr = gt_ranked_list_iter_next(iter)) {
GtRankedListTestStruct *str = (GtRankedListTestStruct*)
gt_array_get(arr, (GtUword) i++);
gt_ensure(mystr != NULL);
gt_ensure(mystr->id == str->id);
gt_ensure(mystr->score == str->score);
/*
printf("id: "GT_WU"/"GT_WU", score "GT_WU"/"GT_WU"\n", mystr->id,
str->id, mystr->score, str->score); */
}
gt_ranked_list_iter_delete(iter);
gt_array_delete(arr);
gt_ranked_list_delete(rl);
}
return had_err;
}
int gt_range_unit_test(GtError *err)
{
static GtRange ranges_in[] = { { 620432, 620536 }, { 620432, 620536 },
{ 620957, 621056 }, { 620957, 621056 },
{ 625234, 625253 }, { 625500, 625655 },
{ 625533, 625655 }, { 625533, 625655 },
{ 627618, 627729 }, { 627618, 627729 },
{ 627618, 627729 }, { 662083, 662194 },
{ 662083, 662194 }, { 662083, 662194 },
{ 663032, 663166 }, { 663032, 663166 },
{ 663032, 663166 }, { 664782, 664906 },
{ 664782, 664906 }, { 664782, 664906 },
{ 665748, 665823 }, { 665748, 665823 },
{ 665748, 665823 }, { 666825, 666881 },
{ 666825, 666881 }, { 667797, 667954 },
{ 667845, 667954 }, { 667845, 667954 },
{ 679175, 679280 }, { 679175, 679280 },
{ 679175, 679280 }, { 680427, 680540 },
{ 680427, 680540 }, { 680427, 680540 },
{ 684144, 684293 }, { 684144, 684293 },
{ 684144, 684293 }, { 724903, 724985 },
{ 724903, 724985 }, { 727099, 727325 },
{ 727099, 727325 }, { 732544, 732821 },
{ 732544, 732821 }, { 750016, 750280 },
{ 750016, 750280 }, { 769508, 769734 },
{ 769508, 769734 } },
ranges_out[] = { { 620432, 620536 }, { 620957, 621056 },
{ 625234, 625253 }, { 625500, 625655 },
{ 625533, 625655 }, { 627618, 627729 },
{ 662083, 662194 }, { 663032, 663166 },
{ 664782, 664906 }, { 665748, 665823 },
{ 666825, 666881 }, { 667797, 667954 },
{ 667845, 667954 }, { 679175, 679280 },
{ 680427, 680540 }, { 684144, 684293 },
{ 724903, 724985 }, { 727099, 727325 },
{ 732544, 732821 }, { 750016, 750280 },
{ 769508, 769734 }};
GtUword counts[] = { 2, 2, 1, 1, 2, 3, 3, 3, 3, 3, 2, 1, 2, 3, 3, 3, 2,
2, 2, 2, 2 };
GtArray *ranges, *tmp_ranges, *ctr;
GtUword i;
int had_err = 0;
gt_error_check(err);
gt_ensure(sizeof (ranges_out) / sizeof (ranges_out[0]) ==
sizeof (counts) / sizeof (counts[0]));
/* test gt_ranges_uniq() */
ranges = gt_array_new(sizeof (GtRange));
tmp_ranges = gt_array_new(sizeof (GtRange));
for (i = 0;
i < sizeof (ranges_in) / sizeof (ranges_in[0]) && !had_err;
i++)
gt_array_add(ranges, ranges_in[i]);
gt_ranges_uniq(tmp_ranges, ranges);
gt_ensure(gt_array_size(ranges) ==
sizeof (ranges_in) / sizeof (ranges_in[0]));
gt_ensure(gt_array_size(tmp_ranges) ==
sizeof (ranges_out) / sizeof (ranges_out[0]));
for (i = 0; i < gt_array_size(tmp_ranges) && !had_err; i++) {
gt_ensure(ranges_out[i].start ==
(*(GtRange*) gt_array_get(tmp_ranges, i)).start);
gt_ensure(ranges_out[i].end ==
(*(GtRange*) gt_array_get(tmp_ranges, i)).end);
}
/* test gt_ranges_uniq_in_place() */
gt_array_reset(tmp_ranges);
gt_array_add_array(tmp_ranges, ranges);
gt_ranges_uniq_in_place(tmp_ranges);
for (i = 0; i < gt_array_size(tmp_ranges) && !had_err; i++) {
gt_ensure(ranges_out[i].start ==
(*(GtRange*) gt_array_get(tmp_ranges, i)).start);
gt_ensure(ranges_out[i].end ==
(*(GtRange*) gt_array_get(tmp_ranges, i)).end);
}
/* test gt_ranges_uniq_count() */
gt_array_reset(tmp_ranges);
ctr = gt_ranges_uniq_count(tmp_ranges, ranges);
gt_ensure(gt_array_size(tmp_ranges) == gt_array_size(ctr));
gt_ensure(
gt_array_size(ctr) == sizeof (counts) / sizeof (counts[0]));
for (i = 0; i < gt_array_size(ctr) && !had_err; i++) {
gt_ensure(counts[i] == *(GtUword*) gt_array_get(ctr, i));
gt_ensure(ranges_out[i].start ==
(*(GtRange*) gt_array_get(tmp_ranges, i)).start);
gt_ensure(ranges_out[i].end ==
(*(GtRange*) gt_array_get(tmp_ranges, i)).end);
}
gt_array_delete(ctr);
/* test gt_ranges_uniq_in_place_count() */
ctr = gt_ranges_uniq_in_place_count(ranges);
gt_ensure(gt_array_size(ranges) == gt_array_size(ctr));
gt_ensure(
gt_array_size(ctr) == sizeof (counts) / sizeof (counts[0]));
for (i = 0; i < gt_array_size(ctr) && !had_err; i++) {
gt_ensure(counts[i] == *(GtUword*) gt_array_get(ctr, i));
gt_ensure(
ranges_out[i].start == (*(GtRange*)
gt_array_get(ranges, i)).start);
gt_ensure(
ranges_out[i].end == (*(GtRange*) gt_array_get(ranges, i)).end);
}
gt_array_delete(ctr);
/* test gt_range_reorder() */
if (!had_err) {
GtRange range = { 1, 100 };
range = gt_range_reorder(range);
gt_ensure(range.start == 1 && range.end == 100);
range.start = 100;
range.end = 1;
range = gt_range_reorder(range);
gt_ensure(range.start == 1 && range.end == 100);
}
/* free */
gt_array_delete(ranges);
gt_array_delete(tmp_ranges);
return had_err;
}
int gt_clustered_set_union_find_unit_test(GtError *err)
{
int had_err = 0, i = 0, j = 0;
GtClusteredSet *cs = NULL;
cs = gt_clustered_set_union_find_new(1, err);
gt_ensure(
gt_clustered_set_union_find_num_of_elements(cs, err) ==
gt_clustered_set_union_find_cluster_num(cs, 0, err));
gt_ensure(
gt_clustered_set_union_find_num_of_clusters(cs, err) == 0);
gt_clustered_set_union_find_delete(cs, err);
if (!had_err) {
cs = gt_clustered_set_union_find_new(2, err);
gt_clustered_set_union_find_merge_clusters(cs, 0, 1, err);
gt_ensure(
gt_clustered_set_union_find_num_of_clusters(cs, err) == 1);
gt_ensure(
gt_clustered_set_union_find_cluster_num(cs, 0, err) ==
gt_clustered_set_union_find_cluster_num(cs, 1, err));
gt_ensure(
gt_clustered_set_union_find_num_of_clusters(cs, err) == 1);
gt_clustered_set_union_find_delete(cs, err);
}
if (!had_err) {
cs = gt_clustered_set_union_find_new(3, err);
gt_clustered_set_union_find_merge_clusters(cs, 0, 1, err);
gt_clustered_set_union_find_merge_clusters(cs, 1, 2, err);
gt_ensure(
gt_clustered_set_union_find_num_of_clusters(cs, err) == 1);
gt_ensure(
gt_clustered_set_union_find_cluster_num(cs, 0, err) ==
gt_clustered_set_union_find_cluster_num(cs, 1, err));
gt_ensure(
gt_clustered_set_union_find_cluster_num(cs, 0, err) ==
gt_clustered_set_union_find_cluster_num(cs, 2, err));
gt_ensure(
gt_clustered_set_union_find_cluster_num(cs, 1, err) ==
gt_clustered_set_union_find_cluster_num(cs, 2, err));
gt_clustered_set_union_find_delete(cs, err);
}
if (!had_err) {
cs = gt_clustered_set_union_find_new(4, err);
gt_clustered_set_union_find_merge_clusters(cs, 0, 1, err);
gt_clustered_set_union_find_merge_clusters(cs, 2, 3, err);
gt_ensure(
gt_clustered_set_union_find_num_of_clusters(cs, err) == 2);
gt_clustered_set_union_find_merge_clusters(cs, 0, 2, err);
for (i = 0; i < 4 - 1; i++) {
for (j = i + 1; j < 4; j++) {
gt_ensure(
gt_clustered_set_union_find_cluster_num(cs, i, err) ==
gt_clustered_set_union_find_cluster_num(cs, j, err));
}
}
gt_clustered_set_union_find_delete(cs, err);
}
if (!had_err) {
cs = gt_clustered_set_union_find_new(CLUSTERED_SET_UNION_FIND_TEST_SIZE,
err);
for (i = 0; !had_err && i < CLUSTERED_SET_UNION_FIND_TEST_SIZE; i++) {
gt_ensure(
gt_clustered_set_union_find_num_of_elements(cs, err) ==
gt_clustered_set_union_find_cluster_num(cs, i, err));
}
for (i = 1;!had_err && i < CLUSTERED_SET_UNION_FIND_TEST_SIZE; i++) {
gt_clustered_set_union_find_merge_clusters(cs, 0, i, err);
}
for (i = 0; !had_err && i < CLUSTERED_SET_UNION_FIND_TEST_SIZE; i++) {
gt_ensure(
gt_clustered_set_union_find_cluster_num(cs, i, err) == 0);
}
gt_clustered_set_union_find_delete(cs, err);
}
return had_err;
}
/* to be called from implementing class! */
int gt_feature_index_unit_test(GtFeatureIndex *fi, GtError *err)
{
int had_err = 0, i, rval;
GtFeatureIndexTestShared sh;
GtStrArray *seqids;
GtStr *seqid;
GtRange check_range;
GtRegionNode *rn;
bool has_seqid;
gt_error_check(err);
sh.mutex = gt_mutex_new();
sh.nodes = gt_array_new(sizeof (GtFeatureNode*));
sh.error_count = 0;
sh.next_node_idx = 0;
sh.fi = fi;
sh.err = gt_error_new();
/* create region */
seqid = gt_str_new_cstr(GT_FI_TEST_SEQID);
rn = (GtRegionNode*) gt_region_node_new(seqid, GT_FI_TEST_START,
GT_FI_TEST_END);
/* test seqid is not supposed to exist */
gt_ensure(gt_feature_index_has_seqid(sh.fi, &has_seqid,
GT_FI_TEST_SEQID, err) == 0);
gt_ensure(!has_seqid);
/* add a sequence region directly and check if it has been added */
rval = gt_feature_index_add_region_node(sh.fi, rn, err);
gt_ensure(rval == 0);
gt_genome_node_delete((GtGenomeNode*) rn);
gt_ensure(gt_feature_index_has_seqid(sh.fi, &has_seqid,
GT_FI_TEST_SEQID, err) == 0);
gt_ensure(has_seqid);
gt_feature_index_get_range_for_seqid(sh.fi, &check_range, GT_FI_TEST_SEQID,
err);
gt_ensure(check_range.start == GT_FI_TEST_START
&& check_range.end == GT_FI_TEST_END);
/* set up nodes to store */
for (i=0;i<GT_FI_TEST_FEATURES_PER_THREAD*gt_jobs;i++) {
GtUword start, end;
GtFeatureNode *fn;
start = random() % (GT_FI_TEST_END - GT_FI_TEST_FEATURE_WIDTH);
end = start + random() % (GT_FI_TEST_FEATURE_WIDTH);
fn = gt_feature_node_cast(gt_feature_node_new(seqid, "gene", start, end,
GT_STRAND_FORWARD));
gt_array_add(sh.nodes, fn);
}
/* test parallel addition */
gt_multithread(gt_feature_index_unit_test_add, &sh, err);
seqids = gt_feature_index_get_seqids(fi, err);
gt_ensure(seqids);
gt_ensure(gt_feature_index_has_seqid(fi, &has_seqid,GT_FI_TEST_SEQID,
err) == 0);
gt_ensure(has_seqid);
gt_ensure(gt_str_array_size(seqids) == 1);
/* test parallel query */
if (!had_err)
gt_multithread(gt_feature_index_unit_test_query, &sh, err);
gt_ensure(sh.error_count == 0);
gt_mutex_delete(sh.mutex);
gt_error_delete(sh.err);
gt_str_array_delete(seqids);
gt_array_delete(sh.nodes);
gt_str_delete(seqid);
return had_err;
}
int gt_tag_value_map_unit_test(GtError *err)
{
GtTagValueMap map;
int had_err = 0;
gt_error_check(err);
/* test gt_tag_value_map_set() (new tags are shorter than old tags) */
map = create_filled_tag_value_list();
gt_tag_value_map_set(&map, "tag 1", "val X");
gt_tag_value_map_set(&map, "tag 2", "val Y");
gt_tag_value_map_set(&map, "tag 3", "val Z");
gt_ensure(!gt_tag_value_map_get(map, "unused tag"));
gt_ensure(!strcmp(gt_tag_value_map_get(map, "tag 1"), "val X"));
gt_ensure(!strcmp(gt_tag_value_map_get(map, "tag 2"), "val Y"));
gt_ensure(!strcmp(gt_tag_value_map_get(map, "tag 3"), "val Z"));
gt_tag_value_map_delete(map);
/* test gt_tag_value_map_set() (new tags have same length) */
if (!had_err) {
map = create_filled_tag_value_list();
gt_tag_value_map_set(&map, "tag 1", "value X");
gt_tag_value_map_set(&map, "tag 2", "value Y");
gt_tag_value_map_set(&map, "tag 3", "value Z");
gt_ensure(!gt_tag_value_map_get(map, "unused tag"));
gt_ensure(!strcmp(gt_tag_value_map_get(map, "tag 1"), "value X"));
gt_ensure(!strcmp(gt_tag_value_map_get(map, "tag 2"), "value Y"));
gt_ensure(!strcmp(gt_tag_value_map_get(map, "tag 3"), "value Z"));
gt_tag_value_map_delete(map);
}
/* test gt_tag_value_map_set() (new tags are longer than old tags) */
if (!had_err) {
map = create_filled_tag_value_list();
gt_tag_value_map_set(&map, "tag 1", "value XXX");
gt_tag_value_map_set(&map, "tag 2", "value YYY");
gt_tag_value_map_set(&map, "tag 3", "value ZZZ");
gt_ensure(!gt_tag_value_map_get(map, "unused tag"));
gt_ensure(
!strcmp(gt_tag_value_map_get(map, "tag 1"), "value XXX"));
gt_ensure(
!strcmp(gt_tag_value_map_get(map, "tag 2"), "value YYY"));
gt_ensure(
!strcmp(gt_tag_value_map_get(map, "tag 3"), "value ZZZ"));
gt_tag_value_map_delete(map);
}
/* test gt_tag_value_map_remove() (remove first tag)*/
if (!had_err) {
size_t old_map_len, new_map_len;
map = create_filled_tag_value_list();
gt_tag_value_map_set(&map, "tag 1", "value XXX");
gt_tag_value_map_set(&map, "tag 2", "value YYY");
gt_tag_value_map_set(&map, "tag 3", "value ZZZ");
old_map_len = get_map_len(map);
gt_tag_value_map_remove(&map, "tag 1");
new_map_len = get_map_len(map);
gt_ensure(!gt_tag_value_map_get(map, "unused tag"));
gt_ensure(!(old_map_len - new_map_len - strlen("tag 1") - 1
- strlen("value XXX") -1));
gt_tag_value_map_delete(map);
}
/* test gt_tag_value_map_remove() (remove middle tag)*/
if (!had_err) {
size_t old_map_len, new_map_len;
map = create_filled_tag_value_list();
gt_tag_value_map_set(&map, "tag 1", "value XXX");
gt_tag_value_map_set(&map, "tag 2", "value YYY");
gt_tag_value_map_set(&map, "tag 3", "value ZZZ");
old_map_len = get_map_len(map);
gt_tag_value_map_remove(&map, "tag 2");
new_map_len = get_map_len(map);
gt_ensure(!gt_tag_value_map_get(map, "unused tag"));
gt_ensure(!(old_map_len - new_map_len - strlen("tag 2") - 1
- strlen("value YYY") -1));
gt_tag_value_map_delete(map);
}
/* test gt_tag_value_map_remove() (remove last tag)*/
if (!had_err) {
size_t old_map_len, new_map_len;
map = create_filled_tag_value_list();
gt_tag_value_map_set(&map, "tag 1", "value XXX");
gt_tag_value_map_set(&map, "tag 2", "value YYY");
gt_tag_value_map_set(&map, "tag 3", "value ZZZ");
old_map_len = get_map_len(map);
gt_tag_value_map_remove(&map, "tag 3");
new_map_len = get_map_len(map);
gt_ensure(!gt_tag_value_map_get(map, "unused tag"));
gt_ensure(!(old_map_len - new_map_len - strlen("tag 3") - 1
- strlen("value ZZZ") -1));
gt_tag_value_map_delete(map);
}
return had_err;
}
int gt_track_unit_test(GtError *err)
{
int had_err = 0;
GtBlock *b[4];
GtRange r[4];
GtTrack *track;
GtGenomeNode *parent[4], *gn[4];
GtStr *title;
double height, tmp;
GtStyle *sty;
unsigned long i;
GtLineBreaker *lb;
double t_rest = 0,
l_rest = 0;
gt_error_check(err);
title = gt_str_new_cstr("test");
r[0].start=100UL;
r[0].end=1000UL;
r[1].start=1001UL;
r[1].end=1500UL;
r[2].start=700UL;
r[2].end=1200UL;
r[3].start=10UL;
r[3].end=200UL;
for (i=0; i<4; i++)
{
parent[i] = gt_feature_node_new(title, gt_ft_gene, r[i].start, r[i].end,
GT_STRAND_FORWARD);
gn[i] = gt_feature_node_new(title, gt_ft_exon, r[i].start, r[i].end,
GT_STRAND_FORWARD);
gt_feature_node_add_child((GtFeatureNode*) parent[i],
(GtFeatureNode*) gn[i]);
gt_feature_node_add_attribute((GtFeatureNode*) parent[i], GT_GFF_NAME,
"parent");
gt_feature_node_add_attribute((GtFeatureNode*) gn[i], GT_GFF_NAME, "child");
}
for (i=0; i<4; i++)
{
b[i] = gt_block_new();
gt_block_set_range(b[i], r[i]);
gt_block_insert_element(b[i], (GtFeatureNode*) parent[i]);
gt_block_insert_element(b[i], (GtFeatureNode*) gn[i]);
}
lb = gt_line_breaker_bases_new();
sty = gt_style_new(err);
if (gt_style_get_num(sty, "format", "track_caption_font_size", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = TEXT_SIZE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "track_caption_space", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = CAPTION_BAR_SPACE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "track_vspace", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = TRACK_VSPACE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "bar_vspace", &l_rest,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
l_rest = BAR_VSPACE_DEFAULT;
}
track = gt_track_new(title, GT_UNDEF_ULONG, true, lb);
gt_ensure(had_err, track);
gt_ensure(had_err, gt_track_get_title(track) == title);
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 0);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[0], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 1);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + l_rest + BAR_HEIGHT_DEFAULT);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[1], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 1);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + l_rest + BAR_HEIGHT_DEFAULT);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[2], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 2);
gt_ensure(had_err, gt_track_insert_block(track, b[3], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 2);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest + BAR_HEIGHT_DEFAULT));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_set_num(sty, "exon", "bar_height", 42);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+42));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_set_num(sty, "gene", "bar_height", 23);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+42));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_unset(sty, "exon", "bar_height");
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+23));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_unset(sty, "gene", "bar_height");
gt_style_set_num(sty, "format", "bar_height", 99);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+99));
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_discarded_blocks(track) == 0);
gt_track_delete(track);
gt_str_delete(title);
gt_style_delete(sty);
for (i=0; i<4; i++)
{
gt_block_delete(b[i]);
gt_genome_node_delete(parent[i]);
}
return had_err;
}
int gt_desc_buffer_unit_test(GtError *err)
{
GtDescBuffer *s;
static char *strs[] = { "foo", "bar", "baz"};
const char *ret;
int had_err = 0;
GtUword i, j;
gt_error_check(err);
s = gt_desc_buffer_new();
ret = gt_desc_buffer_get_next(s);
gt_ensure(strcmp(ret, "") == 0);
gt_ensure(ret == s->buf);
gt_ensure(gt_desc_buffer_length(s) == 0);
gt_desc_buffer_delete(s);
s = gt_desc_buffer_new();
for (i = 0; i < strlen(strs[0]); i++) {
gt_desc_buffer_append_char(s, strs[0][i]);
}
gt_desc_buffer_finish(s);
ret = gt_desc_buffer_get_next(s);
gt_ensure(strcmp(ret, strs[0]) == 0);
gt_ensure(ret == s->buf);
gt_ensure(gt_desc_buffer_length(s) == 4);
gt_desc_buffer_delete(s);
s = gt_desc_buffer_new();
for (j = 0; j < 2; j++) {
for (i = 0; i < strlen(strs[j]); i++) {
gt_desc_buffer_append_char(s, strs[j][i]);
}
gt_desc_buffer_finish(s);
}
ret = gt_desc_buffer_get_next(s);
gt_ensure(strcmp(ret, strs[0]) == 0);
gt_ensure(ret == s->buf);
ret = gt_desc_buffer_get_next(s);
gt_ensure(strcmp(ret, strs[1]) == 0);
gt_ensure(ret == s->buf+4);
gt_ensure(gt_desc_buffer_length(s) == 8);
gt_desc_buffer_delete(s);
s = gt_desc_buffer_new();
for (j = 0; j < 3; j++) {
for (i = 0; i < strlen(strs[j]); i++) {
gt_desc_buffer_append_char(s, strs[j][i]);
}
gt_desc_buffer_finish(s);
}
ret = gt_desc_buffer_get_next(s);
gt_ensure(strcmp(ret, strs[0]) == 0);
gt_ensure(ret == s->buf);
ret = gt_desc_buffer_get_next(s);
gt_ensure(strcmp(ret, strs[1]) == 0);
gt_ensure(ret == s->buf+4);
ret = gt_desc_buffer_get_next(s);
gt_ensure(strcmp(ret, strs[2]) == 0);
gt_ensure(ret == s->buf+8);
gt_ensure(gt_desc_buffer_length(s) == 12);
gt_desc_buffer_delete(s);
return had_err;
}
int gt_translator_unit_test(GtError *err)
{
int had_err = 0;
GtTranslatorStatus test_errnum;
GtTranslator *tr;
GtCodonIterator *ci;
GtError *test_err;
GtStrArray *codons, *invalidcodons;
const char *seq = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGT"
"GGATTAAAAAAAGAGTGTCTGATAGCAGCTTCTGAACTGGT"
"TACCTGCCGTGAGTAAATTAAAATTTTATTGACTTAGG";
const char *no_startcodon = "AAAAAAAAAATCATCTCCCCATTTTTTT";
const char *invalidseq = "ZAGCTTTTCATTCTGACTGCAAATATGTCTCTGTGT";
const char *invalidseq2 = "AGCTTTTCATTCTGACZTGCAAATATGTCTCTGTGT";
char translated;
unsigned int frame;
GtUword pos = 0;
GtStr *protein[3];
gt_error_check(err);
test_err = gt_error_new();
ci = gt_codon_iterator_simple_new(seq, (GtUword) strlen(seq), test_err);
tr = gt_translator_new(ci);
protein[0] = gt_str_new();
protein[1] = gt_str_new();
protein[2] = gt_str_new();
codons = gt_str_array_new();
gt_str_array_add_cstr(codons, "ACG");
gt_str_array_add_cstr(codons, "ACT");
invalidcodons = gt_str_array_new();
gt_str_array_add_cstr(invalidcodons, "ACG");
gt_str_array_add_cstr(invalidcodons, "AC");
/* do 3-frame translation */
gt_error_unset(test_err);
test_errnum = gt_translator_next(tr, &translated, &frame, test_err);
while (!test_errnum && translated) {
gt_str_append_char(protein[frame], translated);
test_errnum = gt_translator_next(tr, &translated, &frame, test_err);
gt_ensure(
test_errnum != GT_TRANSLATOR_ERROR && !gt_error_is_set(test_err));
}
gt_ensure(
test_errnum == GT_TRANSLATOR_END && !gt_error_is_set(test_err));
/* check 3-frame translation */
gt_ensure(strcmp(gt_str_get(protein[0]),
"SFSF*LQRAICLCVD*KKSV**QLLNWLPAVSKLKFY*LR") == 0);
gt_ensure(strcmp(gt_str_get(protein[1]),
"AFHSDCNGQYVSVWIKKRVSDSSF*TGYLP*VN*NFIDL") == 0);
gt_ensure(strcmp(gt_str_get(protein[2]),
"LFILTATGNMSLCGLKKECLIAASELVTCRE*IKILLT*") == 0);
/* find start codon -- positive */
gt_error_unset(test_err);
gt_codon_iterator_rewind(ci);
test_errnum = gt_translator_find_startcodon(tr, &pos, test_err);
gt_ensure(!test_errnum && !gt_error_is_set(test_err));
gt_ensure(pos == 11UL);
/* find stop codon -- positive */
gt_error_unset(test_err);
gt_codon_iterator_rewind(ci);
test_errnum = gt_translator_find_stopcodon(tr, &pos, test_err);
gt_ensure(!test_errnum && !gt_error_is_set(test_err));
gt_ensure(pos == 12UL);
/* find arbitrary codons -- positive */
gt_error_unset(test_err);
gt_codon_iterator_rewind(ci);
test_errnum = gt_translator_find_codon(tr, codons, &pos, test_err);
gt_ensure(!test_errnum && !gt_error_is_set(test_err));
gt_ensure(pos == 14UL);
/* find arbitrary codons -- negative (invalid codons) */
gt_error_unset(test_err);
gt_codon_iterator_rewind(ci);
test_errnum = gt_translator_find_codon(tr, invalidcodons, &pos, test_err);
gt_ensure(
test_errnum == GT_TRANSLATOR_ERROR && gt_error_is_set(test_err));
gt_error_unset(test_err);
gt_codon_iterator_delete(ci);
ci = gt_codon_iterator_simple_new(invalidseq,
(GtUword) strlen(invalidseq),
test_err);
gt_ensure(ci && !gt_error_is_set(test_err));
gt_translator_reset(tr, ci);
/* check translation of sequence with invalid beginning */
test_errnum = gt_translator_next(tr, &translated, &frame, test_err);
gt_ensure(test_errnum && gt_error_is_set(test_err));
/* check translation of sequence with invalid character within */
gt_error_unset(test_err);
gt_codon_iterator_delete(ci);
ci = gt_codon_iterator_simple_new(invalidseq2,
(GtUword) strlen(invalidseq2),
test_err);
gt_ensure(ci && !gt_error_is_set(test_err));
gt_translator_reset(tr, ci);
test_errnum = gt_translator_next(tr, &translated, &frame, test_err);
while (!test_errnum && translated) {
gt_str_append_char(protein[frame], translated);
test_errnum = gt_translator_next(tr, &translated, &frame, test_err);
}
gt_ensure(
test_errnum == GT_TRANSLATOR_ERROR && gt_error_is_set(test_err));
/* find start codon -- fail */
gt_error_unset(test_err);
gt_codon_iterator_delete(ci);
ci = gt_codon_iterator_simple_new(no_startcodon,
(GtUword) strlen(no_startcodon),
test_err);
gt_ensure(ci && !gt_error_is_set(test_err));
gt_translator_reset(tr, ci);
test_errnum = gt_translator_find_startcodon(tr, &pos, test_err);
gt_ensure(
test_errnum == GT_TRANSLATOR_END && !gt_error_is_set(test_err));
/* find stop codon -- fail */
gt_error_unset(test_err);
gt_codon_iterator_rewind(ci);
test_errnum = gt_translator_find_stopcodon(tr, &pos, test_err);
gt_ensure(
test_errnum == GT_TRANSLATOR_END && !gt_error_is_set(test_err));
/* find arbitrary codons -- negative (none there) */
gt_error_unset(test_err);
gt_codon_iterator_rewind(ci);
test_errnum = gt_translator_find_codon(tr, codons, &pos, test_err);
gt_ensure(
test_errnum == GT_TRANSLATOR_END && !gt_error_is_set(test_err));
gt_codon_iterator_delete(ci);
gt_translator_delete(tr);
gt_str_delete(protein[0]);
gt_str_delete(protein[1]);
gt_str_delete(protein[2]);
gt_str_array_delete(codons);
gt_str_array_delete(invalidcodons);
gt_error_delete(test_err);
return had_err;
}
int
gt_bitPackStringInt8_unit_test(GtError *err)
{
BitString bitStore = NULL;
BitString bitStoreCopy = NULL;
uint8_t *randSrc = NULL; /*< create random ints here for input as bit
* store */
uint8_t *randCmp = NULL; /*< used for random ints read back */
unsigned *numBitsList = NULL;
size_t i, numRnd;
BitOffset offsetStart, offset;
int had_err = 0;
offset = offsetStart = random()%(sizeof (uint8_t) * CHAR_BIT);
numRnd = random() % (MAX_RND_NUMS_uint8_t + 1);
gt_log_log("offset=%lu, numRnd=%lu\n",
(long unsigned)offsetStart, (long unsigned)numRnd);
{
BitOffset numBits = sizeof (uint8_t) * CHAR_BIT * numRnd + offsetStart;
randSrc = gt_malloc(sizeof (uint8_t)*numRnd);
bitStore = gt_malloc(bitElemsAllocSize(numBits) * sizeof (BitElem));
bitStoreCopy = gt_calloc(bitElemsAllocSize(numBits), sizeof (BitElem));
randCmp = gt_malloc(sizeof (uint8_t)*numRnd);
}
/* first test unsigned types */
gt_log_log("gt_bsStoreUInt8/gt_bsGetUInt8: ");
for (i = 0; i < numRnd; ++i)
{
#if 8 > 32 && LONG_BIT < 8
uint8_t v = randSrc[i] = (uint8_t)random() << 32 | random();
#else /* 8 > 32 && LONG_BIT < 8 */
uint8_t v = randSrc[i] = random();
#endif /* 8 > 32 && LONG_BIT < 8 */
int bits = gt_requiredUInt8Bits(v);
gt_bsStoreUInt8(bitStore, offset, bits, v);
offset += bits;
}
offset = offsetStart;
for (i = 0; i < numRnd; ++i)
{
uint8_t v = randSrc[i];
int bits = gt_requiredUInt8Bits(v);
uint8_t r = gt_bsGetUInt8(bitStore, offset, bits);
gt_ensure(had_err, r == v);
if (had_err)
{
gt_log_log("Expected %"PRIu8", got %"PRIu8", i = %lu\n",
v, r, (unsigned long)i);
freeResourcesAndReturn(had_err);
}
offset += bits;
}
gt_log_log("passed\n");
if (numRnd > 0)
{
uint8_t v = randSrc[0], r = 0;
unsigned numBits = gt_requiredUInt8Bits(v);
BitOffset i = offsetStart + numBits;
uint8_t mask = ~(uint8_t)0;
if (numBits < 8)
mask = ~(mask << numBits);
gt_log_log("bsSetBit, gt_bsClearBit, bsToggleBit, gt_bsGetBit: ");
while (v)
{
int lowBit = v & 1;
v >>= 1;
gt_ensure(had_err, lowBit == (r = gt_bsGetBit(bitStore, --i)));
if (had_err)
{
gt_log_log("Expected %d, got %d, i = %llu\n",
lowBit, (int)r, (unsigned long long)i);
freeResourcesAndReturn(had_err);
}
}
i = offsetStart + numBits;
gt_bsClear(bitStoreCopy, offsetStart, numBits, random()&1);
v = randSrc[0];
while (i)
{
int lowBit = v & 1;
v >>= 1;
if (lowBit)
bsSetBit(bitStoreCopy, --i);
else
gt_bsClearBit(bitStoreCopy, --i);
}
v = randSrc[0];
r = gt_bsGetUInt8(bitStoreCopy, offsetStart, numBits);
gt_ensure(had_err, r == v);
if (had_err)
{
gt_log_log("Expected %"PRIu8", got %"PRIu8"\n", v, r);
freeResourcesAndReturn(had_err);
}
for (i = 0; i < numBits; ++i)
bsToggleBit(bitStoreCopy, offsetStart + i);
r = gt_bsGetUInt8(bitStoreCopy, offsetStart, numBits);
gt_ensure(had_err, r == (v = (~v & mask)));
if (had_err)
{
gt_log_log("Expected %"PRIu8", got %"PRIu8"\n", v, r);
freeResourcesAndReturn(had_err);
}
gt_log_log("passed\n");
}
