static void *gt_tyr_occratio_arguments_new(void)
{
Tyr_occratio_options *arguments
= gt_malloc(sizeof (Tyr_occratio_options));
arguments->mersizesstrings = gt_str_array_new();
arguments->outputspec = gt_str_array_new();
arguments->str_inputindex = gt_str_new();
arguments->outputvector = NULL;
arguments->outputmode = 0;
return arguments;
}
static void* gt_linspace_align_arguments_new(void)
{
GtLinspaceArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
arguments->outputfile = gt_str_new();
arguments->strings = gt_str_array_new();
arguments->files = gt_str_array_new();
arguments->linearcosts = gt_str_array_new();
arguments->affinecosts = gt_str_array_new();
arguments->diagonalbonds = gt_str_array_new();
return arguments;
}
static void* gt_matstat_arguments_new_generic(bool doms)
{
Gfmsubcallinfo *arguments = gt_calloc((size_t) 1, sizeof *arguments);
arguments->minlength.defined = false;
arguments->maxlength.defined = false;
arguments->showmode = 0;
arguments->indexname = gt_str_new();
arguments->queryfilenames = gt_str_array_new();
arguments->flagsoutputoption = gt_str_array_new();
arguments->doms = doms;
return arguments;
}
static void *gt_tyr_search_arguments_new(void)
{
Tyr_search_options *arguments
= gt_malloc(sizeof (Tyr_search_options));
arguments->str_inputindex = gt_str_new();
arguments->strandspec = gt_str_new();
arguments->queryfilenames = gt_str_array_new();
arguments->showmodespec = gt_str_array_new();
arguments->showmode = 0;
arguments->strand = 0;
return arguments;
}
static void gth_file_stat_info_new(GthFileStatInfo *file_stat_info)
{
file_stat_info->file_mode = GT_FILE_MODE_UNCOMPRESSED;
file_stat_info->consensusfiles = gt_str_array_new();
file_stat_info->sa_filter = gth_sa_filter_new();
file_stat_info->showverbose = NULL;
}
GtNodeStream* gt_gff3_in_stream_plain_new_sorted(const char *filename)
{
GtStrArray *files = gt_str_array_new();
if (filename)
gt_str_array_add_cstr(files, filename);
return gff3_in_stream_plain_new(files, true);
}
GtStrArray* gt_feature_node_get_attribute_list(const GtFeatureNode *fn)
{
GtStrArray *list = gt_str_array_new();
if (fn->attributes)
gt_tag_value_map_foreach(fn->attributes, store_attribute, list);
return list;
}
GtAlphabet* gt_alphabet_new_from_string(const char *alphadef, unsigned long len,
GtError *err)
{
unsigned long i, j;
GtStrArray *sa;
GtAlphabet *alpha;
gt_assert(alphadef && len > 0);
gt_error_check(err);
alpha = gt_alphabet_new_empty();
gt_assert(alphadef);
sa = gt_str_array_new();
j = 0;
for (i = 0; i < len; i++) {
if (alphadef[i] == '\n' || i == len - 1) {
gt_str_array_add_cstr_nt(sa, alphadef+j, i - j);
j = i+1;
}
}
if (read_symbolmap_from_lines(alpha, NULL, sa, err) != 0) {
gt_str_array_delete(sa);
gt_assert(gt_error_is_set(err));
return NULL;
}
gt_str_array_delete(sa);
return alpha;
}
static void *gt_cge_spacedseed_arguments_new(void)
{
Cge_spacedseed_options *arguments
= gt_malloc(sizeof (Cge_spacedseed_options));
arguments->str_inputindex = gt_str_new();
arguments->queryfilenames = gt_str_array_new();
return arguments;
}
static void *gt_repfind_arguments_new(void)
{
Maxpairsoptions *arguments;
arguments = gt_malloc(sizeof (*arguments));
arguments->indexname = gt_str_new();
arguments->queryfiles = gt_str_array_new();
return arguments;
}
static void* gt_tir_arguments_new(void)
{
GtTirArguments *arguments = gt_calloc(1, sizeof *arguments);
arguments->str_indexname = gt_str_new();
arguments->str_overlaps = gt_str_new();
arguments->cutoffs = gt_str_new();
arguments->hmm_files = gt_str_array_new();
return arguments;
}
GtNodeStream* gt_gff3_in_stream_plain_new_unsorted(int num_of_files,
const char **filenames)
{
int i;
GtStrArray *files = gt_str_array_new();
for (i = 0; i < num_of_files; i++)
gt_str_array_add_cstr(files, filenames[i]);
return gff3_in_stream_plain_new(files, false);
}
static void initGthsplitinfo(Gthsplitinfo *gthsplitinfo)
{
gthsplitinfo->splitmode = UNDEF_SPLIT;
gthsplitinfo->range = DEFAULT_RANGE;
gthsplitinfo->file_mode = GT_FILE_MODE_UNCOMPRESSED;
gthsplitinfo->showverbose = NULL;
gthsplitinfo->force = false;
gthsplitinfo->sa_filter = gth_sa_filter_new();
gthsplitinfo->consensusfiles = gt_str_array_new();
}
static void* gt_genomediff_arguments_new(void)
{
GtGenomediffArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
arguments->indexname = gt_str_new();
arguments->unitfile = gt_str_new();
arguments->indextype = gt_str_new();
arguments->filenames = gt_str_array_new();
arguments->with_esa = arguments->with_pck = false;
return arguments;
}
static int construct_bioseq_files(GtBioseq *bs, GtStr *bioseq_indexname,
GtError *err)
{
GtStr *sequence_filename;
GtEncseqEncoder *ee;
GtStrArray *indexfn;
int had_err = 0;
gt_error_check(err);
/* register the signal handler to remove incomplete files upon termination */
if (!bs->use_stdin) {
gt_bioseq_index_filename = gt_str_get(bs->sequence_file);
gt_sig_register_all(remove_bioseq_files);
}
/* if stdin is used as input, we need to create a tempfile containing the
sequence as GtEncseq cannot be built from stdin directly */
if (bs->use_stdin) {
GtStr *tmpfilename;
FILE *tmpfile = NULL;
int i;
char buf[BUFSIZ];
tmpfilename = gt_str_new();
tmpfile = gt_xtmpfp(tmpfilename);
gt_assert(tmpfile);
i = 1;
while (i > 0) {
i = fread(buf, 1, BUFSIZ, stdin);
if (i > 0) fwrite(buf, 1, i, tmpfile);
}
gt_fa_xfclose(tmpfile);
sequence_filename = tmpfilename;
} else {
sequence_filename = gt_str_ref(bs->sequence_file);
}
gt_assert(gt_str_length(sequence_filename) > 0);
ee = gt_encseq_encoder_new();
gt_encseq_encoder_enable_description_support(ee);
gt_encseq_encoder_enable_md5_support(ee);
gt_encseq_encoder_enable_multiseq_support(ee);
gt_encseq_encoder_enable_lossless_support(ee);
indexfn = gt_str_array_new();
gt_str_array_add(indexfn, sequence_filename);
gt_str_delete(sequence_filename);
had_err = gt_encseq_encoder_encode(ee, indexfn,
gt_str_get(bioseq_indexname), err);
/* unregister the signal handler */
if (!bs->use_stdin)
gt_sig_unregister_all();
gt_str_array_delete(indexfn);
gt_encseq_encoder_delete(ee);
return had_err;
}
static NodeInfoElement* nodeinfo_get(GtDiagram *d, GtFeatureNode *node)
{
NodeInfoElement *ni;
gt_assert(d && node);
if (!(ni = gt_hashmap_get(d->nodeinfo, node))) {
ni = gt_calloc(1, sizeof (NodeInfoElement));
ni->type_index = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
ni->types = gt_str_array_new();
gt_hashmap_add(d->nodeinfo, node, ni);
}
return ni;
}
static void* gt_ltrdigest_arguments_new(void)
{
GtLTRdigestOptions *arguments = gt_calloc((size_t) 1, sizeof *arguments);
memset(arguments, 0, sizeof *arguments);
arguments->trna_lib = gt_str_new();
arguments->prefix = gt_str_new();
arguments->cutoffs = gt_str_new();
arguments->ofi = gt_output_file_info_new();
arguments->hmm_files = gt_str_array_new();
arguments->s2fi = gt_seqid2file_info_new();
return arguments;
}
static void* gt_ltrdigest_arguments_new(void)
{
GtLTRdigestOptions *arguments = gt_calloc((size_t) 1, sizeof *arguments);
memset(arguments, 0, sizeof *arguments);
#ifdef HAVE_HMMER
arguments->pdom_opts.hmm_files = gt_str_array_new();
#endif
arguments->trna_lib = gt_str_new();
arguments->prefix = gt_str_new();
arguments->cutoffs = gt_str_new();
arguments->ofi = gt_outputfileinfo_new();
return arguments;
}
static int extract_feature_visitor_feature_node(GtNodeVisitor *nv,
GtFeatureNode *fn, GtError *err)
{
GtExtractFeatureVisitor *efv;
GtFeatureNodeIterator *fni;
GtFeatureNode *child;
GtStrArray *target_ids = NULL;
GtStr *seqid = NULL,
*description,
*sequence;
int had_err = 0;
gt_error_check(err);
efv = gt_extract_feature_visitor_cast(nv);
gt_assert(efv->region_mapping);
fni = gt_feature_node_iterator_new(fn);
if (efv->target)
target_ids = gt_str_array_new();
if (efv->seqid)
seqid = gt_str_new();
description = gt_str_new();
sequence = gt_str_new();
while (!had_err && (child = gt_feature_node_iterator_next(fni))) {
if (seqid)
gt_str_reset(seqid);
if (target_ids)
gt_str_array_reset(target_ids);
if (gt_extract_feature_sequence(sequence, (GtGenomeNode*) child, efv->type,
efv->join, seqid, target_ids,
efv->region_mapping, err)) {
had_err = -1;
}
if (!had_err && gt_str_length(sequence)) {
efv->fastaseq_counter++;
construct_description(description, efv->type, efv->fastaseq_counter,
efv->join, efv->translate, seqid, target_ids);
had_err = show_entry(description, sequence, efv->translate, efv->width,
efv->outfp);
gt_str_reset(description);
gt_str_reset(sequence);
}
}
gt_str_delete(sequence);
gt_str_delete(description);
gt_str_delete(seqid);
gt_str_array_delete(target_ids);
gt_feature_node_iterator_delete(fni);
return had_err;
}
static void* gt_select_arguments_new(void)
{
SelectArguments *arguments = gt_calloc(1, sizeof *arguments);
arguments->seqid = gt_str_new();
arguments->source = gt_str_new();
arguments->gt_strand_char = gt_str_new();
arguments->strand = GT_NUM_OF_STRAND_TYPES;
arguments->targetgt_strand_char = gt_str_new();
arguments->targetstrand = GT_NUM_OF_STRAND_TYPES;
arguments->ofi = gt_output_file_info_new();
arguments->filter_files = gt_str_array_new();
arguments->filter_logic = gt_str_new();
arguments->dropped_file = gt_str_new();
return arguments;
}
static void* gt_compreads_compress_arguments_new(void)
{
GtCsrHcrEncodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
arguments->smap = gt_str_new();
arguments->name = gt_str_new();
arguments->files = gt_str_array_new();
arguments->qrng.start = GT_UNDEF_UINT;
arguments->qrng.end = GT_UNDEF_UINT;
arguments->arg_range.start = GT_UNDEF_UWORD;
arguments->arg_range.end = GT_UNDEF_UWORD;
arguments->method = gt_str_new();
arguments->pagewise = false;
arguments->regular = false;
return arguments;
}
static int m2i_change_target_seqids(GtFeatureNode *fn, const char *target,
GtRegionMapping *region_mapping,
GtError *err)
{
GtStrArray *target_ids;
GtArray *target_ranges, *target_strands;
GtStr *desc, *new_seqid;
unsigned long i;
int had_err;
gt_error_check(err);
gt_assert(fn && target && region_mapping);
target_ids = gt_str_array_new();
target_ranges = gt_array_new(sizeof (GtRange));
target_strands = gt_array_new(sizeof (GtStrand));
desc = gt_str_new();
new_seqid = gt_str_new();
had_err = gt_gff3_parser_parse_all_target_attributes(target, false,
target_ids,
target_ranges,
target_strands, "", 0,
err);
for (i = 0; !had_err && i < gt_str_array_size(target_ids); i++) {
GtStr *seqid;
gt_str_reset(desc);
gt_str_reset(new_seqid);
seqid = gt_str_array_get_str(target_ids, i);
had_err = gt_region_mapping_get_description(region_mapping, desc, seqid,
err);
if (!had_err)
gt_regular_seqid_save(new_seqid, desc);
gt_str_array_set(target_ids, i, new_seqid);
}
if (!had_err) {
GtStr *new_target = gt_str_new();
gt_gff3_parser_build_target_str(new_target, target_ids, target_ranges,
target_strands);
gt_feature_node_set_attribute(fn, GT_GFF_TARGET, gt_str_get(new_target));
gt_str_delete(new_target);
}
gt_str_delete(new_seqid);
gt_str_delete(desc);
gt_array_delete(target_strands);
gt_array_delete(target_ranges);
gt_str_array_delete(target_ids);
return had_err;
}
int gt_mergeesa(int argc, const char **argv, GtError *err)
{
GtStr *storeindex;
GtStrArray *indexnametab;
bool haserr = false;
int parsed_args;
gt_error_check(err);
storeindex = gt_str_new();
indexnametab = gt_str_array_new();
switch (parse_options(storeindex, indexnametab, &parsed_args, argc, argv,
err)) {
case GT_OPTION_PARSER_OK:
break;
case GT_OPTION_PARSER_ERROR:
haserr = true;
break;
case GT_OPTION_PARSER_REQUESTS_EXIT:
return 0;
}
if (!haserr)
{
GtUword i;
GtLogger *logger;
printf("# storeindex=%s\n",gt_str_get(storeindex));
for (i=0; i<gt_str_array_size(indexnametab); i++)
{
printf("# input=%s\n",gt_str_array_get(indexnametab,i));
}
logger = gt_logger_new(false, GT_LOGGER_DEFLT_PREFIX, stdout);
if (gt_performtheindexmerging(storeindex,
indexnametab,
logger,
err) != 0)
{
haserr = true;
}
gt_logger_delete(logger);
}
gt_str_delete(storeindex);
gt_str_array_delete(indexnametab);
return haserr ? -1 : 0;
}
static int gt_encseq_encode_runner(GT_UNUSED int argc, const char **argv,
int parsed_args, GT_UNUSED void *tool_arguments,
GtError *err)
{
int had_err = 0,
i;
GtEncseqEncodeArguments *arguments =
(GtEncseqEncodeArguments*) tool_arguments;
GtStrArray *infiles;
gt_error_check(err);
infiles = gt_str_array_new();
for (i = parsed_args; i < argc; i++) {
gt_str_array_add_cstr(infiles, argv[i]);
}
if (gt_str_length(arguments->indexname) == 0UL) {
if (gt_str_array_size(infiles) > 1UL) {
gt_error_set(err,"if more than one input file is given, then "
"option -indexname is mandatory");
had_err = -1;
} else {
char *basenameptr;
basenameptr = gt_basename(gt_str_array_get(infiles, 0UL));
gt_str_set(arguments->indexname, basenameptr);
gt_free(basenameptr);
}
}
if (!had_err) {
gt_assert(gt_str_length(arguments->indexname) > 0UL);
had_err = encode_sequence_files(infiles,
arguments->eopts,
gt_str_get(arguments->indexname),
arguments->verbose,
arguments->no_esq_header,
err);
}
if (!had_err && arguments->showstats)
show_encoded_statistics(infiles, gt_str_get(arguments->indexname));
gt_str_array_delete(infiles);
return had_err;
}
static int region_mapping_lua_new_seqfile(lua_State *L)
{
const char *seqfilename;
GtStrArray *seqfile;
GtRegionMapping **region_mapping;
gt_assert(L);
seqfilename = luaL_checkstring(L, 1);
region_mapping = lua_newuserdata(L, sizeof (GtRegionMapping*));
gt_assert(region_mapping);
seqfile = gt_str_array_new();
gt_str_array_add_cstr(seqfile, seqfilename);
/* XXX: make second and third parameter available */
*region_mapping = gt_region_mapping_new_seqfiles(seqfile, false, false);
gt_str_array_delete(seqfile);
luaL_getmetatable(L, REGION_MAPPING_METATABLE);
lua_setmetatable(L, -2);
return 1;
}
static int process_fastakeyfile(GtStr *fastakeyfile, int argc,
const char **argv, unsigned long width,
GtFile *outfp, GtError *err)
{
int had_err = 0;
gt_error_check(err);
gt_assert(gt_str_length(fastakeyfile));
if (argc == 0) {
gt_error_set(err,"option -keys requires at least one file argument");
had_err = -1;
}
if (!had_err)
{
GtStr *indexname = gt_str_new_cstr(argv[0]);
if (argc == 1 && gt_deskeysfileexists(indexname))
{
if (gt_extractkeysfromfastaindex(indexname,fastakeyfile,width,err) != 0)
{
had_err = -1;
}
} else
{
GtStrArray *referencefiletab;
int i;
referencefiletab = gt_str_array_new();
for (i = 0; i < argc; i++)
{
gt_str_array_add_cstr(referencefiletab, argv[i]);
}
if (gt_extractkeysfromfastafile(true, outfp, width, fastakeyfile,
referencefiletab, err) != 1)
{
had_err = -1;
}
gt_str_array_delete(referencefiletab);
}
gt_str_delete(indexname);
}
return had_err;
}
/* 'static' function */
GtStrArray* gt_trans_table_get_scheme_descriptions()
{
GtUword i;
GtTranslationScheme *scheme;
GtStr *str;
GtStrArray *sa = gt_str_array_new();
str = gt_str_new();
for (i = 1UL; i < (GtUword) GT_SIZEOFTRANSRANGE; i++) {
if (transnum2index[i] == GT_UNDEFTRANSNUM)
continue;
scheme = schemetable + transnum2index[i];
gt_str_reset(str);
gt_str_append_uint(str, scheme->identity);
gt_str_append_cstr(str, ": ");
gt_str_append_cstr(str, scheme->name);
gt_str_array_add_cstr(sa, gt_str_get(str));
}
gt_str_delete(str);
return sa;
}
static int encseq_encoder_lua_encode(lua_State *L)
{
GtEncseqEncoder **encoder;
GtStrArray *seqfiles = gt_str_array_new();
GtError *err;
const char *indexname;
encoder = check_encseq_encoder(L, 1);
err = gt_error_new();
if (gt_lua_get_table_as_strarray(L, 2, seqfiles, err) != 0) {
gt_str_array_delete(seqfiles);
gt_lua_error(L, err);
}
indexname = luaL_checkstring(L, 3);
gt_assert(*encoder);
if (gt_encseq_encoder_encode(*encoder, seqfiles, indexname, err) != 0) {
gt_str_array_delete(seqfiles);
gt_lua_error(L, err);
}
gt_str_array_delete(seqfiles);
gt_error_delete(err);
return 0;
}
static GtIndexOptions* gt_index_options_new(void)
{
GtIndexOptions *oi = gt_malloc(sizeof *oi);
oi->algbounds = gt_str_array_new();
oi->dir = gt_str_new_cstr("fwd");
oi->indexname = NULL;
oi->kysargumentstring = gt_str_new();
oi->lcpdist = false;
oi->maximumspace = 0UL; /* in bytes */
oi->memlimit = gt_str_new();
oi->numofparts = 1U;
oi->option = NULL;
oi->optionalgbounds = NULL;
oi->optioncmpcharbychar = NULL;
oi->optiondifferencecover = NULL;
oi->optionmaxwidthrealmedian = NULL;
oi->optionmemlimit = NULL;
oi->optionoutbcktab = NULL;
oi->optionoutbwttab = NULL;
oi->optionoutlcptab = NULL;
oi->optionoutsuftab = NULL;
oi->optionparts = NULL;
oi->optionprefixlength = NULL;
oi->optionspmopt = NULL;
oi->optionstorespecialcodes = NULL;
oi->outbcktab = false;
oi->outbwttab = false;
oi->outkyssort = false;
oi->outkystab = false;
oi->outlcptab = false;
oi->outsuftab = false; /* only defined for GT_INDEX_OPTIONS_ESA */
oi->prefixlength = GT_PREFIXLENGTH_AUTOMATIC;
oi->swallow_tail = false;
oi->type = GT_INDEX_OPTIONS_UNDEFINED;
return oi;
}
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;
}
