1 // documentation and/or other materials provided with the distribution.
2 // * Neither the name of Knut Reinert or the FU Berlin nor the names of
3 // its contributors may be used to endorse or promote products derived
4 // from this software without specific prior written permission.
5 //
6 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
7 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
8 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
9 // ARE DISCLAIMED. IN NO EVENT SHALL KNUT REINERT OR THE FU BERLIN BE LIABLE
10 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
11 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
12 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
13 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
14 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
15 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
16 // DAMAGE.
17 //
18 // ==========================================================================
19 // Author: Manuel Holtgrewe <manuel.holtgrew@fu-berlin.de>
20 // ==========================================================================
21 // Tests for the Holder classes.
22 // ==========================================================================
23
24 #ifndef TESTS_BASIC_TEST_BASIC_HOLDER_H_
25 #define TESTS_BASIC_TEST_BASIC_HOLDER_H_
26
27 // --------------------------------------------------------------------------
28 // Test for Simple Holder
29 // --------------------------------------------------------------------------
30
SEQAN_DEFINE_TEST(test_basic_holder_simple_metafunctions)31 SEQAN_DEFINE_TEST(test_basic_holder_simple_metafunctions)
32 {
33 using namespace seqan;
34
35 // Tests for non-const holder.
36 {
37 typedef Holder<int, Simple> THolder;
38
39 typedef typename Value<THolder>::Type TValue;
40 bool b = IsSameType<int, TValue>::Type::VALUE;
41 SEQAN_ASSERT(b);
42
43 typedef typename GetValue<THolder>::Type TGetValue;
44 b = IsSameType<int const &, TGetValue>::Type::VALUE;
45 SEQAN_ASSERT(b);
46
47 typedef typename Reference<THolder>::Type TReference;
48 b = IsSameType<int &, TReference>::Type::VALUE;
49 SEQAN_ASSERT(b);
50
51 typedef typename Spec<THolder>::Type TSpec;
52 b = IsSameType<Simple, TSpec>::Type::VALUE;
53 SEQAN_ASSERT(b);
54 }
55
56 // Tests for const holder.
57 {
58 typedef Holder<int, Simple> const THolder;
59
60 typedef typename Value<THolder>::Type TValue;
61 bool b = IsSameType<int, TValue>::Type::VALUE;
62 SEQAN_ASSERT(b);
63
64 typedef typename GetValue<THolder>::Type TGetValue;
65 b = IsSameType<int const &, TGetValue>::Type::VALUE;
66 SEQAN_ASSERT(b);
67
68 typedef typename Reference<THolder>::Type TReference;
69 b = IsSameType<int &, TReference>::Type::VALUE;
70 SEQAN_ASSERT(b);
71
72 typedef typename Spec<THolder>::Type TSpec;
73 b = IsSameType<Simple, TSpec>::Type::VALUE;
74 SEQAN_ASSERT(b);
75 }
76 }
77
SEQAN_DEFINE_TEST(test_basic_holder_simple_constructors)78 SEQAN_DEFINE_TEST(test_basic_holder_simple_constructors)
79 {
80 using namespace seqan;
81
82 // Simple Holder always copies, wo we do not really have to test much
83 // here.
84
85 // Construct from value.
86 {
87 typedef Holder<int, Simple> THolder;
88
89 int x = 10;
90 THolder holder(x);
91
92 SEQAN_ASSERT_EQ(value(holder), 10);
93 SEQAN_ASSERT_NEQ(&value(holder), &x);
94 SEQAN_ASSERT_NOT(empty(holder));
95 SEQAN_ASSERT_NOT(dependent(holder));
96 }
97
98 // Construct from other holder.
99 {
100 typedef Holder<int, Simple> THolderSource;
101 typedef Holder<int, Simple> THolderTarget;
102
103 int x = 10;
104 THolderSource holderSource(x);
105 THolderTarget holderTarget(holderSource);
106
107 SEQAN_ASSERT_EQ(value(holderTarget), 10);
108 SEQAN_ASSERT_NEQ(&value(holderTarget), &value(holderSource));
109 SEQAN_ASSERT_NOT(empty(holderTarget));
110 SEQAN_ASSERT_NOT(dependent(holderTarget));
111 }
112 }
113
SEQAN_DEFINE_TEST(test_basic_holder_simple_transport)114 SEQAN_DEFINE_TEST(test_basic_holder_simple_transport)
115 {
116 using namespace seqan;
117
118 // assign()
119 {
120 typedef Holder<CDStruct, Simple> THolder;
121
122 resetCDStructStatics();
123
124 CDStruct s1;
125 CDStruct s2;
126 THolder s(s1);
127 THolder t(s2);
128 assign(t, s);
129
130 SEQAN_ASSERT_EQ(value(t).assignedFrom, value(s).id);
131 }
132
133 // move()
134 {
135 typedef Holder<CDStruct, Simple> THolder;
136
137 resetCDStructStatics();
138
139 CDStruct s1;
140 CDStruct s2;
141 THolder s(s1);
142 THolder t(s2);
143 move(t, s);
144
145 SEQAN_ASSERT_EQ(value(t).assignedFrom, value(s).id);
146 }
147
148 // set()
149 {
150 typedef Holder<CDStruct, Simple> THolder;
151
152 resetCDStructStatics();
153
154 CDStruct s1;
155 CDStruct s2;
156 THolder s(s1);
157 THolder t(s2);
158 set(t, s);
159
160 SEQAN_ASSERT_EQ(value(t).assignedFrom, value(s).id);
161 }
162 }
163
SEQAN_DEFINE_TEST(test_basic_holder_simple_transport_value)164 SEQAN_DEFINE_TEST(test_basic_holder_simple_transport_value)
165 {
166 using namespace seqan;
167
168 // assignValue()
169 {
170 typedef Holder<CDStruct, Simple> THolder;
171
172 resetCDStructStatics();
173
174 CDStruct s1;
175 CDStruct s2;
176 THolder h(s1);
177 assignValue(h, s2);
178
179 SEQAN_ASSERT_EQ(value(h).assignedFrom, s2.id);
180 }
181
182 // moveValue()
183 {
184 typedef Holder<CDStruct, Simple> THolder;
185
186 resetCDStructStatics();
187
188 CDStruct s1;
189 CDStruct s2;
190 THolder h(s1);
191 moveValue(h, s2);
192
193 SEQAN_ASSERT_EQ(value(h).movedFrom, s2.id);
194 }
195
196 // setValue()
197 {
198 typedef Holder<CDStruct, Simple> THolder;
199
200 resetCDStructStatics();
201
202 CDStruct s1;
203 CDStruct s2;
204 THolder h(s1);
205 setValue(h, s2);
206
207 SEQAN_ASSERT_EQ(value(h).setFrom, s2.id);
208 }
209 }
210
SEQAN_DEFINE_TEST(test_basic_holder_simple_dependencies)211 SEQAN_DEFINE_TEST(test_basic_holder_simple_dependencies)
212 {
213 using namespace seqan;
214
215 // Since Simple Holder always copies, some simple tests are enough.
216
217 // Construct from value; Clearing should have no effect.
218 {
219 typedef Holder<CDStruct, Simple> THolder;
220
221 resetCDStructStatics();
222
223 CDStruct x;
224 THolder holder(x);
225
226 SEQAN_ASSERT_NOT(empty(holder));
227 SEQAN_ASSERT_NOT(dependent(holder));
228 clear(holder);
229 SEQAN_ASSERT_NOT(empty(holder));
230
231 SEQAN_ASSERT_EQ(value(holder).copiedFrom, x.id);
232
233 SEQAN_ASSERT_EQ(CDStruct::lastOther, &x);
234 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
235 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 1);
236 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
237 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
238 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
239 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
240 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
241 }
242
243 // Test detach - empty implementation.
244 {
245 typedef Holder<CDStruct, Simple> THolder;
246
247 resetCDStructStatics();
248
249 CDStruct x;
250 THolder holder(x);
251
252 SEQAN_ASSERT_NOT(empty(holder));
253 SEQAN_ASSERT_NOT(dependent(holder));
254 clear(holder);
255 SEQAN_ASSERT_NOT(empty(holder));
256
257 detach(holder);
258
259 SEQAN_ASSERT_EQ(value(holder).copiedFrom, x.id);
260
261 SEQAN_ASSERT_EQ(CDStruct::lastOther, &x);
262 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
263 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 1);
264 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
265 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
266 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
267 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
268 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
269 }
270
271 // Test create - trivial implementation.
272 {
273 typedef Holder<CDStruct, Simple> THolder;
274
275 resetCDStructStatics();
276
277 CDStruct x;
278 THolder holder(x);
279 SEQAN_ASSERT_EQ(value(holder).copiedFrom, x.id);
280 SEQAN_ASSERT_EQ(CDStruct::lastOther, &x);
281
282 create(holder); // Does nothing.
283
284 CDStruct y;
285 create(holder, y); // Assigns.
286 SEQAN_ASSERT_EQ(value(holder).assignedFrom, y.id);
287 SEQAN_ASSERT_EQ(CDStruct::lastOther, &y);
288
289 CDStruct z;
290 create(holder, z, Move()); // Moves
291 SEQAN_ASSERT_EQ(value(holder).assignedFrom, z.id);
292 // SEQAN_ASSERT_EQ(value(holder).movedFrom, z.id);
293 SEQAN_ASSERT_EQ(CDStruct::lastOther, &z);
294
295 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 3);
296 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 1);
297 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
298 // SEQAN_ASSERT_EQ(CDStruct::moves, 1);
299 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
300 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
301 // SEQAN_ASSERT_EQ(CDStruct::assignments, 1);
302 SEQAN_ASSERT_EQ(CDStruct::assignments, 2);
303 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
304 }
305
306 // Copy construct from same type. Should copy all the same and not be
307 // dependent.
308 {
309 typedef Holder<CDStruct, Simple> THolder;
310
311 resetCDStructStatics();
312
313 CDStruct x;
314 THolder holderSource(x);
315 THolder holderTarget(holderSource);
316
317 SEQAN_ASSERT_EQ(value(holderTarget).copiedFrom, value(holderSource).id);
318 SEQAN_ASSERT_EQ(CDStruct::lastOther, &value(holderSource));
319
320 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
321 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 2);
322 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
323 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
324 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
325 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
326 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
327 }
328 }
329
SEQAN_DEFINE_TEST(test_basic_holder_simple_accessor)330 SEQAN_DEFINE_TEST(test_basic_holder_simple_accessor)
331 {
332 using namespace seqan;
333
334 typedef Holder<int, Simple> THolder;
335
336 THolder holder(10);
337
338 SEQAN_ASSERT_EQ(value(holder), 10);
339 SEQAN_ASSERT_EQ(getValue(holder), 10);
340
341 THolder const constHolder(10);
342
343 SEQAN_ASSERT_EQ(value(constHolder), 10);
344 SEQAN_ASSERT_EQ(getValue(constHolder), 10);
345 }
346
347 // --------------------------------------------------------------------------
348 // Test for Tristate Holder
349 // --------------------------------------------------------------------------
350
SEQAN_DEFINE_TEST(test_basic_holder_tristate_metafunctions)351 SEQAN_DEFINE_TEST(test_basic_holder_tristate_metafunctions)
352 {
353 using namespace seqan;
354
355 // Tests for non-const holder.
356 {
357 typedef Holder<int, Tristate> THolder;
358
359 typedef typename Value<THolder>::Type TValue;
360 bool b = IsSameType<int, TValue>::Type::VALUE;
361 SEQAN_ASSERT(b);
362
363 typedef typename GetValue<THolder>::Type TGetValue;
364 b = IsSameType<int const &, TGetValue>::Type::VALUE;
365 SEQAN_ASSERT(b);
366
367 typedef typename Reference<THolder>::Type TReference;
368 b = IsSameType<int &, TReference>::Type::VALUE;
369 SEQAN_ASSERT(b);
370
371 typedef typename Spec<THolder>::Type TSpec;
372 b = IsSameType<Tristate, TSpec>::Type::VALUE;
373 SEQAN_ASSERT(b);
374 }
375
376 // Tests for const holder.
377 {
378 typedef Holder<int, Tristate> const THolder;
379
380 typedef typename Value<THolder>::Type TValue;
381 bool b = IsSameType<int, TValue>::Type::VALUE;
382 SEQAN_ASSERT(b);
383
384 typedef typename GetValue<THolder>::Type TGetValue;
385 b = IsSameType<int const &, TGetValue>::Type::VALUE;
386 SEQAN_ASSERT(b);
387
388 typedef typename Reference<THolder>::Type TReference;
389 b = IsSameType<int &, TReference>::Type::VALUE;
390 SEQAN_ASSERT(b);
391
392 typedef typename Spec<THolder>::Type TSpec;
393 b = IsSameType<Tristate, TSpec>::Type::VALUE;
394 SEQAN_ASSERT(b);
395 }
396 }
397
SEQAN_DEFINE_TEST(test_basic_holder_tristate_constructors)398 SEQAN_DEFINE_TEST(test_basic_holder_tristate_constructors)
399 {
400 using namespace seqan;
401
402 typedef Holder<CDStruct, Tristate> THolder;
403 typedef Holder<CDStruct, Tristate> TConstHolder;
404
405 // Default constructor
406 {
407 THolder holder;
408 TConstHolder constHolder;
409 }
410
411 // Constructor with reference
412 {
413 resetCDStructStatics();
414 CDStruct s;
415
416 THolder holder(s);
417 TConstHolder constHolder(s);
418
419 SEQAN_ASSERT_NOT(empty(holder));
420 SEQAN_ASSERT(dependent(holder));
421 SEQAN_ASSERT_EQ(&value(holder), &s);
422
423 SEQAN_ASSERT_NOT(empty(constHolder));
424 SEQAN_ASSERT(dependent(constHolder));
425 SEQAN_ASSERT_EQ(&value(constHolder), &s);
426
427 SEQAN_ASSERT_EQ(CDStruct::lastOther, static_cast<CDStruct *>(0));
428 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
429 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 0);
430 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
431 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
432 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
433 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
434 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
435 }
436 {
437 resetCDStructStatics();
438 CDStruct const s;
439
440 THolder holder(s);
441 TConstHolder constHolder(s);
442
443 SEQAN_ASSERT_NOT(empty(holder));
444 SEQAN_ASSERT_NOT(dependent(holder));
445 SEQAN_ASSERT_NEQ(&value(holder), &s);
446
447 // TODO(holtgrew): Change tests once Holder is fixed for const values.
448
449 SEQAN_ASSERT_NOT(empty(holder));
450 // SEQAN_ASSERT(dependent(constHolder));
451 SEQAN_ASSERT_NOT(dependent(constHolder));
452 // SEQAN_ASSERT_EQ(&value(constHolder), &s);
453 SEQAN_ASSERT_NEQ(&value(constHolder), &s);
454
455 SEQAN_ASSERT_EQ(CDStruct::lastOther, &s);
456 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
457 // SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 1);
458 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 2);
459 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
460 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
461 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
462 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
463 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
464 }
465
466 // TODO(holtgrew): Complete the following once holders of const values work!
467
468 // Copy constructor const to const
469 // Copy constructor const to non-const
470 // Copy constructor non-const to const
471 // Copy constructor non-const to non-const
472 }
473
SEQAN_DEFINE_TEST(test_basic_holder_tristate_transport)474 SEQAN_DEFINE_TEST(test_basic_holder_tristate_transport)
475 {
476 using namespace seqan;
477
478 // TODO(holtgrew): Complete the following once holders of const values work!
479
480 // Also check dependencies on the following.
481 // FAST
482 // const <-- set/move <-- non-const
483 // const <-- set/move <-- const
484 // non-const <-- set/move <-- non-const
485 // COPY
486 // non-const <-- set/move <-- const
487 }
488
SEQAN_DEFINE_TEST(test_basic_holder_tristate_transport_value)489 SEQAN_DEFINE_TEST(test_basic_holder_tristate_transport_value)
490 {
491 // assignValue()
492 {
493 typedef Holder<CDStruct, Simple> THolder;
494
495 resetCDStructStatics();
496
497 CDStruct s1;
498 CDStruct s2;
499 THolder h(s1);
500 assignValue(h, s2);
501
502 SEQAN_ASSERT_EQ(value(h).assignedFrom, s2.id);
503 }
504
505 // moveValue()
506 {
507 typedef Holder<CDStruct, Simple> THolder;
508
509 resetCDStructStatics();
510
511 CDStruct s1;
512 CDStruct s2;
513 THolder h(s1);
514 moveValue(h, s2);
515
516 SEQAN_ASSERT_EQ(value(h).movedFrom, s2.id);
517 }
518
519 // setValue()
520 {
521 typedef Holder<CDStruct, Simple> THolder;
522
523 resetCDStructStatics();
524
525 CDStruct s1;
526 CDStruct s2;
527 THolder h(s1);
528 setValue(h, s2);
529
530 SEQAN_ASSERT_EQ(value(h).setFrom, s2.id);
531 }
532 }
533
SEQAN_DEFINE_TEST(test_basic_holder_tristate_dependencies)534 SEQAN_DEFINE_TEST(test_basic_holder_tristate_dependencies)
535 {
536 using namespace seqan;
537
538 typedef Holder<CDStruct, Tristate> THolder;
539
540 // Default construction -> assignment.
541 {
542 resetCDStructStatics();
543
544 THolder holder;
545 CDStruct s;
546
547 SEQAN_ASSERT(empty(holder));
548 assignValue(holder, s);
549
550 SEQAN_ASSERT_EQ(CDStruct::lastOther, &s);
551 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
552 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 1);
553 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
554 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
555 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
556 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
557 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
558 }
559
560 // Default construction -> create, default construction.
561 {
562 resetCDStructStatics();
563
564 THolder holder;
565
566 SEQAN_ASSERT(empty(holder));
567 create(holder);
568
569 SEQAN_ASSERT_EQ(CDStruct::lastOther, static_cast<CDStruct *>(0));
570 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
571 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 0);
572 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
573 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
574 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
575 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
576 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
577 }
578 // Default construction -> create, copy construction.
579 {
580 resetCDStructStatics();
581
582 THolder holder;
583 CDStruct s;
584
585 SEQAN_ASSERT(empty(holder));
586 create(holder, s);
587
588 SEQAN_ASSERT_EQ(CDStruct::lastOther, &s);
589 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
590 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 1);
591 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
592 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
593 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
594 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
595 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
596 }
597
598 // Default construction -> create -> create.
599 {
600 resetCDStructStatics();
601
602 THolder holder;
603
604 SEQAN_ASSERT(empty(holder));
605 create(holder);
606 create(holder);
607
608 SEQAN_ASSERT_EQ(CDStruct::lastOther, static_cast<CDStruct *>(0));
609 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
610 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 0);
611 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
612 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
613 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
614 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
615 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
616 }
617
618 // Construction with value -> detach.
619 {
620 resetCDStructStatics();
621
622 CDStruct s;
623 THolder holder(s);
624
625 SEQAN_ASSERT(dependent(holder));
626
627 SEQAN_ASSERT_EQ(CDStruct::lastOther, static_cast<CDStruct *>(0));
628 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
629 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 0);
630 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
631 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
632 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
633 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
634 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
635
636 detach(holder);
637
638 SEQAN_ASSERT_NEQ(&value(holder), &s);
639
640 SEQAN_ASSERT_EQ(CDStruct::lastOther, &s);
641 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
642 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 1);
643 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
644 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
645 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
646 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
647 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
648 }
649
650 // Copy construction.
651 {
652 resetCDStructStatics();
653
654 CDStruct s;
655 THolder holder(s);
656 THolder holder2(s);
657
658 SEQAN_ASSERT(dependent(holder));
659 SEQAN_ASSERT(dependent(holder2));
660 SEQAN_ASSERT_EQ(&value(holder), &s);
661 SEQAN_ASSERT_EQ(&value(holder2), &s);
662
663 SEQAN_ASSERT_EQ(CDStruct::lastOther, static_cast<CDStruct *>(0));
664 SEQAN_ASSERT_EQ(CDStruct::defaultConstructions, 1);
665 SEQAN_ASSERT_EQ(CDStruct::copyConstructions, 0);
666 SEQAN_ASSERT_EQ(CDStruct::moveConstructions, 0);
667 SEQAN_ASSERT_EQ(CDStruct::moves, 0);
668 SEQAN_ASSERT_EQ(CDStruct::destructions, 0);
669 SEQAN_ASSERT_EQ(CDStruct::assignments, 0);
670 SEQAN_ASSERT_EQ(CDStruct::sets, 0);
671 }
672 }
673
SEQAN_DEFINE_TEST(test_basic_holder_tristate_accessor)674 SEQAN_DEFINE_TEST(test_basic_holder_tristate_accessor)
675 {
676 using namespace seqan;
677
678 typedef Holder<int, Tristate> THolder;
679
680 THolder holder(10);
681
682 SEQAN_ASSERT_EQ(value(holder), 10);
683 SEQAN_ASSERT_EQ(getValue(holder), 10);
684
685 THolder const constHolder(10);
686
687 SEQAN_ASSERT_EQ(value(constHolder), 10);
688 SEQAN_ASSERT_EQ(getValue(constHolder), 10);
689 }
690
691 #endif // #ifndef TESTS_BASIC_TEST_BASIC_HOLDER_H_
692