There can be only one (filename convention)

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

diff --git a/alg/test/test_glsequence.cpp b/alg/test/test_glsequence.cpp
new file mode 100644 (file)
index 0000000..220b455
--- /dev/null
+++ b/alg/test/test_glsequence.cpp
@@ -0,0 +1,106 @@
+#include <boost/test/auto_unit_test.hpp>
+
+#include <string>
+
+#include "alg/glsequence.hpp"
+#include "alg/sequence.hpp"
+
+using namespace std;
+
+BOOST_AUTO_TEST_CASE ( glsequence_operator_equal )
+{
+  // 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);
+
+  GlSequence glseq0(seq0);
+  BOOST_CHECK (glseq0.sequence().get_seq() == s0);
+  GlSequence glseq1(seq1);
+  GlSequence glseq_copy0(glseq0);
+
+  BOOST_CHECK(glseq_copy0.sequence().get_seq() == glseq0.sequence().get_seq());
+  BOOST_CHECK( &(glseq_copy0.sequence()) == &(glseq0.sequence()));
+
+  glseq0 = glseq1;
+
+  BOOST_CHECK( glseq0.sequence().get_seq() == s1 );
+}
+
+BOOST_AUTO_TEST_CASE( glsequence_color )
+{
+  Color black(0.0, 0.0, 0.0, 0.0);
+  Color c(0.1, 0.2, 0.3, 0.4);
+  Sequence seq("AAGGCCTT");
+  GlSequence s(seq);
+  
+  BOOST_CHECK_EQUAL(s.color(), black );
+  s.setColor( c );
+  BOOST_CHECK_EQUAL( s.color(), c );
+}
+
+BOOST_AUTO_TEST_CASE( glsequence_renderable )
+{
+  Sequence seq("AAGGCCTT");
+  GlSequence s(seq);
+
+  // way more base pairs than viewport pixel width 
+  BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 1000, 500), false );
+  // way fewer basepairs than viewport pixel width
+  BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 10, 500), true);
+}
+
+BOOST_AUTO_TEST_CASE( glsequence_sequence )
+{
+  string seq_string("AAGGCCTTNNAAGGCCTTNNAAGGCCTTNN");
+  string::size_type seqlen = seq_string.size();
+  Sequence seq(seq_string);
+  GlSequence glseq(seq);
+
+  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() );
+  // do we get the right end pointer?
+  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() );
+
+  // 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() );
+
+  Sequence::const_iterator seq_itor;
+
+  // if we as for an empty segment? start and end should equal
+  seq_itor = glseq.sequence_begin(10, 10);
+  BOOST_CHECK( seq_itor == glseq.sequence_end(10, 10) );
+
+  // reuse seq_itor downhere 
+  string::const_iterator str_itor;
+  for(str_itor = seq.begin(),
+      seq_itor = glseq.sequence_begin();
+      str_itor != seq.end() and 
+      seq_itor != glseq.sequence_end();
+      ++str_itor, ++seq_itor)
+  {
+    BOOST_CHECK_EQUAL( *str_itor, *seq_itor );
+  }
+}
+
+// make sure the computation of the leftmost and rightmost base is correct
+BOOST_AUTO_TEST_CASE( glsequence_leftright_base )
+{
+  std::string seq_string = "AAGGCCTT";
+  Sequence seq(seq_string);
+  GlSequence glseq(seq);
+
+  BOOST_CHECK_EQUAL( glseq.leftbase( -50.0 ), 0 );
+  BOOST_CHECK_EQUAL( glseq.leftbase(   0.5 ), 1 );
+  BOOST_CHECK_EQUAL( glseq.rightbase( 1000.0 ), seq_string.size() );
+  BOOST_CHECK_EQUAL( glseq.rightbase( seq_string.size()-0.5),
+                     seq_string.size()-1);
+}