alg/test/test_glseqbrowser.cpp

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