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 Pair, Triple and Tuple hierarchy in module basic.
35 // ==========================================================================
36
37 // TODO(holtgrew): Test/Implement Metafunction.GetValue.
38
39 #include <sstream>
40
41 #ifndef TESTS_BASIC_TEST_BASIC_AGGREGATES_H_
42 #define TESTS_BASIC_TEST_BASIC_AGGREGATES_H_
43
44 using namespace seqan;
45
46 // ==========================================================================
47 // Helper Code
48 // ==========================================================================
49
50 // Helper type for testing transports. Each constructed objects gets an id
51 // and increases the static nextId member. Assignment only updates the id,
52 // setting sets the id as well and movement copies id and value and sets the
53 // id of the other to -1 to signal emptiness.
54
55 struct Transportable_
56 {
57 static int nextId;
58 int id;
59 int value;
60
Transportable_Transportable_61 Transportable_()
62 {
63 id = nextId++;
64 }
65
66 explicit
Transportable_Transportable_67 Transportable_(int i)
68 {
69 id = nextId++;
70 value = i;
71 }
72
Transportable_Transportable_73 Transportable_(const Transportable_ & other)
74 {
75 id = nextId++;
76 value = other.value;
77 }
78
Transportable_Transportable_79 Transportable_(Transportable_ & other, Move const & /*tag*/)
80 {
81 id = other.id;
82 value = other.value;
83 other.id = -1;
84 }
85
86 Transportable_ & operator=(Transportable_ const & other)
87 {
88 value = other.value;
89 return *this;
90 }
91 };
92
93 int Transportable_::nextId = 0;
94
assign(Transportable_ & target,Transportable_ & source)95 void assign(Transportable_ & target, Transportable_ & source)
96 {
97 target.value = source.value;
98 }
99
assign(Transportable_ & target,Transportable_ const & source)100 void assign(Transportable_ & target, Transportable_ const & source)
101 {
102 target.value = source.value;
103 }
104
move(Transportable_ & target,Transportable_ & source)105 void move(Transportable_ & target, Transportable_ & source)
106 {
107 target.value = source.value;
108 target.id = source.id;
109 source.id = -1;
110 }
111
set(Transportable_ & target,Transportable_ & source)112 void set(Transportable_ & target, Transportable_ & source)
113 {
114 target.value = source.value;
115 target.id = source.id;
116 }
117
set(Transportable_ & target,Transportable_ const & source)118 void set(Transportable_ & target, Transportable_ const & source)
119 {
120 target.value = source.value;
121 target.id = source.id;
122 }
123
124 // ==========================================================================
125 // Generic Test Helpers.
126 // ==========================================================================
127
128 // ==========================================================================
129 // Actual Tests Definitions.
130 // ==========================================================================
131
132 // --------------------------------------------------------------------------
133 // Tests for Base Pair.
134 // --------------------------------------------------------------------------
135
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_metafunctions)136 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_metafunctions)
137 {
138 typedef Pair<int, unsigned> TPair;
139 // Metafunction LENGTH
140 unsigned l = LENGTH<TPair>::VALUE;
141 SEQAN_ASSERT_EQ(l, 2u);
142 // Metafunction Value
143 bool b = IsSameType<typename Value<TPair, 1>::Type, int>::VALUE;
144 SEQAN_ASSERT_EQ(b, true);
145 b = IsSameType<typename Value<TPair, 2>::Type, unsigned>::VALUE;
146 SEQAN_ASSERT_EQ(b, true);
147 // Metafunction Spec
148 b = IsSameType<typename Spec<TPair>::Type, void>::VALUE;
149 SEQAN_ASSERT_EQ(b, true);
150 // // Metafunction Key
151 // b = IsSameType<typename Key<TPair>::Type, int>::VALUE;
152 // SEQAN_ASSERT_EQ(b, true);
153 // // Metafunction Cargo
154 // b = IsSameType<typename Cargo<TPair>::Type, unsigned>::VALUE;
155 // SEQAN_ASSERT_EQ(b, true);
156 }
157
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_constructors)158 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_constructors)
159 {
160 typedef Pair<int, unsigned> TPair;
161
162 // Default constructor.
163 {
164 TPair p;
165 }
166
167 // Normal Constructor Pair(i1, i2).
168 {
169 TPair p(1, 2);
170
171 SEQAN_ASSERT_EQ(p.i1, 1);
172 SEQAN_ASSERT_EQ(p.i2, 2u);
173 }
174
175 // Copy Constructor Pair(p).
176 {
177 TPair p(1, 2);
178 TPair p2(p);
179
180 SEQAN_ASSERT_EQ(p2.i1, 1);
181 SEQAN_ASSERT_EQ(p2.i2, 2u);
182 }
183
184 // Conversion constructor from other pair.
185 {
186 Pair<int, int, Pack> p2(1, 2);
187 TPair p(p2);
188
189 SEQAN_ASSERT_EQ(p.i1, 1);
190 SEQAN_ASSERT_EQ(p.i2, 2u);
191 }
192 }
193
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_assign)194 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_assign)
195 {
196 // Test with ints.
197 {
198 Pair<int, int> p1;
199 Pair<int, int> p2(1, 2);
200 assign(p1, p2);
201 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
202 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
203 }
204
205 // Test with Transportable_ type.
206 {
207 Pair<Transportable_, Transportable_> p1;
208 Pair<Transportable_, Transportable_> p2(Transportable_(1), Transportable_(2));
209 assign(p1, p2);
210 SEQAN_ASSERT_NEQ(p1.i1.id, p2.i1.id);
211 SEQAN_ASSERT_EQ(p1.i1.value, p2.i1.value);
212 SEQAN_ASSERT_NEQ(p1.i2.id, p2.i2.id);
213 SEQAN_ASSERT_EQ(p1.i2.value, p2.i2.value);
214 }
215 }
216
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_set)217 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_set)
218 {
219 // Test with ints.
220 {
221 Pair<int, int> p1;
222 Pair<int, int> p2(1, 2);
223 set(p1, p2);
224 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
225 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
226 }
227
228 // Test with Transportable_ type.
229 {
230 Pair<Transportable_, Transportable_> p1;
231 Pair<Transportable_, Transportable_> p2(Transportable_(1), Transportable_(2));
232 set(p1, p2);
233 SEQAN_ASSERT_EQ(p1.i1.id, p2.i1.id);
234 SEQAN_ASSERT_EQ(p1.i1.value, p2.i1.value);
235 SEQAN_ASSERT_EQ(p1.i2.id, p2.i2.id);
236 SEQAN_ASSERT_EQ(p1.i2.value, p2.i2.value);
237 }
238 }
239
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_move)240 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_move)
241 {
242 // Test with ints.
243 {
244 Pair<int, int> p1;
245 Pair<int, int> p2(1, 2);
246 move(p1, p2);
247 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
248 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
249 }
250
251 // Test with Transportable_ type.
252 {
253 Pair<Transportable_, Transportable_> p1;
254 Pair<Transportable_, Transportable_> p2(Transportable_(1), Transportable_(2));
255 int p2I1Id = p2.i1.id;
256 int p2I1Value = p2.i1.value;
257 int p2I2Id = p2.i2.id;
258 int p2I2Value = p2.i2.value;
259 move(p1, p2);
260 SEQAN_ASSERT_EQ(p1.i1.id, p2I1Id);
261 SEQAN_ASSERT_EQ(p1.i1.value, p2I1Value);
262 SEQAN_ASSERT_EQ(p1.i2.id, p2I2Id);
263 SEQAN_ASSERT_EQ(p1.i2.value, p2I2Value);
264 SEQAN_ASSERT_EQ(p2.i1.id, -1);
265 SEQAN_ASSERT_EQ(p2.i2.id, -1);
266 }
267 }
268
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_value)269 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_value)
270 {
271 SEQAN_ASSERT_FAIL("No reference in Pair<>");
272 }
273
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_get_value)274 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_get_value)
275 {
276 Pair<int, int> p(-1, 1);
277 SEQAN_ASSERT_EQ(getValueI1(p), -1);
278 SEQAN_ASSERT_EQ(getValueI2(p), 1);
279 }
280
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_assign_value)281 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_assign_value)
282 {
283 // Test with ints.
284 {
285 Pair<int, int> p1;
286 Pair<int, int> p2(1, 2);
287
288 assignValueI1(p1, p2.i1);
289 assignValueI2(p1, p2.i2);
290
291 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
292 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
293 }
294
295 // Test with Transportable_ type.
296 {
297 Pair<Transportable_, Transportable_> p1;
298 Pair<Transportable_, Transportable_> p2(Transportable_(1), Transportable_(2));
299 int p1I1Id = p1.i1.id;
300 int p1I2Id = p1.i2.id;
301 int p2I1Id = p2.i1.id;
302 int p2I1Value = p2.i1.value;
303 int p2I2Id = p2.i2.id;
304 int p2I2Value = p2.i2.value;
305
306 assignValueI1(p1, p2.i1);
307 assignValueI2(p1, p2.i2);
308
309 SEQAN_ASSERT_EQ(p1.i1.id, p1I1Id);
310 SEQAN_ASSERT_EQ(p1.i1.value, p2I1Value);
311 SEQAN_ASSERT_EQ(p1.i2.id, p1I2Id);
312 SEQAN_ASSERT_EQ(p1.i2.value, p2I2Value);
313 SEQAN_ASSERT_EQ(p2.i1.id, p2I1Id);
314 SEQAN_ASSERT_EQ(p2.i1.value, p2I1Value);
315 SEQAN_ASSERT_EQ(p2.i2.id, p2I2Id);
316 SEQAN_ASSERT_EQ(p2.i2.value, p2I2Value);
317 }
318 }
319
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_set_value)320 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_set_value)
321 {
322 // Test with ints.
323 {
324 Pair<int, int> p1;
325 Pair<int, int> p2(1, 2);
326
327 setValueI1(p1, p2.i1);
328 setValueI2(p1, p2.i2);
329
330 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
331 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
332 }
333
334 // Test with Transportable_ type.
335 {
336 Pair<Transportable_, Transportable_> p1;
337 Pair<Transportable_, Transportable_> p2(Transportable_(1), Transportable_(2));
338 int p2I1Id = p2.i1.id;
339 int p2I1Value = p2.i1.value;
340 int p2I2Id = p2.i2.id;
341 int p2I2Value = p2.i2.value;
342
343 setValueI1(p1, p2.i1);
344 setValueI2(p1, p2.i2);
345
346 SEQAN_ASSERT_EQ(p1.i1.id, p2I1Id);
347 SEQAN_ASSERT_EQ(p1.i1.value, p2I1Value);
348 SEQAN_ASSERT_EQ(p1.i2.id, p2I2Id);
349 SEQAN_ASSERT_EQ(p1.i2.value, p2I2Value);
350 SEQAN_ASSERT_EQ(p2.i1.id, p2I1Id);
351 SEQAN_ASSERT_EQ(p2.i1.value, p2I1Value);
352 SEQAN_ASSERT_EQ(p2.i2.id, p2I2Id);
353 SEQAN_ASSERT_EQ(p2.i2.value, p2I2Value);
354 }
355 }
356
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_move_value)357 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_move_value)
358 {
359 // Test with ints.
360 {
361 Pair<int, int> p1;
362 Pair<int, int> p2(1, 2);
363
364 moveValueI1(p1, p2.i1);
365 moveValueI2(p1, p2.i2);
366
367 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
368 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
369 }
370
371 // Test with Transportable_ type.
372 {
373 Pair<Transportable_, Transportable_> p1;
374 Pair<Transportable_, Transportable_> p2(Transportable_(1), Transportable_(2));
375 int p2I1Id = p2.i1.id;
376 int p2I1Value = p2.i1.value;
377 int p2I2Id = p2.i2.id;
378 int p2I2Value = p2.i2.value;
379
380 moveValueI1(p1, p2.i1);
381 moveValueI2(p1, p2.i2);
382
383 SEQAN_ASSERT_EQ(p1.i1.id, p2I1Id);
384 SEQAN_ASSERT_EQ(p1.i1.value, p2I1Value);
385 SEQAN_ASSERT_EQ(p1.i2.id, p2I2Id);
386 SEQAN_ASSERT_EQ(p1.i2.value, p2I2Value);
387 SEQAN_ASSERT_EQ(p2.i1.id, -1);
388 SEQAN_ASSERT_EQ(p2.i1.value, p2I1Value);
389 SEQAN_ASSERT_EQ(p2.i2.id, -1);
390 SEQAN_ASSERT_EQ(p2.i2.value, p2I2Value);
391 }
392 }
393
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_comparison_same_spec)394 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_comparison_same_spec)
395 {
396 Pair<int, int> p00(0, 0);
397 Pair<int, int> p01(0, 1);
398 Pair<int, int> p10(1, 0);
399
400 SEQAN_ASSERT(p00 == p00);
401 SEQAN_ASSERT_NOT(p01 == p10);
402
403 SEQAN_ASSERT(p00 != p10);
404 SEQAN_ASSERT_NOT(p01 != p01);
405
406 SEQAN_ASSERT(p01 > p00);
407 SEQAN_ASSERT_NOT(p01 > p10);
408
409 SEQAN_ASSERT(p01 >= p01);
410 SEQAN_ASSERT(p01 >= p00);
411 SEQAN_ASSERT_NOT(p01 >= p10);
412
413 SEQAN_ASSERT(p00 <= p01);
414 SEQAN_ASSERT(p00 <= p00);
415 SEQAN_ASSERT_NOT(p10 <= p01);
416 }
417
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_comparison_different_spec)418 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_comparison_different_spec)
419 {
420 Pair<int, int64_t> p00(0, 0);
421 Pair<int, int64_t, Pack> p01(0, 1);
422 Pair<int, short int, BitPacked<20, 12> > p10(1, 0);
423
424 SEQAN_ASSERT(p00 == p00);
425 SEQAN_ASSERT_NOT(p01 == p10);
426
427 SEQAN_ASSERT(p00 != p10);
428 SEQAN_ASSERT_NOT(p01 != p01);
429
430 SEQAN_ASSERT(p01 > p00);
431 SEQAN_ASSERT_NOT(p01 > p10);
432
433 SEQAN_ASSERT(p01 >= p01);
434 SEQAN_ASSERT(p01 >= p00);
435 SEQAN_ASSERT_NOT(p01 >= p10);
436
437 SEQAN_ASSERT(p00 <= p01);
438 SEQAN_ASSERT(p00 <= p00);
439 SEQAN_ASSERT_NOT(p10 <= p01);
440 }
441
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_stream_output)442 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_base_stream_output)
443 {
444 std::stringstream s;
445 Pair<int, int> p(-1, 1);
446 s << p;
447 SEQAN_ASSERT_EQ(s.str(), "< -1 , 1 >");
448 }
449
450 // --------------------------------------------------------------------------
451 // Tests for Pack Pair.
452 // --------------------------------------------------------------------------
453
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_metafunctions)454 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_metafunctions)
455 {
456 typedef Pair<int, unsigned, Pack> TPair;
457 // Metafunction LENGTH
458 unsigned l = LENGTH<TPair>::VALUE;
459 SEQAN_ASSERT_EQ(l, 2u);
460 // Metafunction Value
461 bool b = IsSameType<typename Value<TPair, 1>::Type, int>::VALUE;
462 SEQAN_ASSERT_EQ(b, true);
463 b = IsSameType<typename Value<TPair, 2>::Type, unsigned>::VALUE;
464 SEQAN_ASSERT_EQ(b, true);
465 // Metafunction Spec
466 b = IsSameType<typename Spec<TPair>::Type, Pack>::VALUE;
467 SEQAN_ASSERT_EQ(b, true);
468 // // Metafunction Key
469 // b = IsSameType<typename Key<TPair>::Type, int>::VALUE;
470 // SEQAN_ASSERT_EQ(b, true);
471 // // Metafunction Cargo
472 // b = IsSameType<typename Cargo<TPair>::Type, unsigned>::VALUE;
473 // SEQAN_ASSERT_EQ(b, true);
474 }
475
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_constructors)476 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_constructors)
477 {
478 typedef Pair<int, unsigned, Pack> TPair;
479
480 // Default constructor.
481 {
482 TPair p{};
483
484 SEQAN_ASSERT_EQ(p.i1, 0);
485 SEQAN_ASSERT_EQ(p.i2, 0u);
486 }
487
488 // Normal Constructor Pair(i1, i2).
489 {
490 TPair p(1, 2);
491
492 SEQAN_ASSERT_EQ(p.i1, 1);
493 SEQAN_ASSERT_EQ(p.i2, 2u);
494 }
495
496 // Copy Constructor Pair(p).
497 {
498 TPair p(1, 2);
499 TPair p2(p);
500
501 SEQAN_ASSERT_EQ(p2.i1, 1);
502 SEQAN_ASSERT_EQ(p2.i2, 2u);
503 }
504
505 // Conversion constructor from other pair.
506 {
507 Pair<int, int> p2(1, 2);
508 TPair p(p2);
509
510 SEQAN_ASSERT_EQ(p.i1, 1);
511 SEQAN_ASSERT_EQ(p.i2, 2u);
512 }
513 }
514
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_assign)515 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_assign)
516 {
517 // Test with ints.
518 {
519 Pair<int, int, Pack> p1;
520 Pair<int, int, Pack> p2(1, 2);
521 assign(p1, p2);
522 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
523 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
524 }
525 }
526
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_set)527 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_set)
528 {
529 // Test with ints.
530 {
531 Pair<int, int, Pack> p1;
532 Pair<int, int, Pack> p2(1, 2);
533 set(p1, p2);
534 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
535 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
536 }
537 }
538
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_move)539 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_move)
540 {
541 // Test with ints.
542 {
543 Pair<int, int, Pack> p1;
544 Pair<int, int, Pack> p2(1, 2);
545 move(p1, p2);
546 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
547 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
548 }
549 }
550
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_stream_output)551 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_stream_output)
552 {
553 std::stringstream s;
554 Pair<int, int, Pack> p(-1, 1);
555 s << p;
556 SEQAN_ASSERT_EQ(s.str(), "< -1 , 1 >");
557
558 }
559
560 // SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_value)
561
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_get_value)562 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_get_value)
563 {
564 Pair<int, int, Pack> p(-1, 1);
565 SEQAN_ASSERT_EQ(getValueI1(p), -1);
566 SEQAN_ASSERT_EQ(getValueI2(p), 1);
567 }
568
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_assign_value)569 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_assign_value)
570
571 {
572 // Test with ints.
573 {
574 Pair<int, int, Pack> p1;
575 Pair<int, int, Pack> p2(1, 2);
576
577 assignValueI1(p1, p2.i1);
578 assignValueI2(p1, p2.i2);
579
580 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
581 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
582 }
583 }
584
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_set_value)585 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_set_value)
586 {
587 // Test with ints.
588 {
589 Pair<int, int, Pack> p1;
590 Pair<int, int, Pack> p2(1, 2);
591
592 setValueI1(p1, p2.i1);
593 setValueI2(p1, p2.i2);
594
595 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
596 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
597 }
598 }
599
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_move_value)600 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_move_value)
601 {
602 // Test with ints.
603 {
604 Pair<int, int, Pack> p1;
605 Pair<int, int, Pack> p2(1, 2);
606
607 int i1 = p2.i1;
608 int i2 = p2.i2;
609
610 moveValueI1(p1, i1);
611 moveValueI2(p1, i2);
612
613 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
614 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
615 }
616 }
617
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_comparison_same_spec)618 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_comparison_same_spec)
619 {
620 Pair<int, int, Pack> p00(0, 0);
621 Pair<int, int, Pack> p01(0, 1);
622 Pair<int, int, Pack> p10(1, 0);
623
624 SEQAN_ASSERT(p00 == p00);
625 SEQAN_ASSERT_NOT(p01 == p10);
626
627 SEQAN_ASSERT(p00 != p10);
628 SEQAN_ASSERT_NOT(p01 != p01);
629
630 SEQAN_ASSERT(p01 > p00);
631 SEQAN_ASSERT_NOT(p01 > p10);
632
633 SEQAN_ASSERT(p01 >= p01);
634 SEQAN_ASSERT(p01 >= p00);
635 SEQAN_ASSERT_NOT(p01 >= p10);
636
637 SEQAN_ASSERT(p00 <= p01);
638 SEQAN_ASSERT(p00 <= p00);
639 SEQAN_ASSERT_NOT(p10 <= p01);
640 }
641
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_comparison_different_spec)642 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_packed_comparison_different_spec)
643 {
644 Pair<int, int64_t> p00(0, 0);
645 Pair<int, int64_t, Pack> p01(0, 1);
646 Pair<int, short int, BitPacked<20, 12> > p10(1, 0);
647
648 SEQAN_ASSERT(p00 == p00);
649 SEQAN_ASSERT_NOT(p01 == p10);
650
651 SEQAN_ASSERT(p00 != p10);
652 SEQAN_ASSERT_NOT(p01 != p01);
653
654 SEQAN_ASSERT(p01 > p00);
655 SEQAN_ASSERT_NOT(p01 > p10);
656
657 SEQAN_ASSERT(p01 >= p01);
658 SEQAN_ASSERT(p01 >= p00);
659 SEQAN_ASSERT_NOT(p01 >= p10);
660
661 SEQAN_ASSERT(p00 <= p01);
662 SEQAN_ASSERT(p00 <= p00);
663 SEQAN_ASSERT_NOT(p10 <= p01);
664 }
665
666 // --------------------------------------------------------------------------
667 // Tests for Bit Pack Pair.
668 // --------------------------------------------------------------------------
669
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_metafunctions)670 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_metafunctions)
671 {
672 typedef BitPacked<16, 16> TSpec;
673 typedef Pair<int, unsigned, TSpec> TPair;
674 // Metafunction LENGTH
675 unsigned l = LENGTH<TPair>::VALUE;
676 SEQAN_ASSERT_EQ(l, 2u);
677 // Metafunction Value
678 bool b = IsSameType<typename Value<TPair, 1>::Type, int>::VALUE;
679 SEQAN_ASSERT_EQ(b, true);
680 b = IsSameType<typename Value<TPair, 2>::Type, unsigned>::VALUE;
681 SEQAN_ASSERT_EQ(b, true);
682 // Metafunction Spec
683 b = IsSameType<typename Spec<TPair>::Type, TSpec>::VALUE;
684 SEQAN_ASSERT_EQ(b, true);
685 // // Metafunction Key
686 // b = IsSameType<typename Key<TPair>::Type, int>::VALUE;
687 // SEQAN_ASSERT_EQ(b, true);
688 // // Metafunction Cargo
689 // b = IsSameType<typename Cargo<TPair>::Type, unsigned>::VALUE;
690 // SEQAN_ASSERT_EQ(b, true);
691 }
692
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_constructors)693 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_constructors)
694 {
695 typedef Pair<int, unsigned, BitPacked<16, 16> > TPair;
696
697 // Default constructor.
698 {
699 TPair p;
700 }
701
702 // Normal Constructor Pair(i1, i2).
703 {
704 TPair p(1, 2);
705
706 SEQAN_ASSERT_EQ(p.i1, 1);
707 SEQAN_ASSERT_EQ(p.i2, 2u);
708 }
709
710 // Copy Constructor Pair(p).
711 {
712 TPair p(1, 2);
713 TPair p2(p);
714
715 SEQAN_ASSERT_EQ(p2.i1, 1);
716 SEQAN_ASSERT_EQ(p2.i2, 2u);
717 }
718
719 // Conversion constructor from other pair.
720 {
721 Pair<int, int, Pack> p2(1, 2);
722 TPair p(p2);
723
724 SEQAN_ASSERT_EQ(p.i1, 1);
725 SEQAN_ASSERT_EQ(p.i2, 2u);
726 }
727 }
728
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_assign)729 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_assign)
730 {
731 // Test with ints.
732 {
733 Pair<int, int, BitPacked<16, 16> > p1;
734 Pair<int, int, BitPacked<16, 16> > p2(1, 2);
735 assign(p1, p2);
736 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
737 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
738 }
739 }
740
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_set)741 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_set)
742 {
743 // Test with ints.
744 {
745 Pair<int, int, BitPacked<16, 16> > p1;
746 Pair<int, int, BitPacked<16, 16> > p2(1, 2);
747 set(p1, p2);
748 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
749 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
750 }
751
752 }
753
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_move)754 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_move)
755 {
756 // Test with ints.
757 {
758 Pair<int, int, BitPacked<16, 16> > p1;
759 Pair<int, int, BitPacked<16, 16> > p2(1, 2);
760 move(p1, p2);
761 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
762 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
763 }
764 }
765
766 // SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_value)
767
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_get_value)768 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_get_value)
769 {
770 Pair<int, int, BitPacked<16, 16> > p(-1, 1);
771 SEQAN_ASSERT_EQ(getValueI1(p), -1);
772 SEQAN_ASSERT_EQ(getValueI2(p), 1);
773 }
774
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_assign_value)775 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_assign_value)
776 {
777 // Test with ints.
778 {
779 Pair<int, int, BitPacked<16, 16> > p1;
780 Pair<int, int, BitPacked<16, 16> > p2(1, 2);
781
782 assignValueI1(p1, p2.i1);
783 assignValueI2(p1, p2.i2);
784
785 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
786 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
787 }
788 }
789
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_set_value)790 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_set_value)
791 {
792 // Test with ints.
793 {
794 Pair<int, int, BitPacked<16, 16> > p1;
795 Pair<int, int, BitPacked<16, 16> > p2(1, 2);
796
797 setValueI1(p1, p2.i1);
798 setValueI2(p1, p2.i2);
799
800 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
801 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
802 }
803 }
804
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_move_value)805 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_move_value)
806 {
807 // Test with ints.
808 {
809 Pair<int, int, BitPacked<16, 16> > p1;
810 Pair<int, int, BitPacked<16, 16> > p2(1, 2);
811
812 int i1 = p2.i1;
813 int i2 = p2.i2;
814
815 moveValueI1(p1, i1);
816 moveValueI2(p1, i2);
817
818 SEQAN_ASSERT_EQ(p1.i1, p2.i1);
819 SEQAN_ASSERT_EQ(p1.i2, p2.i2);
820 }
821 }
822
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_comparison_same_spec)823 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_comparison_same_spec)
824 {
825 Pair<int, int, BitPacked<16, 16> > p00(0, 0);
826 Pair<int, int, BitPacked<16, 16> > p01(0, 1);
827 Pair<int, int, BitPacked<16, 16> > p10(1, 0);
828
829 SEQAN_ASSERT(p00 == p00);
830 SEQAN_ASSERT_NOT(p01 == p10);
831
832 SEQAN_ASSERT(p00 != p10);
833 SEQAN_ASSERT_NOT(p01 != p01);
834
835 SEQAN_ASSERT(p01 > p00);
836 SEQAN_ASSERT_NOT(p01 > p10);
837
838 SEQAN_ASSERT(p01 >= p01);
839 SEQAN_ASSERT(p01 >= p00);
840 SEQAN_ASSERT_NOT(p01 >= p10);
841
842 SEQAN_ASSERT(p00 <= p01);
843 SEQAN_ASSERT(p00 <= p00);
844 SEQAN_ASSERT_NOT(p10 <= p01);
845 }
846
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_comparison_different_spec)847 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_comparison_different_spec)
848 {
849 Pair<int, int64_t> p00(0, 0);
850 Pair<int, int64_t, Pack> p01(0, 1);
851 Pair<int, short int, BitPacked<20, 12> > p10(1, 0);
852
853 SEQAN_ASSERT(p00 == p00);
854 SEQAN_ASSERT_NOT(p01 == p10);
855
856 SEQAN_ASSERT(p00 != p10);
857 SEQAN_ASSERT_NOT(p01 != p01);
858
859 SEQAN_ASSERT(p01 > p00);
860 SEQAN_ASSERT_NOT(p01 > p10);
861
862 SEQAN_ASSERT(p01 >= p01);
863 SEQAN_ASSERT(p01 >= p00);
864 SEQAN_ASSERT_NOT(p01 >= p10);
865
866 SEQAN_ASSERT(p00 <= p01);
867 SEQAN_ASSERT(p00 <= p00);
868 SEQAN_ASSERT_NOT(p10 <= p01);
869 }
870
SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_stream_output)871 SEQAN_DEFINE_TEST(test_basic_aggregates_pair_bit_packed_stream_output)
872 {
873 std::stringstream s;
874 Pair<int, int> p(-1, 1);
875 s << p;
876 SEQAN_ASSERT_EQ(s.str(), "< -1 , 1 >");
877 }
878
879 // --------------------------------------------------------------------------
880 // Tests for Base Triple.
881 // --------------------------------------------------------------------------
882
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_metafunctions)883 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_metafunctions)
884 {
885 typedef Triple<int, unsigned, double> TTriple;
886 // Metafunction LENGTH
887 unsigned l = LENGTH<TTriple>::VALUE;
888 SEQAN_ASSERT_EQ(l, 3u);
889 // Metafunction Value
890 bool b = IsSameType<typename Value<TTriple, 1>::Type, int>::VALUE;
891 SEQAN_ASSERT_EQ(b, true);
892 b = IsSameType<typename Value<TTriple, 2>::Type, unsigned>::VALUE;
893 SEQAN_ASSERT_EQ(b, true);
894 b = IsSameType<typename Value<TTriple, 3>::Type, double>::VALUE;
895 SEQAN_ASSERT_EQ(b, true);
896 // Metafunction Spec
897 b = IsSameType<typename Spec<TTriple>::Type, void>::VALUE;
898 SEQAN_ASSERT_EQ(b, true);
899 }
900
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_constructors)901 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_constructors)
902 {
903 typedef Triple<int, unsigned, double, Pack> TTriple;
904
905 // Default constructor.
906 {
907 TTriple t;
908 }
909
910 // Normal Constructor Triple(i1, i2).
911 {
912 TTriple t(1, 2, 3);
913
914 SEQAN_ASSERT_EQ(t.i1, 1);
915 SEQAN_ASSERT_EQ(t.i2, 2u);
916 SEQAN_ASSERT_EQ(t.i3, 3.);
917 }
918
919 // Copy Constructor Triple(p).
920 {
921 TTriple t(1, 2, 3);
922 TTriple t2(t);
923
924 SEQAN_ASSERT_EQ(t2.i1, 1);
925 SEQAN_ASSERT_EQ(t2.i2, 2u);
926 SEQAN_ASSERT_EQ(t2.i3, 3.);
927 }
928
929 // Conversion constructor from other triple.
930 {
931 Triple<int, int, int> t2(1, 2, 3);
932 TTriple t(t2);
933
934 SEQAN_ASSERT_EQ(t.i1, 1);
935 SEQAN_ASSERT_EQ(t.i2, 2u);
936 SEQAN_ASSERT_EQ(t.i3, 3.);
937 }
938 }
939
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_assign)940 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_assign)
941 {
942 // Test with ints.
943 {
944 Triple<int, int, int, Pack> t1;
945 Triple<int, int, int, Pack> t2(1, 2, 3);
946 assign(t1, t2);
947 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
948 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
949 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
950 }
951 }
952
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_set)953 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_set)
954 {
955 // Test with ints.
956 {
957 Triple<int, int, int, Pack> t1;
958 Triple<int, int, int, Pack> t2(1, 2, 3);
959 set(t1, t2);
960 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
961 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
962 }
963 }
964
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_move)965 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_move)
966 {
967 // Test with ints.
968 {
969 Triple<int, int, int, Pack> t1;
970 Triple<int, int, int, Pack> t2(1, 2, 3);
971 move(t1, t2);
972 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
973 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
974 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
975 }
976 }
977
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_get_value)978 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_get_value)
979 {
980 Triple<int, int, int> t(-1, 1, 0);
981 SEQAN_ASSERT_EQ(getValueI1(t), -1);
982 SEQAN_ASSERT_EQ(getValueI2(t), 1);
983 SEQAN_ASSERT_EQ(getValueI3(t), 0);
984 }
985
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_assign_value)986 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_assign_value)
987 {
988 // Test with ints.
989 {
990 Triple<int, int, int> t1;
991 Triple<int, int, int> t2(1, 2, 3);
992
993 assignValueI1(t1, t2.i1);
994 assignValueI2(t1, t2.i2);
995 assignValueI3(t1, t2.i3);
996
997 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
998 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
999 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
1000 }
1001 }
1002
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_set_value)1003 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_set_value)
1004 {
1005 // Test with ints.
1006 {
1007 Triple<int, int, int> t1;
1008 Triple<int, int, int> t2(1, 2, 3);
1009
1010 setValueI1(t1, t2.i1);
1011 setValueI2(t1, t2.i2);
1012 setValueI3(t1, t2.i3);
1013
1014 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
1015 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
1016 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
1017 }
1018 }
1019
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_move_value)1020 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_move_value)
1021 {
1022 // Test with ints.
1023 {
1024 Triple<int, int, int> t1;
1025 Triple<int, int, int> t2(1, 2, 3);
1026
1027 moveValueI1(t1, t2.i1);
1028 moveValueI2(t1, t2.i2);
1029 moveValueI3(t1, t2.i3);
1030
1031 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
1032 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
1033 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
1034 }
1035 }
1036
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_comparison_same_spec)1037 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_comparison_same_spec)
1038 {
1039 Triple<int, int, int> t001(0, 0, 1);
1040 Triple<int, int, int> t010(0, 1, 0);
1041 Triple<int, int, int> t100(1, 0, 0);
1042
1043 SEQAN_ASSERT(t001 == t001);
1044 SEQAN_ASSERT_NOT(t010 == t100);
1045
1046 SEQAN_ASSERT(t001 != t100);
1047 SEQAN_ASSERT_NOT(t010 != t010);
1048
1049 SEQAN_ASSERT(t010 > t001);
1050 SEQAN_ASSERT_NOT(t010 > t100);
1051
1052 SEQAN_ASSERT(t010 >= t010);
1053 SEQAN_ASSERT(t010 >= t001);
1054 SEQAN_ASSERT_NOT(t010 >= t100);
1055
1056 SEQAN_ASSERT(t001 <= t010);
1057 SEQAN_ASSERT(t001 <= t001);
1058 SEQAN_ASSERT_NOT(t100 <= t010);
1059 }
1060
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_comparison_different_spec)1061 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_comparison_different_spec)
1062 {
1063 Triple<int, int64_t, char> t001(0, 0, 1);
1064 Triple<int, int64_t, char, Pack> t010(0, 1, 0);
1065 Triple<int, short int, char > t100(1, 0, 0);
1066
1067 SEQAN_ASSERT(t001 == t001);
1068 SEQAN_ASSERT_NOT(t010 == t100);
1069
1070 SEQAN_ASSERT(t001 != t100);
1071 SEQAN_ASSERT_NOT(t010 != t010);
1072
1073 SEQAN_ASSERT(t010 > t001);
1074 SEQAN_ASSERT_NOT(t010 > t100);
1075
1076 SEQAN_ASSERT(t010 >= t010);
1077 SEQAN_ASSERT(t010 >= t001);
1078 SEQAN_ASSERT_NOT(t010 >= t100);
1079
1080 SEQAN_ASSERT(t001 <= t010);
1081 SEQAN_ASSERT(t001 <= t001);
1082 SEQAN_ASSERT_NOT(t100 <= t010);
1083 }
1084
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_stream_output)1085 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_base_stream_output)
1086 {
1087 std::stringstream s;
1088 Triple<int, int, int> t(-1, 1, 0);
1089 s << t;
1090 SEQAN_ASSERT_EQ(s.str(), "< -1 , 1 , 0 >");
1091 }
1092
1093 // --------------------------------------------------------------------------
1094 // Tests for Pack Triple.
1095 // --------------------------------------------------------------------------
1096
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_metafunctions)1097 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_metafunctions)
1098 {
1099 typedef Triple<int, unsigned, double, Pack> TTriple;
1100 // Metafunction LENGTH
1101 unsigned l = LENGTH<TTriple>::VALUE;
1102 SEQAN_ASSERT_EQ(l, 3u);
1103 // Metafunction Value
1104 bool b = IsSameType<typename Value<TTriple, 1>::Type, int>::VALUE;
1105 SEQAN_ASSERT_EQ(b, true);
1106 b = IsSameType<typename Value<TTriple, 2>::Type, unsigned>::VALUE;
1107 SEQAN_ASSERT_EQ(b, true);
1108 b = IsSameType<typename Value<TTriple, 3>::Type, double>::VALUE;
1109 SEQAN_ASSERT_EQ(b, true);
1110 // Metafunction Spec
1111 b = IsSameType<typename Spec<TTriple>::Type, Pack>::VALUE;
1112 SEQAN_ASSERT_EQ(b, true);
1113 }
1114
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_constructors)1115 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_constructors)
1116 {
1117 typedef Triple<int, unsigned, double, Pack> TTriple;
1118
1119 // Default constructor.
1120 {
1121 TTriple p;
1122 }
1123
1124 // Normal Constructor Triple(i1, i2).
1125 {
1126 TTriple t(1, 2, 3);
1127
1128 SEQAN_ASSERT_EQ(t.i1, 1);
1129 SEQAN_ASSERT_EQ(t.i2, 2u);
1130 SEQAN_ASSERT_EQ(t.i3, 3.);
1131 }
1132
1133 // Copy Constructor Triple(p).
1134 {
1135 TTriple t(1, 2, 3);
1136 TTriple t2(t);
1137
1138 SEQAN_ASSERT_EQ(t2.i1, 1);
1139 SEQAN_ASSERT_EQ(t2.i2, 2u);
1140 SEQAN_ASSERT_EQ(t2.i3, 3.);
1141 }
1142
1143 // Conversion constructor from other triple.
1144 {
1145 Triple<int, int, int> t2(1, 2, 3);
1146 TTriple t(t2);
1147
1148 SEQAN_ASSERT_EQ(t.i1, 1);
1149 SEQAN_ASSERT_EQ(t.i2, 2u);
1150 SEQAN_ASSERT_EQ(t.i3, 3.);
1151 }
1152 }
1153
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_assign)1154 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_assign)
1155 {
1156 // Test with ints.
1157 {
1158 Triple<int, int, int, Pack> t1;
1159 Triple<int, int, int, Pack> t2(1, 2, 3);
1160 assign(t1, t2);
1161 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
1162 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
1163 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
1164 }
1165 }
1166
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_set)1167 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_set)
1168 {
1169 // Test with ints.
1170 {
1171 Triple<int, int, int, Pack> t1;
1172 Triple<int, int, int, Pack> t2(1, 2, 3);
1173 set(t1, t2);
1174 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
1175 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
1176 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
1177 }
1178 }
1179
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_move)1180 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_move)
1181 {
1182 // Test with ints.
1183 {
1184 Triple<int, int, int, Pack> t1;
1185 Triple<int, int, int, Pack> t2(1, 2, 3);
1186 move(t1, t2);
1187 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
1188 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
1189 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
1190 }
1191 }
1192
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_stream_output)1193 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_stream_output)
1194 {
1195 std::stringstream s;
1196 Triple<int, int, int, Pack> p(-1, 1, 0);
1197 s << p;
1198 SEQAN_ASSERT_EQ(s.str(), "< -1 , 1 , 0 >");
1199
1200 }
1201
1202 // SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_value)
1203
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_get_value)1204 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_get_value)
1205 {
1206 Triple<int, int, int, Pack> t(-1, 1, 0);
1207 SEQAN_ASSERT_EQ(getValueI1(t), -1);
1208 SEQAN_ASSERT_EQ(getValueI2(t), 1);
1209 SEQAN_ASSERT_EQ(getValueI3(t), 0);
1210 }
1211
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_assign_value)1212 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_assign_value)
1213
1214 {
1215 // Test with ints.
1216 {
1217 Triple<int, int, int, Pack> t1;
1218 Triple<int, int, int, Pack> t2(1, 2, 3);
1219
1220 assignValueI1(t1, t2.i1);
1221 assignValueI2(t1, t2.i2);
1222 assignValueI3(t1, t2.i3);
1223
1224 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
1225 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
1226 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
1227 }
1228 }
1229
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_set_value)1230 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_set_value)
1231 {
1232 // Test with ints.
1233 {
1234 Triple<int, int, int, Pack> t1;
1235 Triple<int, int, int, Pack> t2(1, 2, 3);
1236
1237 setValueI1(t1, t2.i1);
1238 setValueI2(t1, t2.i2);
1239 setValueI3(t1, t2.i3);
1240
1241 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
1242 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
1243 SEQAN_ASSERT_EQ(t1.i3, t2.i3);
1244 }
1245 }
1246
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_move_value)1247 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_move_value)
1248 {
1249 // Test with ints.
1250 {
1251 Triple<int, int, int, Pack> t1;
1252 Triple<int, int, int, Pack> t2(1, 2, 3);
1253
1254 int i1 = t2.i1;
1255 int i2 = t2.i2;
1256 int i3 = t2.i3;
1257
1258 moveValueI1(t1, i1);
1259 moveValueI2(t1, i2);
1260 moveValueI3(t1, i3);
1261
1262 SEQAN_ASSERT_EQ(t1.i1, t2.i1);
1263 SEQAN_ASSERT_EQ(t1.i2, t2.i2);
1264 }
1265 }
1266
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_comparison_same_spec)1267 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_comparison_same_spec)
1268 {
1269 Triple<int, int, int, Pack> t001(0, 0, 1);
1270 Triple<int, int, int, Pack> t010(0, 1, 0);
1271 Triple<int, int, int, Pack> t100(1, 0, 0);
1272
1273 SEQAN_ASSERT(t001 == t001);
1274 SEQAN_ASSERT_NOT(t010 == t100);
1275
1276 SEQAN_ASSERT(t001 != t100);
1277 SEQAN_ASSERT_NOT(t010 != t010);
1278
1279 SEQAN_ASSERT(t010 > t001);
1280 SEQAN_ASSERT_NOT(t010 > t100);
1281
1282 SEQAN_ASSERT(t010 >= t010);
1283 SEQAN_ASSERT(t010 >= t001);
1284 SEQAN_ASSERT_NOT(t010 >= t100);
1285
1286 SEQAN_ASSERT(t001 <= t010);
1287 SEQAN_ASSERT(t001 <= t001);
1288 SEQAN_ASSERT_NOT(t100 <= t010);
1289 }
1290
SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_comparison_different_spec)1291 SEQAN_DEFINE_TEST(test_basic_aggregates_triple_packed_comparison_different_spec)
1292 {
1293 Triple<int, int64_t, char> t001(0, 0, 1);
1294 Triple<int, int64_t, char, Pack> t010(0, 1, 0);
1295 Triple<int, short int, char, BitPacked<20, 12> > t100(1, 0, 0);
1296
1297 SEQAN_ASSERT(t001 == t001);
1298 SEQAN_ASSERT_NOT(t010 == t100);
1299
1300 SEQAN_ASSERT(t001 != t100);
1301 SEQAN_ASSERT_NOT(t010 != t010);
1302
1303 SEQAN_ASSERT(t010 > t001);
1304 SEQAN_ASSERT_NOT(t010 > t100);
1305
1306 SEQAN_ASSERT(t010 >= t010);
1307 SEQAN_ASSERT(t010 >= t001);
1308 SEQAN_ASSERT_NOT(t010 >= t100);
1309
1310 SEQAN_ASSERT(t001 <= t010);
1311 SEQAN_ASSERT(t001 <= t001);
1312 SEQAN_ASSERT_NOT(t100 <= t010);
1313 }
1314
1315 // --------------------------------------------------------------------------
1316 // Tests for Base Tuple.
1317 // --------------------------------------------------------------------------
1318
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_metafunctions)1319 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_metafunctions)
1320 {
1321 typedef Tuple<int, 2> TTuple;
1322 // Metafunction LENGTH
1323 unsigned l = LENGTH<TTuple>::VALUE;
1324 SEQAN_ASSERT_EQ(l, 2u);
1325 // Metafunction Value
1326 bool b = IsSameType<typename Value<TTuple>::Type, int>::VALUE;
1327 SEQAN_ASSERT_EQ(b, true);
1328 // Metafunction Spec
1329 b = IsSameType<typename Spec<TTuple>::Type, void>::VALUE;
1330 SEQAN_ASSERT_EQ(b, true);
1331 }
1332
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_constructors)1333 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_constructors)
1334 {
1335 // Default constructor.
1336 Tuple<int, 2> t;
1337 (void)t;
1338 }
1339
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_assign)1340 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_assign)
1341 {
1342 typedef Tuple<int, 2> TTuple;
1343 TTuple t1;
1344 TTuple t2;
1345
1346 t1.i[0] = 1;
1347 t1.i[1] = -1;
1348
1349 assign(t2, t1);
1350
1351 SEQAN_ASSERT_EQ(t1.i[0], 1);
1352 SEQAN_ASSERT_EQ(t1.i[1], -1);
1353 }
1354
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_set)1355 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_set)
1356 {
1357 // Test with ints.
1358 {
1359 Tuple<int, 2> t1;
1360 Tuple<int, 2> t2;
1361 t2.i[0] = 1;
1362 t2.i[1] = 2;
1363
1364 set(t1, t2);
1365
1366 SEQAN_ASSERT_EQ(t1.i[0], t2.i[0]);
1367 SEQAN_ASSERT_EQ(t1.i[1], t2.i[1]);
1368 }
1369
1370 // Test with Transportable_ type.
1371 {
1372 Tuple<Transportable_, 2> t1;
1373 Tuple<Transportable_, 2> t2;
1374 t2.i[0] = Transportable_(1);
1375 t2.i[1] = Transportable_(2);
1376
1377 set(t1, t2);
1378
1379 SEQAN_ASSERT_EQ(t1.i[0].id, t2.i[0].id);
1380 SEQAN_ASSERT_EQ(t1.i[0].value, t2.i[0].value);
1381 SEQAN_ASSERT_EQ(t1.i[1].id, t2.i[1].id);
1382 SEQAN_ASSERT_EQ(t1.i[1].value, t2.i[1].value);
1383 }
1384 }
1385
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_move)1386 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_move)
1387 {
1388 // Test with ints.
1389 {
1390 Tuple<int, 2> t1;
1391 Tuple<int, 2> t2;
1392 t2.i[0] = 1;
1393 t2.i[1] = 2;
1394
1395 move(t1, t2);
1396
1397 SEQAN_ASSERT_EQ(t1.i[0], t2.i[0]);
1398 SEQAN_ASSERT_EQ(t1.i[1], t2.i[1]);
1399 }
1400
1401 // Test with Transportable_ type.
1402 {
1403 Tuple<Transportable_, 2> t1;
1404 Tuple<Transportable_, 2> t2;
1405 t2.i[0] = Transportable_(1);
1406 t2.i[1] = Transportable_(2);
1407 int t2I1Id = t2.i[0].id;
1408 int t2I1Value = t2.i[0].value;
1409 int t2I2Id = t2.i[1].id;
1410 int t2I2Value = t2.i[1].value;
1411
1412 move(t1, t2);
1413
1414 SEQAN_ASSERT_EQ(t1.i[0].id, t2I1Id);
1415 SEQAN_ASSERT_EQ(t1.i[0].value, t2I1Value);
1416 SEQAN_ASSERT_EQ(t1.i[1].id, t2I2Id);
1417 SEQAN_ASSERT_EQ(t1.i[1].value, t2I2Value);
1418 SEQAN_ASSERT_EQ(t2.i[0].id, -1);
1419 SEQAN_ASSERT_EQ(t2.i[1].id, -1);
1420 }
1421 }
1422
1423 // SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_value); // TODO(holtgrew): Need proxy for this.
1424
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_get_value)1425 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_get_value)
1426 {
1427 Tuple<int, 2> t;
1428 t.i[0] = 1;
1429 t.i[1] = -1;
1430 SEQAN_ASSERT_EQ(getValue(t, 0), 1);
1431 SEQAN_ASSERT_EQ(getValue(t, 1), -1);
1432 }
1433
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_assign_value)1434 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_assign_value)
1435 {
1436 // Test with ints.
1437 {
1438 Tuple<int, 2> t1;
1439 Tuple<int, 2> t2;
1440 t2.i[0] = 1;
1441 t2.i[1] = -1;
1442
1443 assignValue(t1, 0, t2.i[0]);
1444 assignValue(t1, 1, t2.i[1]);
1445
1446 SEQAN_ASSERT_EQ(t1.i[0], t2.i[0]);
1447 SEQAN_ASSERT_EQ(t1.i[1], t2.i[1]);
1448 }
1449
1450 // Test with Transportable_ type.
1451 {
1452 Tuple<Transportable_, 2> t1;
1453 Tuple<Transportable_, 2> t2;
1454 t2.i[0] = Transportable_(1);
1455 t2.i[1] = Transportable_(-1);
1456 int t1I1Id = t1.i[0].id;
1457 int t1I2Id = t1.i[1].id;
1458 int t2I1Id = t2.i[0].id;
1459 int t2I1Value = t2.i[0].value;
1460 int t2I2Id = t2.i[1].id;
1461 int t2I2Value = t2.i[1].value;
1462
1463 assignValue(t1, 0, t2.i[0]);
1464 assignValue(t1, 1, t2.i[1]);
1465
1466 SEQAN_ASSERT_EQ(t1.i[0].id, t1I1Id);
1467 SEQAN_ASSERT_EQ(t1.i[0].value, t2I1Value);
1468 SEQAN_ASSERT_EQ(t1.i[1].id, t1I2Id);
1469 SEQAN_ASSERT_EQ(t1.i[1].value, t2I2Value);
1470 SEQAN_ASSERT_EQ(t2.i[0].id, t2I1Id);
1471 SEQAN_ASSERT_EQ(t2.i[0].value, t2I1Value);
1472 SEQAN_ASSERT_EQ(t2.i[1].id, t2I2Id);
1473 SEQAN_ASSERT_EQ(t2.i[1].value, t2I2Value);
1474 }
1475 }
1476
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_set_value)1477 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_set_value)
1478 {
1479 // Test with ints.
1480 {
1481 Tuple<int, 2> t1;
1482 Tuple<int, 2> t2;
1483 t2.i[0] = 1;
1484 t2.i[1] = 2;
1485
1486 setValue(t1, 0, t2.i[0]);
1487 setValue(t1, 1, t2.i[1]);
1488
1489 SEQAN_ASSERT_EQ(t1.i[0], t2.i[0]);
1490 SEQAN_ASSERT_EQ(t1.i[1], t2.i[1]);
1491 }
1492
1493 // Test with Transportable_ type.
1494 {
1495 Tuple<Transportable_, 2> t1;
1496 Tuple<Transportable_, 2> t2;
1497 t2.i[0] = Transportable_(1);
1498 t2.i[1] = Transportable_(2);
1499 int t2I1Id = t2.i[0].id;
1500 int t2I1Value = t2.i[0].value;
1501 int t2I2Id = t2.i[1].id;
1502 int t2I2Value = t2.i[1].value;
1503
1504 setValue(t1, 0, t2.i[0]);
1505 setValue(t1, 1, t2.i[1]);
1506
1507 SEQAN_ASSERT_EQ(t1.i[0].id, t2I1Id);
1508 SEQAN_ASSERT_EQ(t1.i[0].value, t2I1Value);
1509 SEQAN_ASSERT_EQ(t1.i[1].id, t2I2Id);
1510 SEQAN_ASSERT_EQ(t1.i[1].value, t2I2Value);
1511 SEQAN_ASSERT_EQ(t2.i[0].id, t2I1Id);
1512 SEQAN_ASSERT_EQ(t2.i[0].value, t2I1Value);
1513 SEQAN_ASSERT_EQ(t2.i[1].id, t2I2Id);
1514 SEQAN_ASSERT_EQ(t2.i[1].value, t2I2Value);
1515 }
1516 }
1517
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_move_value)1518 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_move_value)
1519 {
1520 // Test with ints.
1521 {
1522 Tuple<int, 2> t1;
1523 Tuple<int, 2> t2;
1524 t2.i[0] = 1;
1525 t2.i[1] = 2;
1526
1527 setValue(t1, 0, t2.i[0]);
1528 setValue(t1, 1, t2.i[1]);
1529
1530 SEQAN_ASSERT_EQ(t1.i[0], t2.i[0]);
1531 SEQAN_ASSERT_EQ(t1.i[1], t2.i[1]);
1532 }
1533
1534 // Test with Transportable_ type.
1535 {
1536 Tuple<Transportable_, 2> t1;
1537 Tuple<Transportable_, 2> t2;
1538 t2.i[0] = Transportable_(1);
1539 t2.i[1] = Transportable_(2);
1540 int t2I1Id = t2.i[0].id;
1541 int t2I1Value = t2.i[0].value;
1542 int t2I2Id = t2.i[1].id;
1543 int t2I2Value = t2.i[1].value;
1544
1545 moveValue(t1, 0, t2.i[0]);
1546 moveValue(t1, 1, t2.i[1]);
1547
1548 SEQAN_ASSERT_EQ(t1.i[0].id, t2I1Id);
1549 SEQAN_ASSERT_EQ(t1.i[0].value, t2I1Value);
1550 SEQAN_ASSERT_EQ(t1.i[1].id, t2I2Id);
1551 SEQAN_ASSERT_EQ(t1.i[1].value, t2I2Value);
1552 SEQAN_ASSERT_EQ(t2.i[0].id, -1);
1553 SEQAN_ASSERT_EQ(t2.i[0].value, t2I1Value);
1554 SEQAN_ASSERT_EQ(t2.i[1].id, -1);
1555 SEQAN_ASSERT_EQ(t2.i[1].value, t2I2Value);
1556 }
1557 }
1558
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_shift_left)1559 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_shift_left)
1560 {
1561 // Test with ints.
1562 {
1563 Tuple<int, 3> t1;
1564 t1.i[0] = 1;
1565 t1.i[1] = 2;
1566 t1.i[2] = 3;
1567
1568 shiftLeft(t1);
1569
1570 SEQAN_ASSERT_EQ(t1.i[0], 2);
1571 SEQAN_ASSERT_EQ(t1.i[1], 3);
1572 SEQAN_ASSERT_EQ(t1.i[1], 3);
1573 }
1574
1575 // TODO(holtgrew): Test with transportable after fixing set/move/assign here.
1576 }
1577
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_shift_right)1578 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_shift_right)
1579 {
1580 // Test with ints.
1581 {
1582 Tuple<int, 3> t1;
1583 t1.i[0] = 1;
1584 t1.i[1] = 2;
1585 t1.i[2] = 3;
1586
1587 shiftRight(t1);
1588
1589 SEQAN_ASSERT_EQ(t1.i[0], 1);
1590 SEQAN_ASSERT_EQ(t1.i[1], 1);
1591 SEQAN_ASSERT_EQ(t1.i[2], 2);
1592 }
1593
1594 // TODO(holtgrew): Test with transportable after fixing set/move/assign here.
1595 }
1596
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_clear)1597 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_clear)
1598 {
1599 // Test with ints.
1600 {
1601 Tuple<int, 3> t1;
1602 t1.i[0] = 1;
1603 t1.i[1] = 2;
1604 t1.i[2] = 3;
1605
1606 clear(t1);
1607
1608 SEQAN_ASSERT_EQ(t1.i[0], 0);
1609 SEQAN_ASSERT_EQ(t1.i[1], 0);
1610 SEQAN_ASSERT_EQ(t1.i[2], 0);
1611 }
1612 }
1613
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_length)1614 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_length)
1615 {
1616 // Test with ints.
1617 {
1618 Tuple<int, 3> t1;
1619 SEQAN_ASSERT_EQ(length(t1), 3u);
1620 }
1621 }
1622
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_comparison_same_spec)1623 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_comparison_same_spec)
1624 {
1625 Tuple<int, 2> p00; p00.i[0] = 0; p00.i[1] = 0;
1626 Tuple<int, 2> p01; p01.i[0] = 0; p01.i[1] = 1;
1627 Tuple<int, 2> p10; p10.i[0] = 1; p10.i[1] = 0;
1628
1629 SEQAN_ASSERT(p00 == p00);
1630 SEQAN_ASSERT_NOT(p01 == p10);
1631
1632 SEQAN_ASSERT(p00 != p10);
1633 SEQAN_ASSERT_NOT(p01 != p01);
1634
1635 SEQAN_ASSERT(p01 > p00);
1636 SEQAN_ASSERT_NOT(p01 > p10);
1637
1638 SEQAN_ASSERT(p01 >= p01);
1639 SEQAN_ASSERT(p01 >= p00);
1640 SEQAN_ASSERT_NOT(p01 >= p10);
1641
1642 SEQAN_ASSERT(p00 <= p01);
1643 SEQAN_ASSERT(p00 <= p00);
1644 SEQAN_ASSERT_NOT(p10 <= p01);
1645 }
1646
1647 // SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_comparison_different_spec) // Not worth the bother, probably.
1648
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_stream_output)1649 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_base_stream_output)
1650 {
1651 Tuple<int, 3> t1;
1652 t1.i[0] = 1;
1653 t1.i[1] = 2;
1654 t1.i[2] = 3;
1655
1656 std::stringstream s;
1657 s << t1;
1658 SEQAN_ASSERT_EQ(s.str(), "[1 2 3]"); // TODO(holtgrew): Why not "< 1 , 2 , 3 >", as for triples?
1659 }
1660
1661 // --------------------------------------------------------------------------
1662 // Tests for Bit-Pack Tuple.
1663 // --------------------------------------------------------------------------
1664
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_metafunctions)1665 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_metafunctions)
1666 {
1667 typedef Tuple<char, 2, BitPacked<> > TTuple;
1668 // Metafunction LENGTH
1669 unsigned l = LENGTH<TTuple>::VALUE;
1670 SEQAN_ASSERT_EQ(l, 2u);
1671 // Metafunction Value
1672 bool b = IsSameType<typename Value<TTuple>::Type, char>::VALUE;
1673 SEQAN_ASSERT_EQ(b, true);
1674 // Metafunction Spec
1675 b = IsSameType<typename Spec<TTuple>::Type, BitPacked<> >::VALUE;
1676 SEQAN_ASSERT_EQ(b, true);
1677 }
1678
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_constructors)1679 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_constructors)
1680 {
1681 // Default constructor.
1682 Tuple<char, 2, BitPacked<> > t;
1683 (void)t;
1684 }
1685
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_assign)1686 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_assign)
1687 {
1688 typedef Tuple<char, 2, BitPacked<> > TTuple;
1689 TTuple t1;
1690 TTuple t2;
1691
1692 clear(t1);
1693 assignValue(t1, 0, 1);
1694 assignValue(t1, 1, 2);
1695
1696 assign(t2, t1);
1697
1698 SEQAN_ASSERT_EQ(getValue(t2, 0), 1);
1699 SEQAN_ASSERT_EQ(getValue(t2, 1), 2);
1700 }
1701
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_set)1702 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_set)
1703 {
1704 typedef Tuple<char, 2, BitPacked<> > TTuple;
1705 TTuple t1;
1706 TTuple t2;
1707
1708 clear(t1);
1709 assignValue(t1, 0, 1);
1710 assignValue(t1, 1, 2);
1711
1712 set(t2, t1);
1713
1714 SEQAN_ASSERT_EQ(getValue(t2, 0), 1);
1715 SEQAN_ASSERT_EQ(getValue(t2, 1), 2);
1716 }
1717
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_move)1718 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_move)
1719 {
1720 typedef Tuple<char, 2, BitPacked<> > TTuple;
1721 TTuple t1;
1722 TTuple t2;
1723
1724 clear(t1);
1725 assignValue(t1, 0, 1);
1726 assignValue(t1, 1, 2);
1727
1728 move(t2, t1);
1729
1730 SEQAN_ASSERT_EQ(getValue(t2, 0), 1);
1731 SEQAN_ASSERT_EQ(getValue(t2, 1), 2);
1732 }
1733
1734 // SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_value); // TODO(holtgrew): Need proxy for this.
1735
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_get_value)1736 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_get_value)
1737 {
1738 typedef Tuple<char, 2, BitPacked<> > TTuple;
1739 TTuple t1;
1740
1741 clear(t1);
1742 assignValue(t1, 0, 1);
1743 assignValue(t1, 1, 2);
1744
1745 SEQAN_ASSERT_EQ(getValue(t1, 0), 1);
1746 SEQAN_ASSERT_EQ(getValue(t1, 1), 2);
1747 }
1748
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_assign_value)1749 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_assign_value)
1750 {
1751 typedef Tuple<char, 2, BitPacked<> > TTuple;
1752 TTuple t1;
1753
1754 clear(t1);
1755 assignValue(t1, 0, 1);
1756 assignValue(t1, 1, 2);
1757
1758 SEQAN_ASSERT_EQ(getValue(t1, 0), 1);
1759 SEQAN_ASSERT_EQ(getValue(t1, 1), 2);
1760 }
1761
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_set_value)1762 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_set_value)
1763 {
1764 typedef Tuple<char, 2, BitPacked<> > TTuple;
1765 TTuple t1;
1766
1767 clear(t1);
1768 setValue(t1, 0, 1);
1769 setValue(t1, 1, 2);
1770
1771 SEQAN_ASSERT_EQ(getValue(t1, 0), 1);
1772 SEQAN_ASSERT_EQ(getValue(t1, 1), 2);
1773 }
1774
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_move_value)1775 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_move_value)
1776 {
1777 typedef Tuple<char, 2, BitPacked<> > TTuple;
1778 TTuple t1;
1779
1780 clear(t1);
1781 moveValue(t1, 0, 1);
1782 moveValue(t1, 1, 2);
1783
1784 SEQAN_ASSERT_EQ(getValue(t1, 0), 1);
1785 SEQAN_ASSERT_EQ(getValue(t1, 1), 2);
1786 }
1787
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_shift_left)1788 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_shift_left)
1789 {
1790 Tuple<char, 2, BitPacked<> > t1;
1791 clear(t1);
1792 assignValue(t1, 0, 1);
1793 assignValue(t1, 1, 2);
1794
1795 shiftLeft(t1);
1796
1797 SEQAN_ASSERT_EQ(getValue(t1, 0), 2);
1798 SEQAN_ASSERT_EQ(getValue(t1, 1), 0);
1799 }
1800
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_shift_right)1801 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_shift_right)
1802 {
1803 Tuple<char, 2, BitPacked<> > t1;
1804 clear(t1);
1805 assignValue(t1, 0, 1);
1806 assignValue(t1, 1, 2);
1807
1808 shiftRight(t1);
1809
1810 SEQAN_ASSERT_EQ(getValue(t1, 0), 0);
1811 SEQAN_ASSERT_EQ(getValue(t1, 1), 1);
1812 }
1813
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_clear)1814 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_clear)
1815 {
1816 Tuple<char, 2, BitPacked<> > t1;
1817 clear(t1);
1818 assignValue(t1, 0, 1);
1819 assignValue(t1, 1, 2);
1820
1821 clear(t1);
1822
1823 SEQAN_ASSERT_EQ(getValue(t1, 0), 0);
1824 SEQAN_ASSERT_EQ(getValue(t1, 1), 0);
1825 }
1826
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_length)1827 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_length)
1828 {
1829 Tuple<char, 2, BitPacked<> > t1;
1830 SEQAN_ASSERT_EQ(length(t1), 2u);
1831 }
1832
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_comparison_same_spec)1833 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_comparison_same_spec)
1834 {
1835 Tuple<char, 2, BitPacked<> > t00;
1836 clear(t00);
1837 assignValue(t00, 0, 0);
1838 assignValue(t00, 1, 0);
1839
1840 Tuple<char, 2, BitPacked<> > t01;
1841 clear(t01);
1842 assignValue(t01, 0, 0);
1843 assignValue(t01, 1, 1);
1844
1845 Tuple<char, 2, BitPacked<> > t10;
1846 clear(t10);
1847 assignValue(t10, 0, 1);
1848 assignValue(t10, 1, 0);
1849
1850 SEQAN_ASSERT(t00 == t00);
1851 SEQAN_ASSERT_NOT(t01 == t10);
1852
1853 SEQAN_ASSERT(t00 != t10);
1854 SEQAN_ASSERT_NOT(t01 != t01);
1855
1856 SEQAN_ASSERT(t01 > t00);
1857 SEQAN_ASSERT_NOT(t01 > t10);
1858
1859 SEQAN_ASSERT(t01 >= t01);
1860 SEQAN_ASSERT(t01 >= t00);
1861 SEQAN_ASSERT_NOT(t01 >= t10);
1862
1863 SEQAN_ASSERT(t00 <= t01);
1864 SEQAN_ASSERT(t00 <= t00);
1865 SEQAN_ASSERT_NOT(t10 <= t01);
1866 }
1867
1868 // SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_comparison_different_spec) // Not worth the bother, probably.
1869
SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_stream_output)1870 SEQAN_DEFINE_TEST(test_basic_aggregates_tuple_bit_packed_stream_output)
1871 {
1872 Tuple<char, 2, BitPacked<> > t1;
1873 clear(t1);
1874 assignValue(t1, 0, 'a');
1875 assignValue(t1, 1, 'b');
1876
1877 std::stringstream s;
1878 s << t1;
1879 SEQAN_ASSERT_EQ(s.str(), "[a b]");
1880
1881 }
1882
1883 #endif // #ifndef TESTS_BASIC_TEST_BASIC_AGGREGATES_H_
1884