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; }