alg/test/test_glsequence.cpp

   1 #include <boost/test/auto_unit_test.hpp>
   2
   3 #include <string>
   4
   5 #include "alg/glsequence.hpp"
   6 #include "alg/sequence.hpp"
   7
   8 using namespace std;
   9
  10 BOOST_AUTO_TEST_CASE ( glsequence_operator_equal )
  11 {
  12   // I don't trust my operator = hack so lets make sure it works.
  13   string s0("AAGGCCTT");
  14   string s1("TTGGCCAA");
  15   Sequence seq0(s0);
  16   Sequence seq1(s1);
  17
  18   GlSequence glseq0(seq0);
  19   BOOST_CHECK (glseq0.sequence().get_seq() == s0);
  20   GlSequence glseq1(seq1);
  21   GlSequence glseq_copy0(glseq0);
  22
  23   BOOST_CHECK(glseq_copy0.sequence().get_seq() == glseq0.sequence().get_seq());
  24   BOOST_CHECK( &(glseq_copy0.sequence()) == &(glseq0.sequence()));
  25
  26   glseq0 = glseq1;
  27
  28   BOOST_CHECK( glseq0.sequence().get_seq() == s1 );
  29 }
  30
  31 BOOST_AUTO_TEST_CASE( glsequence_color )
  32 {
  33   Color black(0.0, 0.0, 0.0, 0.0);
  34   Color c(0.1, 0.2, 0.3, 0.4);
  35   Sequence seq("AAGGCCTT");
  36   GlSequence s(seq);
  37
  38   BOOST_CHECK_EQUAL(s.color(), black );
  39   s.setColor( c );
  40   BOOST_CHECK_EQUAL( s.color(), c );
  41 }
  42
  43 BOOST_AUTO_TEST_CASE( glsequence_renderable )
  44 {
  45   Sequence seq("AAGGCCTT");
  46   GlSequence s(seq);
  47
  48   // way more base pairs than viewport pixel width
  49   BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 1000, 500), false );
  50   // way fewer basepairs than viewport pixel width
  51   BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 10, 500), true);
  52 }
  53
  54 BOOST_AUTO_TEST_CASE( glsequence_sequence )
  55 {
  56   string seq_string("AAGGCCTTNNAAGGCCTTNNAAGGCCTTNN");
  57   string::size_type seqlen = seq_string.size();
  58   Sequence seq(seq_string);
  59   GlSequence glseq(seq);
  60
  61   BOOST_CHECK( glseq.sequence_begin(0, 50) == seq.begin() );
  62   // always make sure we return seq.end() regardless of how much extra
  63   // is asked for
  64   BOOST_CHECK( glseq.sequence_end(0, seqlen+10) == seq.end() );
  65   // do we get the right end pointer?
  66   BOOST_CHECK( glseq.sequence_end(0, 5) == seq.begin()+5 );
  67
  68   // when we request far too much sequence what do we get?
  69   BOOST_CHECK( glseq.sequence_begin(seqlen+10, seqlen+20) == seq.end() );
  70   BOOST_CHECK( glseq.sequence_end(seqlen+10, seqlen+20) == seq.end() );
  71
  72   // we cant ask for reversed sequences with sequence_begin/end
  73   BOOST_CHECK( glseq.sequence_begin(10, 5) == seq.end() );
  74   BOOST_CHECK( glseq.sequence_end(10, 5) == seq.end() );
  75
  76   Sequence::const_iterator seq_itor;
  77
  78   // if we as for an empty segment? start and end should equal
  79   seq_itor = glseq.sequence_begin(10, 10);
  80   BOOST_CHECK( seq_itor == glseq.sequence_end(10, 10) );
  81
  82   // reuse seq_itor downhere
  83   string::const_iterator str_itor;
  84   for(str_itor = seq.begin(),
  85       seq_itor = glseq.sequence_begin();
  86       str_itor != seq.end() and
  87       seq_itor != glseq.sequence_end();
  88       ++str_itor, ++seq_itor)
  89   {
  90     BOOST_CHECK_EQUAL( *str_itor, *seq_itor );
  91   }
  92 }
  93
  94 // make sure the computation of the leftmost and rightmost base is correct
  95 BOOST_AUTO_TEST_CASE( glsequence_leftright_base )
  96 {
  97   std::string seq_string = "AAGGCCTT";
  98   Sequence seq(seq_string);
  99   GlSequence glseq(seq);
 100
 101   BOOST_CHECK_EQUAL( glseq.leftbase( -50.0 ), 0 );
 102   BOOST_CHECK_EQUAL( glseq.leftbase(   0.5 ), 1 );
 103   BOOST_CHECK_EQUAL( glseq.rightbase( 1000.0 ), seq_string.size() );
 104   BOOST_CHECK_EQUAL( glseq.rightbase( seq_string.size()-0.5),
 105                      seq_string.size()-1);
 106 }