Update mussa to build on ubuntu 10.04 with qt 4.6.2 +boost 1.40.0.1

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

diff --git a/alg/test/test_conserved_path.cpp b/alg/test/test_conserved_path.cpp
index b28c63573f63bde8d86a3e4e433ff199b9ec1954..2ccea3bbfba5b4fd0bb8da3a4baa4562e7ea5a52 100644 (file)
--- a/alg/test/test_conserved_path.cpp
+++ b/alg/test/test_conserved_path.cpp
@@ -1,4 +1,7 @@
-#include <boost/test/auto_unit_test.hpp>
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE test_conserved_path
+#include <boost/test/unit_test.hpp>
+
 #include <boost/assign/std/vector.hpp>
 using namespace boost::assign;
 
@@ -22,7 +25,7 @@ BOOST_AUTO_TEST_CASE ( conserved_path_simple )
   cp1.track_indexes = path;
   BOOST_CHECK_EQUAL( cp1.size(), path.size() );
 
-  ConservedPath cp2(18, path);
+  ConservedPath cp2(20, 18, path);
   BOOST_CHECK_EQUAL (cp1, cp2);
   BOOST_CHECK_EQUAL( cp2.size(), path.size() );
 
@@ -63,29 +66,49 @@ BOOST_AUTO_TEST_CASE ( conserved_path_vector )
   BOOST_CHECK_EQUAL( cp.size(), 1 );
 }
 
+// does the reverse compliment test work?
+BOOST_AUTO_TEST_CASE ( conserved_path_reverse_compliment ) 
+{
+  vector<int> path;
+  path += 3,4,-5,1; // magic from boost assign
+
+  ConservedPath cp1(20, 10, path);
+  vector<bool> reversed = cp1.reverseComplimented();
+
+  BOOST_CHECK_EQUAL( path.size(), reversed.size());
+  vector<int>::iterator path_i = path.begin();
+  vector<bool>::iterator reversed_i = reversed.begin();
+  for(; path_i != path.end() and reversed_i != reversed.end(); 
+      ++path_i, ++reversed_i)
+  {
+    // if we're less than zero our reversed flag should be true
+    BOOST_CHECK_EQUAL( *path_i < 0, *reversed_i);
+  }
+}
+
 BOOST_AUTO_TEST_CASE ( extended_conserved_path_simple ) 
 {
   vector<int> path;
   path += 3,4,5,1; // magic from boost assign
 
-  ExtendedConservedPath ecp1;
+  ConservedPath ecp1;
   ecp1.window_size = 30;
   ecp1.score = 18;
   ecp1.track_indexes = path;
   BOOST_CHECK_EQUAL ( ecp1.size(), path.size() );
 
-  ExtendedConservedPath ecp2(30, 18.0, path);
+  ConservedPath ecp2(30, 18.0, path);
   BOOST_CHECK_EQUAL ( ecp1, ecp2 );
   BOOST_CHECK_EQUAL ( ecp2.size(), path.size() );
 
-  ExtendedConservedPath ecp_ne(35, 20.0, path);
+  ConservedPath ecp_ne(35, 20.0, path);
   BOOST_CHECK(ecp2 != ecp_ne);
 
   ConservedPath cp1;
   cp1.score = 18;
   cp1.track_indexes = path;
 
-  ExtendedConservedPath ecp3(30, cp1);
+  ConservedPath ecp3(cp1);
   BOOST_CHECK_EQUAL( ecp2, ecp3 );
   BOOST_CHECK_EQUAL( ecp3.size(), path.size() );
 }
@@ -103,10 +126,10 @@ BOOST_AUTO_TEST_CASE ( extended_conserved_path_growth )
   path_not_next += 4,5,6,5; 
   const int window_size = 4;
 
