1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include <cassert>
10#include "support/timer.h"
11
12// This test explicitly tests dynamic cast with types that have inaccessible
13// bases.
14#if defined(__clang__)
15# pragma clang diagnostic ignored "-Winaccessible-base"
16#elif defined(__GNUC__)
17# pragma GCC diagnostic ignored "-Winaccessible-base"
18#endif
19
20/*
21
22A1 A2 A3
23
24*/
25
26namespace t1
27{
28
29struct A1
30{
31 char _[43981];
32 virtual ~A1() {}
33
34 A1* getA1() {return this;}
35};
36
37struct A2
38{
39 char _[34981];
40 virtual ~A2() {}
41
42 A2* getA2() {return this;}
43};
44
45struct A3
46{
47 char _[93481];
48 virtual ~A3() {}
49
50 A3* getA3() {return this;}
51};
52
53void test()
54{
55 A1 a1;
56 A2 a2;
57 A3 a3;
58 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
59 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
60 assert(dynamic_cast<A1*>(a3.getA3()) == 0);
61 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
62 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
63 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
64 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
65 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
66 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
67}
68
69} // t1
70
71/*
72
73A1 A2
74|
75A3
76
77*/
78
79namespace t2
80{
81
82struct A1
83{
84 char _[43981];
85 virtual ~A1() {}
86
87 A1* getA1() {return this;}
88};
89
90struct A2
91{
92 char _[34981];
93 virtual ~A2() {}
94
95 A2* getA2() {return this;}
96};
97
98struct A3
99 : public A1
100{
101 char _[93481];
102 virtual ~A3() {}
103
104 A3* getA3() {return this;}
105};
106
107void test()
108{
109 A1 a1;
110 A2 a2;
111 A3 a3;
112 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
113 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
114 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
115 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
116
117 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
118 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
119 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
120 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
121
122 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
123 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
124 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
125 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
126}
127
128} // t2
129
130namespace t3
131{
132
133struct A1
134{
135 char _[43981];
136 virtual ~A1() {}
137
138 A1* getA1() {return this;}
139};
140
141struct A2
142{
143 char _[34981];
144 virtual ~A2() {}
145
146 A2* getA2() {return this;}
147};
148
149struct A3
150 : public virtual A1
151{
152 char _[93481];
153 virtual ~A3() {}
154
155 A3* getA3() {return this;}
156};
157
158void test()
159{
160 A1 a1;
161 A2 a2;
162 A3 a3;
163 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
164 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
165 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
166 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
167
168 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
169 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
170 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
171 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
172
173 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
174 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
175 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
176 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
177}
178
179} // t3
180
181namespace t4
182{
183
184struct A1
185{
186 char _[43981];
187 virtual ~A1() {}
188
189 A1* getA1() {return this;}
190};
191
192struct A2
193{
194 char _[34981];
195 virtual ~A2() {}
196
197 A2* getA2() {return this;}
198};
199
200struct A3
201 : private A1
202{
203 char _[93481];
204 virtual ~A3() {}
205
206 A1* getA1() {return this;}
207 A3* getA3() {return this;}
208};
209
210void test()
211{
212 A1 a1;
213 A2 a2;
214 A3 a3;
215 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
216 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
217 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
218
219 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
220 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
221 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
222 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
223
224 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
225 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
226 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
227 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
228}
229
230} // t4
231
232namespace t5
233{
234
235struct A1
236{
237 char _[43981];
238 virtual ~A1() {}
239
240 A1* getA1() {return this;}
241};
242
243struct A2
244{
245 char _[34981];
246 virtual ~A2() {}
247
248 A2* getA2() {return this;}
249};
250
251struct A3
252 : private virtual A1
253{
254 char _[93481];
255 virtual ~A3() {}
256
257 A1* getA1() {return this;}
258 A3* getA3() {return this;}
259};
260
261void test()
262{
263 A1 a1;
264 A2 a2;
265 A3 a3;
266 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
267 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
268 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
269
270 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
271 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
272 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
273 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
274
275 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
276 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
277 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
278 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
279}
280
281} // t5
282
283/*
284
285A1 A2
286 \ /
287 A3
288
289*/
290
291namespace t6
292{
293
294struct A1
295{
296 char _[43981];
297 virtual ~A1() {}
298
299 A1* getA1() {return this;}
300};
301
302struct A2
303{
304 char _[34981];
305 virtual ~A2() {}
306
307 A2* getA2() {return this;}
308};
309
310struct A3
311 : public A1,
312 public A2
313{
314 char _[93481];
315 virtual ~A3() {}
316
317 A1* getA1() {return this;}
318 A2* getA2() {return this;}
319 A3* getA3() {return this;}
320};
321
322void test()
323{
324 A1 a1;
325 A2 a2;
326 A3 a3;
327 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
328 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
329 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
330 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
331 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
332
333 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
334 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
335 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
336 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
337 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
338
339 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
340 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
341 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
342 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
343 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
344}
345
346} // t6
347
348namespace t7
349{
350
351struct A1
352{
353 char _[43981];
354 virtual ~A1() {}
355
356 A1* getA1() {return this;}
357};
358
359struct A2
360{
361 char _[34981];
362 virtual ~A2() {}
363
364 A2* getA2() {return this;}
365};
366
367struct A3
368 : public virtual A1,
369 public A2
370{
371 char _[93481];
372 virtual ~A3() {}
373
374 A1* getA1() {return this;}
375 A2* getA2() {return this;}
376 A3* getA3() {return this;}
377};
378
379void test()
380{
381 A1 a1;
382 A2 a2;
383 A3 a3;
384 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
385 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
386 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
387 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
388 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
389
390 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
391 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
392 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
393 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
394 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
395
396 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
397 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
398 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
399 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
400 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
401}
402
403} // t7
404
405namespace t8
406{
407
408struct A1
409{
410 char _[43981];
411 virtual ~A1() {}
412
413 A1* getA1() {return this;}
414};
415
416struct A2
417{
418 char _[34981];
419 virtual ~A2() {}
420
421 A2* getA2() {return this;}
422};
423
424struct A3
425 : private A1,
426 public A2
427{
428 char _[93481];
429 virtual ~A3() {}
430
431 A1* getA1() {return this;}
432 A2* getA2() {return this;}
433 A3* getA3() {return this;}
434};
435
436void test()
437{
438 A1 a1;
439 A2 a2;
440 A3 a3;
441 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
442 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
443 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
444 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
445
446 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
447 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
448 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
449 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
450 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
451
452 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
453 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
454 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
455 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
456 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
457}
458
459} // t8
460
461namespace t9
462{
463
464struct A1
465{
466 char _[43981];
467 virtual ~A1() {}
468
469 A1* getA1() {return this;}
470};
471
472struct A2
473{
474 char _[34981];
475 virtual ~A2() {}
476
477 A2* getA2() {return this;}
478};
479
480struct A3
481 : private virtual A1,
482 public A2
483{
484 char _[93481];
485 virtual ~A3() {}
486
487 A1* getA1() {return this;}
488 A2* getA2() {return this;}
489 A3* getA3() {return this;}
490};
491
492void test()
493{
494 A1 a1;
495 A2 a2;
496 A3 a3;
497 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
498 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
499 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
500 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
501
502 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
503 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
504 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
505 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
506 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
507
508 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
509 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
510 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
511 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
512 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
513}
514
515} // t9
516
517namespace t10
518{
519
520struct A1
521{
522 char _[43981];
523 virtual ~A1() {}
524
525 A1* getA1() {return this;}
526};
527
528struct A2
529{
530 char _[34981];
531 virtual ~A2() {}
532
533 A2* getA2() {return this;}
534};
535
536struct A3
537 : public virtual A1,
538 public virtual A2
539{
540 char _[93481];
541 virtual ~A3() {}
542
543 A1* getA1() {return this;}
544 A2* getA2() {return this;}
545 A3* getA3() {return this;}
546};
547
548void test()
549{
550 A1 a1;
551 A2 a2;
552 A3 a3;
553 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
554 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
555 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
556 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
557 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
558
559 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
560 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
561 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
562 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
563 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
564
565 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
566 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
567 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
568 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
569 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
570}
571
572} // t10
573
574namespace t11
575{
576
577struct A1
578{
579 char _[43981];
580 virtual ~A1() {}
581
582 A1* getA1() {return this;}
583};
584
585struct A2
586{
587 char _[34981];
588 virtual ~A2() {}
589
590 A2* getA2() {return this;}
591};
592
593struct A3
594 : private A1,
595 public virtual A2
596{
597 char _[93481];
598 virtual ~A3() {}
599
600 A1* getA1() {return this;}
601 A2* getA2() {return this;}
602 A3* getA3() {return this;}
603};
604
605void test()
606{
607 A1 a1;
608 A2 a2;
609 A3 a3;
610 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
611 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
612 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
613 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
614
615 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
616 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
617 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
618 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
619 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
620
621 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
622 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
623 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
624 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
625 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
626}
627
628} // t11
629
630namespace t12
631{
632
633struct A1
634{
635 char _[43981];
636 virtual ~A1() {}
637
638 A1* getA1() {return this;}
639};
640
641struct A2
642{
643 char _[34981];
644 virtual ~A2() {}
645
646 A2* getA2() {return this;}
647};
648
649struct A3
650 : private virtual A1,
651 public virtual A2
652{
653 char _[93481];
654 virtual ~A3() {}
655
656 A1* getA1() {return this;}
657 A2* getA2() {return this;}
658 A3* getA3() {return this;}
659};
660
661void test()
662{
663 A1 a1;
664 A2 a2;
665 A3 a3;
666 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
667 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
668 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
669 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
670
671 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
672 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
673 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
674 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
675 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
676
677 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
678 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
679 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
680 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
681 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
682}
683
684} // t12
685
686namespace t13
687{
688
689struct A1
690{
691 char _[43981];
692 virtual ~A1() {}
693
694 A1* getA1() {return this;}
695};
696
697struct A2
698{
699 char _[34981];
700 virtual ~A2() {}
701
702 A2* getA2() {return this;}
703};
704
705struct A3
706 : private A1,
707 private A2
708{
709 char _[93481];
710 virtual ~A3() {}
711
712 A1* getA1() {return this;}
713 A2* getA2() {return this;}
714 A3* getA3() {return this;}
715};
716
717void test()
718{
719 A1 a1;
720 A2 a2;
721 A3 a3;
722 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
723 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
724 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
725 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
726
727 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
728 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
729 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
730 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
731
732 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
733 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
734 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
735 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
736 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
737}
738
739} // t13
740
741namespace t14
742{
743
744struct A1
745{
746 char _[43981];
747 virtual ~A1() {}
748
749 A1* getA1() {return this;}
750};
751
752struct A2
753{
754 char _[34981];
755 virtual ~A2() {}
756
757 A2* getA2() {return this;}
758};
759
760struct A3
761 : private virtual A1,
762 private A2
763{
764 char _[93481];
765 virtual ~A3() {}
766
767 A1* getA1() {return this;}
768 A2* getA2() {return this;}
769 A3* getA3() {return this;}
770};
771
772void test()
773{
774 A1 a1;
775 A2 a2;
776 A3 a3;
777 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
778 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
779 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
780 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
781
782 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
783 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
784 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
785 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
786
787 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
788 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
789 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
790 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
791 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
792}
793
794} // t14
795
796namespace t15
797{
798
799struct A1
800{
801 char _[43981];
802 virtual ~A1() {}
803
804 A1* getA1() {return this;}
805};
806
807struct A2
808{
809 char _[34981];
810 virtual ~A2() {}
811
812 A2* getA2() {return this;}
813};
814
815struct A3
816 : private virtual A1,
817 private virtual A2
818{
819 char _[93481];
820 virtual ~A3() {}
821
822 A1* getA1() {return this;}
823 A2* getA2() {return this;}
824 A3* getA3() {return this;}
825};
826
827void test()
828{
829 A1 a1;
830 A2 a2;
831 A3 a3;
832 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
833 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
834 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
835 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
836
837 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
838 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
839 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
840 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
841
842 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
843 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
844 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
845 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
846 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
847}
848
849} // t15
850
851/*
852
853A1
854|
855A2
856|
857A3
858
859*/
860
861namespace t16
862{
863
864struct A1
865{
866 char _[43981];
867 virtual ~A1() {}
868
869 A1* getA1() {return this;}
870};
871
872struct A2
873 : public A1
874{
875 char _[34981];
876 virtual ~A2() {}
877
878 A1* getA1() {return this;}
879 A2* getA2() {return this;}
880};
881
882struct A3
883 : public A2
884{
885 char _[93481];
886 virtual ~A3() {}
887
888 A1* getA1() {return this;}
889 A2* getA2() {return this;}
890 A3* getA3() {return this;}
891};
892
893void test()
894{
895 A1 a1;
896 A2 a2;
897 A3 a3;
898 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
899 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
900 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
901 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
902 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
903 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
904
905 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
906 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
907 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
908 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
909 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
910 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
911
912 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
913 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
914 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
915 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
916 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
917 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
918}
919
920} // t16
921
922namespace t17
923{
924
925struct A1
926{
927 char _[43981];
928 virtual ~A1() {}
929
930 A1* getA1() {return this;}
931};
932
933struct A2
934 : public virtual A1
935{
936 char _[34981];
937 virtual ~A2() {}
938
939 A1* getA1() {return this;}
940 A2* getA2() {return this;}
941};
942
943struct A3
944 : public A2
945{
946 char _[93481];
947 virtual ~A3() {}
948
949 A1* getA1() {return this;}
950 A2* getA2() {return this;}
951 A3* getA3() {return this;}
952};
953
954void test()
955{
956 A1 a1;
957 A2 a2;
958 A3 a3;
959 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
960 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
961 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
962 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
963 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
964 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
965
966 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
967 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
968 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
969 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
970 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
971 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
972
973 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
974 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
975 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
976 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
977 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
978 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
979}
980
981} // t17
982
983namespace t18
984{
985
986struct A1
987{
988 char _[43981];
989 virtual ~A1() {}
990
991 A1* getA1() {return this;}
992};
993
994struct A2
995 : private A1
996{
997 char _[34981];
998 virtual ~A2() {}
999
1000 A1* getA1() {return this;}
1001 A2* getA2() {return this;}
1002};
1003
1004struct A3
1005 : public A2
1006{
1007 char _[93481];
1008 virtual ~A3() {}
1009
1010 A2* getA2() {return this;}
1011 A3* getA3() {return this;}
1012};
1013
1014void test()
1015{
1016 A1 a1;
1017 A2 a2;
1018 A3 a3;
1019 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1020 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1021 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1022
1023 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1024 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1025 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1026 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1027 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1028 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1029
1030 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1031 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1032 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1033 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1034 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1035 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1036}
1037
1038} // t18
1039
1040namespace t19
1041{
1042
1043struct A1
1044{
1045 char _[43981];
1046 virtual ~A1() {}
1047
1048 A1* getA1() {return this;}
1049};
1050
1051struct A2
1052 : protected virtual A1
1053{
1054 char _[34981];
1055 virtual ~A2() {}
1056
1057 A1* getA1() {return this;}
1058 A2* getA2() {return this;}
1059};
1060
1061struct A3
1062 : public A2
1063{
1064 char _[93481];
1065 virtual ~A3() {}
1066
1067 A2* getA2() {return this;}
1068 A3* getA3() {return this;}
1069};
1070
1071void test()
1072{
1073 A1 a1;
1074 A2 a2;
1075 A3 a3;
1076 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1077 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1078 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1079
1080 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1081 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1082 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1083 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1084 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1085 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1086
1087 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1088 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1089 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1090 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1091 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1092 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1093}
1094
1095} // t19
1096
1097namespace t20
1098{
1099
1100struct A1
1101{
1102 char _[43981];
1103 virtual ~A1() {}
1104
1105 A1* getA1() {return this;}
1106};
1107
1108struct A2
1109 : public virtual A1
1110{
1111 char _[34981];
1112 virtual ~A2() {}
1113
1114 A1* getA1() {return this;}
1115 A2* getA2() {return this;}
1116};
1117
1118struct A3
1119 : public virtual A2
1120{
1121 char _[93481];
1122 virtual ~A3() {}
1123
1124 A1* getA1() {return this;}
1125 A2* getA2() {return this;}
1126 A3* getA3() {return this;}
1127};
1128
1129void test()
1130{
1131 A1 a1;
1132 A2 a2;
1133 A3 a3;
1134 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1135 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1136 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1137 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1138 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
1139 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
1140
1141 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1142 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1143 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1144 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
1145 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1146 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1147
1148 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1149 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1150 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1151 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
1152 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1153 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1154}
1155
1156} // t20
1157
1158namespace t21
1159{
1160
1161struct A1
1162{
1163 char _[43981];
1164 virtual ~A1() {}
1165
1166 A1* getA1() {return this;}
1167};
1168
1169struct A2
1170 : private A1
1171{
1172 char _[34981];
1173 virtual ~A2() {}
1174
1175 A1* getA1() {return this;}
1176 A2* getA2() {return this;}
1177};
1178
1179struct A3
1180 : public virtual A2
1181{
1182 char _[93481];
1183 virtual ~A3() {}
1184
1185 A2* getA2() {return this;}
1186 A3* getA3() {return this;}
1187};
1188
1189void test()
1190{
1191 A1 a1;
1192 A2 a2;
1193 A3 a3;
1194 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1195 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1196 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1197
1198 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1199 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1200 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1201 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1202 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1203 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1204
1205 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1206 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1207 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1208 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1209 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1210 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1211}
1212
1213} // t21
1214
1215namespace t22
1216{
1217
1218struct A1
1219{
1220 char _[43981];
1221 virtual ~A1() {}
1222
1223 A1* getA1() {return this;}
1224};
1225
1226struct A2
1227 : protected virtual A1
1228{
1229 char _[34981];
1230 virtual ~A2() {}
1231
1232 A1* getA1() {return this;}
1233 A2* getA2() {return this;}
1234};
1235
1236struct A3
1237 : public virtual A2
1238{
1239 char _[93481];
1240 virtual ~A3() {}
1241
1242 A2* getA2() {return this;}
1243 A3* getA3() {return this;}
1244};
1245
1246void test()
1247{
1248 A1 a1;
1249 A2 a2;
1250 A3 a3;
1251 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1252 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1253 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1254
1255 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1256 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1257 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1258 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1259 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1260 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1261
1262 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1263 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1264 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1265 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1266 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1267 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1268}
1269
1270} // t22
1271
1272namespace t23
1273{
1274
1275struct A1
1276{
1277 char _[43981];
1278 virtual ~A1() {}
1279
1280 A1* getA1() {return this;}
1281};
1282
1283struct A2
1284 : private A1
1285{
1286 char _[34981];
1287 virtual ~A2() {}
1288
1289 A1* getA1() {return this;}
1290 A2* getA2() {return this;}
1291};
1292
1293struct A3
1294 : private A2
1295{
1296 char _[93481];
1297 virtual ~A3() {}
1298
1299 t23::A1* getA1() {return A2::getA1();}
1300 A2* getA2() {return this;}
1301 A3* getA3() {return this;}
1302};
1303
1304void test()
1305{
1306 A1 a1;
1307 A2 a2;
1308 A3 a3;
1309 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1310 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1311 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1312
1313 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1314 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1315 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1316 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1317 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1318
1319 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1320 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1321 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1322 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1323 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1324 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1325}
1326
1327} // t23
1328
1329namespace t24
1330{
1331
1332struct A1
1333{
1334 char _[43981];
1335 virtual ~A1() {}
1336
1337 A1* getA1() {return this;}
1338};
1339
1340struct A2
1341 : protected virtual A1
1342{
1343 char _[34981];
1344 virtual ~A2() {}
1345
1346 A1* getA1() {return this;}
1347 A2* getA2() {return this;}
1348};
1349
1350struct A3
1351 : private A2
1352{
1353 char _[93481];
1354 virtual ~A3() {}
1355
1356 t24::A1* getA1() {return A2::getA1();}
1357 A2* getA2() {return this;}
1358 A3* getA3() {return this;}
1359};
1360
1361void test()
1362{
1363 A1 a1;
1364 A2 a2;
1365 A3 a3;
1366 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1367 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1368 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1369
1370 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1371 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1372 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1373 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1374 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1375
1376 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1377 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1378 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1379 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1380 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1381 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1382}
1383
1384} // t24
1385
1386namespace t25
1387{
1388
1389struct A1
1390{
1391 char _[43981];
1392 virtual ~A1() {}
1393
1394 A1* getA1() {return this;}
1395};
1396
1397struct A2
1398 : protected virtual A1
1399{
1400 char _[34981];
1401 virtual ~A2() {}
1402
1403 A1* getA1() {return this;}
1404 A2* getA2() {return this;}
1405};
1406
1407struct A3
1408 : private virtual A2
1409{
1410 char _[93481];
1411 virtual ~A3() {}
1412
1413 t25::A1* getA1() {return A2::getA1();}
1414 A2* getA2() {return this;}
1415 A3* getA3() {return this;}
1416};
1417
1418void test()
1419{
1420 A1 a1;
1421 A2 a2;
1422 A3 a3;
1423 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1424 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1425 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1426
1427 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1428 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1429 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1430 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1431 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1432
1433 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1434 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1435 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1436 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1437 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1438 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1439}
1440
1441} // t25
1442
1443/*
1444
1445A1 A1
1446| |
1447A2 |
1448 \ |
1449 A3
1450
1451*/
1452
1453namespace t26
1454{
1455
1456struct A1
1457{
1458 char _[43981];
1459 virtual ~A1() {}
1460
1461 A1* getA1() {return this;}
1462};
1463
1464struct A2
1465 : public A1
1466{
1467 char _[34981];
1468 virtual ~A2() {}
1469
1470 A1* getA1() {return this;}
1471 A2* getA2() {return this;}
1472};
1473
1474struct A3
1475 : public A1,
1476 public A2
1477{
1478 char _[93481];
1479 virtual ~A3() {}
1480
1481 A1* getA12() {return A2::getA1();}
1482 A2* getA2() {return this;}
1483 A3* getA3() {return this;}
1484};
1485
1486void test()
1487{
1488 A1 a1;
1489 A2 a2;
1490 A3 a3;
1491 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1492 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1493 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1494 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1495 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1496
1497 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1498 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1499 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1500 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1501 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1502 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1503
1504 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1505 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1506 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1507 assert(dynamic_cast<A3*>(a3.getA12()) == a3.getA3());
1508 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1509 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1510}
1511
1512} // t26
1513
1514namespace t27
1515{
1516
1517struct A1
1518{
1519 char _[43981];
1520 virtual ~A1() {}
1521
1522 A1* getA1() {return this;}
1523};
1524
1525struct A2
1526 : private A1
1527{
1528 char _[34981];
1529 virtual ~A2() {}
1530
1531 A1* getA1() {return this;}
1532 A2* getA2() {return this;}
1533};
1534
1535struct A3
1536 : public A1,
1537 public A2
1538{
1539 char _[93481];
1540 virtual ~A3() {}
1541
1542 A1* getA12() {return A2::getA1();}
1543 A2* getA2() {return this;}
1544 A3* getA3() {return this;}
1545};
1546
1547void test()
1548{
1549 A1 a1;
1550 A2 a2;
1551 A3 a3;
1552 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1553 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1554 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1555
1556 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1557 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1558 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1559 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1560 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1561 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1562
1563 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1564 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1565 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1566 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1567 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1568 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1569}
1570
1571} // t27
1572
1573namespace t28
1574{
1575
1576struct A1
1577{
1578 char _[43981];
1579 virtual ~A1() {}
1580
1581 A1* getA1() {return this;}
1582};
1583
1584struct A2
1585 : public A1
1586{
1587 char _[34981];
1588 virtual ~A2() {}
1589
1590 A1* getA1() {return this;}
1591 A2* getA2() {return this;}
1592};
1593
1594struct A3
1595 : private A1,
1596 public A2
1597{
1598 char _[93481];
1599 virtual ~A3() {}
1600
1601 A1* getA12() {return A2::getA1();}
1602 A2* getA2() {return this;}
1603 A3* getA3() {return this;}
1604};
1605
1606void test()
1607{
1608 A1 a1;
1609 A2 a2;
1610 A3 a3;
1611 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1612 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1613 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1614 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1615
1616 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1617 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1618 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1619 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1620 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1621 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1622
1623 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1624 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1625 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1626 assert(dynamic_cast<A3*>(a3.getA12()) == a3.getA3());
1627 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1628 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1629}
1630
1631} // t28
1632
1633namespace t29
1634{
1635
1636struct A1
1637{
1638 char _[43981];
1639 virtual ~A1() {}
1640
1641 A1* getA1() {return this;}
1642};
1643
1644struct A2
1645 : public A1
1646{
1647 char _[34981];
1648 virtual ~A2() {}
1649
1650 A1* getA1() {return this;}
1651 A2* getA2() {return this;}
1652};
1653
1654struct A3
1655 : public A1,
1656 private A2
1657{
1658 char _[93481];
1659 virtual ~A3() {}
1660
1661 A1* getA12() {return A2::getA1();}
1662 A2* getA2() {return this;}
1663 A3* getA3() {return this;}
1664};
1665
1666void test()
1667{
1668 A1 a1;
1669 A2 a2;
1670 A3 a3;
1671 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1672 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1673 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1674 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1675
1676 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1677 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1678 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1679 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1680 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1681
1682 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1683 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1684 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1685 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1686 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1687 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1688}
1689
1690} // t29
1691
1692namespace t30
1693{
1694
1695struct A1
1696{
1697 char _[43981];
1698 virtual ~A1() {}
1699
1700 A1* getA1() {return this;}
1701};
1702
1703struct A2
1704 : public A1
1705{
1706 char _[34981];
1707 virtual ~A2() {}
1708
1709 A1* getA1() {return this;}
1710 A2* getA2() {return this;}
1711};
1712
1713struct A3
1714 : private A1,
1715 private A2
1716{
1717 char _[93481];
1718 virtual ~A3() {}
1719
1720 A1* getA12() {return A2::getA1();}
1721 A2* getA2() {return this;}
1722 A3* getA3() {return this;}
1723};
1724
1725void test()
1726{
1727 A1 a1;
1728 A2 a2;
1729 A3 a3;
1730 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1731 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1732 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1733 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1734 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1735
1736 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1737 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1738 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1739 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1740 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1741
1742 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1743 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1744 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1745 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1746 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1747 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1748}
1749
1750} // t30
1751
1752namespace t31
1753{
1754
1755struct A1
1756{
1757 char _[43981];
1758 virtual ~A1() {}
1759
1760 A1* getA1() {return this;}
1761};
1762
1763struct A2
1764 : private A1
1765{
1766 char _[34981];
1767 virtual ~A2() {}
1768
1769 A1* getA1() {return this;}
1770 A2* getA2() {return this;}
1771};
1772
1773struct A3
1774 : public A1,
1775 private A2
1776{
1777 char _[93481];
1778 virtual ~A3() {}
1779
1780 A1* getA12() {return A2::getA1();}
1781 A2* getA2() {return this;}
1782 A3* getA3() {return this;}
1783};
1784
1785void test()
1786{
1787 A1 a1;
1788 A2 a2;
1789 A3 a3;
1790 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1791 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1792 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1793
1794 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1795 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1796 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1797 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1798 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1799
1800 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1801 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1802 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1803 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1804 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1805 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1806}
1807
1808} // t31
1809
1810namespace t32
1811{
1812
1813struct A1
1814{
1815 char _[43981];
1816 virtual ~A1() {}
1817
1818 A1* getA1() {return this;}
1819};
1820
1821struct A2
1822 : private A1
1823{
1824 char _[34981];
1825 virtual ~A2() {}
1826
1827 A1* getA1() {return this;}
1828 A2* getA2() {return this;}
1829};
1830
1831struct A3
1832 : private A1,
1833 public A2
1834{
1835 char _[93481];
1836 virtual ~A3() {}
1837
1838 A1* getA12() {return A2::getA1();}
1839 A2* getA2() {return this;}
1840 A3* getA3() {return this;}
1841};
1842
1843void test()
1844{
1845 A1 a1;
1846 A2 a2;
1847 A3 a3;
1848 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1849 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1850 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1851
1852 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1853 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1854 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1855 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1856 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1857
1858 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1859 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1860 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1861 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1862 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1863 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1864}
1865
1866} // t32
1867
1868namespace t33
1869{
1870
1871struct A1
1872{
1873 char _[43981];
1874 virtual ~A1() {}
1875
1876 A1* getA1() {return this;}
1877};
1878
1879struct A2
1880 : private A1
1881{
1882 char _[34981];
1883 virtual ~A2() {}
1884
1885 A1* getA1() {return this;}
1886 A2* getA2() {return this;}
1887};
1888
1889struct A3
1890 : private A1,
1891 private A2
1892{
1893 char _[93481];
1894 virtual ~A3() {}
1895
1896 A1* getA12() {return A2::getA1();}
1897 A2* getA2() {return this;}
1898 A3* getA3() {return this;}
1899};
1900
1901void test()
1902{
1903 A1 a1;
1904 A2 a2;
1905 A3 a3;
1906 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1907 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1908 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1909
1910 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1911 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1912 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1913 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1914 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1915
1916 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1917 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1918 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1919 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1920 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1921 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1922}
1923
1924} // t33
1925
1926/*
1927
1928A1
1929| \
1930A2 \
1931 \ |
1932 A3
1933
1934*/
1935
1936namespace t34
1937{
1938
1939struct A1
1940{
1941 char _[43981];
1942 virtual ~A1() {}
1943
1944 A1* getA1() {return this;}
1945};
1946
1947struct A2
1948 : public virtual A1
1949{
1950 char _[34981];
1951 virtual ~A2() {}
1952
1953 A1* getA1() {return this;}
1954 A2* getA2() {return this;}
1955};
1956
1957struct A3
1958 : public virtual A1,
1959 public A2
1960{
1961 char _[93481];
1962 virtual ~A3() {}
1963
1964 A1* getA1() {return A1::getA1();}
1965 A2* getA2() {return this;}
1966 A3* getA3() {return this;}
1967};
1968
1969void test()
1970{
1971 A1 a1;
1972 A2 a2;
1973 A3 a3;
1974 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1975 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1976 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1977 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1978 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
1979 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
1980
1981 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1982 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1983 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1984 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
1985 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1986 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1987
1988 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1989 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1990 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1991 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
1992 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1993 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1994}
1995
1996} // t34
1997
1998namespace t35
1999{
2000
2001struct A1
2002{
2003 char _[43981];
2004 virtual ~A1() {}
2005
2006 A1* getA1() {return this;}
2007};
2008
2009struct A2
2010 : private virtual A1
2011{
2012 char _[34981];
2013 virtual ~A2() {}
2014
2015 A1* getA1() {return this;}
2016 A2* getA2() {return this;}
2017};
2018
2019struct A3
2020 : public virtual A1,
2021 public A2
2022{
2023 char _[93481];
2024 virtual ~A3() {}
2025
2026 A1* getA1() {return A1::getA1();}
2027 A2* getA2() {return this;}
2028 A3* getA3() {return this;}
2029};
2030
2031void test()
2032{
2033 A1 a1;
2034 A2 a2;
2035 A3 a3;
2036 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2037 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2038 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2039 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2040
2041 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2042 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2043 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2044 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2045 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2046 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2047
2048 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2049 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2050 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2051 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2052 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2053 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2054}
2055
2056} // t35
2057
2058namespace t36
2059{
2060
2061struct A1
2062{
2063 char _[43981];
2064 virtual ~A1() {}
2065
2066 A1* getA1() {return this;}
2067};
2068
2069struct A2
2070 : public virtual A1
2071{
2072 char _[34981];
2073 virtual ~A2() {}
2074
2075 A1* getA1() {return this;}
2076 A2* getA2() {return this;}
2077};
2078
2079struct A3
2080 : private virtual A1,
2081 public A2
2082{
2083 char _[93481];
2084 virtual ~A3() {}
2085
2086 A1* getA1() {return A1::getA1();}
2087 A2* getA2() {return this;}
2088 A3* getA3() {return this;}
2089};
2090
2091void test()
2092{
2093 A1 a1;
2094 A2 a2;
2095 A3 a3;
2096 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2097 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2098 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2099 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2100 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2101 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2102
2103 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2104 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2105 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2106 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2107 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2108 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2109
2110 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2111 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2112 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2113 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2114 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2115 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2116}
2117
2118} // t36
2119
2120namespace t37
2121{
2122
2123struct A1
2124{
2125 char _[43981];
2126 virtual ~A1() {}
2127
2128 A1* getA1() {return this;}
2129};
2130
2131struct A2
2132 : public virtual A1
2133{
2134 char _[34981];
2135 virtual ~A2() {}
2136
2137 A1* getA1() {return this;}
2138 A2* getA2() {return this;}
2139};
2140
2141struct A3
2142 : public virtual A1,
2143 private A2
2144{
2145 char _[93481];
2146 virtual ~A3() {}
2147
2148 A1* getA1() {return A1::getA1();}
2149 A2* getA2() {return this;}
2150 A3* getA3() {return this;}
2151};
2152
2153void test()
2154{
2155 A1 a1;
2156 A2 a2;
2157 A3 a3;
2158 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2159 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2160 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2161 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2162 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2163 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2164
2165 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2166 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2167 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2168 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2169 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2170
2171 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2172 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2173 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2174 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2175 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2176 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2177}
2178
2179} // t37
2180
2181namespace t38
2182{
2183
2184struct A1
2185{
2186 char _[43981];
2187 virtual ~A1() {}
2188
2189 A1* getA1() {return this;}
2190};
2191
2192struct A2
2193 : public virtual A1
2194{
2195 char _[34981];
2196 virtual ~A2() {}
2197
2198 A1* getA1() {return this;}
2199 A2* getA2() {return this;}
2200};
2201
2202struct A3
2203 : private virtual A1,
2204 private A2
2205{
2206 char _[93481];
2207 virtual ~A3() {}
2208
2209 A1* getA1() {return A1::getA1();}
2210 A2* getA2() {return this;}
2211 A3* getA3() {return this;}
2212};
2213
2214void test()
2215{
2216 A1 a1;
2217 A2 a2;
2218 A3 a3;
2219 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2220 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2221 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2222 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2223 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2224
2225 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2226 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2227 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2228 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2229 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2230
2231 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2232 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2233 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2234 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2235 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2236 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2237}
2238
2239} // t38
2240
2241namespace t39
2242{
2243
2244struct A1
2245{
2246 char _[43981];
2247 virtual ~A1() {}
2248
2249 A1* getA1() {return this;}
2250};
2251
2252struct A2
2253 : private virtual A1
2254{
2255 char _[34981];
2256 virtual ~A2() {}
2257
2258 A1* getA1() {return this;}
2259 A2* getA2() {return this;}
2260};
2261
2262struct A3
2263 : public virtual A1,
2264 private A2
2265{
2266 char _[93481];
2267 virtual ~A3() {}
2268
2269 A1* getA1() {return A1::getA1();}
2270 A2* getA2() {return this;}
2271 A3* getA3() {return this;}
2272};
2273
2274void test()
2275{
2276 A1 a1;
2277 A2 a2;
2278 A3 a3;
2279 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2280 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2281 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2282 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2283
2284 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2285 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2286 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2287 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2288 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2289
2290 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2291 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2292 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2293 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2294 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2295 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2296}
2297
2298} // t39
2299
2300namespace t40
2301{
2302
2303struct A1
2304{
2305 char _[43981];
2306 virtual ~A1() {}
2307
2308 A1* getA1() {return this;}
2309};
2310
2311struct A2
2312 : private virtual A1
2313{
2314 char _[34981];
2315 virtual ~A2() {}
2316
2317 A1* getA1() {return this;}
2318 A2* getA2() {return this;}
2319};
2320
2321struct A3
2322 : private virtual A1,
2323 public A2
2324{
2325 char _[93481];
2326 virtual ~A3() {}
2327
2328 A1* getA1() {return A1::getA1();}
2329 A2* getA2() {return this;}
2330 A3* getA3() {return this;}
2331};
2332
2333void test()
2334{
2335 A1 a1;
2336 A2 a2;
2337 A3 a3;
2338 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2339 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2340 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2341
2342 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2343 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2344 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2345 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2346 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2347 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2348
2349 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2350 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2351 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2352 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2353 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2354 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2355}
2356
2357} // t40
2358
2359namespace t41
2360{
2361
2362struct A1
2363{
2364 char _[43981];
2365 virtual ~A1() {}
2366
2367 A1* getA1() {return this;}
2368};
2369
2370struct A2
2371 : private virtual A1
2372{
2373 char _[34981];
2374 virtual ~A2() {}
2375
2376 A1* getA1() {return this;}
2377 A2* getA2() {return this;}
2378};
2379
2380struct A3
2381 : private virtual A1,
2382 private A2
2383{
2384 char _[93481];
2385 virtual ~A3() {}
2386
2387 A1* getA1() {return A1::getA1();}
2388 A2* getA2() {return this;}
2389 A3* getA3() {return this;}
2390};
2391
2392void test()
2393{
2394 A1 a1;
2395 A2 a2;
2396 A3 a3;
2397 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2398 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2399 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2400
2401 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2402 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2403 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2404 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2405 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2406
2407 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2408 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2409 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2410 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2411 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2412 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2413}
2414
2415} // t41
2416
2417int main(int, char**)
2418{
2419 timer t;
2420 t1::test();
2421 t2::test();
2422 t3::test();
2423 t4::test();
2424 t5::test();
2425 t6::test();
2426 t7::test();
2427 t8::test();
2428 t9::test();
2429 t10::test();
2430 t11::test();
2431 t12::test();
2432 t13::test();
2433 t14::test();
2434 t15::test();
2435 t16::test();
2436 t17::test();
2437 t18::test();
2438 t19::test();
2439 t20::test();
2440 t21::test();
2441 t22::test();
2442 t23::test();
2443 t24::test();
2444 t25::test();
2445 t26::test();
2446 t27::test();
2447 t28::test();
2448 t29::test();
2449 t30::test();
2450 t31::test();
2451 t32::test();
2452 t33::test();
2453 t34::test();
2454 t35::test();
2455 t36::test();
2456 t37::test();
2457 t38::test();
2458 t39::test();
2459 t40::test();
2460 t41::test();
2461
2462 return 0;
2463}
2464

source code of libcxxabi/test/dynamic_cast3.pass.cpp