alg/test/test_glsequence.cpp

   1 #include <boost/test/auto_unit_test.hpp>
   2
   3 #include <string>
   4
   5 #include "alg/annotation_colors.hpp"
   6 #include "alg/glsequence.hpp"
   7 #include "alg/sequence.hpp"
   8
   9 using namespace std;
  10
  11 BOOST_AUTO_TEST_CASE ( glsequence_operator_equal )
  12 {
  13   AnnotationColors cm;
  14   // I don't trust my operator = hack so lets make sure it works.
  15   string s0("AAGGCCTT");
  16   string s1("TTGGCCAA");
  17   Sequence seq0(s0);
  18   Sequence seq1(s1);
  19
  20   GlSequence glseq0(seq0, cm);
  21   BOOST_CHECK (glseq0.sequence().get_seq() == s0);
  22   GlSequence glseq1(seq1, cm);
  23   GlSequence glseq_copy0(glseq0);
  24
  25   BOOST_CHECK(glseq_copy0.sequence().get_seq() == glseq0.sequence().get_seq());
  26   BOOST_CHECK( &(glseq_copy0.sequence()) == &(glseq0.sequence()));
  27
  28   glseq0 = glseq1;
  29
  30   BOOST_CHECK( glseq0.sequence().get_seq() == s1 );
  31 }
  32
  33 BOOST_AUTO_TEST_CASE( glsequence_color )
  34 {
  35   AnnotationColors cm;
  36   Color black(0.0, 0.0, 0.0, 0.0);
  37   Color c(0.1, 0.2, 0.3, 0.4);
  38   Sequence seq("AAGGCCTT");
  39   GlSequence s(seq, cm);
  40
  41   BOOST_CHECK_EQUAL(s.color(), black );
  42   s.setColor( c );
  43   BOOST_CHECK_EQUAL( s.color(), c );
  44 }
  45
  46 BOOST_AUTO_TEST_CASE( glsequence_renderable )
  47 {
  48   AnnotationColors cm;
  49   Sequence seq("AAGGCCTT");
  50   GlSequence s(seq, cm);
  51
  52   // way more base pairs than viewport pixel width
  53   BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 1000, 500), false );
  54   // way fewer basepairs than viewport pixel width
  55   BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 10, 500), true);
  56 }
  57
  58 BOOST_AUTO_TEST_CASE( glsequence_sequence )
  59 {
  60   AnnotationColors cm;
  61   string seq_string("AAGGCCTTNNAAGGCCTTNNAAGGCCTTNN");
  62   string::size_type seqlen = seq_string.size();
  63   Sequence seq(seq_string);
  64   GlSequence glseq(seq, cm);
  65
  66   BOOST_CHECK( glseq.sequence_begin(0, 50) == seq.begin() );
  67   // always make sure we return seq.end() regardless of how much extra
  68   // is asked for
  69   BOOST_CHECK( glseq.sequence_end(0, seqlen+10) == seq.end() );
  70   // do we get the right end pointer?
  71   BOOST_CHECK( glseq.sequence_end(0, 5) == seq.begin()+5 );
  72
  73   // when we request far too much sequence what do we get?
  74   BOOST_CHECK( glseq.sequence_begin(seqlen+10, seqlen+20) == seq.end() );
  75   BOOST_CHECK( glseq.sequence_end(seqlen+10, seqlen+20) == seq.end() );
  76
  77   // we cant ask for reversed sequences with sequence_begin/end
  78   BOOST_CHECK( glseq.sequence_begin(10, 5) == seq.end() );
  79   BOOST_CHECK( glseq.sequence_end(10, 5) == seq.end() );
  80
  81   Sequence::const_iterator seq_itor;
  82
  83   // if we as for an empty segment? start and end should equal
  84   seq_itor = glseq.sequence_begin(10, 10);
  85   BOOST_CHECK( seq_itor == glseq.sequence_end(10, 10) );
  86
  87   // reuse seq_itor downhere
  88   string::const_iterator str_itor;
  89   for(str_itor = seq.begin(),
  90       seq_itor = glseq.sequence_begin();
  91       str_itor != seq.end() and
  92       seq_itor != glseq.sequence_end();
  93       ++str_itor, ++seq_itor)
  94   {
  95     BOOST_CHECK_EQUAL( *str_itor, *seq_itor );
  96   }
  97 }
  98
  99 // make sure the computation of the leftmost and rightmost base is correct
 100 BOOST_AUTO_TEST_CASE( glsequence_leftright_base )
 101 {
 102   AnnotationColors cm;
 103   std::string seq_string = "AAGGCCTT";
 104   Sequence seq(seq_string);
 105   GlSequence glseq(seq, cm);
 106
 107   BOOST_CHECK_EQUAL( glseq.leftbase( -50.0 ), 0 );
 108   BOOST_CHECK_EQUAL( glseq.leftbase(   0.5 ), 1 );
 109   BOOST_CHECK_EQUAL( glseq.leftbase(   5.0 ), 5 );
 110   BOOST_CHECK_EQUAL( glseq.leftbase( 500.0 ), seq_string.size() );
 111   BOOST_CHECK_EQUAL( glseq.rightbase(    0.0 ), 0 );
 112   BOOST_CHECK_EQUAL( glseq.rightbase( 1000.0 ), seq_string.size() );
 113   BOOST_CHECK_EQUAL( glseq.rightbase( seq_string.size()-0.5),
 114                      seq_string.size()-1);
 115 }
 116
 117 // do our left and right most base computations still work if
 118 // we move the sequence around?
 119 BOOST_AUTO_TEST_CASE( glsequence_movex )
 120 {
 121   AnnotationColors cm;
 122   std::string seq_string = "AAGGCCTTAAGGCCTT";
 123   Sequence seq(seq_string);
 124   GlSequence glseq(seq, cm);
 125
 126   glseq.setX(-5);
 127   BOOST_CHECK_EQUAL( glseq.leftbase(-100.0), 0 );
 128   BOOST_CHECK_EQUAL( glseq.leftbase(   0.0), 5 );
 129   BOOST_CHECK_EQUAL( glseq.leftbase(  -2.0), 3 );
 130   BOOST_CHECK_EQUAL( glseq.leftbase( 100.0), seq_string.size() );
 131   BOOST_CHECK_EQUAL( glseq.rightbase( 1000.0 ), seq_string.size() );
 132   BOOST_CHECK_EQUAL( glseq.rightbase(    8.0 ), 8+5 );
 133   BOOST_CHECK_EQUAL( glseq.rightbase(   -7.0 ), 0 );
 134 }
 135
 136 // Check iterators
 137 BOOST_AUTO_TEST_CASE( glsequence_check_iterators )
 138 {
 139   AnnotationColors cm;
 140   std::string seq_string = "AAGGCCTTAAGGCCTT";
 141   Sequence seq(seq_string);
 142   GlSequence glseq(seq, cm);
 143
 144   Sequence::const_iterator seq_begin_i;
 145   Sequence::const_iterator seq_end_i;
 146
 147   BOOST_CHECK(glseq.sequence_begin(5, -5) == seq.end());
 148   BOOST_CHECK(glseq.sequence_begin(0, 20) == seq.begin());
 149   BOOST_CHECK(glseq.sequence_begin(10,20) == seq.begin()+10);
 150
 151   BOOST_CHECK(glseq.sequence_end(5, -5) == seq.end());
 152   BOOST_CHECK(glseq.sequence_end(0, 20) == seq.end());
 153   BOOST_CHECK(glseq.sequence_end(0, 10) == seq.begin()+10);
 154
 155   glseq.setX(-5);
 156   BOOST_CHECK(glseq.sequence_begin(0, 10) == seq.begin()+5);
 157   BOOST_CHECK(glseq.sequence_end(0, 15) == seq.end());
 158 }