alg/test/test_glseqbrowser.cpp

   1 #define BOOST_TEST_DYN_LINK
   2 #define BOOST_TEST_MODULE test_glseqbrowser
   3 #include <boost/test/unit_test.hpp>
   4
   5 #include <boost/assign/std/vector.hpp>
   6 using namespace boost::assign;
   7
   8 #include <boost/shared_ptr.hpp>
   9
  10 #include <string>
  11 #include <list>
  12 #include <vector>
  13
  14 #include "annotation_colors.hpp"
  15 #include "glseqbrowser.hpp"
  16 #include "mussa.hpp"
  17 #include "sequence.hpp"
  18
  19 using namespace std;
  20
  21 BOOST_AUTO_TEST_CASE ( gltracks_connect )
  22 {
  23   string s0("AAGGCCTT");
  24   string s1("TTGGCCAA");
  25   string s2("GATTACAA");
  26   Sequence seq0(s0);
  27   Sequence seq1(s1);
  28   Sequence seq2(s2);
  29
  30   GlSeqBrowser gt;
  31   gt.push_sequence(seq0);
  32   gt.push_sequence(seq1);
  33   gt.push_sequence(seq2);
  34
  35   // make up some sample data
  36   vector<bool> rc;
  37   rc += false, false, false;
  38   vector<int> path;
  39                 path += 1,1,1; gt.link(path, rc, 1);
  40   path.clear(); path += 1,1,3; gt.link(path, rc, 1);
  41   path.clear(); path += 1,2,1; gt.link(path, rc, 1);
  42   path.clear(); path += 2,3,3; gt.link(path, rc, 1);
  43   path.clear(); path += 3,3,3; gt.link(path, rc, 1);
  44
  45   // this represents the "depth" of the path_segment AKA sequences -1
  46   BOOST_CHECK_EQUAL( gt.path_segments.size(), 2 );
  47   BOOST_CHECK_EQUAL( gt.path_segments[0].size(), 4);
  48   BOOST_CHECK_EQUAL( gt.path_segments[1].size(), 4);
  49   GlSeqBrowser::segment_key p11(1, 1);
  50   GlSeqBrowser::segment_key p23(2, 3);
  51   GlSeqBrowser::segment_key p33(3, 3);
  52   GlSeqBrowser::segment_key p13(1, 3);
  53   GlSeqBrowser::pair_segment_map::iterator psm_i = gt.path_segments[0].find(p11);
  54   BOOST_CHECK( psm_i != gt.path_segments[0].end() );
  55   BOOST_CHECK_EQUAL( psm_i->second.path_ids.size(), 2 );
  56   // exaustively test the other keys in the first row
  57   psm_i = gt.path_segments[0].find(p23);
  58   BOOST_CHECK( psm_i != gt.path_segments[0].end());
  59   psm_i = gt.path_segments[0].find(p33);
  60   BOOST_CHECK( psm_i != gt.path_segments[0].end());
  61   // should be missing
  62   psm_i = gt.path_segments[0].find(p13);
  63   BOOST_CHECK( psm_i == gt.path_segments[0].end());
  64
  65   gt.clear();
  66   BOOST_CHECK_EQUAL( gt.path_segments.size(), 0 );
  67 }
  68
  69 BOOST_AUTO_TEST_CASE ( gltracks_connect_different_lengths )
  70 {
  71   string s0("AAGGCCTT");
  72   string s1("TTGGCCAA");
  73   string s2("GATTACAA");
  74   Sequence seq0(s0);
  75   Sequence seq1(s1);
  76   Sequence seq2(s2);
  77
  78   GlSeqBrowser gt;
  79   gt.push_sequence(seq0);
  80   gt.push_sequence(seq1);
  81   gt.push_sequence(seq2);
  82
  83   // make up some sample data
  84   vector<bool> rc;
  85   rc += false, false, false;
  86   vector<int> path;
  87                 path += 1,1,1; gt.link(path, rc, 5);
  88   path.clear(); path += 1,1,3; gt.link(path, rc, 1);
  89   path.clear(); path += 2,3,3; gt.link(path, rc, 1);
  90   path.clear(); path += 3,3,3; gt.link(path, rc, 3);
  91   path.clear(); path += 4,3,3; gt.link(path, rc, 2);
  92
  93   // this represents the "depth" of the path_segment AKA sequences -1
  94   BOOST_CHECK_EQUAL( gt.path_segments.size(), 2 );
  95   BOOST_CHECK_EQUAL( gt.path_segments[0].size(), 4);
  96   BOOST_CHECK_EQUAL( gt.path_segments[1].size(), 3);
  97   GlSeqBrowser::segment_key p1(1, 1);
  98   GlSeqBrowser::pair_segment_map::iterator psm1_i = gt.path_segments[0].find(p1);
  99   BOOST_CHECK( psm1_i != gt.path_segments[0].end() );
 100   BOOST_CHECK_EQUAL( psm1_i->second.start.x, 1); //start segment x coordinate
 101   BOOST_CHECK_EQUAL( psm1_i->second.end.x, 1); //end segment x coordinate
 102   BOOST_CHECK_EQUAL( psm1_i->second.length, 5);
 103   // there should be two paths, the sizes don't match
 104   BOOST_CHECK_EQUAL( psm1_i->second.path_ids.size(), 2 );
 105
 106   // look at the second row
 107   GlSeqBrowser::segment_key p2(3,3);
 108   GlSeqBrowser::pair_segment_map::iterator psm2_i = gt.path_segments[1].find(p2);
 109   BOOST_CHECK( psm2_i != gt.path_segments[1].end() );
 110   BOOST_CHECK_EQUAL( psm2_i->second.start.x, 3); //start segment x coordinate
 111   BOOST_CHECK_EQUAL( psm2_i->second.end.x, 3); //end segment x coordinate
 112   BOOST_CHECK_EQUAL( psm2_i->second.length, 3);
 113 }
 114
 115 BOOST_AUTO_TEST_CASE( glseqbrowser_center )
 116 {
 117   string s0("AAGGCCTT");
 118   string s1("TTGGCCAA");
 119   string s2("GATTACAA");
 120   Sequence seq0(s0);
 121   Sequence seq1(s1);
 122   Sequence seq2(s2);
 123   boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
 124   GlSequence glseq0(seq0, cm);
 125   GlSequence glseq1(seq1, cm);
 126   GlSequence glseq2(seq2, cm);
 127
 128   GlSeqBrowser gt;
 129   gt.push_sequence(glseq0);
 130   gt.push_sequence(glseq1);
 131   gt.push_sequence(glseq2);
 132
 133   vector<int> path;
 134   path += 0,3,7;
 135
 136   BOOST_CHECK_EQUAL( gt.left(), -gt.border() );
 137   BOOST_CHECK_EQUAL( gt.right(), s0.size() + gt.border() );
 138
 139   gt.centerOnPath(path);
 140
 141   // I didn't bother to compute how the path should shift things
 142   // by the magic number 3, i just ran the test and saw how it failed
 143   // and hard coded this in.
 144   BOOST_CHECK_EQUAL( gt.left(), -18-gt.border() );
 145   BOOST_CHECK_EQUAL( gt.right(), s0.size() + gt.border()-11 );
 146
 147   // aparently we end up with a different glsequence in the seqbrowser
 148   BOOST_CHECK( glseq1.x() != gt.sequences()[1]->x() );
 149
 150   BOOST_CHECK_EQUAL( gt.sequences()[0]->x(), (gt.viewportCenter()-15)-path[0] );
 151   BOOST_CHECK_EQUAL( gt.sequences()[1]->x(), (gt.viewportCenter()-15)-path[1] );
 152   BOOST_CHECK_EQUAL( gt.sequences()[2]->x(), (gt.viewportCenter()-15)-path[2] );
 153 }
 154
 155 BOOST_AUTO_TEST_CASE( setSelectedPaths )
 156 {
 157   string s0("AAGGCCTT");
 158   string s1("TTGGCCAA");
 159   string s2("GATTACAA");
 160   Sequence seq0(s0);
 161   Sequence seq1(s1);
 162   Sequence seq2(s2);
 163
 164   GlSeqBrowser gt;
 165   gt.push_sequence(seq0);
 166   gt.push_sequence(seq1);
 167   gt.push_sequence(seq2);
 168
 169   // make up some sample data
 170   vector<bool> rc;
 171   rc += false, false, false;
 172   vector<int> path;
 173                 path += 1,1,1; gt.link(path, rc, 1);
 174   path.clear(); path += 1,1,3; gt.link(path, rc, 1);
 175   path.clear(); path += 2,3,3; gt.link(path, rc, 1);
 176   path.clear(); path += 3,3,3; gt.link(path, rc, 1);
 177
 178   vector<int> selected;
 179   selected += 1,4;
 180   BOOST_CHECK_EQUAL( gt.selectedPaths().size(), 0 );
 181   gt.setSelectedPaths(selected);
 182   BOOST_CHECK_EQUAL( gt.selectedPaths().size(), selected.size() );
 183   gt.clear_selection();
 184   BOOST_CHECK_EQUAL( gt.selectedPaths().size(), 0);
 185 }
 186
 187 BOOST_AUTO_TEST_CASE( setSelectedTracks )
 188 {
 189   string s0("AAGGCCTT");
 190   string s1("TTGGCCAA");
 191   string s2("GATTACAA");
 192   Sequence seq0(s0);
 193   Sequence seq1(s1);
 194   Sequence seq2(s2);
 195
 196   GlSeqBrowser gt;
 197   gt.push_sequence(seq0);
 198   gt.push_sequence(seq1);
 199   gt.push_sequence(seq2);
 200
 201   BOOST_CHECK_EQUAL( gt.selectedTracks().size(), 0 );
 202   gt.appendSelectedTrack(0, 0, seq0.size());
 203   gt.appendSelectedTrack(2, 0, seq2.size());
 204   BOOST_CHECK_EQUAL( gt.selectedTracks().size(), 2 );
 205
 206   list<Sequence> selected_sequence;
 207   BOOST_CHECK_EQUAL(selected_sequence.size(), 0);
 208   gt.copySelectedTracksAsSequences(selected_sequence);
 209   BOOST_CHECK_EQUAL(selected_sequence.size(), 2);
 210   BOOST_CHECK_EQUAL(selected_sequence.front(), seq0);
 211   BOOST_CHECK_EQUAL(selected_sequence.back(), seq2);
 212
 213   gt.clear_selection();
 214   BOOST_CHECK_EQUAL( gt.selectedPaths().size(), 0);
 215
 216   gt.appendSelectedTrack(0, 0, 2);
 217   list<SequenceLocation> seq_locs;
 218   gt.copySelectedTracksAsSeqLocation(seq_locs);
 219   BOOST_CHECK_EQUAL(seq_locs.size(), 1);
 220   BOOST_CHECK_EQUAL(seq_locs.front().getSequence(), seq0);
 221   BOOST_CHECK_EQUAL(seq_locs.front().getLeft(), 0);
 222   BOOST_CHECK_EQUAL(seq_locs.front().getRight(), 2);
 223 }