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;
}
static int layout_tracks(void *key, void *value, void *data,
GtError *err)
{
unsigned long i,
max = 50;
GtTrack *track = NULL;
GtLayoutTraverseInfo *lti = (GtLayoutTraverseInfo*) data;
GtArray *list = (GtArray*) value;
GtStr *gt_track_key;
GtBlock *block;
int had_err = 0;
bool split = true;
double tmp = 50;
gt_assert(list);
/* to get a deterministic layout, we sort the GtBlocks for each type */
if (lti->layout->block_ordering_func) {
gt_array_sort_stable_with_data(list, blocklist_block_compare,
lti->layout);
}
/* XXX: get first block for track property lookups, this should be reworked
to allow arbitrary track keys! */
block = *(GtBlock**) gt_array_get(list, 0);
gt_track_key = gt_str_new_cstr((char*) key);
/* obtain default settings*/
if (gt_style_get_bool(lti->layout->style, "format", "split_lines", &split,
NULL, err) == GT_STYLE_QUERY_ERROR) {
had_err = 1;
}
if (!had_err) {
if (gt_style_get_num(lti->layout->style,
"format", "max_num_lines",
&tmp, NULL, err) == GT_STYLE_QUERY_ERROR) {
had_err = 1;
}
}
/* obtain track-specific settings, should be changed to query arbitrary
track keys! */
if (!had_err) {
if (gt_style_get_bool(lti->layout->style, gt_block_get_type(block),
"split_lines", &split, NULL,
err) == GT_STYLE_QUERY_ERROR) {
had_err = 1;
}
}
if (!had_err) {
if (gt_style_get_num(lti->layout->style, gt_block_get_type(block),
"max_num_lines", &tmp, NULL,
err) == GT_STYLE_QUERY_ERROR) {
had_err = 1;
}
}
if (!had_err) {
max = (unsigned long) tmp;
track = gt_track_new(gt_track_key, max, split,
gt_line_breaker_captions_new(lti->layout,
lti->layout->width,
lti->layout->style));
lti->layout->nof_tracks++;
for (i = 0; !had_err && i < gt_array_size(list); i++) {
block = *(GtBlock**) gt_array_get(list, i);
had_err = gt_track_insert_block(track, block, err);
}
}
if (!had_err) {
gt_hashmap_add(lti->layout->tracks, gt_cstr_dup(gt_str_get(gt_track_key)),
track);
}
else
{
gt_track_delete(track);
}
gt_str_delete(gt_track_key);
return had_err;
}
