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