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