1 // ==========================================================================
2 // SeqAn - The Library for Sequence Analysis
3 // ==========================================================================
4 // Copyright (c) 2006-2018, Knut Reinert, FU Berlin
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions are met:
9 //
10 // * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 // * Redistributions in binary form must reproduce the above copyright
13 // notice, this list of conditions and the following disclaimer in the
14 // documentation and/or other materials provided with the distribution.
15 // * Neither the name of Knut Reinert or the FU Berlin nor the names of
16 // its contributors may be used to endorse or promote products derived
17 // from this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 // ARE DISCLAIMED. IN NO EVENT SHALL KNUT REINERT OR THE FU BERLIN BE LIABLE
23 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
29 // DAMAGE.
30 //
31 // ==========================================================================
32 // Author: Manuel Holtgrewe <manuel.holtgrewe@fu-berlin.de>
33 // ==========================================================================
34 // Tests for the STL adaptions of seqan.
35 // ==========================================================================
36
37 // TODO(holtgrew): Split into a file for STL strings and one for STL lists? Writing templatized tests do not make too much sense, I guess, becauses lists and strings are so dissimilar.
38
39 #ifndef TEST_SEQUENCE_TEST_SEQUENCE_STD_ADAPTIONS_H_
40 #define TEST_SEQUENCE_TEST_SEQUENCE_STD_ADAPTIONS_H_
41
42
43 // Tests the return types and existence of the metafunctions for STL vectors.
SEQAN_DEFINE_TEST(test_sequence_adaptions_metafunctions_std_vector)44 SEQAN_DEFINE_TEST(test_sequence_adaptions_metafunctions_std_vector)
45 {
46 using namespace seqan;
47
48 typedef int TElement;
49 typedef std::vector<TElement> TVector;
50 typedef TVector const TConstVector;
51
52 // Test IsContiguous<>::VALUE
53 {
54 bool b = IsContiguous<TVector>::VALUE;
55 SEQAN_ASSERT(b);
56 b = IsContiguous<TConstVector>::VALUE;
57 SEQAN_ASSERT(b);
58 }
59 // Test Value<>::VALUE
60 {
61 typedef Value<TVector>::Type TValue;
62 bool b = IsSameType<TValue, TElement>::VALUE;
63 SEQAN_ASSERT(b);
64 typedef Value<TConstVector>::Type TConstValue;
65 b = IsSameType<TConstValue, TElement>::VALUE;
66 SEQAN_ASSERT(b);
67 }
68 // Test GetValue<>::VALUE
69 {
70 typedef GetValue<TVector>::Type TGetValue;
71 bool b = IsSameType<TGetValue, TElement const &>::VALUE;
72 SEQAN_ASSERT(b);
73 typedef GetValue<TConstVector>::Type TConstGetValue;
74 b = IsSameType<TConstGetValue, TElement const &>::VALUE;
75 SEQAN_ASSERT(b);
76 }
77 // Test GetReference<>::VALUE
78 {
79 typedef Reference<TVector>::Type TReference;
80 bool b = IsSameType<TReference, TElement &>::VALUE;
81 SEQAN_ASSERT(b);
82 typedef Reference<TConstVector>::Type TConstReference;
83 b = IsSameType<TConstReference, TElement const &>::VALUE;
84 SEQAN_ASSERT(b);
85 }
86 // Test Iterator<, Rooted>::VALUE
87 {
88 typedef Iterator<TVector, Rooted>::Type TIterator;
89 typedef Iter<TVector, AdaptorIterator<Iter<TVector, StdIteratorAdaptor> > > TExpected;
90 bool b = IsSameType<TIterator, TExpected>::VALUE;
91 SEQAN_ASSERT(b);
92 typedef Iterator<TConstVector, Rooted>::Type TConstIterator;
93 typedef Iter<TConstVector, AdaptorIterator<Iter<TConstVector, StdIteratorAdaptor> > > TExpectedConst;
94 b = IsSameType<TConstIterator, TExpectedConst>::VALUE;
95 SEQAN_ASSERT(b);
96 }
97 // Test Iterator<, Standard>::VALUE
98 {
99 typedef Iterator<TVector, Standard>::Type TIterator;
100 typedef Iter<TVector, StdIteratorAdaptor> TExpected;
101 bool b = IsSameType<TIterator, TExpected>::VALUE;
102 SEQAN_ASSERT(b);
103 typedef Iterator<TConstVector, Standard>::Type TConstIterator;
104 typedef Iter<TConstVector, StdIteratorAdaptor> TExpectedConst;
105 b = IsSameType<TConstIterator, TExpectedConst>::VALUE;
106 SEQAN_ASSERT(b);
107 }
108 // Test Position<>::VALUE
109 {
110 typedef Position<TVector>::Type TPosition;
111 bool b = IsSameType<TPosition, TVector::size_type>::VALUE;
112 SEQAN_ASSERT(b);
113 typedef Position<TConstVector>::Type TConstPosition;
114 b = IsSameType<TConstPosition, TVector::size_type>::VALUE;
115 SEQAN_ASSERT(b);
116 }
117 // Test Size<>::VALUE
118 {
119 typedef Size<TVector>::Type TPosition;
120 bool b = IsSameType<TPosition, TVector::size_type>::VALUE;
121 SEQAN_ASSERT(b);
122 typedef Size<TConstVector>::Type TConstPosition;
123 b = IsSameType<TConstPosition, TVector::size_type>::VALUE;
124 SEQAN_ASSERT(b);
125 }
126 }
127
128
129 // Test iterators for STL strings.
SEQAN_DEFINE_TEST(test_sequence_adaptions_iterators_std_vector)130 SEQAN_DEFINE_TEST(test_sequence_adaptions_iterators_std_vector)
131 {
132 using namespace seqan;
133
134 // Test const iterator.
135 {
136 std::vector<int> const vec(2,100);
137 //typedef Iterator<std::vector<int> const>::Type TIterator;
138
139 std::vector<int> vecCopy;
140 vecCopy.resize(2);
141 copy(vec.begin(), vec.begin()+2, vecCopy.begin());
142
143 SEQAN_ASSERT_EQ(vecCopy[0],vec[0]);
144 SEQAN_ASSERT_EQ(vecCopy[1],vec[1]);
145
146 }
147
148 // Test non-const iterator.
149 {
150 std::vector<int> vec(2,100);
151 //typedef Iterator<std::vector<int> >::Type TIterator;
152
153 std::vector<int> vecCopy;
154 vecCopy.resize(2);
155 copy(vec.begin(), vec.begin()+2, vecCopy.begin());
156
157 SEQAN_ASSERT_EQ(vecCopy[0],vec[0]);
158 SEQAN_ASSERT_EQ(vecCopy[1],vec[1]);
159 }
160 }
161
162
163 // Tests for the basic sequence functions for STL strings,
164 // e.g. value(), front(), back().
SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_interface_std_vector)165 SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_interface_std_vector)
166 {
167 using namespace seqan;
168
169 std::vector<int> vec(2,100);
170
171 // value(str, i), getValue(str, i)
172 SEQAN_ASSERT_EQ(value(vec, 0), 100);
173 SEQAN_ASSERT_EQ(value(vec, 1), 100);
174 // front(), back()
175 SEQAN_ASSERT_EQ(front(vec),100);
176 SEQAN_ASSERT_EQ(back(vec),100);
177
178 // length()
179 SEQAN_ASSERT_EQ(length(vec), 2u);
180
181 // TODO(holtgrew): Anything else missing? Probably...
182 }
183
184
185 // Tests for the memory allocation and reservation related functions
186 // for STL strings.
SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_memory_std_vector)187 SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_memory_std_vector)
188 {
189 using namespace seqan;
190
191 // Test resize function -- resize down.
192 {
193 std::vector<int> vec(8,100);
194 resize(vec, 5);
195
196 SEQAN_ASSERT_EQ(vec.size(),5u);
197 }
198
199 // Test resize function -- resize up.
200 {
201 std::vector<int> vec(2,100);
202 resize(vec, 6);
203
204 SEQAN_ASSERT_EQ(vec.size(),6u);
205 }
206
207 // Tests reserve function.
208 {
209 std::vector<int> vec;
210 reserve(vec, 10);
211 SEQAN_ASSERT_GEQ(capacity(vec), 10u);
212 }
213 {
214 std::vector<int> vec;
215 reserve(vec, 10, Generous());
216 SEQAN_ASSERT_GEQ(capacity(vec), 10u);
217 }
218 // We cannot guarantee that the behaviour is supported by the STL
219 // implementation with the Exact() tag.
220 {
221 std::vector<int> vec;
222 reserve(vec, 10, Exact());
223 SEQAN_ASSERT_EQ(capacity(vec), 10u);
224 }
225 // test first replace
226 {
227 std::vector<int> vec_target(5,100);
228 std::vector<int> vec_source(3,10);
229 std::vector<int> vec_source2(2,20);
230 typename Position< std::vector<int> >::Type pos_begin = 3;
231 typename Position< std::vector<int> >::Type pos_end = 4;
232
233 // replace with insertion
234 replace(vec_target,pos_begin,pos_end,vec_source);
235
236 SEQAN_ASSERT_EQ(vec_target[2],100);
237 SEQAN_ASSERT_EQ(vec_target[3],10);
238 SEQAN_ASSERT_EQ(vec_target[5],10);
239 SEQAN_ASSERT_EQ(vec_target[6],100);
240
241 // replace with shrinking
242 pos_begin = 2;
243 pos_end = 5;
244 replace(vec_target,pos_begin,pos_end,vec_source2);
245 SEQAN_ASSERT_EQ(vec_target[1],100);
246 SEQAN_ASSERT_EQ(vec_target[2],20);
247 SEQAN_ASSERT_EQ(vec_target[3],20);
248 SEQAN_ASSERT_EQ(vec_target[4],10);
249
250
251 }
252 // test replace with limits
253 {
254 std::vector<int> vec_target(8,100);
255 std::vector<int> vec_source(6,10);
256 typename Position< std::vector<int> >::Type pos_begin = 4;
257 typename Position< std::vector<int> >::Type pos_end = 8;
258
259
260 // replace with insertion
261 typename Size< std::vector<int> >::Type limit = 5;
262
263 replace(vec_target,pos_begin,pos_end,vec_source,limit);
264
265 SEQAN_ASSERT_EQ(vec_target[3],100);
266 SEQAN_ASSERT_EQ(vec_target[4],10);
267 SEQAN_ASSERT_EQ(length(vec_target),9u);
268 }
269 }
270
271
272 // **************************************************************************
273 // Tests the return types and existence of the metafunctions for STL strings.
SEQAN_DEFINE_TEST(test_sequence_adaptions_metafunctions_std_string)274 SEQAN_DEFINE_TEST(test_sequence_adaptions_metafunctions_std_string)
275 {
276 using namespace seqan;
277
278 typedef int TElement;
279 typedef std::basic_string<TElement> TString;
280 typedef TString const TConstString;
281
282 // Test IsContiguous<>::VALUE
283 {
284 bool b = IsContiguous<TString>::VALUE;
285 SEQAN_ASSERT(b);
286 b = IsContiguous<TConstString>::VALUE;
287 SEQAN_ASSERT(b);
288 }
289 // Test Value<>::VALUE
290 {
291 typedef Value<TString>::Type TValue;
292 bool b = IsSameType<TValue, TElement>::VALUE;
293 SEQAN_ASSERT(b);
294 typedef Value<TConstString>::Type TConstValue;
295 b = IsSameType<TConstValue, TElement>::VALUE;
296 SEQAN_ASSERT(b);
297 }
298 // Test GetValue<>::VALUE
299 {
300 typedef GetValue<TString>::Type TGetValue;
301 bool b = IsSameType<TGetValue, TElement const &>::VALUE;
302 SEQAN_ASSERT(b);
303 typedef GetValue<TConstString>::Type TConstGetValue;
304 b = IsSameType<TConstGetValue, TElement const &>::VALUE;
305 SEQAN_ASSERT(b);
306 }
307 // Test Reference<>::VALUE
308 {
309 typedef Reference<TString>::Type TReference;
310 bool b = IsSameType<TReference, TElement &>::VALUE;
311 SEQAN_ASSERT(b);
312 typedef Reference<TConstString>::Type TConstReference;
313 b = IsSameType<TConstReference, TElement const &>::VALUE;
314 SEQAN_ASSERT(b);
315 }
316 // Test Iterator<, Rooted>::VALUE
317 {
318 typedef Iterator<TString, Rooted>::Type TIterator;
319 typedef Iter<TString, AdaptorIterator<Iterator<TString, Standard>::Type> > TExpected;
320 bool b = IsSameType<TIterator, TExpected>::VALUE;
321 SEQAN_ASSERT(b);
322 typedef Iterator<TConstString, Rooted>::Type TConstIterator;
323 typedef Iter<TConstString, AdaptorIterator<Iterator<TConstString, Standard>::Type> > TExpectedConst;
324 b = IsSameType<TConstIterator, TExpectedConst>::VALUE;
325 SEQAN_ASSERT(b);
326 }
327 // Test Iterator<, Standard>::VALUE
328 {
329 typedef Iterator<TString, Standard>::Type TIterator;
330 typedef Iter<TString, StdIteratorAdaptor> TExpected;
331 bool b = IsSameType<TIterator, TExpected>::VALUE;
332 SEQAN_ASSERT(b);
333 typedef Iterator<TConstString, Standard>::Type TConstIterator;
334 typedef Iter<TString const, StdIteratorAdaptor> TExpectedConst;
335 b = IsSameType<TConstIterator, TExpectedConst>::VALUE;
336 SEQAN_ASSERT(b);
337 }
338 // Test Position<>::VALUE
339 {
340 typedef Position<TString>::Type TPosition;
341 bool b = IsSameType<TPosition, TString::size_type>::VALUE;
342 SEQAN_ASSERT(b);
343 typedef Position<TConstString>::Type TConstPosition;
344 b = IsSameType<TConstPosition, TString::size_type>::VALUE;
345 SEQAN_ASSERT(b);
346 }
347 // Test Size<>::VALUE
348 {
349 typedef Size<TString>::Type TPosition;
350 bool b = IsSameType<TPosition, TString::size_type>::VALUE;
351 SEQAN_ASSERT(b);
352 typedef Size<TConstString>::Type TConstPosition;
353 b = IsSameType<TConstPosition, TString::size_type>::VALUE;
354 SEQAN_ASSERT(b);
355 }
356 }
357
358
359 // Test iterators for STL strings.
SEQAN_DEFINE_TEST(test_sequence_adaptions_iterators_std_string)360 SEQAN_DEFINE_TEST(test_sequence_adaptions_iterators_std_string)
361 {
362 using namespace seqan;
363
364 // Test const iterator.
365 {
366 std::string const str = "Unimportant contents.";
367 typedef Iterator<std::string const>::Type TIterator;
368
369 std::string strCopy;
370 for (TIterator it = begin(str, Standard()); it != end(str, Standard()); ++it)
371 appendValue(strCopy, value(it));
372
373 SEQAN_ASSERT_EQ(str, strCopy);
374 }
375
376 // Test non-const iterator.
377 {
378 std::string str = "Unimportant contents.";
379 typedef Iterator<std::string>::Type TIterator;
380
381 std::string strCopy;
382 for (TIterator it = begin(str, Standard()); it != end(str, Standard()); ++it)
383 appendValue(strCopy, value(it));
384
385 SEQAN_ASSERT_EQ(str, strCopy);
386 }
387 }
388
389
390 // Tests for the basic sequence functions for STL strings,
391 // e.g. value(), front(), back().
SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_interface_std_string)392 SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_interface_std_string)
393 {
394 using namespace seqan;
395
396 std::string str = "Hello World!";
397
398 // value(str, i), getValue(str, i)
399 SEQAN_ASSERT_EQ(value(str, 0), 'H');
400 SEQAN_ASSERT_EQ(value(str, 4), 'o');
401 SEQAN_ASSERT_EQ(getValue(str, 0), 'H');
402 SEQAN_ASSERT_EQ(getValue(str, 4), 'o');
403
404 // front(), back()
405 SEQAN_ASSERT_EQ(front(str), 'H');
406 SEQAN_ASSERT_EQ(back(str), '!');
407
408 // length()
409 SEQAN_ASSERT_EQ(length(str), 12u);
410
411 // TODO(holtgrew): Anything else missing? Probably...
412 }
413
414
415 // Tests for the memory allocation and reservation related functions
416 // for STL strings.
SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_memory_std_string)417 SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_memory_std_string)
418 {
419 using namespace seqan;
420
421 // Test resize function -- resize down.
422 {
423 std::string str = "Hello world!";
424 resize(str, 5);
425 SEQAN_ASSERT_EQ(str, "Hello");
426 }
427
428 // Test resize function -- resize up.
429 {
430 std::string str = "12345";
431 resize(str, 6);
432 // The following gives an assertion in positional setValue() if not resized properly.
433 str[5] = '6';
434 SEQAN_ASSERT_EQ(str, "123456");
435 }
436
437 // Tests reserve function.
438 {
439 std::string str;
440 reserve(str, 10);
441 SEQAN_ASSERT_GEQ(capacity(str), 10u);
442 }
443 {
444 std::string str;
445 reserve(str, 10, Generous());
446 SEQAN_ASSERT_GEQ(capacity(str), 10u);
447 }
448 // We cannot guarantee that the behaviour is supported by the STL
449 // implementation with the Exact() tag.
450 // {
451 // std::string str;
452 // reserve(str, 10, Exact());
453 // SEQAN_ASSERT_EQ(capacity(str), 10u);
454 // }
455 }
456
457
458 // *******************************************************************
459 // Tests the return types and existence of the metafunctions for STL lists.
SEQAN_DEFINE_TEST(test_sequence_adaptions_metafunctions_std_list)460 SEQAN_DEFINE_TEST(test_sequence_adaptions_metafunctions_std_list)
461 {
462 using namespace seqan;
463
464 typedef int TElement;
465 typedef std::list<TElement> TList;
466 typedef TList const TConstList;
467
468 // Test IsContiguous<>::VALUE
469 {
470 bool b = IsContiguous<TList>::VALUE;
471 SEQAN_ASSERT_NOT(b);
472 b = IsContiguous<TConstList>::VALUE;
473 SEQAN_ASSERT_NOT(b);
474 }
475 // Test Value<>::VALUE
476 {
477 typedef Value<TList>::Type TValue;
478 bool b = IsSameType<TValue, TElement>::VALUE;
479 SEQAN_ASSERT(b);
480 typedef Value<TConstList>::Type TConstValue;
481 b = IsSameType<TConstValue, TElement>::VALUE;
482 SEQAN_ASSERT(b);
483 }
484 // Test GetValue<>::VALUE
485 {
486 typedef GetValue<TList>::Type TGetValue;
487 bool b = IsSameType<TGetValue, TElement const &>::VALUE;
488 SEQAN_ASSERT(b);
489 typedef GetValue<TConstList>::Type TConstGetValue;
490 b = IsSameType<TConstGetValue, TElement const &>::VALUE;
491 SEQAN_ASSERT(b);
492 }
493 // Test Reference<>::VALUE
494 {
495 typedef Reference<TList>::Type TReference;
496 bool b = IsSameType<TReference, TElement &>::VALUE;
497 SEQAN_ASSERT(b);
498 typedef Reference<TConstList>::Type TConstReference;
499 b = IsSameType<TConstReference, TElement const &>::VALUE;
500 SEQAN_ASSERT(b);
501 }
502 // Test Iterator<, Rooted>::VALUE
503 {
504 typedef Iterator<TList, Rooted>::Type TIterator;
505 typedef Iter<TList, AdaptorIterator<Iter<TList, StdIteratorAdaptor> > > TExpected;
506 bool b = IsSameType<TIterator, TExpected>::VALUE;
507 SEQAN_ASSERT(b);
508 typedef Iterator<TConstList, Rooted>::Type TConstIterator;
509 typedef Iter<TConstList, AdaptorIterator<Iter<TConstList, StdIteratorAdaptor> > > TExpectedConst;
510 b = IsSameType<TConstIterator, TExpectedConst>::VALUE;
511 SEQAN_ASSERT(b);
512 }
513 // Test Iterator<, Standard>::VALUE
514 {
515 typedef Iterator<TList, Standard>::Type TIterator;
516 typedef Iter<TList, StdIteratorAdaptor> TExpected;
517 bool b = IsSameType<TIterator, TExpected>::VALUE;
518 SEQAN_ASSERT(b);
519 typedef Iterator<TConstList, Standard>::Type TConstIterator;
520 typedef Iter<TConstList, StdIteratorAdaptor> TExpectedConst;
521 b = IsSameType<TConstIterator, TExpectedConst>::VALUE;
522 SEQAN_ASSERT(b);
523 }
524 // Test Position<>::VALUE
525 {
526 typedef Position<TList>::Type TPosition;
527 bool b = IsSameType<TPosition, TList::size_type>::VALUE;
528 SEQAN_ASSERT(b);
529 typedef Position<TConstList>::Type TConstPosition;
530 b = IsSameType<TConstPosition, TList::size_type>::VALUE;
531 SEQAN_ASSERT(b);
532 }
533 // Test Size<>::VALUE
534 {
535 typedef Size<TList>::Type TPosition;
536 bool b = IsSameType<TPosition, TList::size_type>::VALUE;
537 SEQAN_ASSERT(b);
538 typedef Size<TConstList>::Type TConstPosition;
539 b = IsSameType<TConstPosition, TList::size_type>::VALUE;
540 SEQAN_ASSERT(b);
541 }
542 }
543
544
545 // Test iterators for STL lists.
SEQAN_DEFINE_TEST(test_sequence_adaptions_iterators_std_list)546 SEQAN_DEFINE_TEST(test_sequence_adaptions_iterators_std_list)
547 {
548 using namespace seqan;
549
550 typedef int TElement;
551
552 // Test Standard, non-const iterators.
553 {
554 typedef std::list<TElement> TList;
555 typedef Iterator<TList, Standard>::Type TIterator;
556
557 TList list;
558 appendValue(list, 1);
559 appendValue(list, 2);
560 appendValue(list, 3);
561
562 // The command sequence in the following is a bit arbitrary
563 // but should robustly test that the iterators work correctly.
564 TIterator it = seqan::begin(list);
565 SEQAN_ASSERT_EQ(1, *it);
566 ++it;
567 SEQAN_ASSERT_EQ(2, *it);
568 --it;
569 SEQAN_ASSERT_EQ(1, *it);
570 TIterator itEnd = seqan::end(list);
571 SEQAN_ASSERT_NOT(it == itEnd);
572 ++it;
573 ++it;
574 ++it;
575 SEQAN_ASSERT(it == itEnd);
576
577 // The following does not apply to const iterators.
578 it = seqan::begin(list);
579 *seqan::begin(list) = 4;
580 SEQAN_ASSERT_EQ(4, *it);
581 }
582 // Test Standard, const iterators.
583 {
584 typedef std::list<TElement> TList;
585 typedef Iterator<TList const, Standard>::Type TIterator;
586
587 TList mutableList;
588 appendValue(mutableList, 1);
589 appendValue(mutableList, 2);
590 appendValue(mutableList, 3);
591
592 TList const & list = mutableList;
593
594 // The command sequence in the following is a bit arbitrary
595 // but should robustly test that the iterators work correctly.
596 TIterator it = seqan::begin(list);
597 SEQAN_ASSERT_EQ(1, *it);
598 ++it;
599 SEQAN_ASSERT_EQ(2, *it);
600 --it;
601 SEQAN_ASSERT_EQ(1, *it);
602 TIterator itEnd = seqan::end(list);
603 SEQAN_ASSERT_NOT(it == itEnd);
604 ++it;
605 ++it;
606 ++it;
607 SEQAN_ASSERT(it == itEnd);
608 }
609 // Test Rooted, non-const iterators.
610 {
611 typedef std::list<TElement> TList;
612 typedef Iterator<TList, Rooted>::Type TIterator;
613
614 TList list;
615 appendValue(list, 1);
616 appendValue(list, 2);
617 appendValue(list, 3);
618
619 // The command sequence in the following is a bit arbitrary
620 // but should robustly test that the iterators work correctly.
621 TIterator it = seqan::begin(list);
622 SEQAN_ASSERT_EQ(1, *it);
623 ++it;
624 SEQAN_ASSERT_EQ(2, *it);
625 --it;
626 SEQAN_ASSERT_EQ(1, *it);
627 TIterator itEnd = seqan::end(list);
628 SEQAN_ASSERT_NOT(it == itEnd);
629 ++it;
630 ++it;
631 ++it;
632 SEQAN_ASSERT(it == itEnd);
633
634 // The following does not apply to const iterators.
635 it = seqan::begin(list);
636 *seqan::begin(list) = 4;
637 SEQAN_ASSERT_EQ(4, *it);
638 }
639 // Test Rooted, const iterators.
640 {
641 typedef std::list<TElement> TList;
642 typedef Iterator<TList const, Rooted>::Type TIterator;
643
644 TList mutableList;
645 appendValue(mutableList, 1);
646 appendValue(mutableList, 2);
647 appendValue(mutableList, 3);
648
649 TList const & list = mutableList;
650
651 // The command sequence in the following is a bit arbitrary
652 // but should robustly test that the iterators work correctly.
653 TIterator it = seqan::begin(list);
654 SEQAN_ASSERT_EQ(1, *it);
655 ++it;
656 SEQAN_ASSERT_EQ(2, *it);
657 --it;
658 SEQAN_ASSERT_EQ(1, *it);
659 TIterator itEnd = seqan::end(list);
660 SEQAN_ASSERT_NOT(it == itEnd);
661 ++it;
662 ++it;
663 ++it;
664 SEQAN_ASSERT(it == itEnd);
665 }
666 }
667
668
669 // Test the basic sequence interface implemented for STL list, e.g. front() and back().
SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_interface_std_list)670 SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_interface_std_list)
671 {
672 using namespace seqan;
673
674 typedef int TElement;
675
676 // Test with non-const container.
677 {
678 typedef std::list<TElement> TList;
679 typedef Iterator<TList>::Type TIterator;
680
681 // Prepare list...
682 TList list;
683 appendValue(list, 1);
684 appendValue(list, 2);
685 appendValue(list, 3);
686
687 // Test reading front and back.
688 SEQAN_ASSERT_EQ(1, front(list));
689 SEQAN_ASSERT_EQ(3, back(list));
690
691 // Test assigning to front and back.
692 front(list) = -1;
693 back(list) = -3;
694
695 TIterator it = seqan::begin(list);
696 SEQAN_ASSERT_EQ(-1, *it);
697 ++it;
698 SEQAN_ASSERT_EQ(2, *it);
699 ++it;
700 SEQAN_ASSERT_EQ(-3, *it);
701
702 // Test appending and prepending values.
703 prependValue(list, 42);
704 appendValue(list, 43);
705 SEQAN_ASSERT_EQ(42, front(list));
706 SEQAN_ASSERT_EQ(43, back(list));
707
708 // Test length().
709 SEQAN_ASSERT_EQ(5u, length(list));
710
711 // Test clear().
712 {
713 TList listCopy(list);
714 SEQAN_ASSERT_EQ(5u, length(listCopy));
715 clear(listCopy);
716 SEQAN_ASSERT_EQ(0u, length(listCopy));
717 }
718 }
719 // Test with const container.
720 {
721 typedef std::list<TElement> TList;
722 //typedef Iterator<TList>::Type TIterator;
723
724 // Prepare list...
725 TList mutableList;
726 appendValue(mutableList, 1);
727 appendValue(mutableList, 2);
728 appendValue(mutableList, 3);
729
730 TList const & list = mutableList;
731
732 // Test reading front and back.
733 SEQAN_ASSERT_EQ(1, front(list));
734 SEQAN_ASSERT_EQ(3, back(list));
735
736 // Test length().
737 SEQAN_ASSERT_EQ(3u, length(list));
738
739 // Test reserve().
740 reserve(mutableList, 4);
741 SEQAN_ASSERT_EQ(3u, length(list));
742 SEQAN_ASSERT_EQ(3u, length(mutableList));
743 SEQAN_ASSERT_EQ(3u, capacity(list));
744 SEQAN_ASSERT_EQ(3u, capacity(mutableList));
745 }
746 }
747
748 // Tests the return types and existence of the metafunctions for STL arrays.
SEQAN_DEFINE_TEST(test_sequence_adaptions_metafunctions_std_array)749 SEQAN_DEFINE_TEST(test_sequence_adaptions_metafunctions_std_array)
750 {
751 using namespace seqan;
752
753 typedef int TElement;
754 typedef std::array<TElement, 1> TArray;
755 typedef TArray const TConstArray;
756
757 // Test IsContiguous<>::VALUE
758 {
759 bool b = IsContiguous<TArray>::VALUE;
760 SEQAN_ASSERT(b);
761 b = IsContiguous<TConstArray>::VALUE;
762 SEQAN_ASSERT(b);
763 }
764 // Test Value<>::VALUE
765 {
766 typedef Value<TArray>::Type TValue;
767 bool b = IsSameType<TValue, TElement>::VALUE;
768 SEQAN_ASSERT(b);
769 typedef Value<TConstArray>::Type TConstValue;
770 b = IsSameType<TConstValue, TElement>::VALUE;
771 SEQAN_ASSERT(b);
772 }
773 // Test GetValue<>::VALUE
774 {
775 typedef GetValue<TArray>::Type TGetValue;
776 bool b = IsSameType<TGetValue, TElement const &>::VALUE;
777 SEQAN_ASSERT(b);
778 typedef GetValue<TConstArray>::Type TConstGetValue;
779 b = IsSameType<TConstGetValue, TElement const &>::VALUE;
780 SEQAN_ASSERT(b);
781 }
782 // Test GetReference<>::VALUE
783 {
784 typedef Reference<TArray>::Type TReference;
785 bool b = IsSameType<TReference, TElement &>::VALUE;
786 SEQAN_ASSERT(b);
787 typedef Reference<TConstArray>::Type TConstReference;
788 b = IsSameType<TConstReference, TElement const &>::VALUE;
789 SEQAN_ASSERT(b);
790 }
791 // Test Iterator<, Rooted>::VALUE
792 {
793 typedef Iterator<TArray, Rooted>::Type TIterator;
794 typedef Iter<TArray, AdaptorIterator<Iter<TArray, StdIteratorAdaptor> > > TExpected;
795 bool b = IsSameType<TIterator, TExpected>::VALUE;
796 SEQAN_ASSERT(b);
797 typedef Iterator<TConstArray, Rooted>::Type TConstIterator;
798 typedef Iter<TConstArray, AdaptorIterator<Iter<TConstArray, StdIteratorAdaptor> > > TExpectedConst;
799 b = IsSameType<TConstIterator, TExpectedConst>::VALUE;
800 SEQAN_ASSERT(b);
801 }
802 // Test Iterator<, Standard>::VALUE
803 {
804 typedef Iterator<TArray, Standard>::Type TIterator;
805 typedef Iter<TArray, StdIteratorAdaptor> TExpected;
806 bool b = IsSameType<TIterator, TExpected>::VALUE;
807 SEQAN_ASSERT(b);
808 typedef Iterator<TConstArray, Standard>::Type TConstIterator;
809 typedef Iter<TConstArray, StdIteratorAdaptor> TExpectedConst;
810 b = IsSameType<TConstIterator, TExpectedConst>::VALUE;
811 SEQAN_ASSERT(b);
812 }
813 // Test Position<>::VALUE
814 {
815 typedef Position<TArray>::Type TPosition;
816 bool b = IsSameType<TPosition, TArray::size_type>::VALUE;
817 SEQAN_ASSERT(b);
818 typedef Position<TConstArray>::Type TConstPosition;
819 b = IsSameType<TConstPosition, TArray::size_type>::VALUE;
820 SEQAN_ASSERT(b);
821 }
822 // Test Size<>::VALUE
823 {
824 typedef Size<TArray>::Type TPosition;
825 bool b = IsSameType<TPosition, TArray::size_type>::VALUE;
826 SEQAN_ASSERT(b);
827 typedef Size<TConstArray>::Type TConstPosition;
828 b = IsSameType<TConstPosition, TArray::size_type>::VALUE;
829 SEQAN_ASSERT(b);
830 }
831 }
832
833
834 // Test iterators for STL strings.
SEQAN_DEFINE_TEST(test_sequence_adaptions_iterators_std_array)835 SEQAN_DEFINE_TEST(test_sequence_adaptions_iterators_std_array)
836 {
837 using namespace seqan;
838
839 // Test const iterator.
840 {
841 std::array<int, 3> const vec = { {100, 101, 102} };
842 //typedef Iterator<std::array<int> const>::Type TIterator;
843
844 std::array<int, 2> vecCopy;
845 std::copy(vec.begin(), vec.begin()+2, vecCopy.begin());
846
847 SEQAN_ASSERT_EQ(vecCopy[0],vec[0]);
848 SEQAN_ASSERT_EQ(vecCopy[1],vec[1]);
849
850 }
851
852 // Test non-const iterator.
853 {
854 std::array<int, 3> vec = { {100, 101, 102} };
855 //typedef Iterator<std::array<int> >::Type TIterator;
856
857 std::array<int, 2> vecCopy;
858 std::copy(vec.begin(), vec.begin()+2, vecCopy.begin());
859
860 SEQAN_ASSERT_EQ(vecCopy[0],vec[0]);
861 SEQAN_ASSERT_EQ(vecCopy[1],vec[1]);
862 }
863 }
864
865
866 // Tests for the basic sequence functions for STL strings,
867 // e.g. value(), front(), back().
SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_interface_std_array)868 SEQAN_DEFINE_TEST(test_sequence_adaptions_sequence_interface_std_array)
869 {
870 using namespace seqan;
871
872 std::array<int, 2> vec = { {100, 101} };
873
874 // value(str, i), getValue(str, i)
875 SEQAN_ASSERT_EQ(value(vec, 0), 100);
876 SEQAN_ASSERT_EQ(value(vec, 1), 101);
877 // front(), back()
878 SEQAN_ASSERT_EQ(front(vec),100);
879 SEQAN_ASSERT_EQ(back(vec),101);
880
881 // length()
882 SEQAN_ASSERT_EQ(length(vec), 2u);
883
884 // TODO(holtgrew): Anything else missing? Probably...
885 }
886
887 #endif // TEST_SEQUENCE_TEST_SEQUENCE_STD_ADAPTIONS_H_
888