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_find_null_sequence )
  78 {
  79   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
  80   GlSequence s("AAAAAAAAAANNNNNANAN", cm);
  81   //            0123456789012345678
  82   s.add_annotations_for_undefined_sequence();
  83
  84   BOOST_CHECK_EQUAL(s.annotations().size(), 3);
  85   std::vector<SeqSpanRef> annot(s.annotations().begin(), s.annotations().end());
  86   BOOST_CHECK_EQUAL(annot[0]->start(), 10);
  87   BOOST_CHECK_EQUAL(annot[0]->stop(), 15);
  88   BOOST_CHECK_EQUAL(annot[1]->start(), 16);
  89   BOOST_CHECK_EQUAL(annot[1]->size(), 1);
  90   BOOST_CHECK_EQUAL(annot[2]->start(), 18);
  91   BOOST_CHECK_EQUAL(annot[2]->size(), 1);
  92 }
  93
  94 BOOST_AUTO_TEST_CASE( glsequence_renderable )
  95 {
  96   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
  97   Sequence seq("AAGGCCTT");
  98   GlSequence s(seq, cm);
  99
 100   // way more base pairs than viewport pixel width
 101   BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 1000, 500), false );
 102   // way fewer basepairs than viewport pixel width
 103   BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 10, 500), true);
 104
 105   BOOST_CHECK_CLOSE((double)s.pixelWidth(0, 100, 100), 1.0, 1e-6);
 106   BOOST_CHECK_CLOSE((double)s.pixelWidth(0, 1000, 100), 10.0, 1e-6);
 107 }
 108
 109 BOOST_AUTO_TEST_CASE( glsequence_sequence )
 110 {
 111   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
 112   string seq_string("AAGGCCTTNNAAGGCCTTNNAAGGCCTTNN");
 113   string::size_type seqlen = seq_string.size();
 114   Sequence seq(seq_string);
 115   GlSequence glseq(seq, cm);
 116
 117   BOOST_CHECK( glseq.region_begin(0, 50) == seq.begin() );
 118   // always make sure we return seq.end() regardless of how much extra
 119   // is asked for
 120   BOOST_CHECK( glseq.region_end(0, seqlen+10) == seq.end() );
 121   // do we get the right end pointer?
 122   BOOST_CHECK( glseq.region_end(0, 5) == seq.begin()+5 );
 123
 124   // when we request far too much sequence what do we get?
 125   BOOST_CHECK( glseq.region_begin(seqlen+10, seqlen+20) == seq.end() );
 126   BOOST_CHECK( glseq.region_end(seqlen+10, seqlen+20) == seq.end() );
 127
 128   // we cant ask for reversed sequences with region_begin/end
 129   BOOST_CHECK( glseq.region_begin(10, 5) == seq.end() );
 130   BOOST_CHECK( glseq.region_end(10, 5) == seq.end() );
 131
 132   Sequence::const_iterator seq_itor;
 133
 134   // if we as for an empty segment? start and end should equal
 135   seq_itor = glseq.region_begin(10, 10);
 136   BOOST_CHECK( seq_itor == glseq.region_end(10, 10) );
 137
 138   // reuse seq_itor downhere
 139   string::const_iterator str_itor;
 140   for(str_itor = seq.begin(),
 141       seq_itor = glseq.begin();
 142       str_itor != seq.end() and
 143       seq_itor != glseq.end();
 144       ++str_itor, ++seq_itor)
 145   {
 146     BOOST_CHECK_EQUAL( *str_itor, *seq_itor );
 147   }
 148 }
 149
 150 // make sure the computation of the leftmost and rightmost base is correct
 151 BOOST_AUTO_TEST_CASE( glsequence_leftright_base )
 152 {
 153   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
 154   std::string seq_string = "AAGGCCTT";
 155   Sequence seq(seq_string);
 156   GlSequence glseq(seq, cm);
 157
 158   BOOST_CHECK_EQUAL( glseq.leftbase( -50.0 ), 0 );
 159   BOOST_CHECK_EQUAL( glseq.leftbase(   0.5 ), 1 );
 160   BOOST_CHECK_EQUAL( glseq.leftbase(   5.0 ), 5 );
 161   BOOST_CHECK_EQUAL( glseq.leftbase( 500.0 ), seq_string.size() );
 162   BOOST_CHECK_EQUAL( glseq.rightbase(    0.0 ), 0 );
 163   BOOST_CHECK_EQUAL( glseq.rightbase( 1000.0 ), seq_string.size() );
 164   BOOST_CHECK_EQUAL( glseq.rightbase( seq_string.size()-0.5),
 165                      seq_string.size()-1);
 166 }
 167
 168 // do our left and right most base computations still work if
 169 // we move the sequence around?
 170 BOOST_AUTO_TEST_CASE( glsequence_movex )
 171 {
 172   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
 173   std::string seq_string = "AAGGCCTTAAGGCCTT";
 174   Sequence seq(seq_string);
 175   GlSequence glseq(seq, cm);
 176
 177   glseq.setX(-5);
 178   BOOST_CHECK_EQUAL( glseq.leftbase(-100.0), 0 );
 179   BOOST_CHECK_EQUAL( glseq.leftbase(   0.0), 5 );
 180   BOOST_CHECK_EQUAL( glseq.leftbase(  -2.0), 3 );
 181   BOOST_CHECK_EQUAL( glseq.leftbase( 100.0), seq_string.size() );
 182   BOOST_CHECK_EQUAL( glseq.rightbase( 1000.0 ), seq_string.size() );
 183   BOOST_CHECK_EQUAL( glseq.rightbase(    8.0 ), 8+5 );
 184   BOOST_CHECK_EQUAL( glseq.rightbase(   -7.0 ), 0 );
 185 }
 186
 187 // Check iterators
 188 BOOST_AUTO_TEST_CASE( glsequence_check_iterators )
 189 {
 190   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
 191   std::string seq_string = "AAGGCCTTAAGGCCTT";
 192   Sequence seq(seq_string);
 193   GlSequence glseq(seq, cm);
 194
 195   Sequence::const_iterator seq_begin_i;
 196   Sequence::const_iterator seq_end_i;
 197
 198   BOOST_CHECK(glseq.region_begin(5, -5) == seq.end());
 199   BOOST_CHECK(glseq.region_begin(0, 20) == seq.begin());
 200   BOOST_CHECK(glseq.region_begin(10,20) == seq.begin()+10);
 201
 202   BOOST_CHECK(glseq.region_end(5, -5) == seq.end());
 203   BOOST_CHECK(glseq.region_end(0, 20) == seq.end());
 204   BOOST_CHECK(glseq.region_end(0, 10) == seq.begin()+10);
 205
 206   glseq.setX(-5);
 207   BOOST_CHECK(glseq.region_begin(0, 10) == seq.begin()+5);
 208   BOOST_CHECK(glseq.region_end(0, 15) == seq.end());
 209 }
 210
 211 BOOST_AUTO_TEST_CASE( glsequence_subseq )
 212 {
 213   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
 214   boost::shared_ptr<Color> c(new Color(1.0, 0.5, 0.5));
 215
 216   GlSequence seq("AAGGCCTT", cm);
 217   seq.setColor(c);
 218
 219   GlSequence subseq = seq.subseq(4,2);
 220   BOOST_CHECK_EQUAL(subseq.get_sequence(), "CC");
 221   BOOST_CHECK_EQUAL(subseq.color(), c);
 222 }
 223
 224 /*
 225 BOOST_AUTO_TEST_CASE ( shared_ptr_test )
 226 {
 227   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
 228   // I don't trust my operator= hack so lets make sure it works.
 229   string s0("AAGGCCTT");
 230   string s1("TTGGCCAA");
 231   Sequence seq0(s0);
 232   BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
 233   Sequence seq1(s1);
 234   BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
 235
 236   // make a block to test deallocation
 237   {
 238     GlSequence glseq0(seq0, cm);
 239     BOOST_CHECK_EQUAL(seq0.use_count(), 2);
 240     GlSequence glseq1(seq1, cm);
 241     BOOST_CHECK_EQUAL(seq1.use_count(), 2);
 242
 243     glseq0 = glseq1;
 244     BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
 245     BOOST_CHECK_EQUAL( seq1.use_count(), 3 );
 246   }
 247   BOOST_CHECK_EQUAL(seq0.use_count(), 1);
 248   BOOST_CHECK_EQUAL(seq1.use_count(), 1);
 249 }
 250 */