alg/test/test_glsequence.cpp

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