-  ExtendedConservedPath ecp_base(window_size, 20, path_base);
-  ConservedPath cp_next(25, path_next);
-  ConservedPath cp_next_reversed(25, path_next_reversed);
-  ConservedPath cp_not_next(22, path_not_next);
+  ConservedPath ecp_base(window_size, 20, path_base);
+  ConservedPath cp_next(window_size, 25, path_next);
+  ConservedPath cp_next_reversed(window_size, 25, path_next_reversed);
+  ConservedPath cp_not_next(window_size, 22, path_not_next);
 
   BOOST_CHECK(ecp_base.nextTo(cp_next));
   BOOST_CHECK(!ecp_base.nextTo(cp_not_next));
@@ -117,3 +140,83 @@ BOOST_AUTO_TEST_CASE ( extended_conserved_path_growth )
   ecp_base.extend(growth);
   BOOST_CHECK_EQUAL( ecp_base.window_size, window_size + growth );
 }
+
+BOOST_AUTO_TEST_CASE ( extended_conserved_normalized ) 
+{
+  vector<int> path;
+  path += 3,-14,5,-19; // magic from boost assign
+  vector<int> normalized_path;
+  normalized_path += 3,4, 5,9;
+
+  ConservedPath ecp1;
+  ecp1.window_size = 10;
+  ecp1.score = 18;
+  ecp1.track_indexes = path;
+  BOOST_CHECK_EQUAL ( ecp1.size(), path.size() );
+
+  vector<ConservedPath::path_element> normalized_index(ecp1.normalizedIndexes());
+ 
+  for(int i=0; i != ecp1.size(); ++i)
+  {
+    BOOST_CHECK_EQUAL(normalized_index[i], normalized_path[i]);
+  }
+}
+
+BOOST_AUTO_TEST_CASE( conserved_path_less_than )
+{
+  vector<int> p111;
+  p111 += 1,1,1;
+  vector<int> p112;
+  p112 += 1,1,2;
+  vector<int> p115;
+  p115 += 1,1,5; 
+  vector<int> p112a;
+  p112a += 1,1,1;
+  vector<int> p1111;
+  p1111 += 1,1,1,1; 
+  
+  ConservedPath cp111(10, 1.0, p111);
+  ConservedPath cp112(10, 1.0, p112);
+  ConservedPath cp112a(10, 1.0, p112a);
+  ConservedPath cp115(10, 1.0, p115);
+  ConservedPath cp1111(10, 1.0, p1111);
+  
+  BOOST_CHECK_EQUAL( cp111 < cp112, true );
+  BOOST_CHECK_EQUAL( cp111 < cp1111, true );
+  BOOST_CHECK_EQUAL( cp1111 < cp111, false );
+  BOOST_CHECK_EQUAL( cp112 < cp112, false );
+  BOOST_CHECK_EQUAL( cp112 == cp112, true );
+  BOOST_CHECK_EQUAL( cp112 < cp115, true );
+}
+
+BOOST_AUTO_TEST_CASE( conserved_path_sort )
+{
+  vector<int> p111;
+  p111 += 1,1,1;
+  vector<int> p112;
+  p112 += 1,1,2;
+  vector<int> p115;
+  p115 += 1,1,5;
+  vector<int> p121;
+  p121 += 1,2,1; 
+
+  ConservedPath cp111(10, 1.0, p111);
+  ConservedPath cp112(10, 1.0, p112);
+  ConservedPath cp115(10, 1.0, p115);
+  ConservedPath cp121(10, 1.0, p121);
+  
+  list<ConservedPath> paths;
+  paths.push_back(cp115);
+  paths.push_back(cp121);
+  paths.push_back(cp112);
+  paths.push_back(cp111);
+  
+  paths.sort();
+  BOOST_REQUIRE_EQUAL( paths.size(), 4 );
+  list<ConservedPath>::const_iterator path_i = paths.begin();
+  
+  BOOST_CHECK_EQUAL( *path_i, cp111 ); ++path_i;
+  BOOST_CHECK_EQUAL( *path_i, cp112 ); ++path_i;
+  BOOST_CHECK_EQUAL( *path_i, cp115 ); ++path_i;
+  BOOST_CHECK_EQUAL( *path_i, cp121 );
+}