1 #define BOOST_AUTO_TEST_MAIN
2 #include <boost/test/auto_unit_test.hpp>
4 #include "seq_span.hpp"
5 #include "mussa_exceptions.hpp"
9 BOOST_AUTO_TEST_CASE( seqspan_from_string )
11 std::string str1("AAGGCCTT");
12 SeqSpanRef span1(new SeqSpan(str1));
13 BOOST_CHECK_EQUAL(span1->length(), str1.length());
14 BOOST_CHECK_EQUAL(span1->sequence(), str1);
17 BOOST_AUTO_TEST_CASE( seqspan_from_seqspan )
19 std::string str1("AAGGCCTT");
20 SeqSpanRef span1(new SeqSpan(str1));
21 SeqSpanRef span2(new SeqSpan(span1));
22 SeqSpanRef span3(new SeqSpan(span1));
24 BOOST_CHECK_EQUAL(span1->length(), str1.length());
25 BOOST_CHECK_EQUAL(span1->sequence(), str1);
26 BOOST_CHECK_EQUAL(span1->length(), span2->length());
27 BOOST_CHECK_EQUAL(span2->sequence(), str1);
29 BOOST_CHECK_EQUAL(span1->length(), span3->length());
30 BOOST_CHECK_EQUAL(span3->sequence(), str1);
33 BOOST_AUTO_TEST_CASE( seqspan_equality )
35 std::string str1("AAGGCCTT");
36 std::string str2("AACCGGTT");
37 std::string str3("AACCGGTT");
38 SeqSpanRef span1(new SeqSpan(str1));
39 SeqSpanRef span1copy(new SeqSpan(span1));
40 SeqSpanRef span2(new SeqSpan(str2));
41 SeqSpanRef span3(new SeqSpan(str3));
43 BOOST_CHECK_EQUAL(*span1, *span1copy);
44 BOOST_CHECK(*span1 != *span3);
45 // if its different source strings, compare the underlying string
46 BOOST_CHECK(*span2 != *span3);
47 BOOST_CHECK_EQUAL(SeqSpan::isFamily(*span2, *span3), false);
50 BOOST_AUTO_TEST_CASE( seqspan_find_first_not_of )
52 std::string str1("AAAAT");
54 BOOST_CHECK_EQUAL(seq1.find_first_not_of("A"), str1.find_first_not_of("A"));
56 std::string str2("AATTGGCC");
58 BOOST_CHECK_EQUAL(seq2.find_first_not_of("qwer"), str2.find_first_not_of("qwer"));
61 BOOST_AUTO_TEST_CASE( seqspan_at )
63 std::string str1("AAGGCCTT");
64 SeqSpanRef seq1(new SeqSpan(str1));
65 SeqSpanRef seq2(new SeqSpan(seq1, 2, 2));
67 BOOST_CHECK_EQUAL( seq1->at(0), str1.at(0) );
68 BOOST_CHECK_EQUAL( seq1->at(2), seq2->at(0) );
69 BOOST_CHECK_EQUAL( str1[2], seq2->at(0) );
70 BOOST_CHECK_EQUAL( (*seq1)[0], seq1->at(0) );
71 BOOST_CHECK_EQUAL( (*seq1)[2], (*seq2)[0] );
74 BOOST_AUTO_TEST_CASE( seqspan_data )
76 std::string str1("AAGGCCTT");
77 SeqSpanRef seq1(new SeqSpan(str1));
78 SeqSpanRef seq2(new SeqSpan(seq1, 3, 2));
80 BOOST_REQUIRE_EQUAL( str1.length(), seq1->length());
81 BOOST_CHECK_EQUAL( str1.data(), seq1->data() );
82 std::string str1sub = str1.substr(3,2);
83 BOOST_REQUIRE_EQUAL( seq2->size(), str1sub.size() );
84 BOOST_REQUIRE_EQUAL( seq2->length(), str1sub.length() );
85 for (int i = 0; i != seq2->size(); ++i) {
86 BOOST_CHECK_EQUAL( seq2->data()[i], str1sub.data()[i] );
90 BOOST_AUTO_TEST_CASE( seqspan_begin_end )
92 std::string str1("AAGGCCTT");
93 SeqSpanRef seq1(new SeqSpan(str1));
94 SeqSpanRef seq2(new SeqSpan(seq1, 2, 2));
96 BOOST_CHECK(seq1->begin() + 2 == seq2->begin());
98 std::string::const_iterator str1_i = str1.begin();
99 SeqSpan::const_iterator seq1_i = seq1->begin();
100 for(; not ((str1_i == str1.end()) or (seq1_i == seq1->end())); ++str1_i, ++seq1_i) {
101 BOOST_CHECK_EQUAL( *str1_i, *seq1_i );
105 BOOST_AUTO_TEST_CASE( seqspan_rbegin_rend )
107 std::string str1("AAGGCCTT");
108 SeqSpanRef seq1(new SeqSpan(str1));
110 std::string::const_reverse_iterator str1_i = str1.rbegin();
111 SeqSpan::const_reverse_iterator seq1_i = seq1->rbegin();
112 for(; seq1_i != seq1->rend(); ++str1_i, ++seq1_i) {
113 BOOST_CHECK_EQUAL( *str1_i, *seq1_i );
117 BOOST_AUTO_TEST_CASE( seqspan_empty_start_stop )
119 SeqSpanRef s1(new SeqSpan(""));
120 BOOST_CHECK_EQUAL( s1->start(), 0 );
121 BOOST_CHECK_EQUAL( s1->stop(), 0 );
123 BOOST_CHECK_EQUAL( s1->parentStart(), 0 );
124 BOOST_CHECK_EQUAL( s1->parentStop(), 0 );
126 BOOST_CHECK_EQUAL( s1->size(), 0 );
129 BOOST_AUTO_TEST_CASE( seqspan_global_start_stop )
131 std::string seq_string("AAGGCCTT");
132 SeqSpanRef s1(new SeqSpan(seq_string));
133 BOOST_CHECK_EQUAL( s1->start(), 0 );
134 BOOST_CHECK_EQUAL( s1->stop(), seq_string.size() );
136 std::string s2seq_string = seq_string.substr(2,3);
137 SeqSpanRef s2 = s1->subseq(2,3);
138 BOOST_CHECK_EQUAL( s2->start(), 2);
139 BOOST_CHECK_EQUAL( s2->stop(), 2+3);
140 BOOST_CHECK_EQUAL( s2->size(), 3);
141 BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
143 std::string s3seq_string = s2seq_string.substr(1,1);
144 SeqSpanRef s3 = s2->subseq(1,1);
145 BOOST_CHECK_EQUAL( s3->start(), 2+1 );
146 BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
147 BOOST_CHECK_EQUAL( s3->size(), 1);
148 BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
151 BOOST_AUTO_TEST_CASE( seqspan_global_to_large )
153 std::string seq_string("AAGGCCTT");
154 SeqSpanRef s1(new SeqSpan(seq_string));
155 BOOST_CHECK_EQUAL( s1->start(), 0 );
156 BOOST_CHECK_EQUAL( s1->stop(), seq_string.size() );
158 std::string s2seq_string = seq_string.substr(2,3);
159 SeqSpanRef s2 = s1->subseq(4,8);
160 BOOST_CHECK_EQUAL( s2->start(), 4);
161 BOOST_CHECK_EQUAL( s2->size(), 4);
162 BOOST_CHECK_EQUAL( s2->stop(), 8);
165 BOOST_AUTO_TEST_CASE( seqspan_parent_start_stop )
167 std::string seq_string("AAGGCCTT");
168 SeqSpanRef s1(new SeqSpan(seq_string));
169 BOOST_CHECK_EQUAL( s1->parentStart(), 0 );
170 BOOST_CHECK_EQUAL( s1->parentStop(), seq_string.size() );
172 std::string s2seq_string = seq_string.substr(2,3);
173 SeqSpanRef s2 = s1->subseq(2,3);
174 BOOST_CHECK_EQUAL( s2->parentStart(), 2);
175 BOOST_CHECK_EQUAL( s2->parentStop(), 2+3);
176 BOOST_CHECK_EQUAL( s2->size(), 3);
177 BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
179 std::string s3seq_string = s2seq_string.substr(1,1);
180 SeqSpanRef s3 = s2->subseq(1,1);
181 BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
182 BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
183 BOOST_CHECK_EQUAL( s3->size(), 1);
184 BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
187 BOOST_AUTO_TEST_CASE( seqspan_global_mutable_start_stop )
189 std::string seq_string("AAGGCCTT");
190 SeqSpanRef s1(new SeqSpan(seq_string));
192 std::string s2seq_string = seq_string.substr(2,3);
193 SeqSpanRef s2 = s1->subseq(2,3);
194 BOOST_CHECK_EQUAL( s2->start(), 2);
195 BOOST_CHECK_EQUAL( s2->stop(), 2+3);
196 BOOST_CHECK_EQUAL( s2->size(), 3);
197 BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
199 std::string s3seq_string = s2seq_string.substr(1,1);
200 SeqSpanRef s3 = s2->subseq(1,1);
201 // Check root location
202 BOOST_CHECK_EQUAL( s3->start(), 2+1 );
203 BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
204 BOOST_CHECK_EQUAL( s3->size(), 1);
205 // Check parent location
206 BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
207 BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
208 BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
210 // Extend s2 to the left
212 BOOST_CHECK_EQUAL( s2->start(), 1);
213 BOOST_CHECK_EQUAL( s2->stop(), 1+1+3);
214 BOOST_CHECK_EQUAL( s2->size(), 4);
216 // Child sequence should have the same global location
217 BOOST_CHECK_EQUAL( s3->start(), 2+1 );
218 BOOST_CHECK_EQUAL( s3->stop(), 2+1+1);
219 BOOST_CHECK_EQUAL( s3->size(), 1);
220 // Child sequence should now have different parent location
221 BOOST_CHECK_EQUAL( s3->parentStart(), 2 );
222 BOOST_CHECK_EQUAL( s3->parentStop(), 2+1);
223 BOOST_CHECK_EQUAL( s3->size(), 1);
226 BOOST_AUTO_TEST_CASE( seqspan_parent_mutable_start_stop )
228 std::string seq_string("AAGGCCTT");
229 SeqSpanRef s1(new SeqSpan(seq_string));
231 std::string s2seq_string = seq_string.substr(3,3);
232 SeqSpanRef s2 = s1->subseq(3,3);
233 BOOST_CHECK_EQUAL( s2->start(), 3);
234 BOOST_CHECK_EQUAL( s2->stop(), 3+3);
235 BOOST_CHECK_EQUAL( s2->size(), 3);
236 BOOST_CHECK_EQUAL( s2->sequence(), s2seq_string);
238 std::string s3seq_string = s2seq_string.substr(1,1);
239 SeqSpanRef s3 = s2->subseq(1,1);
240 // Check root location
241 BOOST_CHECK_EQUAL( s3->start(), 3+1 );
242 BOOST_CHECK_EQUAL( s3->stop(), 3+1+1);
243 BOOST_CHECK_EQUAL( s3->size(), 1);
244 // Check parent location
245 BOOST_CHECK_EQUAL( s3->parentStart(), 1 );
246 BOOST_CHECK_EQUAL( s3->parentStop(), 1+1);
247 BOOST_CHECK_EQUAL( s3->sequence(), s3seq_string);
249 // s2 should now be equivalent to s1->subseq(1,5)
250 s2->setParentStart(1);
251 BOOST_CHECK_EQUAL( s2->start(), 1);
252 BOOST_CHECK_EQUAL( s2->stop(), 3+3);
253 BOOST_CHECK_EQUAL( s2->size(), 5);
255 // Child sequence should have the same global location
256 BOOST_CHECK_EQUAL( s3->start(), 3+1 );
257 BOOST_CHECK_EQUAL( s3->stop(), 3+1+1);
258 BOOST_CHECK_EQUAL( s3->size(), 1);
259 // Child sequence should now have different parent location
260 BOOST_CHECK_EQUAL( s3->parentStart(), 1+2);
261 BOOST_CHECK_EQUAL( s3->parentStop(), 1+2+1);
264 // what happens if we set a stop past our actual end
265 BOOST_AUTO_TEST_CASE( seqspan_stop_past_end )
267 std::string seq_string("AAGGCCTT");
268 SeqSpanRef s1(new SeqSpan(seq_string));
269 std::string s2seq_string = seq_string.substr(3,3);
270 SeqSpanRef s2 = s1->subseq(3,3);
271 std::string s3seq_string = s2seq_string.substr(1,1);
272 SeqSpanRef s3 = s2->subseq(1,1);
274 // should be limited by our parent sequence
276 BOOST_CHECK_EQUAL( s3->size(), 2);
279 BOOST_CHECK_EQUAL( s2->size(), 5);
282 BOOST_CHECK_EQUAL( s3->size(), 4);