コード例 #1
0
ファイル: gtf_in_stream.c プロジェクト: kowsky/genometools
GtNodeStream* gt_gtf_in_stream_new(const char *filename)
{
  GtGTFInStream *gtf_in_stream;
  GtNodeStream *ns = gt_node_stream_create(gt_gtf_in_stream_class(), false);
  gtf_in_stream = gtf_in_stream_cast(ns);
  gtf_in_stream->genome_node_buffer = gt_queue_new();
  gtf_in_stream->type_checker = gt_type_checker_builtin_new();
  gtf_in_stream->filename = filename ? gt_cstr_dup(filename) : NULL;
  return ns;
}
コード例 #2
0
ファイル: bed_parser.c プロジェクト: AnnSeidel/genometools
GtBEDParser* gt_bed_parser_new(void)
{
  GtBEDParser *bed_parser = gt_calloc(1, sizeof *bed_parser);
  bed_parser->region_node_builder = gt_region_node_builder_new();
  bed_parser->feature_nodes = gt_queue_new();
  bed_parser->seqid_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL,
                                                    (GtFree) gt_str_delete);
  bed_parser->word = gt_str_new();
  bed_parser->another_word = gt_str_new();
  return bed_parser;
}
コード例 #3
0
GtNodeVisitor* gt_add_ids_visitor_new(bool ensure_sorting)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_add_ids_visitor_class());
  GtAddIDsVisitor *add_ids_visitor = add_ids_visitor_cast(nv);
  add_ids_visitor->node_buffer = gt_queue_new();
  add_ids_visitor->defined_seqids = gt_cstr_table_new();
  add_ids_visitor->undefined_sequence_regions =
    gt_hashmap_new(GT_HASH_STRING, NULL,
                   (GtFree) automatic_sequence_region_delete);
  add_ids_visitor->ensure_sorting = ensure_sorting;
  return nv;
}
コード例 #4
0
ファイル: buffer_stream.c プロジェクト: 9beckert/TIR
GtNodeStream* gt_buffer_stream_new(GtNodeStream *in_stream)
{
  GtBufferStream *bs;
  GtNodeStream *ns;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_buffer_stream_class(), false);
  bs = buffer_stream_cast(ns);
  bs->in_stream = gt_node_stream_ref(in_stream);
  bs->node_buffer = gt_queue_new();
  bs->buffering = true;
  return ns;
}
コード例 #5
0
ファイル: AgnFilterStream.c プロジェクト: jfdenton/AEGeAn
GtNodeStream* agn_filter_stream_new(GtNodeStream *in_stream,
                                    GtHashmap *typestokeep)
{
  GtNodeStream *ns;
  AgnFilterStream *stream;
  gt_assert(in_stream && typestokeep);
  ns = gt_node_stream_create(filter_stream_class(), false);
  stream = filter_stream_cast(ns);
  stream->in_stream = gt_node_stream_ref(in_stream);
  stream->cache = gt_queue_new();
  stream->typestokeep = gt_hashmap_ref(typestokeep);
  return ns;
}
コード例 #6
0
GtNodeStream* gt_feature_in_stream_new(GtFeatureIndex *fi)
{
  GtNodeStream *ns;
  GtFeatureInStream *stream;
  gt_assert(fi);

  ns = gt_node_stream_create(gt_feature_in_stream_class(), true);
  stream = feature_in_stream_cast(ns);
  stream->fi = fi;
  stream->regioncache = gt_queue_new();
  stream->featurecache = NULL;
  stream->useorig = false;
  stream->init = false;
  return ns;
}
コード例 #7
0
GtDescBuffer* gt_desc_buffer_new(void)
{
  GtDescBuffer *db = gt_malloc(sizeof *db);
  db->buf = gt_calloc(GT_DESC_BUFFER_INIT_SIZE, sizeof (char));
  db->length = 0;
  db->maxlength = db->curlength = 0;
  db->allocated = GT_DESC_BUFFER_INIT_SIZE;
  db->finished = false;
  db->dirty = true;
  db->shorten = false;
  db->seen_whitespace = false;
  db->reference_count = 0;
  db->startqueue = gt_queue_new();
  gt_queue_add(db->startqueue, (void*) 0);
  return db;
}
コード例 #8
0
ファイル: select_visitor.c プロジェクト: 9beckert/TIR
GtNodeVisitor* gt_select_visitor_new(GtStr *seqid,
                                     GtStr *source,
                                     const GtRange *contain_range,
                                     const GtRange *overlap_range,
                                     GtStrand strand, GtStrand targetstrand,
                                     bool has_CDS,
                                     unsigned long max_gene_length,
                                     unsigned long max_gene_num,
                                     double min_gene_score,
                                     double max_gene_score,
                                     double min_average_splice_site_prob,
                                     unsigned long feature_num)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_select_visitor_class());
  GtSelectVisitor *select_visitor = select_visitor_cast(nv);
  select_visitor->node_buffer = gt_queue_new();
  select_visitor->seqid = gt_str_ref(seqid);
  select_visitor->source = gt_str_ref(source);
  if (contain_range)
    select_visitor->contain_range = *contain_range;
  else {
    select_visitor->contain_range.start = GT_UNDEF_ULONG;
    select_visitor->contain_range.end   = GT_UNDEF_ULONG;
  }
  if (overlap_range)
    select_visitor->overlap_range = *overlap_range;
  else {
    select_visitor->overlap_range.start = GT_UNDEF_ULONG;
    select_visitor->overlap_range.end   = GT_UNDEF_ULONG;
  }
  select_visitor->strand = strand;
  select_visitor->targetstrand = targetstrand;
  select_visitor->has_CDS = has_CDS;
  select_visitor->max_gene_length = max_gene_length;
  select_visitor->gene_num = 0;
  select_visitor->max_gene_num = max_gene_num;
  select_visitor->min_gene_score = min_gene_score;
  select_visitor->max_gene_score = max_gene_score;
  select_visitor->min_average_splice_site_prob = min_average_splice_site_prob;
  select_visitor->feature_num = feature_num;
  return nv;
}
コード例 #9
0
ファイル: gff3_in_stream_plain.c プロジェクト: 9beckert/TIR
/* takes ownership of <files> */
static GtNodeStream* gff3_in_stream_plain_new(GtStrArray *files,
                                              bool ensure_sorting)
{
  GtNodeStream *ns = gt_node_stream_create(gt_gff3_in_stream_plain_class(),
                                           ensure_sorting);
  GtGFF3InStreamPlain *gff3_in_stream_plain = gff3_in_stream_plain_cast(ns);
  gff3_in_stream_plain->next_file          = 0;
  gff3_in_stream_plain->files              = files;
  gff3_in_stream_plain->stdinstr           = gt_str_new_cstr("stdin");
  gff3_in_stream_plain->ensure_sorting     = ensure_sorting;
  gff3_in_stream_plain->stdin_argument     = false;
  gff3_in_stream_plain->file_is_open       = false;
  gff3_in_stream_plain->fpin               = NULL;
  gff3_in_stream_plain->line_number        = 0;
  gff3_in_stream_plain->genome_node_buffer = gt_queue_new();
  gff3_in_stream_plain->checkids           = false;
  gff3_in_stream_plain->checkregions       = false;
  gff3_in_stream_plain->gff3_parser        = gt_gff3_parser_new(NULL);
  gff3_in_stream_plain->used_types         = gt_cstr_table_new();
  gff3_in_stream_plain->progress_bar       = false;
  return ns;
}
コード例 #10
0
static int gff3_numsorted_out_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                           GtError *err)
{
  GtGFF3NumsortedOutStream *gff3_out_stream;
  int had_err = 0;
  GtUword i = 0;
  gt_error_check(err);
  gff3_out_stream = gff3_numsorted_out_stream_cast(ns);
  if (!gff3_out_stream->outqueue) {
    gff3_out_stream->outqueue = gt_queue_new();
    while (!(had_err =
                    gt_node_stream_next(gff3_out_stream->in_stream, gn, err))) {
      if (!*gn) break;
      gt_array_add(gff3_out_stream->buffer, *gn);
    }
    if (!had_err) {
      gt_genome_nodes_sort_stable_with_func(gff3_out_stream->buffer,
                             (GtCompare) gt_genome_node_compare_numeric_seqids);
      for (i = 0; !had_err && i < gt_array_size(gff3_out_stream->buffer); i++) {
        GtGenomeNode *mygn = *(GtGenomeNode**)
                                       gt_array_get(gff3_out_stream->buffer, i);
        gt_queue_add(gff3_out_stream->outqueue, mygn);
      }
    }
  }
  if (gff3_out_stream->outqueue && !had_err) {
    if (gt_queue_size(gff3_out_stream->outqueue) > 0) {
      GtGenomeNode *mygn = (GtGenomeNode*)
                                        gt_queue_get(gff3_out_stream->outqueue);
      gt_assert(mygn);
      had_err = gt_genome_node_accept(mygn, gff3_out_stream->gff3_visitor, err);
      if (!had_err)
        *gn = mygn;
    }
  }
  return had_err;
}
コード例 #11
0
GtNodeVisitor*
agn_gaeval_visitor_new(GtNodeStream *astream, AgnGaevalParams gparams)
{
  agn_assert(astream);

  // Create the node visitor
  GtNodeVisitor *nv = gt_node_visitor_create(gaeval_visitor_class());
  AgnGaevalVisitor *v = gaeval_visitor_cast(nv);
  v->alignments = gt_feature_index_memory_new();
  v->tsvout = NULL;
  v->params = gparams;

  // Check that sum of weights is 1.0
  double weights_total = gparams.alpha + gparams.beta +
                         gparams.gamma + gparams.epsilon;
  if(fabs(weights_total - 1.0) > 0.0001)
  {
    fprintf(stderr, "[AgnGaevalVisitor::agn_gaeval_visitor_new] warning: "
            "sum of weights is not 1.0 %.3lf; integrity calculations will be "
            "incorrect\n", weights_total);
  }


  // Set up node stream to load alignment features into memory
  GtQueue *streams = gt_queue_new();
  GtNodeStream *stream, *last_stream;
  GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
  gt_hashmap_add(typestokeep, "cDNA_match", "cDNA_match");
  gt_hashmap_add(typestokeep, "EST_match", "EST_match");
  gt_hashmap_add(typestokeep, "nucleotide_match", "nucleotide_match");
  stream = agn_filter_stream_new(astream, typestokeep);
  gt_queue_add(streams, stream);
  last_stream = stream;

  stream = gt_feature_out_stream_new(last_stream, v->alignments);
  gt_queue_add(streams, stream);
  last_stream = stream;

  stream = gt_inter_feature_stream_new(last_stream, "cDNA_match", "match_gap");
  gt_queue_add(streams, stream);
  last_stream = stream;

  stream = gt_inter_feature_stream_new(last_stream, "EST_match", "match_gap");
  gt_queue_add(streams, stream);
  last_stream = stream;

  stream = gt_inter_feature_stream_new(last_stream, "nucleotide_match",
                                       "match_gap");
  gt_queue_add(streams, stream);
  last_stream = stream;

  // Process the node stream
  GtError *error = gt_error_new();
  int result = gt_node_stream_pull(last_stream, error);
  if(result == -1)
  {
    fprintf(stderr, "[AEGeAn::AgnGaevalStream] error parsing alignments: %s\n",
            gt_error_get(error));
    gt_node_visitor_delete(nv);
    return NULL;
  }
  gt_error_delete(error);
  gt_hashmap_delete(typestokeep);
  while(gt_queue_size(streams) > 0)
  {
    stream = gt_queue_get(streams);
    gt_node_stream_delete(stream);
  }
  gt_queue_delete(streams);

  return nv;
}
コード例 #12
0
bool agn_infer_cds_visitor_unit_test(AgnUnitTest *test)
{
  GtQueue *queue = gt_queue_new();
  infer_cds_visitor_test_data(queue);
  agn_assert(gt_queue_size(queue) == 4);

  GtFeatureNode *fn = gt_queue_get(queue);
  GtArray *cds = agn_typecheck_select(fn, agn_typecheck_cds);
  bool grape1 = (gt_array_size(cds) == 4);
  if(grape1)
  {
    GtGenomeNode *cds2 = *(GtGenomeNode **)gt_array_get(cds, 1);
    GtRange range = gt_genome_node_get_range(cds2);
    grape1 = (range.start == 349 && range.end == 522);
  }
  agn_unit_test_result(test, "grape test sans UTRs", grape1);
  gt_genome_node_delete((GtGenomeNode *)fn);
  gt_array_delete(cds);

  fn = gt_queue_get(queue);
  cds = agn_typecheck_select(fn, agn_typecheck_cds);
  bool grape2 = (gt_array_size(cds) == 1);
  if(grape2)
  {
    GtGenomeNode *cds1 = *(GtGenomeNode **)gt_array_get(cds, 0);
    GtRange range = gt_genome_node_get_range(cds1);
    GtStrand strand = gt_feature_node_get_strand((GtFeatureNode *)cds1);
    grape2 = (range.start == 10747 && range.end == 11577 &&
              strand == GT_STRAND_REVERSE);
  }
  agn_unit_test_result(test, "grape test with UTRs, strand check", grape2);
  gt_genome_node_delete((GtGenomeNode *)fn);
  gt_array_delete(cds);

  fn = gt_queue_get(queue);
  cds = agn_typecheck_select(fn, agn_typecheck_cds);
  bool grape3 = (gt_array_size(cds) == 2);
  if(grape3)
  {
    GtGenomeNode *cds2 = *(GtGenomeNode **)gt_array_get(cds, 1);
    GtRange range = gt_genome_node_get_range(cds2);
    grape3 = (range.start == 22651 && range.end == 23022);
  }
  agn_unit_test_result(test, "grape test 3", grape3);
  gt_genome_node_delete((GtGenomeNode *)fn);
  gt_array_delete(cds);

  fn = gt_queue_get(queue);
  cds = agn_typecheck_select(fn, agn_typecheck_cds);
  bool grape4 = (gt_array_size(cds) == 12);
  if(grape4)
  {
    GtGenomeNode *cds7 = *(GtGenomeNode **)gt_array_get(cds, 6);
    GtRange range = gt_genome_node_get_range(cds7);
    grape4 = (range.start == 27956 && range.end == 27996);
  }
  agn_unit_test_result(test, "grape test 4", grape4);
  gt_genome_node_delete((GtGenomeNode *)fn);
  gt_array_delete(cds);

  while(gt_queue_size(queue) > 0)
  {
    GtGenomeNode *cds_n = gt_queue_get(queue);
    gt_genome_node_delete(cds_n);
  }
  gt_queue_delete(queue);
  return agn_unit_test_success(test);
}
コード例 #13
0
ファイル: canon-gff3.c プロジェクト: BrendelGroup/AEGeAn
// Main method
int main(int argc, char * const *argv)
{
  GtError *error;
  GtLogger *logger;
  GtQueue *streams;
  GtNodeStream *stream, *last_stream;
  CanonGFF3Options options = { NULL, NULL, false };

  gt_lib_init();
  error = gt_error_new();
  canon_gff3_parse_options(argc, argv + 0, &options, error);

  streams = gt_queue_new();
  logger = gt_logger_new(true, "", stderr);

  stream = gt_gff3_in_stream_new_unsorted(argc - optind, (const char **)
                                                          argv+optind);
  gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)stream);
  gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)stream);
  gt_queue_add(streams, stream);
  last_stream = stream;

  if(options.infer)
  {
    GtHashmap *type_parents = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                             gt_free_func);
    gt_hashmap_add(type_parents, gt_cstr_dup("mRNA"), gt_cstr_dup("gene"));
    gt_hashmap_add(type_parents, gt_cstr_dup("tRNA"), gt_cstr_dup("gene"));
    stream = agn_infer_parent_stream_new(last_stream,
                                                 type_parents);
    gt_hashmap_delete(type_parents);
    gt_queue_add(streams, stream);
    last_stream = stream;
  }

  stream = agn_gene_stream_new(last_stream, logger);
  gt_queue_add(streams, stream);
  last_stream = stream;

  if(options.source != NULL)
  {
    GtNodeVisitor *ssv = gt_set_source_visitor_new(options.source);
    stream = gt_visitor_stream_new(last_stream, ssv);
    gt_queue_add(streams, stream);
    last_stream = stream;
  }

  stream = gt_gff3_out_stream_new(last_stream, options.outstream);
  if(!options.infer)
    gt_gff3_out_stream_retain_id_attributes((GtGFF3OutStream *)stream);
  gt_queue_add(streams, stream);
  last_stream = stream;

  if(gt_node_stream_pull(last_stream, error) == -1)
  {
    fprintf(stderr, "[CanonGFF3] error processing node stream: %s",
            gt_error_get(error));
  }

  while(gt_queue_size(streams) > 0)
  {
    stream = gt_queue_get(streams);
    gt_node_stream_delete(stream);
  }
  gt_queue_delete(streams);
  if(options.source != NULL)
    gt_str_delete(options.source);
  if(options.outstream != NULL)
    gt_file_delete(options.outstream);
  gt_error_delete(error);
  gt_logger_delete(logger);
  gt_lib_clean();

  return 0;
}
コード例 #14
0
ファイル: queue.c プロジェクト: oeigenbrod/genometools
int gt_queue_unit_test(GtError *err)
{
  long check_counter = 0, check_counter_reverse = 1023;
  unsigned long i;
  int had_err = 0;
  GtQueue *q;

  gt_error_check(err);

  /* without wraparound */
  q = gt_queue_new();
  gt_ensure(had_err, !gt_queue_size(q));
  for (i = 0; !had_err && i < 1024; i++) {
    gt_queue_add(q, (void*) i);
    gt_ensure(had_err, gt_queue_size(q) == i + 1);
  }
  if (!had_err)
    had_err = gt_queue_iterate(q, check_queue, &check_counter, err);
  if (!had_err) {
    had_err = gt_queue_iterate_reverse(q, check_queue_reverse,
                                    &check_counter_reverse, err);
  }
  gt_ensure(had_err, gt_queue_iterate(q, fail_func, NULL, NULL));
  gt_ensure(had_err, gt_queue_iterate_reverse(q, fail_func, NULL, NULL));
  if (!had_err) {
    gt_queue_remove(q, (void*) 0);
    gt_ensure(had_err, gt_queue_size(q) == 1023);
  }
  for (i = 1; !had_err && i < 1024; i++) {
    gt_ensure(had_err, gt_queue_head(q) == (void*) i);
    gt_ensure(had_err, gt_queue_get(q) == (void*) i);
    gt_ensure(had_err, gt_queue_size(q) == 1024 - i - 1);
  }
  gt_ensure(had_err, !gt_queue_size(q));
  gt_queue_delete(q);

  /* with wraparound (without full queue) */
  if (!had_err) {
    q = gt_queue_new();
    gt_ensure(had_err, !gt_queue_size(q));
    for (i = 0; !had_err && i < 1024; i++) {
      gt_queue_add(q, (void*) i);
      gt_ensure(had_err, gt_queue_size(q) == i + 1);
    }
    check_counter = 0;
    check_counter_reverse = 1023;
    if (!had_err)
      had_err = gt_queue_iterate(q, check_queue, &check_counter, err);
    gt_ensure(had_err, gt_queue_iterate(q, fail_func, NULL, NULL));
    gt_ensure(had_err, gt_queue_iterate_reverse(q, fail_func, NULL, NULL));
    if (!had_err) {
      had_err = gt_queue_iterate_reverse(q, check_queue_reverse,
                                         &check_counter_reverse, err);
    }
    for (i = 0; !had_err && i < 512; i++) {
      gt_ensure(had_err, gt_queue_head(q) == (void*) i);
      gt_ensure(had_err, gt_queue_get(q) == (void*) i);
      gt_ensure(had_err, gt_queue_size(q) == 1024 - i - 1);
    }
    for (i = 0; !had_err && i < 512; i++) {
      gt_queue_add(q, (void*) (i + 1024));
      gt_ensure(had_err, gt_queue_size(q) == 512 + i + 1);
    }
    check_counter = 512;
    check_counter_reverse = 1535;
    if (!had_err)
      had_err = gt_queue_iterate(q, check_queue, &check_counter, err);
    if (!had_err) {
      had_err = gt_queue_iterate_reverse(q, check_queue_reverse,
                                         &check_counter_reverse, err);
    }
    gt_ensure(had_err, gt_queue_iterate(q, fail_func, NULL, NULL));
    gt_ensure(had_err, gt_queue_iterate_reverse(q, fail_func, NULL, NULL));
    if (!had_err) {
      gt_queue_remove(q, (void*) 512);
      gt_ensure(had_err, gt_queue_size(q) == 1023);
    }
    for (i = 1; !had_err && i < 1024; i++) {
      gt_ensure(had_err, gt_queue_head(q) == (void*) (512 + i));
      gt_ensure(had_err, gt_queue_get(q) == (void*) (512 + i));
      gt_ensure(had_err, gt_queue_size(q) == 1024 - i - 1);
    }
    gt_ensure(had_err, !gt_queue_size(q));
    gt_queue_delete(q);
  }

  /* with wraparound (with full queue) */
  if (!had_err) {
    q = gt_queue_new();
    gt_ensure(had_err, !gt_queue_size(q));
    for (i = 0; !had_err && i < 1024; i++) {
      gt_queue_add(q, (void*) i);
      gt_ensure(had_err, gt_queue_size(q) == i + 1);
    }
    check_counter = 0;
    check_counter_reverse = 1023;
    if (!had_err)
      had_err = gt_queue_iterate(q, check_queue, &check_counter, err);
    if (!had_err) {
      had_err = gt_queue_iterate_reverse(q, check_queue_reverse,
                                      &check_counter_reverse, err);
    }
    gt_ensure(had_err, gt_queue_iterate(q, fail_func, NULL, NULL));
    gt_ensure(had_err, gt_queue_iterate_reverse(q, fail_func, NULL, NULL));
    for (i = 0; !had_err && i < 512; i++) {
      gt_ensure(had_err, gt_queue_head(q) == (void*) i);
      gt_ensure(had_err, gt_queue_get(q) == (void*) i);
      gt_ensure(had_err, gt_queue_size(q) == 1024 - i - 1);
    }
    for (i = 0; !had_err && i < 1024; i++) {
      gt_queue_add(q, (void*) (i + 1024));
      gt_ensure(had_err, gt_queue_size(q) == 512 + i + 1);
    }
    check_counter = 512;
    check_counter_reverse = 2047;
    if (!had_err)
      had_err = gt_queue_iterate(q, check_queue, &check_counter, err);
    if (!had_err) {
      had_err = gt_queue_iterate_reverse(q, check_queue_reverse,
                                      &check_counter_reverse, err);
    }
    gt_ensure(had_err, gt_queue_iterate(q, fail_func, NULL, NULL));
    gt_ensure(had_err, gt_queue_iterate_reverse(q, fail_func, NULL, NULL));
    if (!had_err) {
      gt_queue_remove(q, (void*) 512);
      gt_ensure(had_err, gt_queue_size(q) == 1535);
    }
    for (i = 1; !had_err && i < 1536; i++) {
      gt_ensure(had_err, gt_queue_head(q) == (void*) (512 + i));
      gt_ensure(had_err, gt_queue_get(q) == (void*) (512 + i));
      gt_ensure(had_err, gt_queue_size(q) == 1536 - i - 1);
    }
    gt_ensure(had_err, !gt_queue_size(q));
    gt_queue_delete(q);
  }

  /* test a corner case */
  if (!had_err) {
    q = gt_queue_new();
    gt_queue_add(q, (void*) 1);
    gt_ensure(had_err, gt_queue_size(q) == 1);
    if (!had_err)
      gt_queue_add(q, (void*) 1);
    gt_ensure(had_err, gt_queue_size(q) == 2);
    gt_ensure(had_err, gt_queue_get(q));
    gt_ensure(had_err, gt_queue_size(q) == 1);
    if (!had_err)
      gt_queue_add(q, (void*) 1);
    gt_ensure(had_err, gt_queue_size(q) == 2);
    gt_ensure(had_err, gt_queue_get(q));
    gt_ensure(had_err, gt_queue_size(q) == 1);
    if (!had_err)
      gt_queue_add(q, (void*) 1);
    gt_ensure(had_err, gt_queue_size(q) == 2);
    gt_ensure(had_err, gt_queue_get(q));
    gt_ensure(had_err, gt_queue_size(q) == 1);
    gt_ensure(had_err, gt_queue_get(q));
    gt_ensure(had_err, gt_queue_size(q) == 0);
    if (!had_err)
      gt_queue_add(q, (void*) 1);
    gt_ensure(had_err, gt_queue_size(q) == 1);
    gt_ensure(had_err, gt_queue_get(q));
    gt_ensure(had_err, gt_queue_size(q) == 0);
    gt_queue_delete(q);
  }

  /* gt_queue_remove() corner case */
  if (!had_err) {
    q = gt_queue_new();
    gt_queue_add(q, (void*) 1);
    gt_ensure(had_err, gt_queue_size(q) == 1);
    gt_queue_remove(q, (void*) 1);
    gt_ensure(had_err, gt_queue_size(q) == 0);
    gt_queue_delete(q);
  }

  /* gt_queue_remove() corner case */
  if (!had_err) {
    q = gt_queue_new();
    gt_queue_add(q, (void*) 0);
    gt_queue_add(q, (void*) 1);
    gt_queue_add(q, (void*) 2);
    gt_queue_add(q, (void*) 3);
    gt_ensure(had_err, gt_queue_get(q) == (void*) 0);
    gt_ensure(had_err, gt_queue_get(q) == (void*) 1);
    gt_queue_add(q, (void*) 4);
    gt_queue_add(q, (void*) 5);
    gt_queue_remove(q, (void*) 4);
    gt_queue_remove(q, (void*) 2);
    gt_queue_remove(q, (void*) 5);
    gt_queue_remove(q, (void*) 3);
    gt_ensure(had_err, gt_queue_size(q) == 0);
    gt_queue_delete(q);
  }

  /* delete with contents */
  if (!had_err) {
    q = gt_queue_new();
    gt_ensure(had_err, !gt_queue_size(q));
    if (!had_err)
      gt_queue_add(q, gt_calloc(1, 16));
    gt_ensure(had_err, gt_queue_size(q) == 1);
    if (!had_err)
      gt_queue_add(q, gt_calloc(1, 32));
    gt_ensure(had_err, gt_queue_size(q) == 2);
    gt_queue_delete_with_contents(q);
  }

  return had_err;
}