alg/test/test_sequence.cpp

   1 #include <boost/test/auto_unit_test.hpp>
   2 #include <boost/filesystem/path.hpp>
   3 #include <boost/filesystem/operations.hpp>
   4 namespace fs=boost::filesystem;
   5
   6 #include <list>
   7 #include <iostream>
   8 #include <sstream>
   9
  10 #include <boost/archive/text_oarchive.hpp>
  11 #include <boost/archive/text_iarchive.hpp>
  12 #include <boost/archive/xml_oarchive.hpp>
  13 #include <boost/archive/xml_iarchive.hpp>
  14
  15 #include "alg/sequence.hpp"
  16 #include "mussa_exceptions.hpp"
  17
  18 using namespace std;
  19
  20 //! when we try to load a missing file, do we get an error?
  21 BOOST_AUTO_TEST_CASE( sequence_load_exception )
  22 {
  23   Sequence s;
  24   // there should be errors when we try to load something that doesn't exist
  25   BOOST_CHECK_THROW( s.load_fasta("alkejralk", 1, 0, 0), mussa_load_error);
  26   BOOST_CHECK_THROW( s.load_annot("alkejralk", 0, 0), mussa_load_error);
  27 }
  28
  29 BOOST_AUTO_TEST_CASE( sequence_eol_conventions )
  30 {
  31   string header(">Header");
  32   string line1("AAAAGGGGCCCCTTTTT");
  33   string line2("AAAAGGGGCCCCTTTTT");
  34   int seq_len = line1.size() + line2.size();
  35
  36   stringstream cr;
  37   cr << header << "\015" << line1 << "\015" << line2 << "\015";
  38   Sequence seq_cr;
  39   seq_cr.load_fasta(cr);
  40
  41   stringstream crlf;
  42   crlf << header << "\015\012" << line1 << "\015\012" << line2 << "\015\012";
  43   Sequence seq_crlf;
  44   seq_crlf.load_fasta(crlf);
  45
  46   stringstream lf;
  47   lf << header << "\012" << line1 << "\012" << line2 << "\012";
  48   Sequence seq_lf;
  49   seq_lf.load_fasta(lf);
  50
  51   BOOST_CHECK_EQUAL(seq_cr.size(),   seq_len);
  52   BOOST_CHECK_EQUAL(seq_crlf.size(), seq_len);
  53   BOOST_CHECK_EQUAL(seq_cr.size(),   seq_len);
  54 }
  55
  56
  57 //! Do simple operations work correctly?
  58 BOOST_AUTO_TEST_CASE( sequence_filter )
  59 {
  60   const char *core_seq = "AATTGGCC";
  61   Sequence s1(core_seq);
  62   BOOST_CHECK_EQUAL(s1, core_seq);
  63
  64   Sequence s2("aattggcc");
  65   BOOST_CHECK_EQUAL(s2, "AATTGGCC");
  66   BOOST_CHECK_EQUAL(s2.rev_comp(), "GGCCAATT");
  67   BOOST_CHECK_EQUAL(s2.size(), s2.size());
  68   BOOST_CHECK_EQUAL(s2.get_sequence(), core_seq);
  69
  70   Sequence s3("asdfg");
  71   BOOST_CHECK_EQUAL(s3, "ANNNG");
  72   BOOST_CHECK_EQUAL(s3.subseq(0,2), "AN");
  73
  74   s3.set_filtered_sequence("AAGGCCTT", 0, 2);
  75   BOOST_CHECK_EQUAL(s3, "AA");
  76   s3.set_filtered_sequence("AAGGCCTT", 2, 2);
  77   BOOST_CHECK_EQUAL( s3, "GG");
  78   s3.set_filtered_sequence("AAGGCCTT", 4);
  79   BOOST_CHECK_EQUAL( s3, "CCTT");
  80
  81   s3 = "AAGGFF";
  82   BOOST_CHECK_EQUAL(s3, "AAGGNN");
  83 }
  84
  85 BOOST_AUTO_TEST_CASE( subseq_names )
  86 {
  87   Sequence s1("AAGGCCTT");
  88   s1.set_species("species");
  89   s1.set_fasta_header("a fasta header");
  90   Sequence s2 = s1.subseq(2,2);
  91   BOOST_CHECK_EQUAL(s2, "GG");
  92   BOOST_CHECK_EQUAL(s2.get_species(), s1.get_species());
  93   BOOST_CHECK_EQUAL(s2.get_fasta_header(), s1.get_fasta_header());
  94 }
  95
  96 BOOST_AUTO_TEST_CASE( sequence_start_stop )
  97 {
  98   Sequence s1;
  99   BOOST_CHECK_EQUAL( s1.start(), 0 );
 100   BOOST_CHECK_EQUAL( s1.stop(), 0 );
 101
 102   std::string seq_string("AAGGCCTT");
 103   Sequence s2(seq_string);
 104   BOOST_CHECK_EQUAL( s2.start(), 0 );
 105   BOOST_CHECK_EQUAL( s2.stop(), seq_string.size() );
 106
 107   std::string s3seq_string = seq_string.substr(2,3);
 108   Sequence s3 = s2.subseq(2,3);
 109   BOOST_CHECK_EQUAL( s3.start(), 2);
 110   BOOST_CHECK_EQUAL( s3.stop(), 2+3);
 111   BOOST_CHECK_EQUAL( s3.size(), 3);
 112   BOOST_CHECK_EQUAL( s3, s3seq_string);
 113
 114   // FIXME: updated for ticket:129
 115   // once I have a solution for ticket:129 the commented
 116   // out version should work.
 117   //std::string s4seq_string = s3seq_string.substr(1,1);
 118   std::string s4seq_string = seq_string.substr(1,1);
 119   Sequence s4 = s2.subseq(1,1);
 120   BOOST_CHECK_EQUAL( s4.start(), 1 );
 121   BOOST_CHECK_EQUAL( s4.stop(), 1+1);
 122   BOOST_CHECK_EQUAL( s4.size(), 1);
 123   BOOST_CHECK_EQUAL( s4, s4seq_string);
 124 }
 125
 126 //! Can we load data from a file
 127 BOOST_AUTO_TEST_CASE( sequence_load )
 128 {
 129   fs::path seq_path(fs::path(EXAMPLE_DIR, fs::native)/ "seq");
 130   seq_path /=  "human_mck_pro.fa";
 131   Sequence s;
 132   s.load_fasta(seq_path);
 133   BOOST_CHECK_EQUAL(s.subseq(0, 5), "GGATC"); // first few chars of fasta file
 134   BOOST_CHECK_EQUAL(s.subseq(2, 3), "ATC");
 135   BOOST_CHECK_EQUAL(s.get_fasta_header(), "gi|180579|gb|M21487.1|HUMCKMM1 Human "
 136                                     "muscle creatine kinase gene (CKMM), "
 137                                     "5' flank");
 138 }
 139
 140 BOOST_AUTO_TEST_CASE( annotation_load )
 141 {
 142   string annot_data = "human\n"
 143                       "0 10 name   type\n"
 144                       "10 20 myf7\n"
 145                       "20 30 myod\n"
 146                       "50\t55 anothername\n"
 147                       "60 50 backward\n"
 148                       ">ident3 asdf\n"
 149                       "GCT\n"
 150                       "gCTn\n"
 151                       "75\t90\tname2\ttype2\n"
 152                       "100 120 name-asdf type!@#$%\n"
 153                       ;
 154   string s(100, 'A');
 155   s += "GCTGCTAATT";
 156   Sequence seq(s);
 157
 158   //istringstream annot_stream(annot_data);
 159   seq.parse_annot(annot_data, 0, 0);
 160   std::list<annot> annots_list = seq.annotations();
 161   std::vector<annot> annots(annots_list.begin(), annots_list.end());
 162   BOOST_REQUIRE_EQUAL( annots.size(), 8);
 163   BOOST_CHECK_EQUAL( annots[0].begin, 0 );
 164   BOOST_CHECK_EQUAL( annots[0].end, 10 );
 165   BOOST_CHECK_EQUAL( annots[0].type, "type");
 166   BOOST_CHECK_EQUAL( annots[0].name, "name");
 167   BOOST_CHECK_EQUAL( annots[1].name, "myf7");
 168   BOOST_CHECK_EQUAL( annots[2].name, "myod");
 169   BOOST_CHECK_EQUAL( annots[3].name, "anothername");
 170   BOOST_CHECK_EQUAL( annots[4].name, "backward");
 171   BOOST_CHECK_EQUAL( annots[5].name, "name2");
 172   BOOST_CHECK_EQUAL( annots[5].end, 90);
 173   BOOST_CHECK_EQUAL( annots[6].begin, 100);
 174   BOOST_CHECK_EQUAL( annots[6].end, 120);
 175   BOOST_CHECK_EQUAL( annots[6].name, "name-asdf");
 176   BOOST_CHECK_EQUAL( annots[6].type, "type!@#$%");
 177   // sequence defined annotations will always be after the
 178   // absolute positions
 179   BOOST_CHECK_EQUAL( annots[7].name, "ident3 asdf");
 180   BOOST_CHECK_EQUAL( annots[7].begin, 100);
 181
 182   //BOOST_CHECK_EQUAL( annots
 183 }
 184
 185
 186 BOOST_AUTO_TEST_CASE(annotation_ucsc_html_load)
 187 {
 188   // this actually is basically what's returned by UCSC
 189   // (well actually with some of the sequence and copies of fasta blocks
 190   // removed to make the example shorter
 191   string annot_data = "\n"
 192     "<PRE>\n"
 193     ">hg17_knownGene_NM_001824_0 range=chr19:50517919-50517974 5'pad=0 3'pad=0 revComp=TRUE strand=- repeatMasking=none\n"
 194     "GGGTCAGTGTCACCTCCAGGATACAGACAG\n"
 195     "&gt;hg17_knownGene_NM_001824_3 range=chr19:50510563-50510695 5'pad=0 3'pad=0 revComp=TRUE strand=- repeatMasking=none\n"
 196     "GGTGGAGACGACCTGGACCCTAACTACGT\n"
 197     "</PRE>\n"
 198     "\n"
 199     "</BODY>\n"
 200     "</HTML>\n"
 201     ;
 202
 203   string s =
 204     "TGGGTCAGTGTCACCTCCAGGATACAGACAGCCCCCCTTCAGCCCAGCCCAGCCAG"
 205     "AAAAA"
 206     "GGTGGAGACGACCTGGACCCTAACTACGTGCTCAGCAGCCGCGTCCGCAC";
 207   Sequence seq(s);
 208   seq.parse_annot(annot_data);
 209   std::list<annot> annots = seq.annotations();
 210   BOOST_CHECK_EQUAL( annots.size(), 2);
 211 }
 212
 213 BOOST_AUTO_TEST_CASE( annotation_load_no_species_name )
 214 {
 215   string annot_data = "0 10 name   type\n"
 216                       "10 20 myf7\n"
 217                       "20 30 myod\n"
 218                       "50\t55 anothername\n"
 219                       "60 50 backward\n"
 220                       ">ident3 asdf\n"
 221                       "GCT\n"
 222                       "gCTn\n"
 223                       "75\t90\tname2\ttype2\n"
 224                       "100 120 name-asdf type!@#$%\n"
 225                       ;
 226   string s(100, 'A');
 227   s += "GCTGCTAATT";
 228   Sequence seq(s);
 229
 230   //istringstream annot_stream(annot_data);
 231   seq.parse_annot(annot_data, 0, 0);
 232   std::list<annot> annots_list = seq.annotations();
 233   std::vector<annot> annots(annots_list.begin(), annots_list.end());
 234   BOOST_REQUIRE_EQUAL( annots.size(), 8);
 235   BOOST_CHECK_EQUAL( annots[0].begin, 0 );
 236   BOOST_CHECK_EQUAL( annots[0].end, 10 );
 237   BOOST_CHECK_EQUAL( annots[0].type, "type");
 238 }
 239
 240 // ticket:83 when you try to load a sequence from a file that doesn't
 241 // have fasta headers it crashes.
 242 BOOST_AUTO_TEST_CASE( sequence_past_end )
 243 {
 244   fs::path seq_path(fs::path(EXAMPLE_DIR, fs::native)/ "seq" );
 245   seq_path /=  "misformated_seq.fa";
 246   Sequence s;
 247   BOOST_CHECK_THROW( s.load_fasta(seq_path), mussa_load_error );
 248 }
 249
 250 BOOST_AUTO_TEST_CASE ( sequence_empty )
 251 {
 252
 253   Sequence s;
 254   BOOST_CHECK_EQUAL( s.empty(), true );
 255   s = "AAAGGG";
 256   BOOST_CHECK_EQUAL( s.empty(), false );
 257   s.clear();
 258   BOOST_CHECK_EQUAL( s.empty(), true);
 259   s = "";
 260   BOOST_CHECK_EQUAL( s.empty(), true);
 261 }
 262
 263 BOOST_AUTO_TEST_CASE ( sequence_size )
 264 {
 265
 266   Sequence s;
 267   BOOST_CHECK_EQUAL( s.size(), 0);
 268   std::string seq_string("AAAGGG");
 269   s = seq_string;
 270   BOOST_CHECK_EQUAL( s.size(), seq_string.size() );
 271   s.clear();
 272   BOOST_CHECK_EQUAL( s.size(), 0);
 273   s = "";
 274   BOOST_CHECK_EQUAL( s.size(), 0);
 275 }
 276
 277 BOOST_AUTO_TEST_CASE( sequence_empty_equality )
 278 {
 279   Sequence szero("");
 280   BOOST_CHECK_EQUAL(szero.empty(), true);
 281   BOOST_CHECK_EQUAL(szero, szero);
 282   BOOST_CHECK_EQUAL(szero, "");
 283
 284   Sequence sclear("AGCT");
 285   sclear.clear();
 286   BOOST_CHECK_EQUAL(sclear.empty(), true);
 287   BOOST_CHECK_EQUAL(sclear, sclear);
 288   BOOST_CHECK_EQUAL(sclear, szero);
 289   BOOST_CHECK_EQUAL(sclear, "");
 290
 291 }
 292 BOOST_AUTO_TEST_CASE ( sequence_iterators )
 293 {
 294   std::string seq_string = "AAGGCCTTNNTATA";
 295   Sequence s(seq_string);
 296   const Sequence cs(s);
 297   std::string::size_type count = 0;
 298
 299   std::string::iterator str_itor;
 300   Sequence::const_iterator s_itor;
 301   Sequence::const_iterator cs_itor;
 302
 303   for( str_itor = seq_string.begin(),
 304        s_itor   = s.begin(),
 305        cs_itor  = cs.begin();
 306        str_itor != seq_string.end() and
 307        s_itor   != s.end() and
 308        cs_itor  != cs.end();
 309        ++str_itor, ++s_itor, ++cs_itor, ++count)
 310   {
 311     BOOST_CHECK_EQUAL ( *str_itor, *s_itor );
 312     BOOST_CHECK_EQUAL ( *s_itor, *cs_itor );
 313     BOOST_CHECK_EQUAL ( *cs_itor, *str_itor );
 314   }
 315   BOOST_CHECK_EQUAL( seq_string.size(), count );
 316   BOOST_CHECK_EQUAL( s.size(), count );
 317   BOOST_CHECK_EQUAL( cs.size(), count );
 318 }
 319
 320 BOOST_AUTO_TEST_CASE( sequence_motifs )
 321 {
 322   string m("AAAA");
 323   string bogus("AATTGGAA");
 324   Sequence s1("AAAAGGGGCCCCTTTT");
 325
 326   list<motif>::const_iterator motif_i = s1.motifs().begin();
 327   list<motif>::const_iterator motif_end = s1.motifs().end();
 328
 329   // do our iterators work?
 330   BOOST_CHECK( motif_i == s1.motifs().begin() );
 331   BOOST_CHECK( motif_end == s1.motifs().end() );
 332   BOOST_CHECK( motif_i == motif_end );
 333
 334   // this shouldn't show up
 335   s1.add_motif(bogus);
 336   BOOST_CHECK( s1.motifs().begin() == s1.motifs().end() );
 337   BOOST_CHECK_EQUAL( s1.motifs().size(), 0 );
 338
 339   s1.add_motif(m);
 340   BOOST_CHECK( s1.motifs().begin() != s1.motifs().end() );
 341   BOOST_CHECK_EQUAL( s1.motifs().size(), 2 );
 342
 343   for(motif_i = s1.motifs().begin();
 344       motif_i != s1.motifs().end();
 345       ++motif_i)
 346   {
 347     BOOST_CHECK_EQUAL( motif_i->type, "motif" );
 348     BOOST_CHECK_EQUAL( motif_i->name, m);
 349     BOOST_CHECK_EQUAL( motif_i->sequence, m);
 350   }
 351
 352   s1.clear_motifs();
 353   BOOST_CHECK( s1.motifs().begin() == s1.motifs().end() );
 354
 355   /* FIXME: enable this when i find a way of passing storing the motif name
 356   // does our annotation travel?
 357   Sequence motif_seq(m);
 358   motif_seq.set_fasta_header("hi");
 359   s1.add_motif(motif_seq);
 360
 361   BOOST_CHECK_EQUAL(s1.motifs().size(), 2);
 362   for(motif_i = s1.motifs().begin();
 363       motif_i != s1.motifs().end();
 364       ++motif_i)
 365   {
 366     BOOST_CHECK_EQUAL( motif_i->type, "motif" );
 367     BOOST_CHECK_EQUAL( motif_i->name, "hi");
 368     BOOST_CHECK_EQUAL( motif_i->sequence, m);
 369   }
 370   */
 371 }
 372
 373 BOOST_AUTO_TEST_CASE( annot_test )
 374 {
 375   annot a(0, 10, "test", "thing");
 376
 377   BOOST_CHECK_EQUAL( a.begin, 0 );
 378   BOOST_CHECK_EQUAL( a.end,   10 );
 379   BOOST_CHECK_EQUAL( a.type,  "test" );
 380   BOOST_CHECK_EQUAL( a.name,  "thing" );
 381
 382   motif m(10, "AAGGCC");
 383   BOOST_CHECK_EQUAL( m.begin, 10 );
 384   BOOST_CHECK_EQUAL( m.type, "motif" );
 385   BOOST_CHECK_EQUAL( m.name, "AAGGCC" );
 386   BOOST_CHECK_EQUAL( m.end,  10+6 );
 387 }
 388
 389 BOOST_AUTO_TEST_CASE( annotate_from_sequence )
 390 {
 391   string s("CCGCCCCCCATCATCGCGGCTCTCCGAGAGTCCCGCGCCCCACTCCCGGC"
 392            "ACCCACCTGACCGCGGGCGGCTCCGGCCCCGCTTCGCCCCACTGCGATCA"
 393            "GTCGCGTCCCGCAGGCCAGGCACGCCCCGCCGCTCCCGCTGCGCCGGGCG"
 394            "TCTGGGACCTCGGGCGGCTCCTCCGAGGGGCGGGGCAGCCGGGAGCCACG"
 395            "CCCCCGCAGGTGAGCCGGCCACGCCCACCGCCCGTGGGAAGTTCAGCCTC"
 396            "GGGGCTCCAGCCCCGCGGGAATGGCAGAACTTCGCACGCGGAACTGGTAA"
 397            "CCTCCAGGACACCTCGAATCAGGGTGATTGTAGCGCAGGGGCCTTGGCCA"
 398            "AGCTAAAACTTTGGAAACTTTAGATCCCAGACAGGTGGCTTTCTTGCAGT");
 399   string gc("GCCCCC");
 400   string gga("GGACACCTC");
 401   Sequence seq(s);
 402
 403   std::list<Sequence> query_list;
 404   std::list<string> string_list;
 405   query_list.push_back(Sequence(gc));
 406   string_list.push_back(gc);
 407   query_list.push_back(Sequence(gga));
 408   string_list.push_back(gga);
 409
 410   BOOST_CHECK_EQUAL( seq.annotations().size(), 0 );
 411   seq.find_sequences(query_list.begin(), query_list.end());
 412
 413   int count = 0;
 414   for(list<string>::iterator string_i = string_list.begin();
 415       string_i != string_list.end();
 416       ++string_i)
 417   {
 418     string::size_type pos=0;
 419     while(pos != string::npos) {
 420       pos = s.find(*string_i, pos);
 421       if (pos != string::npos) {
 422         ++count;
 423         ++pos;
 424       }
 425     }
 426   }
 427   BOOST_CHECK_EQUAL(seq.annotations().size(), count);
 428 }
 429
 430 BOOST_AUTO_TEST_CASE( subseq_annotation_test )
 431 {
 432   string s("CCGCCCCCCATCATCGCGGCTCTCCGAGAGTCCCGCGCCCCACTCCCGGC"
 433            "ACCCACCTGACCGCGGGCGGCTCCGGCCCCGCTTCGCCCCACTGCGATCA"
 434            "GTCGCGTCCCGCAGGCCAGGCACGCCCCGCCGCTCCCGCTGCGCCGGGCG"
 435            "TCTGGGACCTCGGGCGGCTCCTCCGAGGGGCGGGGCAGCCGGGAGCCACG"
 436            "CCCCCGCAGGTGAGCCGGCCACGCCCACCGCCCGTGGGAAGTTCAGCCTC"
 437            "GGGGCTCCAGCCCCGCGGGAATGGCAGAACTTCGCACGCGGAACTGGTAA"
 438            "CCTCCAGGACACCTCGAATCAGGGTGATTGTAGCGCAGGGGCCTTGGCCA"
 439            "AGCTAAAACTTTGGAAACTTTAGATCCCAGACAGGTGGCTTTCTTGCAGT");
 440   Sequence seq(s);
 441
 442
 443   seq.add_annotation(annot(0, 10, "0-10", "0-10"));
 444   seq.add_annotation(annot(10, 20, "10-20", "10-20"));
 445   seq.add_annotation(annot(0, 20, "0-20", "0-20"));
 446   seq.add_annotation(annot(8, 12, "8-12", "8-12"));
 447   seq.add_annotation(annot(100, 5000, "100-5000", "100-5000"));
 448
 449   Sequence subseq = seq.subseq(5, 10);
 450   const list<annot> annots = subseq.annotations();
 451   // generate some ground truth
 452   list<annot> correct;
 453   correct.push_back(annot(0, 5, "0-10",  "0-10"));
 454   correct.push_back(annot(5,10, "10-20", "10-20"));
 455   correct.push_back(annot(0,10, "0-20",  "0-20"));
 456   correct.push_back(annot(3, 7, "8-12",  "8-12"));
 457   BOOST_REQUIRE_EQUAL( annots.size(), correct.size() );
 458
 459   list<annot>::iterator correct_i = correct.begin();
 460   list<annot>::const_iterator annot_i = annots.begin();
 461   for(; annot_i != annots.end(); ++annot_i, ++correct_i)
 462   {
 463     BOOST_CHECK( *annot_i == *correct_i );
 464   }
 465 }
 466
 467 BOOST_AUTO_TEST_CASE( motif_annotation_update )
 468 {
 469   string s("CCGTCCCCCATCATCGCGGCTCTCCGAGAGTCCCGCGCCCCACTCCCGGC"
 470            "ACCCACCTGACCGCGGGCGGCTCCGGCCCCGCTTCGCCCCACTGCGATCA"
 471            "GTCGCGTCCCGCAGGCCAGGCACGCCCCGCCGCTCCCGCTGCGCCGGGCG"
 472            "TCTGGGACCTCGGGCGGCTCCTCCGAGGGGCGGGGCAGCCGGGAGCCACG"
 473            "CCCCCGCAGGTGAGCCGGCCACGCCCACCGCCCGTGGGAAGTTCAGCCTC"
 474            "GGGGCTCCAGCCCCGCGGGAATGGCAGAACTTCGCACGCGGAACTGGTAA"
 475            "CCTCCAGGACACCTCGAATCAGGGTGATTGTAGCGCAGGGGCCTTGGCCA"
 476            "AGCTAAAACTTTGGAAACTTTAGATCCCAGACAGGTGGCTTTCTTGCAGT");
 477   Sequence seq(s);
 478
 479   // starting conditions
 480   BOOST_CHECK_EQUAL(seq.annotations().size(), 0);
 481   BOOST_CHECK_EQUAL(seq.motifs().size(), 0);
 482   seq.add_annotation(annot(0, 10, "0-10", "0-10"));
 483   seq.add_annotation(annot(10, 20, "10-20", "10-20"));
 484   seq.add_annotation(annot(0, 20, "0-20", "0-20"));
 485   BOOST_CHECK_EQUAL(seq.annotations().size(), 3);
 486   BOOST_CHECK_EQUAL(seq.motifs().size(), 0);
 487   seq.add_motif("CCGTCCC");
 488   BOOST_CHECK_EQUAL(seq.annotations().size(), 3);
 489   BOOST_CHECK_EQUAL(seq.motifs().size(), 1);
 490   seq.clear_motifs();
 491   BOOST_CHECK_EQUAL(seq.annotations().size(), 3);
 492   BOOST_CHECK_EQUAL(seq.motifs().size(), 0);
 493 }
 494
 495 BOOST_AUTO_TEST_CASE( out_operator )
 496 {
 497   string s("AAGGCCTT");
 498   Sequence seq(s);
 499
 500   ostringstream buf;
 501   buf << s;
 502   BOOST_CHECK_EQUAL( s, buf.str() );
 503 }
 504
 505 BOOST_AUTO_TEST_CASE( get_name )
 506 {
 507   Sequence seq("AAGGCCTT");
 508
 509   BOOST_CHECK_EQUAL( seq.get_name(), "" );
 510   seq.set_species("hooman"); // anyone remember tradewars?
 511   BOOST_CHECK_EQUAL( seq.get_name(), "hooman");
 512   seq.set_fasta_header("fasta human");
 513   BOOST_CHECK_EQUAL( seq.get_name(), "fasta human");
 514 }
 515
 516 BOOST_AUTO_TEST_CASE( serialize_simple )
 517 {
 518   std::string seq_string = "AAGGCCTT";
 519   Sequence seq(seq_string);
 520   seq.set_species("ribbet");
 521   std::ostringstream oss;
 522   // allocate/deallocate serialization components
 523   {
 524     boost::archive::text_oarchive oarchive(oss);
 525     const Sequence& const_seq(seq);
 526     BOOST_CHECK_EQUAL(seq, const_seq);
 527     oarchive << const_seq;
 528   }
 529   Sequence seq_loaded;
 530   {
 531     std::istringstream iss(oss.str());
 532     boost::archive::text_iarchive iarchive(iss);
 533     iarchive >> seq_loaded;
 534   }
 535   BOOST_CHECK_EQUAL(seq_loaded, seq);
 536   BOOST_CHECK_EQUAL(seq.get_species(), "ribbet");
 537 }
 538
 539 BOOST_AUTO_TEST_CASE( serialize_tree )
 540 {
 541   std::string seq_string = "AAGGCCTT";
 542   Sequence seq(seq_string);
 543   seq.set_species("ribbet");
 544   seq.add_motif("AA");
 545   seq.add_motif("GC");
 546   annot a1(6,7,"t","t");
 547   seq.add_annotation(a1);
 548
 549   std::ostringstream oss;
 550   // allocate/deallocate serialization components
 551   {
 552     boost::archive::text_oarchive oarchive(oss);
 553     const Sequence& const_seq(seq);
 554     BOOST_CHECK_EQUAL(seq, const_seq);
 555     oarchive << const_seq;
 556   }
 557
 558   Sequence seq_loaded;
 559   {
 560     std::istringstream iss(oss.str());
 561     boost::archive::text_iarchive iarchive(iss);
 562     iarchive >> seq_loaded;
 563   }
 564   BOOST_CHECK_EQUAL(seq_loaded, seq);
 565 }
 566
 567 // this writes out an "old" style annotated sequence
 568 // with annotations attached as "motifs" and "annots"
 569 BOOST_AUTO_TEST_CASE( serialize_xml_sequence )
 570 {
 571   std::string seq_string = "AAGGCCTT";
 572   Sequence seq(seq_string);
 573   seq.set_species("ribbet");
 574   seq.add_motif("AA");
 575   seq.add_motif("GC");
 576   annot a1(6,7,"t","t");
 577   seq.add_annotation(a1);
 578
 579   std::ostringstream oss;
 580   // allocate/deallocate serialization components
 581   {
 582     boost::archive::xml_oarchive oarchive(oss);
 583     const Sequence& const_seq(seq);
 584     BOOST_CHECK_EQUAL(seq, const_seq);
 585     oarchive << boost::serialization::make_nvp("root", const_seq);
 586   }
 587   Sequence seq_loaded;
 588   {
 589     std::istringstream iss(oss.str());
 590     boost::archive::xml_iarchive iarchive(iss);
 591     iarchive >> boost::serialization::make_nvp("root", seq_loaded);
 592   }
 593   BOOST_CHECK_EQUAL(seq_loaded, seq);
 594 }
 595
 596 BOOST_AUTO_TEST_CASE( serialize_xml_two )
 597 {
 598   std::string seq_string = "AAGGCCTT";
 599   Sequence seq1(seq_string);
 600   Sequence seq2(seq1);
 601
 602   std::ostringstream oss;
 603   // allocate/deallocate serialization components
 604   {
 605     boost::archive::xml_oarchive oarchive(oss);
 606     const Sequence& const_seq1(seq1);
 607     const Sequence& const_seq2(seq2);
 608     oarchive << boost::serialization::make_nvp("seq1", const_seq1);
 609     oarchive << boost::serialization::make_nvp("seq2", const_seq2);
 610   }
 611   //std::cout << "xml: " << oss.str() << std::endl;
 612   Sequence seq1_loaded;
 613   Sequence seq2_loaded;
 614   {
 615     std::istringstream iss(oss.str());
 616     boost::archive::xml_iarchive iarchive(iss);
 617     iarchive >> boost::serialization::make_nvp("seq1", seq1_loaded);
 618     iarchive >> boost::serialization::make_nvp("seq2", seq2_loaded);
 619   }
 620   BOOST_CHECK_EQUAL(seq1_loaded, seq1);
 621   BOOST_CHECK_EQUAL(seq2_loaded, seq2);
 622   // test if our pointers are the same
 623   BOOST_CHECK_EQUAL(seq1_loaded.c_str(), seq2_loaded.c_str());
 624 }