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