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