1 #define BOOST_AUTO_TEST_MAIN
2 #include <boost/test/auto_unit_test.hpp>
3 #include <boost/test/floating_point_comparison.hpp>
4 #include <boost/shared_ptr.hpp>
8 #include "alg/annotation_colors.hpp"
9 #include "alg/glsequence.hpp"
10 #include "alg/sequence.hpp"
14 BOOST_AUTO_TEST_CASE ( glsequence_operator_assignment )
16 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
17 string s0("AAGGCCTT");
18 string s1("TTGGCCAA");
22 GlSequence glseq0(seq0, cm);
23 BOOST_CHECK (glseq0.get_sequence() == s0);
24 GlSequence glseq1(seq1, cm);
25 GlSequence glseq_copy0(glseq0);
27 BOOST_CHECK(glseq_copy0.get_sequence() == glseq0.get_sequence());
28 BOOST_CHECK( glseq_copy0.get_sequence() == glseq0.get_sequence());
31 BOOST_CHECK( glseq0.get_sequence() == s1 );
34 BOOST_AUTO_TEST_CASE( glsequence_copy_constructor )
36 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
37 string s0("AAAAAAGGGGGG");
39 GlSequenceRef glsp0(new GlSequence(s0, cm));
41 BOOST_CHECK_EQUAL(glsp0->get_sequence(), s0);
42 BOOST_CHECK_EQUAL(glsp0->y(), 100.0);
44 GlSequenceRef glsp0ref(glsp0);
45 GlSequenceRef glsp0copy(new GlSequence(glsp0));
46 BOOST_CHECK_EQUAL(glsp0->get_sequence(), s0);
47 BOOST_CHECK_EQUAL(glsp0->y(), 100.0);
48 BOOST_CHECK_EQUAL(glsp0ref->get_sequence(), s0);
49 BOOST_CHECK_EQUAL(glsp0ref->y(), 100.0);
50 BOOST_CHECK_EQUAL(glsp0copy->get_sequence(), s0);
51 BOOST_CHECK_EQUAL(glsp0copy->y(), 100.0);
54 BOOST_CHECK_EQUAL(glsp0->y(), 50.0);
55 BOOST_CHECK_EQUAL(glsp0ref->y(), 50.0);
56 BOOST_CHECK_EQUAL(glsp0copy->y(), 100.0);
58 glsp0copy->setY(75.0);
59 BOOST_CHECK_EQUAL(glsp0->y(), 50.0);
60 BOOST_CHECK_EQUAL(glsp0ref->y(), 50.0);
61 BOOST_CHECK_EQUAL(glsp0copy->y(), 75.0);
64 BOOST_AUTO_TEST_CASE( glsequence_color )
66 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
67 boost::shared_ptr<Color> black(new Color(0.0, 0.0, 0.0, 1.0));
68 boost::shared_ptr<Color> c(new Color(0.1, 0.2, 0.3, 0.4));
69 Sequence seq("AAGGCCTT");
70 GlSequence s(seq, cm);
72 BOOST_CHECK_EQUAL(*s.color(), *black );
74 BOOST_CHECK_EQUAL( *(s.color()), *c );
77 BOOST_AUTO_TEST_CASE( glsequence_find_null_sequence )
79 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
80 GlSequence s("AAAAAAAAAANNNNNANAN", cm);
81 // 0123456789012345678
82 s.add_annotations_for_undefined_sequence();
84 BOOST_CHECK_EQUAL(s.annotations().size(), 3);
85 std::vector<SeqSpanRef> annot(s.annotations().begin(), s.annotations().end());
86 BOOST_CHECK_EQUAL(annot[0]->start(), 10);
87 BOOST_CHECK_EQUAL(annot[0]->stop(), 15);
88 BOOST_CHECK_EQUAL(annot[1]->start(), 16);
89 BOOST_CHECK_EQUAL(annot[1]->size(), 1);
90 BOOST_CHECK_EQUAL(annot[2]->start(), 18);
91 BOOST_CHECK_EQUAL(annot[2]->size(), 1);
94 BOOST_AUTO_TEST_CASE( glsequence_renderable )
96 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
97 Sequence seq("AAGGCCTT");
98 GlSequence s(seq, cm);
100 // way more base pairs than viewport pixel width
101 BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 1000, 500), false );
102 // way fewer basepairs than viewport pixel width
103 BOOST_CHECK_EQUAL(s.is_sequence_renderable( 0, 10, 500), true);
105 BOOST_CHECK_CLOSE((double)s.pixelWidth(0, 100, 100), 1.0, 1e-6);
106 BOOST_CHECK_CLOSE((double)s.pixelWidth(0, 1000, 100), 10.0, 1e-6);
109 BOOST_AUTO_TEST_CASE( glsequence_sequence )
111 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
112 string seq_string("AAGGCCTTNNAAGGCCTTNNAAGGCCTTNN");
113 string::size_type seqlen = seq_string.size();
114 Sequence seq(seq_string);
115 GlSequence glseq(seq, cm);
117 BOOST_CHECK( glseq.region_begin(0, 50) == seq.begin() );
118 // always make sure we return seq.end() regardless of how much extra
120 BOOST_CHECK( glseq.region_end(0, seqlen+10) == seq.end() );
121 // do we get the right end pointer?
122 BOOST_CHECK( glseq.region_end(0, 5) == seq.begin()+5 );
124 // when we request far too much sequence what do we get?
125 BOOST_CHECK( glseq.region_begin(seqlen+10, seqlen+20) == seq.end() );
126 BOOST_CHECK( glseq.region_end(seqlen+10, seqlen+20) == seq.end() );
128 // we cant ask for reversed sequences with region_begin/end
129 BOOST_CHECK( glseq.region_begin(10, 5) == seq.end() );
130 BOOST_CHECK( glseq.region_end(10, 5) == seq.end() );
132 Sequence::const_iterator seq_itor;
134 // if we as for an empty segment? start and end should equal
135 seq_itor = glseq.region_begin(10, 10);
136 BOOST_CHECK( seq_itor == glseq.region_end(10, 10) );
138 // reuse seq_itor downhere
139 string::const_iterator str_itor;
140 for(str_itor = seq.begin(),
141 seq_itor = glseq.begin();
142 str_itor != seq.end() and
143 seq_itor != glseq.end();
144 ++str_itor, ++seq_itor)
146 BOOST_CHECK_EQUAL( *str_itor, *seq_itor );
150 // make sure the computation of the leftmost and rightmost base is correct
151 BOOST_AUTO_TEST_CASE( glsequence_leftright_base )
153 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
154 std::string seq_string = "AAGGCCTT";
155 Sequence seq(seq_string);
156 GlSequence glseq(seq, cm);
158 BOOST_CHECK_EQUAL( glseq.leftbase( -50.0 ), 0 );
159 BOOST_CHECK_EQUAL( glseq.leftbase( 0.5 ), 1 );
160 BOOST_CHECK_EQUAL( glseq.leftbase( 5.0 ), 5 );
161 BOOST_CHECK_EQUAL( glseq.leftbase( 500.0 ), seq_string.size() );
162 BOOST_CHECK_EQUAL( glseq.rightbase( 0.0 ), 0 );
163 BOOST_CHECK_EQUAL( glseq.rightbase( 1000.0 ), seq_string.size() );
164 BOOST_CHECK_EQUAL( glseq.rightbase( seq_string.size()-0.5),
165 seq_string.size()-1);
168 // do our left and right most base computations still work if
169 // we move the sequence around?
170 BOOST_AUTO_TEST_CASE( glsequence_movex )
172 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
173 std::string seq_string = "AAGGCCTTAAGGCCTT";
174 Sequence seq(seq_string);
175 GlSequence glseq(seq, cm);
178 BOOST_CHECK_EQUAL( glseq.leftbase(-100.0), 0 );
179 BOOST_CHECK_EQUAL( glseq.leftbase( 0.0), 5 );
180 BOOST_CHECK_EQUAL( glseq.leftbase( -2.0), 3 );
181 BOOST_CHECK_EQUAL( glseq.leftbase( 100.0), seq_string.size() );
182 BOOST_CHECK_EQUAL( glseq.rightbase( 1000.0 ), seq_string.size() );
183 BOOST_CHECK_EQUAL( glseq.rightbase( 8.0 ), 8+5 );
184 BOOST_CHECK_EQUAL( glseq.rightbase( -7.0 ), 0 );
188 BOOST_AUTO_TEST_CASE( glsequence_check_iterators )
190 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
191 std::string seq_string = "AAGGCCTTAAGGCCTT";
192 Sequence seq(seq_string);
193 GlSequence glseq(seq, cm);
195 Sequence::const_iterator seq_begin_i;
196 Sequence::const_iterator seq_end_i;
198 BOOST_CHECK(glseq.region_begin(5, -5) == seq.end());
199 BOOST_CHECK(glseq.region_begin(0, 20) == seq.begin());
200 BOOST_CHECK(glseq.region_begin(10,20) == seq.begin()+10);
202 BOOST_CHECK(glseq.region_end(5, -5) == seq.end());
203 BOOST_CHECK(glseq.region_end(0, 20) == seq.end());
204 BOOST_CHECK(glseq.region_end(0, 10) == seq.begin()+10);
207 BOOST_CHECK(glseq.region_begin(0, 10) == seq.begin()+5);
208 BOOST_CHECK(glseq.region_end(0, 15) == seq.end());
211 BOOST_AUTO_TEST_CASE( glsequence_subseq )
213 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
214 boost::shared_ptr<Color> c(new Color(1.0, 0.5, 0.5));
216 GlSequence seq("AAGGCCTT", cm);
219 GlSequence subseq = seq.subseq(4,2);
220 BOOST_CHECK_EQUAL(subseq.get_sequence(), "CC");
221 BOOST_CHECK_EQUAL(subseq.color(), c);
225 BOOST_AUTO_TEST_CASE ( shared_ptr_test )
227 boost::shared_ptr<AnnotationColors> cm(new AnnotationColors);
228 // I don't trust my operator= hack so lets make sure it works.
229 string s0("AAGGCCTT");
230 string s1("TTGGCCAA");
232 BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
234 BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
236 // make a block to test deallocation
238 GlSequence glseq0(seq0, cm);
239 BOOST_CHECK_EQUAL(seq0.use_count(), 2);
240 GlSequence glseq1(seq1, cm);
241 BOOST_CHECK_EQUAL(seq1.use_count(), 2);
244 BOOST_CHECK_EQUAL( seq0.use_count(), 1 );
245 BOOST_CHECK_EQUAL( seq1.use_count(), 3 );
247 BOOST_CHECK_EQUAL(seq0.use_count(), 1);
248 BOOST_CHECK_EQUAL(seq1.use_count(), 1);