Getting closer to a subanalysis mode

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

diff --git a/alg/test/test_glsequence.cpp b/alg/test/test_glsequence.cpp
index 32fc0ad9cc10aa7f8624e3c5aeddff6aeee70003..b0aa6ad545a8d4ec2ab1a1610e458302a0e6cf8c 100644 (file)
--- a/alg/test/test_glsequence.cpp
+++ b/alg/test/test_glsequence.cpp
@@ -1,5 +1,6 @@
 #include <boost/test/auto_unit_test.hpp>
 #include <boost/test/floating_point_comparison.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include <string>
 
@@ -9,14 +10,14 @@
 
 using namespace std;
 
-BOOST_AUTO_TEST_CASE ( glsequence_operator_equal )
+BOOST_AUTO_TEST_CASE ( glsequence_operator_assignment )
 {
-  AnnotationColors cm;
-  // I don't trust my operator = hack so lets make sure it works.
+  boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
+  // I don't trust my operator= hack so lets make sure it works.
   string s0("AAGGCCTT");
   string s1("TTGGCCAA");
-  Sequence seq0(s0);
-  Sequence seq1(s1);
+  boost::shared_ptr<Sequence> seq0(new Sequence(s0));
+  boost::shared_ptr<Sequence> seq1(new Sequence(s1));
 
   GlSequence glseq0(seq0, cm);
   BOOST_CHECK (glseq0.sequence() == s0);
@@ -27,16 +28,15 @@ BOOST_AUTO_TEST_CASE ( glsequence_operator_equal )
   BOOST_CHECK( &(glseq_copy0.sequence()) == &(glseq0.sequence()));
 
   glseq0 = glseq1;
-
   BOOST_CHECK( glseq0.sequence() == s1 );
 }
 
 BOOST_AUTO_TEST_CASE( glsequence_color )
 {
-  AnnotationColors cm;
+  boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
   Color black(0.0, 0.0, 0.0, 0.0);
   Color c(0.1, 0.2, 0.3, 0.4);
-  Sequence seq("AAGGCCTT");
+  boost::shared_ptr<Sequence> seq(new Sequence("AAGGCCTT"));
   GlSequence s(seq, cm);
   
   BOOST_CHECK_EQUAL(s.color(), black );
@@ -46,8 +46,8 @@ BOOST_AUTO_TEST_CASE( glsequence_color )
 
 BOOST_AUTO_TEST_CASE( glsequence_renderable )
 {
-  AnnotationColors cm;
-  Sequence seq("AAGGCCTT");
+  boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
+  boost::shared_ptr<Sequence> seq(new Sequence("AAGGCCTT"));
   GlSequence s(seq, cm);
 
   // way more base pairs than viewport pixel width 
@@ -61,26 +61,26 @@ BOOST_AUTO_TEST_CASE( glsequence_renderable )
 
 BOOST_AUTO_TEST_CASE( glsequence_sequence )
 {
-  AnnotationColors cm;
+  boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
   string seq_string("AAGGCCTTNNAAGGCCTTNNAAGGCCTTNN");
   string::size_type seqlen = seq_string.size();
-  Sequence seq(seq_string);
+  boost::shared_ptr<Sequence> seq(new Sequence(seq_string));
   GlSequence glseq(seq, cm);
 
-  BOOST_CHECK( glseq.sequence_begin(0, 50) == seq.begin() );
-  // always make sure we return seq.end() regardless of how much extra
+  BOOST_CHECK( glseq.sequence_begin(0, 50) == seq->begin() );
+  // always make sure we return seq->end() regardless of how much extra
   // is asked for
-  BOOST_CHECK( glseq.sequence_end(0, seqlen+10) == seq.end() );
+  BOOST_CHECK( glseq.sequence_end(0, seqlen+10) == seq->end() );
   // do we get the right end pointer?
-  BOOST_CHECK( glseq.sequence_end(0, 5) == seq.begin()+5 );
+  BOOST_CHECK( glseq.sequence_end(0, 5) == seq->begin()+5 );
 
   // when we request far too much sequence what do we get?
-  BOOST_CHECK( glseq.sequence_begin(seqlen+10, seqlen+20) == seq.end() );
-  BOOST_CHECK( glseq.sequence_end(seqlen+10, seqlen+20) == seq.end() );
+  BOOST_CHECK( glseq.sequence_begin(seqlen+10, seqlen+20) == seq->end() );
+  BOOST_CHECK( glseq.sequence_end(seqlen+10, seqlen+20) == seq->end() );
 
   // we cant ask for reversed sequences with sequence_begin/end
-  BOOST_CHECK( glseq.sequence_begin(10, 5) == seq.end() );
-  BOOST_CHECK( glseq.sequence_end(10, 5) == seq.end() );
+  BOOST_CHECK( glseq.sequence_begin(10, 5) == seq->end() );
+  BOOST_CHECK( glseq.sequence_end(10, 5) == seq->end() );
 
   Sequence::const_iterator seq_itor;
 
@@ -90,9 +90,9 @@ BOOST_AUTO_TEST_CASE( glsequence_sequence )
 
   // reuse seq_itor downhere 
   string::const_iterator str_itor;
-  for(str_itor = seq.begin(),
+  for(str_itor = seq->begin(),
       seq_itor = glseq.sequence_begin();
-      str_itor != seq.end() and 
+      str_itor != seq->end() and 
       seq_itor != glseq.sequence_end();
       ++str_itor, ++seq_itor)
   {
@@ -103,9 +103,9 @@ BOOST_AUTO_TEST_CASE( glsequence_sequence )
 // make sure the computation of the leftmost and rightmost base is correct
 BOOST_AUTO_TEST_CASE( glsequence_leftright_base )
 {
-  AnnotationColors cm;
+  boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
   std::string seq_string = "AAGGCCTT";
-  Sequence seq(seq_string);
+  boost::shared_ptr<Sequence> seq(new Sequence(seq_string));
   GlSequence glseq(seq, cm);
 
   BOOST_CHECK_EQUAL( glseq.leftbase( -50.0 ), 0 );
@@ -122,9 +122,9 @@ BOOST_AUTO_TEST_CASE( glsequence_leftright_base )
 // we move the sequence around?
 BOOST_AUTO_TEST_CASE( glsequence_movex )
 {
-  AnnotationColors cm;
+  boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
   std::string seq_string = "AAGGCCTTAAGGCCTT";
-  Sequence seq(seq_string);
+  boost::shared_ptr<Sequence> seq(new Sequence(seq_string));
   GlSequence glseq(seq, cm);
 
   glseq.setX(-5);
@@ -140,23 +140,51 @@ BOOST_AUTO_TEST_CASE( glsequence_movex )
 // Check iterators
 BOOST_AUTO_TEST_CASE( glsequence_check_iterators )
 {
-  AnnotationColors cm;
+  boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
   std::string seq_string = "AAGGCCTTAAGGCCTT";
-  Sequence seq(seq_string);
+  boost::shared_ptr<Sequence> seq(new Sequence(seq_string));
   GlSequence glseq(seq, cm);
 
   Sequence::const_iterator seq_begin_i;
   Sequence::const_iterator seq_end_i;
 
-  BOOST_CHECK(glseq.sequence_begin(5, -5) == seq.end());
-  BOOST_CHECK(glseq.sequence_begin(0, 20) == seq.begin());
-  BOOST_CHECK(glseq.sequence_begin(10,20) == seq.begin()+10);
+  BOOST_CHECK(glseq.sequence_begin(5, -5) == seq->end());
+  BOOST_CHECK(glseq.sequence_begin(0, 20) == seq->begin());
+  BOOST_CHECK(glseq.sequence_begin(10,20) == seq->begin()+10);
 
-  BOOST_CHECK(glseq.sequence_end(5, -5) == seq.end());
-  BOOST_CHECK(glseq.sequence_end(0, 20) == seq.end());
-  BOOST_CHECK(glseq.sequence_end(0, 10) == seq.begin()+10);
+  BOOST_CHECK(glseq.sequence_end(5, -5) == seq->end());
+  BOOST_CHECK(glseq.sequence_end(0, 20) == seq->end());
+  BOOST_CHECK(glseq.sequence_end(0, 10) == seq->begin()+10);
 
   glseq.setX(-5);
-  BOOST_CHECK(glseq.sequence_begin(0, 10) == seq.begin()+5);
-  BOOST_CHECK(glseq.sequence_end(0, 15) == seq.end());
+  BOOST_CHECK(glseq.sequence_begin(0, 10) == seq->begin()+5);
+  BOOST_CHECK(glseq.sequence_end(0, 15) == seq->end());
 }
+
+BOOST_AUTO_TEST_CASE ( shared_ptr_test )
+{
+  boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
+  // I don't trust my operator= hack so lets make sure it works.
+  string s0("AAGGCCTT");
+  string s1("TTGGCCAA");
+  boost::shared_ptr<Sequence> seq0(new Sequence(s0));
+  BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
+  boost::shared_ptr<Sequence> seq1(new Sequence(s1));
+  BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
+
+  // make a block to test deallocation
+  {
+    GlSequence glseq0(seq0, cm);
+    BOOST_CHECK_EQUAL(seq0.use_count(), 2);
+    GlSequence glseq1(seq1, cm);
+    BOOST_CHECK_EQUAL(seq1.use_count(), 2);
+
+    glseq0 = glseq1;
+    BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
+    BOOST_CHECK_EQUAL( seq1.use_count(), 3 );
+  }
+  BOOST_CHECK_EQUAL(seq0.use_count(), 1);
+  BOOST_CHECK_EQUAL(seq1.use_count(), 1);
+}
+
+