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   BOOST_CHECK_EQUAL(span1->strand(), SeqSpan::PlusStrand);
  16 }
  17
  18 BOOST_AUTO_TEST_CASE( seqspan_from_string_with_alphabet )
  19 {
  20   std::string str1("AAGGCCUU");
  21   SeqSpanRef span1(new SeqSpan(str1, reduced_rna_alphabet));
  22   BOOST_CHECK_EQUAL(span1->length(), str1.length());
  23   BOOST_CHECK_EQUAL(span1->sequence(), str1);
  24   BOOST_CHECK_EQUAL(span1->get_alphabet(), Alphabet::reduced_rna_alphabet());
  25 }
  26
  27 BOOST_AUTO_TEST_CASE( seqspan_from_string_with_alphabet_and_plusstrand )
  28 {
  29   std::string str1("AAGGCCUU");
  30   SeqSpanRef span1(new SeqSpan(str1, reduced_rna_alphabet, SeqSpan::PlusStrand));
  31   BOOST_CHECK_EQUAL(span1->length(), str1.length());
  32   BOOST_CHECK_EQUAL(span1->sequence(), str1);
  33   BOOST_CHECK_EQUAL(span1->get_alphabet(), Alphabet::reduced_rna_alphabet());
  34   BOOST_CHECK_EQUAL(span1->strand(), SeqSpan::PlusStrand);
  35 }
  36
  37 BOOST_AUTO_TEST_CASE( seqspan_from_string_with_alphabet_and_singlestrand )
  38 {
  39   std::string str1("AAAAGCT");
  40   SeqSpanRef span1(new SeqSpan(str1, reduced_dna_alphabet, SeqSpan::SingleStrand));
  41   BOOST_CHECK_EQUAL(span1->length(), str1.length());
  42   BOOST_CHECK_EQUAL(span1->sequence(), str1);
  43   BOOST_CHECK_EQUAL(span1->get_alphabet(), Alphabet::reduced_dna_alphabet());
  44   // we always store strands as Plus
  45   BOOST_CHECK_EQUAL(span1->strand(), SeqSpan::SingleStrand);
  46   BOOST_CHECK_EQUAL(span1->sequence(), "AAAAGCT");
  47   BOOST_CHECK_THROW(span1->subseq(0,2,SeqSpan::OppositeStrand), sequence_invalid_strand);
  48 }
  49
  50 BOOST_AUTO_TEST_CASE( seqspan_from_string_with_invalidstrand )
  51 {
  52   std::string s("AAAAGCT");
  53   BOOST_CHECK_THROW(SeqSpan(s, reduced_dna_alphabet, SeqSpan::UnknownStrand), sequence_invalid_strand);
  54   BOOST_CHECK_THROW(SeqSpan(s, reduced_dna_alphabet, SeqSpan::BothStrand), sequence_invalid_strand);
  55   BOOST_CHECK_THROW(SeqSpan(s, reduced_dna_alphabet, SeqSpan::SameStrand), sequence_invalid_strand);
  56   BOOST_CHECK_THROW(SeqSpan(s, reduced_dna_alphabet, SeqSpan::OppositeStrand), sequence_invalid_strand);
  57   BOOST_CHECK_THROW(SeqSpan(s, reduced_dna_alphabet, SeqSpan::BothStrand), sequence_invalid_strand);
  58 }
  59
  60 BOOST_AUTO_TEST_CASE( seqspan_from_seqspan )
  61 {
  62   std::string str1("AAGGCCTT");
  63   SeqSpanRef span1(new SeqSpan(str1));
  64   SeqSpanRef span2(new SeqSpan(span1));
  65   SeqSpanRef span3(new SeqSpan(span1));
  66
  67   BOOST_CHECK_EQUAL(span1->length(), str1.length());
  68   BOOST_CHECK_EQUAL(span1->sequence(), str1);
  69   BOOST_CHECK_EQUAL(span1->length(), span2->length());
  70   BOOST_CHECK_EQUAL(span2->sequence(), str1);
  71
  72   BOOST_CHECK_EQUAL(span1->length(), span3->length());
  73   BOOST_CHECK_EQUAL(span3->sequence(), str1);
  74 }
  75
  76 BOOST_AUTO_TEST_CASE( seqspan_copy )
  77 {
  78   SeqSpanRef span1(new SeqSpan("AAAAGGGG"));
  79   SeqSpanRef span2 = span1->subseq(0,4);
  80   SeqSpanRef span2ref(span2);
  81   SeqSpanRef span2copy(new SeqSpan(span2));
  82
  83   BOOST_CHECK_EQUAL(span2->start(), 0);
  84   BOOST_CHECK_EQUAL(span2ref->start(), 0);
  85   BOOST_CHECK_EQUAL(span2copy->start(), 0);
  86
  87   span2->setStart(2);
  88   BOOST_CHECK_EQUAL(span2->start(), 2);
  89   BOOST_CHECK_EQUAL(span2ref->start(), 2);
  90   BOOST_CHECK_EQUAL(span2copy->start(), 0);
  91 }
  92
  93 BOOST_AUTO_TEST_CASE( seqspan_equality )
  94 {
  95   std::string str1("AAGGCCTT");
  96   std::string str2("AACCGGTT");
  97   std::string str3("AACCGGTT");
  98   SeqSpanRef span1(new SeqSpan(str1));
  99   SeqSpanRef span1copy(new SeqSpan(span1));
 100   SeqSpanRef span2(new SeqSpan(str2));
 101   SeqSpanRef span3(new SeqSpan(str3));
 102
 103   BOOST_CHECK_EQUAL(*span1, *span1copy);
 104   BOOST_CHECK(*span1 != *span3);
 105   // if its different source strings, compare the underlying string
 106   BOOST_CHECK(*span2 != *span3);
 107   BOOST_CHECK_EQUAL(SeqSpan::isFamily(*span2, *span3), false);
 108 }
 109
 110 BOOST_AUTO_TEST_CASE( seqspan_parents )
 111 {
 112   std::string str1("AAGGCCTT");
 113   std::string str2("AACCGGTT");
 114   SeqSpanRef s1(new SeqSpan(str1));
 115   SeqSpanRef s1_1 = s1->subseq(2,4);
 116   SeqSpanRef s2(new SeqSpan(str2));
 117   SeqSpanRef s2_1 = s2->subseq(0,2);
 118
 119   BOOST_CHECK_EQUAL(s1, s1_1->parent());
 120   BOOST_CHECK_EQUAL(s2, s2_1->parent());
 121   BOOST_CHECK(s1 != s2_1->parent());
 122   BOOST_CHECK(s2 != s1_1->parent());
 123
 124   SeqSpanRef s2_copy = s2;
 125
 126   BOOST_CHECK_EQUAL(s2_copy, s2_1->parent());
 127 }
 128
 129 BOOST_AUTO_TEST_CASE( seqspan_find_first_not_of )
 130 {
 131   std::string str1("AAAAT");
 132   SeqSpan seq1(str1);
 133   BOOST_CHECK_EQUAL(seq1.find_first_not_of("A"), str1.find_first_not_of("A"));
 134
 135   std::string str2("AATTGGCC");
 136   SeqSpan seq2(str2);
 137   BOOST_CHECK_EQUAL(seq2.find_first_not_of("qwer"), str2.find_first_not_of("qwer"));
 138 }
 139
 140 BOOST_AUTO_TEST_CASE( seqspan_at )
 141 {
 142   std::string str1("AAGGCCTT");
 143   SeqSpanRef seq1(new SeqSpan(str1));
 144   SeqSpanRef seq2(new SeqSpan(seq1, 2, 2));
 145
 146   BOOST_CHECK_EQUAL( seq1->at(0), str1.at(0) );
 147   BOOST_CHECK_EQUAL( seq1->at(2), seq2->at(0) );
 148   BOOST_CHECK_EQUAL( str1[2], seq2->at(0) );
 149   BOOST_CHECK_EQUAL( (*seq1)[0], seq1->at(0) );
 150   BOOST_CHECK_EQUAL( (*seq1)[2], (*seq2)[0] );
 151
 152   SeqSpanRef seq3 = seq1->subseq(0, 4, SeqSpan::OppositeStrand);
 153   BOOST_CHECK_EQUAL( seq3->at(0), 'C');
 154   BOOST_CHECK_EQUAL( seq3->at(1), 'C');
 155   BOOST_CHECK_EQUAL( seq3->at(2), 'T');
 156   BOOST_CHECK_EQUAL( seq3->at(3), 'T');
 157
 158 }
 159
 160 BOOST_AUTO_TEST_CASE( seqspan_data )
 161 {
 162   std::string str1("AAGGCCTT");
 163   SeqSpanRef seq1(new SeqSpan(str1));
 164   SeqSpanRef seq2(new SeqSpan(seq1, 3, 2));
 165
 166   BOOST_REQUIRE_EQUAL( str1.length(), seq1->length());
 167   BOOST_CHECK_EQUAL( str1.data(), seq1->data() );
 168   std::string str1sub = str1.substr(3,2);
 169   BOOST_REQUIRE_EQUAL( seq2->size(), str1sub.size() );
 170   BOOST_REQUIRE_EQUAL( seq2->length(), str1sub.length() );
 171   for (int i = 0; i != seq2->size(); ++i) {
 172     BOOST_CHECK_EQUAL( seq2->data()[i], str1sub.data()[i] );
 173   }
 174 }
 175
 176 BOOST_AUTO_TEST_CASE( seqspan_begin_end )
 177 {
 178   std::string str1("AAGGCCTT");
 179   SeqSpanRef seq1(new SeqSpan(str1));
 180   SeqSpanRef seq2(new SeqSpan(seq1, 2, 2));
 181
 182   BOOST_CHECK(seq1->begin() + 2 == seq2->begin());
 183
 184   std::string::const_iterator str1_i = str1.begin();
 185   SeqSpan::const_iterator seq1_i = seq1->begin();
 186   for(; not ((str1_i == str1.end()) or (seq1_i == seq1->end())); ++str1_i, ++seq1_i) {
 187     BOOST_CHECK_EQUAL( *str1_i, *seq1_i );
 188   }
 189 }
 190
 191 BOOST_AUTO_TEST_CASE( seqspan_subseq_reverse_begin_end )
 192 {
 193   std::string str1("AAAACCTT");
 194   std::string str1rc("AAGGTTTT");
 195   SeqSpanRef seq1(new SeqSpan(str1));
 196   SeqSpanRef seq2(new SeqSpan(seq1, 0, SeqSpan::npos, SeqSpan::OppositeStrand ));
 197
 198
 199   std::string::const_iterator str1rc_i = str1rc.begin();
 200   SeqSpan::const_iterator seq2_i = seq2->begin();
 201   for(; not ((str1rc_i == str1rc.end()) or (seq2_i == seq2->end())); ++str1rc_i, ++seq2_i) {
 202     BOOST_CHECK_EQUAL( *str1rc_i, *seq2_i );
 203   }
 204 }
 205
 206 BOOST_AUTO_TEST_CASE( seqspan_rbegin_rend )
 207 {
 208   std::string str1("AAGGCCTT");
 209   SeqSpanRef seq1(new SeqSpan(str1));
 210
 211   std::string::const_reverse_iterator str1_i = str1.rbegin();
 212   SeqSpan::const_reverse_iterator seq1_i = seq1->rbegin();
 213   for(; seq1_i != seq1->rend(); ++str1_i, ++seq1_i) {
 214     BOOST_CHECK_EQUAL( *str1_i, *seq1_i );
 215   }
 216 }
 217
 218 BOOST_AUTO_TEST_CASE( seqspan_empty_start_stop )
 219 {
 220   SeqSpanRef s1(new SeqSpan(""));
 221   BOOST_CHECK_EQUAL( s1->start(), 0 );
 222   BOOST_CHECK_EQUAL( s1->stop(), 0 );
 223
 224   BOOST_CHECK_EQUAL( s1->parentStart(), 0 );
 225   BOOST_CHECK_EQUAL( s1->parentStop(), 0 );
 226
 227   BOOST_CHECK_EQUAL( s1->size(), 0 );
 228 }
 229
 230 BOOST_AUTO_TEST_CASE( seqspan_global_start_stop )
 231 {
 232   std::string seq_string("AAGGCCTT");
 233   SeqSpanRef s1(new SeqSpan(seq_string));
 234   BOOST_CHECK_EQUAL( s1->start(), 0 );
 235   BOOST_CHECK_EQUAL( s1->stop(), seq_string.size() );
 236
 237   std::string s2seq_string = seq_string.substr(2,3);
 238   SeqSpanRef s2 = s1->subseq(2,3);
 239   BOOST_CHECK_EQUAL( s2->start(), 2);
 240   BOOST_CHECK_EQUAL( s2->stop(), 2+3);
 241   BOOST_CHECK_EQUAL( s2->size(), 3);
 242   BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
 243
 244   std::string s3seq_string = s2seq_string.substr(1,1);
 245   SeqSpanRef s3 = s2->subseq(1,1);
 246   BOOST_CHECK_EQUAL( s3->start(), 2+1 );
 247   BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
 248   BOOST_CHECK_EQUAL( s3->size(), 1);
 249   BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
 250 }
 251
 252 BOOST_AUTO_TEST_CASE( seqspan_global_to_large )
 253 {
 254   std::string seq_string("AAGGCCTT");
 255   SeqSpanRef s1(new SeqSpan(seq_string));
 256   BOOST_CHECK_EQUAL( s1->start(), 0 );
 257   BOOST_CHECK_EQUAL( s1->stop(), seq_string.size() );
 258
 259   std::string s2seq_string = seq_string.substr(2,3);
 260   SeqSpanRef s2 = s1->subseq(4,8);
 261   BOOST_CHECK_EQUAL( s2->start(), 4);
 262   BOOST_CHECK_EQUAL( s2->size(), 4);
 263   BOOST_CHECK_EQUAL( s2->stop(), 8);
 264 }
 265
 266 BOOST_AUTO_TEST_CASE( seqspan_parent_start_stop )
 267 {
 268   std::string seq_string("AAGGCCTT");
 269   SeqSpanRef s1(new SeqSpan(seq_string));
 270   BOOST_CHECK_EQUAL( s1->parentStart(), 0 );
 271   BOOST_CHECK_EQUAL( s1->parentStop(), seq_string.size() );
 272
 273   std::string s2seq_string = seq_string.substr(2,3);
 274   SeqSpanRef s2 = s1->subseq(2,3);
 275   BOOST_CHECK_EQUAL( s2->parentStart(), 2);
 276   BOOST_CHECK_EQUAL( s2->parentStop(), 2+3);
 277   BOOST_CHECK_EQUAL( s2->size(), 3);
 278   BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
 279
 280   std::string s3seq_string = s2seq_string.substr(1,1);
 281   SeqSpanRef s3 = s2->subseq(1,1);
 282   BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
 283   BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
 284   BOOST_CHECK_EQUAL( s3->size(), 1);
 285   BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
 286 }
 287
 288 BOOST_AUTO_TEST_CASE( seqspan_global_mutable_start_stop )
 289 {
 290   std::string seq_string("AAGGCCTT");
 291   SeqSpanRef s1(new SeqSpan(seq_string));
 292
 293   std::string s2seq_string = seq_string.substr(2,3);
 294   SeqSpanRef s2 = s1->subseq(2,3);
 295   BOOST_CHECK_EQUAL( s2->start(), 2);
 296   BOOST_CHECK_EQUAL( s2->stop(), 2+3);
 297   BOOST_CHECK_EQUAL( s2->size(), 3);
 298   BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
 299
 300   std::string s3seq_string = s2seq_string.substr(1,1);
 301   SeqSpanRef s3 = s2->subseq(1,1);
 302   // Check root location
 303   BOOST_CHECK_EQUAL( s3->start(), 2+1 );
 304   BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
 305   BOOST_CHECK_EQUAL( s3->size(), 1);
 306   // Check parent location
 307   BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
 308   BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
 309   BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
 310
 311   // Extend s2 to the left
 312   s2->setStart(1);
 313   BOOST_CHECK_EQUAL( s2->start(), 1);
 314   BOOST_CHECK_EQUAL( s2->stop(), 1+1+3);
 315   BOOST_CHECK_EQUAL( s2->size(), 4);
 316
 317   // Child sequence should have the same global location
 318   BOOST_CHECK_EQUAL( s3->start(), 2+1 );
 319   BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
 320   BOOST_CHECK_EQUAL( s3->size(), 1);
 321   // Child sequence should now have different parent location
 322   BOOST_CHECK_EQUAL( s3->parentStart(), 2 );
 323   BOOST_CHECK_EQUAL( s3->parentStop(), 2+1);
 324   BOOST_CHECK_EQUAL( s3->size(), 1);
 325 }
 326
 327 BOOST_AUTO_TEST_CASE( seqspan_global_mutable_start_stop_minus_strand )
 328 {
 329   std::string seq_string("AAAAGCTA");
 330   SeqSpanRef s1(new SeqSpan(seq_string));
 331
 332   SeqSpanRef s2 = s1->subseq(2,3, SeqSpan::MinusStrand);
 333   BOOST_CHECK_EQUAL( s2->start(), 2);
 334   BOOST_CHECK_EQUAL( s2->stop(), 2+3);
 335   BOOST_CHECK_EQUAL( s2->size(), 3);
 336   BOOST_CHECK_EQUAL( s2->sequence(), "CTT");
 337
 338   SeqSpanRef s3 = s2->subseq(1,2, SeqSpan::SameStrand);
 339   BOOST_CHECK_EQUAL(s3->sequence(), "TT");
 340
 341   // Could also argue that it should be CT
 342   // if you assume that the locations are all relative to the global sequence
 343   // and are then reverse complemented
 344
 345   s2->setStart(1);
 346   BOOST_CHECK_EQUAL( s2->sequence(), "CTTT");
 347 }
 348
 349 BOOST_AUTO_TEST_CASE( seqspan_parent_mutable_start_stop )
 350 {
 351   std::string seq_string("AAGGCCTT");
 352   SeqSpanRef s1(new SeqSpan(seq_string));
 353
 354   std::string s2seq_string = seq_string.substr(3,3);
 355   SeqSpanRef s2 = s1->subseq(3,3);
 356   BOOST_CHECK_EQUAL( s2->start(), 3);
 357   BOOST_CHECK_EQUAL( s2->stop(), 3+3);
 358   BOOST_CHECK_EQUAL( s2->size(), 3);
 359   BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
 360
 361   std::string s3seq_string = s2seq_string.substr(1,1);
 362   SeqSpanRef s3 = s2->subseq(1,1);
 363   // Check root location
 364   BOOST_CHECK_EQUAL( s3->start(), 3+1 );
 365   BOOST_CHECK_EQUAL( s3->stop(), 3+1+1);
 366   BOOST_CHECK_EQUAL( s3->size(), 1);
 367   // Check parent location
 368   BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
 369   BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
 370   BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
 371
 372   // s2 should now be equivalent to s1->subseq(1,5)
 373   s2->setParentStart(1);
 374   BOOST_CHECK_EQUAL( s2->start(), 1);
 375   BOOST_CHECK_EQUAL( s2->stop(), 3+3);
 376   BOOST_CHECK_EQUAL( s2->size(), 5);
 377
 378   // Child sequence should have the same global location
 379   BOOST_CHECK_EQUAL( s3->start(), 3+1 );
 380   BOOST_CHECK_EQUAL( s3->stop(), 3+1+1);
 381   BOOST_CHECK_EQUAL( s3->size(), 1);
 382   // Child sequence should now have different parent location
 383   BOOST_CHECK_EQUAL( s3->parentStart(),  1+2);
 384   BOOST_CHECK_EQUAL( s3->parentStop(), 1+2+1);
 385 }
 386
 387 // what happens if we set a stop past our actual end
 388 BOOST_AUTO_TEST_CASE( seqspan_stop_past_end )
 389 {
 390   std::string seq_string("AAGGCCTT");
 391   SeqSpanRef s1(new SeqSpan(seq_string));
 392   std::string s2seq_string = seq_string.substr(3,3);
 393   SeqSpanRef s2 = s1->subseq(3,3);
 394   std::string s3seq_string = s2seq_string.substr(1,1);
 395   SeqSpanRef s3 = s2->subseq(1,1);
 396
 397   // should be limited by our parent sequence
 398   s3->setStop(8);
 399   BOOST_CHECK_EQUAL( s3->size(), 2);
 400
 401   s2->setStop(8);
 402   BOOST_CHECK_EQUAL( s2->size(), 5);
 403
 404   s3->setStop(8);
 405   BOOST_CHECK_EQUAL( s3->size(), 4);
 406 }
 407
 408 BOOST_AUTO_TEST_CASE( seqspan_strand_sameother )
 409 {
 410   SeqSpanRef seq1(new SeqSpan("AAAAAGGGGG"));
 411   BOOST_CHECK_EQUAL(seq1->strand(), SeqSpan::PlusStrand);
 412
 413   SeqSpanRef seq2 = seq1->subseq(0,4,SeqSpan::SameStrand);
 414   BOOST_CHECK_EQUAL(seq2->sequence(), "AAAA");
 415   BOOST_CHECK_EQUAL(seq2->strand(), SeqSpan::PlusStrand);
 416   SeqSpanRef seq3 = seq1->subseq(0,4,SeqSpan::OppositeStrand);
 417   BOOST_CHECK_EQUAL(seq3->sequence(), "TTTT");
 418   BOOST_CHECK_EQUAL(seq3->strand(), SeqSpan::MinusStrand);
 419
 420   // opposite of a plus strand should be minus
 421   SeqSpanRef seq4 = seq2->subseq(0,4,SeqSpan::OppositeStrand);
 422   BOOST_CHECK_EQUAL(seq4->sequence(), "TTTT");
 423   BOOST_CHECK_EQUAL(seq4->strand(), SeqSpan::MinusStrand);
 424   // opposite of a minus strand should be plus
 425   SeqSpanRef seq5 = seq3->subseq(0,4,SeqSpan::OppositeStrand);
 426   BOOST_CHECK_EQUAL(seq5->sequence(), "AAAA");
 427   BOOST_CHECK_EQUAL(seq5->strand(), SeqSpan::PlusStrand);
 428 }
 429
 430 BOOST_AUTO_TEST_CASE( seqspan_strand_plusminus )
 431 {
 432   SeqSpanRef seq1(new SeqSpan("AAAAAGGGGG"));
 433   BOOST_CHECK_EQUAL(seq1->strand(), SeqSpan::PlusStrand);
 434
 435   SeqSpanRef seq2 = seq1->subseq(0,4,SeqSpan::PlusStrand);
 436   BOOST_CHECK_EQUAL(seq2->sequence(), "AAAA");
 437   SeqSpanRef seq3 = seq1->subseq(0,4,SeqSpan::MinusStrand);
 438   BOOST_CHECK_EQUAL(seq3->sequence(), "TTTT");
 439 }
 440