make mupa file loading eol-style insensitive

[mussa.git] / alg / test / test_mussa.cpp

diff --git a/alg/test/test_mussa.cpp b/alg/test/test_mussa.cpp
index cfa873515c7234d3ffbd8646c7d8be9db9ceb6c4..e1cef22fb6cda9e9213e04e0642bd6306e05a8ab 100644 (file)
--- a/alg/test/test_mussa.cpp
+++ b/alg/test/test_mussa.cpp
@@ -1,3 +1,4 @@
+#define BOOST_AUTO_TEST_MAIN
 #include <boost/test/auto_unit_test.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/filesystem/operations.hpp>
@@ -109,6 +110,25 @@ BOOST_AUTO_TEST_CASE ( empty_mussa_set_threshold )
   m.nway();
 }
 
+BOOST_AUTO_TEST_CASE( mussa_load_mupa_crlf )
+{
+  fs::path example_path(EXAMPLE_DIR, fs::native);
+  fs::path seq_path(example_path / "seq" / "mouse_mck_pro.fa");
+  fs::path annot_path(example_path / "mm_mck3test.annot");
+
+  std::string mupa(
+    "# hello\015\012"
+    "ANA_NAME load_mupa_crlf\015\012");
+  mupa += "SEQUENCE " + seq_path.native_file_string() + "\015\012";
+  mupa += "ANNOTATION " + annot_path.native_file_string() + "\015\012";
+  
+  istringstream mupa_stream(mupa);
+  Mussa m;
+  fs::path base;
+  m.load_mupa_stream( mupa_stream, base );
+  // Should run with no exceptions
+}
+
 BOOST_AUTO_TEST_CASE( mussa_load_mupa )
 {
   fs::path mupa_path(EXAMPLE_DIR, fs::native);
@@ -151,6 +171,17 @@ BOOST_AUTO_TEST_CASE( mussa_load_full_path )
   BOOST_CHECK_EQUAL( m1.is_dirty(), true);
   BOOST_CHECK_EQUAL( m1.get_analysis_path().string(), "");
 }
+  
+BOOST_AUTO_TEST_CASE( mussa_valid_motifs_in_new_analysis )
+{
+  Mussa m1;
+  fs::path full_path(fs::path(EXAMPLE_DIR, fs::native) / "mck3test.mupa");
+  m1.load_mupa_file( full_path );
+  m1.analyze();
+  // check motifs
+  BOOST_CHECK( m1.sequences().size() > 0 );
+  BOOST_CHECK_EQUAL( m1.sequences()[0]->motifs().size(), 0 );  
+}
 
 // make sure we know that mupa files cannot be directories 
 BOOST_AUTO_TEST_CASE( mussa_mupa_is_file_not_directory )
@@ -160,6 +191,14 @@ BOOST_AUTO_TEST_CASE( mussa_mupa_is_file_not_directory )
   BOOST_CHECK_THROW(m1.load_mupa_file( curdir ), mussa_load_error );
 }
 
+// catch error if annotation isn't a file
+BOOST_AUTO_TEST_CASE( mussa_annotation_is_not_file )
+{
+  Mussa m1;
+  fs::path full_path(fs::path(EXAMPLE_DIR, fs::native) / "directory.mupa");
+  BOOST_CHECK_THROW( m1.load_mupa_file( full_path ), mussa_load_error );
+}
+
 BOOST_AUTO_TEST_CASE( mussa_load_analysis )
 {
   fs::path example_dir(EXAMPLE_DIR, fs::native);
@@ -360,9 +399,9 @@ BOOST_AUTO_TEST_CASE( mussa_add_motif )
 }
 
 static void 
-local_align_test(const Mussa::vector_sequence_type &seqs, 
-                 const list<ConservedPath::path_type>& result,
-                 const list<vector<bool> >& reversed)
+two_way_local_align_test(const Mussa::vector_sequence_type &seqs, 
+                         const list<ConservedPath::path_type>& result,
+                         const list<vector<bool> >& reversed)
 {
   map<char, vector <char> >  m;
   assign::insert(m)('A', assign::list_of('A')('T') )
@@ -390,9 +429,8 @@ local_align_test(const Mussa::vector_sequence_type &seqs,
     BOOST_CHECK_EQUAL( first_basepair, complimented_second) ;
   }
 }
