alg/test/test_seq_span.cpp

   1 #define BOOST_AUTO_TEST_MAIN
   2 #include <boost/test/auto_unit_test.hpp>
   3
   4 #include "seq_span.hpp"
   5 #include "mussa_exceptions.hpp"
   6
   7 #include <stdlib.h>
   8
   9 BOOST_AUTO_TEST_CASE( seqspan_from_string )
  10 {
  11   std::string str1("AAGGCCTT");
  12   SeqSpanRef span1(new SeqSpan(str1));
  13   BOOST_CHECK_EQUAL(span1->length(), str1.length());
  14   BOOST_CHECK_EQUAL(span1->sequence(), str1);
  15 }
  16
  17 BOOST_AUTO_TEST_CASE( seqspan_from_seqspan )
  18 {
  19   std::string str1("AAGGCCTT");
  20   SeqSpanRef span1(new SeqSpan(str1));
  21   SeqSpanRef span2(new SeqSpan(span1));
  22   SeqSpanRef span3(new SeqSpan(span1));
  23
  24   BOOST_CHECK_EQUAL(span1->length(), str1.length());
  25   BOOST_CHECK_EQUAL(span1->sequence(), str1);
  26   BOOST_CHECK_EQUAL(span1->length(), span2->length());
  27   BOOST_CHECK_EQUAL(span2->sequence(), str1);
  28
  29   BOOST_CHECK_EQUAL(span1->length(), span3->length());
  30   BOOST_CHECK_EQUAL(span3->sequence(), str1);
  31 }
  32
  33 BOOST_AUTO_TEST_CASE( seqspan_equality )
  34 {
  35   std::string str1("AAGGCCTT");
  36   std::string str2("AACCGGTT");
  37   std::string str3("AACCGGTT");
  38   SeqSpanRef span1(new SeqSpan(str1));
  39   SeqSpanRef span1copy(new SeqSpan(span1));
  40   SeqSpanRef span2(new SeqSpan(str2));
  41   SeqSpanRef span3(new SeqSpan(str3));
  42
  43   BOOST_CHECK_EQUAL(*span1, *span1copy);
  44   BOOST_CHECK(*span1 != *span3);
  45   // if its different source strings, compare the underlying string
  46   BOOST_CHECK(*span2 != *span3);
  47   BOOST_CHECK_EQUAL(SeqSpan::isFamily(*span2, *span3), false);
  48 }
  49
  50 BOOST_AUTO_TEST_CASE( seqspan_find_first_not_of )
  51 {
  52   std::string str1("AAAAT");
  53   SeqSpan seq1(str1);
  54   BOOST_CHECK_EQUAL(seq1.find_first_not_of("A"), str1.find_first_not_of("A"));
  55
  56   std::string str2("AATTGGCC");
  57   SeqSpan seq2(str2);
  58   BOOST_CHECK_EQUAL(seq2.find_first_not_of("qwer"), str2.find_first_not_of("qwer"));
  59 }
  60
  61 BOOST_AUTO_TEST_CASE( seqspan_at )
  62 {
  63   std::string str1("AAGGCCTT");
  64   SeqSpanRef seq1(new SeqSpan(str1));
  65   SeqSpanRef seq2(new SeqSpan(seq1, 2, 2));
  66
  67   BOOST_CHECK_EQUAL( seq1->at(0), str1.at(0) );
  68   BOOST_CHECK_EQUAL( seq1->at(2), seq2->at(0) );
  69   BOOST_CHECK_EQUAL( str1[2], seq2->at(0) );
  70   BOOST_CHECK_EQUAL( (*seq1)[0], seq1->at(0) );
  71   BOOST_CHECK_EQUAL( (*seq1)[2], (*seq2)[0] );
  72 }
  73
  74 BOOST_AUTO_TEST_CASE( seqspan_data )
  75 {
  76   std::string str1("AAGGCCTT");
  77   SeqSpanRef seq1(new SeqSpan(str1));
  78   SeqSpanRef seq2(new SeqSpan(seq1, 3, 2));
  79
  80   BOOST_REQUIRE_EQUAL( str1.length(), seq1->length());
  81   BOOST_CHECK_EQUAL( str1.data(), seq1->data() );
  82   std::string str1sub = str1.substr(3,2);
  83   BOOST_REQUIRE_EQUAL( seq2->size(), str1sub.size() );
  84   BOOST_REQUIRE_EQUAL( seq2->length(), str1sub.length() );
  85   for (int i = 0; i != seq2->size(); ++i) {
  86     BOOST_CHECK_EQUAL( seq2->data()[i], str1sub.data()[i] );
  87   }
  88 }
  89
  90 BOOST_AUTO_TEST_CASE( seqspan_begin_end )
  91 {
  92   std::string str1("AAGGCCTT");
  93   SeqSpanRef seq1(new SeqSpan(str1));
  94   SeqSpanRef seq2(new SeqSpan(seq1, 2, 2));
  95
  96   BOOST_CHECK(seq1->begin() + 2 == seq2->begin());
  97
  98   std::string::const_iterator str1_i = str1.begin();
  99   SeqSpan::const_iterator seq1_i = seq1->begin();
 100   for(; not ((str1_i == str1.end()) or (seq1_i == seq1->end())); ++str1_i, ++seq1_i) {
 101     BOOST_CHECK_EQUAL( *str1_i, *seq1_i );
 102   }
 103 }
 104
 105 BOOST_AUTO_TEST_CASE( seqspan_rbegin_rend )
 106 {
 107   std::string str1("AAGGCCTT");
 108   SeqSpanRef seq1(new SeqSpan(str1));
 109
 110   std::string::const_reverse_iterator str1_i = str1.rbegin();
 111   SeqSpan::const_reverse_iterator seq1_i = seq1->rbegin();
 112   for(; seq1_i != seq1->rend(); ++str1_i, ++seq1_i) {
 113     BOOST_CHECK_EQUAL( *str1_i, *seq1_i );
 114   }
 115 }
 116
 117 BOOST_AUTO_TEST_CASE( seqspan_empty_start_stop )
 118 {
 119   SeqSpanRef s1(new SeqSpan(""));
 120   BOOST_CHECK_EQUAL( s1->start(), 0 );
 121   BOOST_CHECK_EQUAL( s1->stop(), 0 );
 122
 123   BOOST_CHECK_EQUAL( s1->parentStart(), 0 );
 124   BOOST_CHECK_EQUAL( s1->parentStop(), 0 );
 125
 126   BOOST_CHECK_EQUAL( s1->size(), 0 );
 127 }
 128
 129 BOOST_AUTO_TEST_CASE( seqspan_global_start_stop )
 130 {
 131   std::string seq_string("AAGGCCTT");
 132   SeqSpanRef s1(new SeqSpan(seq_string));
 133   BOOST_CHECK_EQUAL( s1->start(), 0 );
 134   BOOST_CHECK_EQUAL( s1->stop(), seq_string.size() );
 135
 136   std::string s2seq_string = seq_string.substr(2,3);
 137   SeqSpanRef s2 = s1->subseq(2,3);
 138   BOOST_CHECK_EQUAL( s2->start(), 2);
 139   BOOST_CHECK_EQUAL( s2->stop(), 2+3);
 140   BOOST_CHECK_EQUAL( s2->size(), 3);
 141   BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
 142
 143   std::string s3seq_string = s2seq_string.substr(1,1);
 144   SeqSpanRef s3 = s2->subseq(1,1);
 145   BOOST_CHECK_EQUAL( s3->start(), 2+1 );
 146   BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
 147   BOOST_CHECK_EQUAL( s3->size(), 1);
 148   BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
 149 }
 150
 151 BOOST_AUTO_TEST_CASE( seqspan_global_to_large )
 152 {
 153   std::string seq_string("AAGGCCTT");
 154   SeqSpanRef s1(new SeqSpan(seq_string));
 155   BOOST_CHECK_EQUAL( s1->start(), 0 );
 156   BOOST_CHECK_EQUAL( s1->stop(), seq_string.size() );
 157
 158   std::string s2seq_string = seq_string.substr(2,3);
 159   SeqSpanRef s2 = s1->subseq(4,8);
 160   BOOST_CHECK_EQUAL( s2->start(), 4);
 161   BOOST_CHECK_EQUAL( s2->size(), 4);
 162   BOOST_CHECK_EQUAL( s2->stop(), 8);
 163 }
 164
 165 BOOST_AUTO_TEST_CASE( seqspan_parent_start_stop )
 166 {
 167   std::string seq_string("AAGGCCTT");
 168   SeqSpanRef s1(new SeqSpan(seq_string));
 169   BOOST_CHECK_EQUAL( s1->parentStart(), 0 );
 170   BOOST_CHECK_EQUAL( s1->parentStop(), seq_string.size() );
 171
 172   std::string s2seq_string = seq_string.substr(2,3);
 173   SeqSpanRef s2 = s1->subseq(2,3);
 174   BOOST_CHECK_EQUAL( s2->parentStart(), 2);
 175   BOOST_CHECK_EQUAL( s2->parentStop(), 2+3);
 176   BOOST_CHECK_EQUAL( s2->size(), 3);
 177   BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
 178
 179   std::string s3seq_string = s2seq_string.substr(1,1);
 180   SeqSpanRef s3 = s2->subseq(1,1);
 181   BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
 182   BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
 183   BOOST_CHECK_EQUAL( s3->size(), 1);
 184   BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
 185 }
 186
 187 BOOST_AUTO_TEST_CASE( seqspan_global_mutable_start_stop )
 188 {
 189   std::string seq_string("AAGGCCTT");
 190   SeqSpanRef s1(new SeqSpan(seq_string));
 191
 192   std::string s2seq_string = seq_string.substr(2,3);
 193   SeqSpanRef s2 = s1->subseq(2,3);
 194   BOOST_CHECK_EQUAL( s2->start(), 2);
 195   BOOST_CHECK_EQUAL( s2->stop(), 2+3);
 196   BOOST_CHECK_EQUAL( s2->size(), 3);
 197   BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
 198
 199   std::string s3seq_string = s2seq_string.substr(1,1);
 200   SeqSpanRef s3 = s2->subseq(1,1);
 201   // Check root location
 202   BOOST_CHECK_EQUAL( s3->start(), 2+1 );
 203   BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
 204   BOOST_CHECK_EQUAL( s3->size(), 1);
 205   // Check parent location
 206   BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
 207   BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
 208   BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
 209
 210   // Extend s2 to the left
 211   s2->setStart(1);
 212   BOOST_CHECK_EQUAL( s2->start(), 1);
 213   BOOST_CHECK_EQUAL( s2->stop(), 1+1+3);
 214   BOOST_CHECK_EQUAL( s2->size(), 4);
 215
 216   // Child sequence should have the same global location
 217   BOOST_CHECK_EQUAL( s3->start(), 2+1 );
 218   BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
 219   BOOST_CHECK_EQUAL( s3->size(), 1);
 220   // Child sequence should now have different parent location
 221   BOOST_CHECK_EQUAL( s3->parentStart(), 2 );
 222   BOOST_CHECK_EQUAL( s3->parentStop(), 2+1);
 223   BOOST_CHECK_EQUAL( s3->size(), 1);
 224 }
 225
 226 BOOST_AUTO_TEST_CASE( seqspan_parent_mutable_start_stop )
 227 {
 228   std::string seq_string("AAGGCCTT");
 229   SeqSpanRef s1(new SeqSpan(seq_string));
 230
 231   std::string s2seq_string = seq_string.substr(3,3);
 232   SeqSpanRef s2 = s1->subseq(3,3);
 233   BOOST_CHECK_EQUAL( s2->start(), 3);
 234   BOOST_CHECK_EQUAL( s2->stop(), 3+3);
 235   BOOST_CHECK_EQUAL( s2->size(), 3);
 236   BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
 237
 238   std::string s3seq_string = s2seq_string.substr(1,1);
 239   SeqSpanRef s3 = s2->subseq(1,1);
 240   // Check root location
 241   BOOST_CHECK_EQUAL( s3->start(), 3+1 );
 242   BOOST_CHECK_EQUAL( s3->stop(), 3+1+1);
 243   BOOST_CHECK_EQUAL( s3->size(), 1);
 244   // Check parent location
 245   BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
 246   BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
 247   BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
 248
 249   // s2 should now be equivalent to s1->subseq(1,5)
 250   s2->setParentStart(1);
 251   BOOST_CHECK_EQUAL( s2->start(), 1);
 252   BOOST_CHECK_EQUAL( s2->stop(), 3+3);
 253   BOOST_CHECK_EQUAL( s2->size(), 5);
 254
 255   // Child sequence should have the same global location
 256   BOOST_CHECK_EQUAL( s3->start(), 3+1 );
 257   BOOST_CHECK_EQUAL( s3->stop(), 3+1+1);
 258   BOOST_CHECK_EQUAL( s3->size(), 1);
 259   // Child sequence should now have different parent location
 260   BOOST_CHECK_EQUAL( s3->parentStart(),  1+2);
 261   BOOST_CHECK_EQUAL( s3->parentStop(), 1+2+1);
 262 }
 263
 264 // what happens if we set a stop past our actual end
 265 BOOST_AUTO_TEST_CASE( seqspan_stop_past_end )
 266 {
 267   std::string seq_string("AAGGCCTT");
 268   SeqSpanRef s1(new SeqSpan(seq_string));
 269   std::string s2seq_string = seq_string.substr(3,3);
 270   SeqSpanRef s2 = s1->subseq(3,3);
 271   std::string s3seq_string = s2seq_string.substr(1,1);
 272   SeqSpanRef s3 = s2->subseq(1,1);
 273
 274   // should be limited by our parent sequence
 275   s3->setStop(8);
 276   BOOST_CHECK_EQUAL( s3->size(), 2);
 277
 278   s2->setStop(8);
 279   BOOST_CHECK_EQUAL( s2->size(), 5);
 280
 281   s3->setStop(8);
 282   BOOST_CHECK_EQUAL( s3->size(), 4);
 283 }