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