alg/test/test_glsequence.cpp

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