alg/test/test_glseqbrowser.cpp

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