-
                  
-BOOST_AUTO_TEST_CASE( local_alignment )
+BOOST_AUTO_TEST_CASE( two_way_local_alignment )
 {
   string s0("GCGCATAT");
   string s1("AAAAAAAT");
@@ -405,6 +443,8 @@ BOOST_AUTO_TEST_CASE( local_alignment )
   analysis.set_window(4);
   analysis.analyze();
   NwayPaths npath = analysis.paths();
+  BOOST_REQUIRE_EQUAL( npath.pathz.size(), 2 );
+  
   list<ConservedPath::path_type> result;
   list<vector<bool> > reversed;
   list<ConservedPath>::iterator pathz_i = npath.pathz.begin();
@@ -416,7 +456,7 @@ BOOST_AUTO_TEST_CASE( local_alignment )
                                 result,
                                 reversed);
 
-  local_align_test(analysis.sequences(), result, reversed);
+  two_way_local_align_test(analysis.sequences(), result, reversed);
 
   ++pathz_i;
   result.clear();
@@ -427,9 +467,64 @@ BOOST_AUTO_TEST_CASE( local_alignment )
                                 selected_paths.end(),
                                 result,
                                 reversed);
-  local_align_test(analysis.sequences(), result, reversed);
+  two_way_local_align_test(analysis.sequences(), result, reversed);
+}
 
+BOOST_AUTO_TEST_CASE( three_way_local_alignment )
+{
+  string s0("AGCAGGGAGGGTTTAAATGGCACCCAGCAGTTGGTGTGAGG");
+  string s1("AGCGGGAAGGGTTTAAATGGCACCGGGCAGTTGGCGTGAGG");
+  string s2("CAGCGCCGGGGTTTAAATGGCACCGAGCAGTTGGCGCAGGG");
+  
+  Mussa analysis;
+  analysis.append_sequence(s0);
+  analysis.append_sequence(s1);
+  analysis.append_sequence(s2);
+  analysis.set_threshold(23);
+  analysis.set_window(30);
+  analysis.analyze();
+  NwayPaths npath = analysis.paths();
+  BOOST_CHECK_EQUAL( npath.refined_pathz.size(), 1 );
+  
+  list<ConservedPath::path_type> result;
+  list<vector<bool> > reversed;
+  // grab 1 path (since there's only one)
+  list<ConservedPath>::iterator pathz_i = npath.pathz.begin();
+  list<ConservedPath> selected_paths;
+  selected_paths.push_back(*pathz_i);
+  analysis.createLocalAlignment(selected_paths.begin(), 
+                                selected_paths.end(),
+                                result,
+                                reversed);
+                                
+  for(std::list<ConservedPath::path_type>::iterator result_i = result.begin();
+      result_i != result.end();
+      ++result_i)
+  {
+    ConservedPath::path_element first_element = *(result_i->begin());
+    for (ConservedPath::path_type::iterator element_i = result_i->begin();
+         element_i != result_i->end();
+         ++element_i)
+    {
+      BOOST_CHECK_EQUAL( *element_i, first_element );
+      BOOST_CHECK_EQUAL( s0[*element_i], s1[*element_i] );
+      BOOST_CHECK_EQUAL( s1[*element_i], s2[*element_i] );
+      BOOST_CHECK_EQUAL( s0[*element_i], s2[*element_i] );
+    }
+  }   
+}
 
+BOOST_AUTO_TEST_CASE( mussa_window_larger_than_sequence )
+{
+  string s0("AGCAGGG");
+  string s1("CAGCGGG");
+  
+  Mussa analysis;
+  analysis.append_sequence(s0);
+  analysis.append_sequence(s1);
+  analysis.set_threshold(23);
+  analysis.set_window(30);
+  BOOST_CHECK_THROW(analysis.analyze(), seqcomp_error);
 }
 
 BOOST_AUTO_TEST_CASE( subanalysis )