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   boost::shared_ptr<Sequence> seq0(new Sequence(s0));
  21   boost::shared_ptr<Sequence> seq1(new Sequence(s1));
  22
  23   GlSequence glseq0(seq0, cm);
  24   BOOST_CHECK (*glseq0.sequence() == s0);
  25   GlSequence glseq1(seq1, cm);
  26   GlSequence glseq_copy0(glseq0);
  27
  28   BOOST_CHECK(glseq_copy0.sequence() == glseq0.sequence());
  29   BOOST_CHECK( glseq_copy0.sequence() == glseq0.sequence());
  30
  31   glseq0 = glseq1;
  32   BOOST_CHECK( *glseq0.sequence() == s1 );
  33 }
  34
  35 BOOST_AUTO_TEST_CASE( glsequence_color )
  36 {
  37   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
  38   Color black(0.0, 0.0, 0.0, 1.0);
  39   Color c(0.1, 0.2, 0.3, 0.4);
  40   boost::shared_ptr<Sequence> seq(new Sequence("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   boost::shared_ptr<Sequence> seq(new Sequence("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   boost::shared_ptr<Sequence> seq(new Sequence(seq_string));
  69   GlSequence glseq(seq, cm);
  70
  71   BOOST_CHECK( glseq.sequence_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.sequence_end(0, seqlen+10) == seq->end() );
  75   // do we get the right end pointer?
  76   BOOST_CHECK( glseq.sequence_end(0, 5) == seq->begin()+5 );
  77
  78   // when we request far too much sequence what do we get?
  79   BOOST_CHECK( glseq.sequence_begin(seqlen+10, seqlen+20) == seq->end() );
  80   BOOST_CHECK( glseq.sequence_end(seqlen+10, seqlen+20) == seq->end() );
  81
  82   // we cant ask for reversed sequences with sequence_begin/end
  83   BOOST_CHECK( glseq.sequence_begin(10, 5) == seq->end() );
  84   BOOST_CHECK( glseq.sequence_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.sequence_begin(10, 10);
  90   BOOST_CHECK( seq_itor == glseq.sequence_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.sequence_begin();
  96       str_itor != seq->end() and
  97       seq_itor != glseq.sequence_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   boost::shared_ptr<Sequence> seq(new Sequence(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   boost::shared_ptr<Sequence> seq(new Sequence(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   boost::shared_ptr<Sequence> seq(new Sequence(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.sequence_begin(5, -5) == seq->end());
 153   BOOST_CHECK(glseq.sequence_begin(0, 20) == seq->begin());
 154   BOOST_CHECK(glseq.sequence_begin(10,20) == seq->begin()+10);
 155
 156   BOOST_CHECK(glseq.sequence_end(5, -5) == seq->end());
 157   BOOST_CHECK(glseq.sequence_end(0, 20) == seq->end());
 158   BOOST_CHECK(glseq.sequence_end(0, 10) == seq->begin()+10);
 159
 160   glseq.setX(-5);
 161   BOOST_CHECK(glseq.sequence_begin(0, 10) == seq->begin()+5);
 162   BOOST_CHECK(glseq.sequence_end(0, 15) == seq->end());
 163 }
 164
 165 BOOST_AUTO_TEST_CASE ( shared_ptr_test )
 166 {
 167   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
 168   // I don't trust my operator= hack so lets make sure it works.
 169   string s0("AAGGCCTT");
 170   string s1("TTGGCCAA");
 171   boost::shared_ptr<Sequence> seq0(new Sequence(s0));
 172   BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
 173   boost::shared_ptr<Sequence> seq1(new Sequence(s1));
 174   BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
 175
 176   // make a block to test deallocation
 177   {
 178     GlSequence glseq0(seq0, cm);
 179     BOOST_CHECK_EQUAL(seq0.use_count(), 2);
 180     GlSequence glseq1(seq1, cm);
 181     BOOST_CHECK_EQUAL(seq1.use_count(), 2);
 182
 183     glseq0 = glseq1;
 184     BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
 185     BOOST_CHECK_EQUAL( seq1.use_count(), 3 );
 186   }
 187   BOOST_CHECK_EQUAL(seq0.use_count(), 1);
 188   BOOST_CHECK_EQUAL(seq1.use_count(), 1);
 189 }
 190
 191