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 
22 A1   A2   A3
23 
24 */
25 
26 namespace t1
27 {
28 
29 struct A1
30 {
31     char _[43981];
32     virtual ~A1() {}
33 
34     A1* getA1() {return this;}
35 };
36 
37 struct A2
38 {
39     char _[34981];
40     virtual ~A2() {}
41 
42     A2* getA2() {return this;}
43 };
44 
45 struct A3
46 {
47     char _[93481];
48     virtual ~A3() {}
49 
50     A3* getA3() {return this;}
51 };
52 
53 void 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 
73 A1   A2
74 |
75 A3
76 
77 */
78 
79 namespace t2
80 {
81 
82 struct A1
83 {
84     char _[43981];
85     virtual ~A1() {}
86 
87     A1* getA1() {return this;}
88 };
89 
90 struct A2
91 {
92     char _[34981];
93     virtual ~A2() {}
94 
95     A2* getA2() {return this;}
96 };
97 
98 struct A3
99     : public A1
100 {
101     char _[93481];
102     virtual ~A3() {}
103 
104     A3* getA3() {return this;}
105 };
106 
107 void 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 
130 namespace t3
131 {
132 
133 struct A1
134 {
135     char _[43981];
136     virtual ~A1() {}
137 
138     A1* getA1() {return this;}
139 };
140 
141 struct A2
142 {
143     char _[34981];
144     virtual ~A2() {}
145 
146     A2* getA2() {return this;}
147 };
148 
149 struct A3
150     : public virtual A1
151 {
152     char _[93481];
153     virtual ~A3() {}
154 
155     A3* getA3() {return this;}
156 };
157 
158 void 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 
181 namespace t4
182 {
183 
184 struct A1
185 {
186     char _[43981];
187     virtual ~A1() {}
188 
189     A1* getA1() {return this;}
190 };
191 
192 struct A2
193 {
194     char _[34981];
195     virtual ~A2() {}
196 
197     A2* getA2() {return this;}
198 };
199 
200 struct A3
201     : private A1
202 {
203     char _[93481];
204     virtual ~A3() {}
205 
206     A1* getA1() {return this;}
207     A3* getA3() {return this;}
208 };
209 
210 void 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 
232 namespace t5
233 {
234 
235 struct A1
236 {
237     char _[43981];
238     virtual ~A1() {}
239 
240     A1* getA1() {return this;}
241 };
242 
243 struct A2
244 {
245     char _[34981];
246     virtual ~A2() {}
247 
248     A2* getA2() {return this;}
249 };
250 
251 struct 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 
261 void 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 
285 A1   A2
286  \  /
287   A3
288 
289 */
290 
291 namespace t6
292 {
293 
294 struct A1
295 {
296     char _[43981];
297     virtual ~A1() {}
298 
299     A1* getA1() {return this;}
300 };
301 
302 struct A2
303 {
304     char _[34981];
305     virtual ~A2() {}
306 
307     A2* getA2() {return this;}
308 };
309 
310 struct 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 
322 void 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 
348 namespace t7
349 {
350 
351 struct A1
352 {
353     char _[43981];
354     virtual ~A1() {}
355 
356     A1* getA1() {return this;}
357 };
358 
359 struct A2
360 {
361     char _[34981];
362     virtual ~A2() {}
363 
364     A2* getA2() {return this;}
365 };
366 
367 struct 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 
379 void 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 
405 namespace t8
406 {
407 
408 struct A1
409 {
410     char _[43981];
411     virtual ~A1() {}
412 
413     A1* getA1() {return this;}
414 };
415 
416 struct A2
417 {
418     char _[34981];
419     virtual ~A2() {}
420 
421     A2* getA2() {return this;}
422 };
423 
424 struct 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 
436 void 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 
461 namespace t9
462 {
463 
464 struct A1
465 {
466     char _[43981];
467     virtual ~A1() {}
468 
469     A1* getA1() {return this;}
470 };
471 
472 struct A2
473 {
474     char _[34981];
475     virtual ~A2() {}
476 
477     A2* getA2() {return this;}
478 };
479 
480 struct 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 
492 void 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 
517 namespace t10
518 {
519 
520 struct A1
521 {
522     char _[43981];
523     virtual ~A1() {}
524 
525     A1* getA1() {return this;}
526 };
527 
528 struct A2
529 {
530     char _[34981];
531     virtual ~A2() {}
532 
533     A2* getA2() {return this;}
534 };
535 
536 struct 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 
548 void 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 
574 namespace t11
575 {
576 
577 struct A1
578 {
579     char _[43981];
580     virtual ~A1() {}
581 
582     A1* getA1() {return this;}
583 };
584 
585 struct A2
586 {
587     char _[34981];
588     virtual ~A2() {}
589 
590     A2* getA2() {return this;}
591 };
592 
593 struct 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 
605 void 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 
630 namespace t12
631 {
632 
633 struct A1
634 {
635     char _[43981];
636     virtual ~A1() {}
637 
638     A1* getA1() {return this;}
639 };
640 
641 struct A2
642 {
643     char _[34981];
644     virtual ~A2() {}
645 
646     A2* getA2() {return this;}
647 };
648 
649 struct 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 
661 void 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 
686 namespace t13
687 {
688 
689 struct A1
690 {
691     char _[43981];
692     virtual ~A1() {}
693 
694     A1* getA1() {return this;}
695 };
696 
697 struct A2
698 {
699     char _[34981];
700     virtual ~A2() {}
701 
702     A2* getA2() {return this;}
703 };
704 
705 struct 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 
717 void 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 
741 namespace t14
742 {
743 
744 struct A1
745 {
746     char _[43981];
747     virtual ~A1() {}
748 
749     A1* getA1() {return this;}
750 };
751 
752 struct A2
753 {
754     char _[34981];
755     virtual ~A2() {}
756 
757     A2* getA2() {return this;}
758 };
759 
760 struct 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 
772 void 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 
796 namespace t15
797 {
798 
799 struct A1
800 {
801     char _[43981];
802     virtual ~A1() {}
803 
804     A1* getA1() {return this;}
805 };
806 
807 struct A2
808 {
809     char _[34981];
810     virtual ~A2() {}
811 
812     A2* getA2() {return this;}
813 };
814 
815 struct 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 
827 void 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 
853 A1
854 |
855 A2
856 |
857 A3
858 
859 */
860 
861 namespace t16
862 {
863 
864 struct A1
865 {
866     char _[43981];
867     virtual ~A1() {}
868 
869     A1* getA1() {return this;}
870 };
871 
872 struct A2
873     : public A1
874 {
875     char _[34981];
876     virtual ~A2() {}
877 
878     A1* getA1() {return this;}
879     A2* getA2() {return this;}
880 };
881 
882 struct 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 
893 void 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 
922 namespace t17
923 {
924 
925 struct A1
926 {
927     char _[43981];
928     virtual ~A1() {}
929 
930     A1* getA1() {return this;}
931 };
932 
933 struct 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 
943 struct 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 
954 void 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 
983 namespace t18
984 {
985 
986 struct A1
987 {
988     char _[43981];
989     virtual ~A1() {}
990 
991     A1* getA1() {return this;}
992 };
993 
994 struct A2
995     : private A1
996 {
997     char _[34981];
998     virtual ~A2() {}
999 
1000     A1* getA1() {return this;}
1001     A2* getA2() {return this;}
1002 };
1003 
1004 struct A3
1005     : public A2
1006 {
1007     char _[93481];
1008     virtual ~A3() {}
1009 
1010     A2* getA2() {return this;}
1011     A3* getA3() {return this;}
1012 };
1013 
1014 void 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 
1040 namespace t19
1041 {
1042 
1043 struct A1
1044 {
1045     char _[43981];
1046     virtual ~A1() {}
1047 
1048     A1* getA1() {return this;}
1049 };
1050 
1051 struct 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 
1061 struct A3
1062     : public A2
1063 {
1064     char _[93481];
1065     virtual ~A3() {}
1066 
1067     A2* getA2() {return this;}
1068     A3* getA3() {return this;}
1069 };
1070 
1071 void 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 
1097 namespace t20
1098 {
1099 
1100 struct A1
1101 {
1102     char _[43981];
1103     virtual ~A1() {}
1104 
1105     A1* getA1() {return this;}
1106 };
1107 
1108 struct 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 
1118 struct 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 
1129 void 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 
1158 namespace t21
1159 {
1160 
1161 struct A1
1162 {
1163     char _[43981];
1164     virtual ~A1() {}
1165 
1166     A1* getA1() {return this;}
1167 };
1168 
1169 struct A2
1170     : private A1
1171 {
1172     char _[34981];
1173     virtual ~A2() {}
1174 
1175     A1* getA1() {return this;}
1176     A2* getA2() {return this;}
1177 };
1178 
1179 struct 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 
1189 void 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 
1215 namespace t22
1216 {
1217 
1218 struct A1
1219 {
1220     char _[43981];
1221     virtual ~A1() {}
1222 
1223     A1* getA1() {return this;}
1224 };
1225 
1226 struct 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 
1236 struct 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 
1246 void 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 
1272 namespace t23
1273 {
1274 
1275 struct A1
1276 {
1277     char _[43981];
1278     virtual ~A1() {}
1279 
1280     A1* getA1() {return this;}
1281 };
1282 
1283 struct A2
1284     : private A1
1285 {
1286     char _[34981];
1287     virtual ~A2() {}
1288 
1289     A1* getA1() {return this;}
1290     A2* getA2() {return this;}
1291 };
1292 
1293 struct 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 
1304 void 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 
1329 namespace t24
1330 {
1331 
1332 struct A1
1333 {
1334     char _[43981];
1335     virtual ~A1() {}
1336 
1337     A1* getA1() {return this;}
1338 };
1339 
1340 struct 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 
1350 struct 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 
1361 void 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 
1386 namespace t25
1387 {
1388 
1389 struct A1
1390 {
1391     char _[43981];
1392     virtual ~A1() {}
1393 
1394     A1* getA1() {return this;}
1395 };
1396 
1397 struct 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 
1407 struct 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 
1418 void 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 
1445 A1 A1
1446 |  |
1447 A2 |
1448  \ |
1449   A3
1450 
1451 */
1452 
1453 namespace t26
1454 {
1455 
1456 struct A1
1457 {
1458     char _[43981];
1459     virtual ~A1() {}
1460 
1461     A1* getA1() {return this;}
1462 };
1463 
1464 struct A2
1465     : public A1
1466 {
1467     char _[34981];
1468     virtual ~A2() {}
1469 
1470     A1* getA1() {return this;}
1471     A2* getA2() {return this;}
1472 };
1473 
1474 struct 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 
1486 void 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 
1514 namespace t27
1515 {
1516 
1517 struct A1
1518 {
1519     char _[43981];
1520     virtual ~A1() {}
1521 
1522     A1* getA1() {return this;}
1523 };
1524 
1525 struct A2
1526     : private A1
1527 {
1528     char _[34981];
1529     virtual ~A2() {}
1530 
1531     A1* getA1() {return this;}
1532     A2* getA2() {return this;}
1533 };
1534 
1535 struct 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 
1547 void 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 
1573 namespace t28
1574 {
1575 
1576 struct A1
1577 {
1578     char _[43981];
1579     virtual ~A1() {}
1580 
1581     A1* getA1() {return this;}
1582 };
1583 
1584 struct A2
1585     : public A1
1586 {
1587     char _[34981];
1588     virtual ~A2() {}
1589 
1590     A1* getA1() {return this;}
1591     A2* getA2() {return this;}
1592 };
1593 
1594 struct 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 
1606 void 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 
1633 namespace t29
1634 {
1635 
1636 struct A1
1637 {
1638     char _[43981];
1639     virtual ~A1() {}
1640 
1641     A1* getA1() {return this;}
1642 };
1643 
1644 struct A2
1645     : public A1
1646 {
1647     char _[34981];
1648     virtual ~A2() {}
1649 
1650     A1* getA1() {return this;}
1651     A2* getA2() {return this;}
1652 };
1653 
1654 struct 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 
1666 void 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 
1692 namespace t30
1693 {
1694 
1695 struct A1
1696 {
1697     char _[43981];
1698     virtual ~A1() {}
1699 
1700     A1* getA1() {return this;}
1701 };
1702 
1703 struct A2
1704     : public A1
1705 {
1706     char _[34981];
1707     virtual ~A2() {}
1708 
1709     A1* getA1() {return this;}
1710     A2* getA2() {return this;}
1711 };
1712 
1713 struct 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 
1725 void 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 
1752 namespace t31
1753 {
1754 
1755 struct A1
1756 {
1757     char _[43981];
1758     virtual ~A1() {}
1759 
1760     A1* getA1() {return this;}
1761 };
1762 
1763 struct A2
1764     : private A1
1765 {
1766     char _[34981];
1767     virtual ~A2() {}
1768 
1769     A1* getA1() {return this;}
1770     A2* getA2() {return this;}
1771 };
1772 
1773 struct 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 
1785 void 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 
1810 namespace t32
1811 {
1812 
1813 struct A1
1814 {
1815     char _[43981];
1816     virtual ~A1() {}
1817 
1818     A1* getA1() {return this;}
1819 };
1820 
1821 struct A2
1822     : private A1
1823 {
1824     char _[34981];
1825     virtual ~A2() {}
1826 
1827     A1* getA1() {return this;}
1828     A2* getA2() {return this;}
1829 };
1830 
1831 struct 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 
1843 void 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 
1868 namespace t33
1869 {
1870 
1871 struct A1
1872 {
1873     char _[43981];
1874     virtual ~A1() {}
1875 
1876     A1* getA1() {return this;}
1877 };
1878 
1879 struct A2
1880     : private A1
1881 {
1882     char _[34981];
1883     virtual ~A2() {}
1884 
1885     A1* getA1() {return this;}
1886     A2* getA2() {return this;}
1887 };
1888 
1889 struct 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 
1901 void 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 
1928 A1
1929 | \
1930 A2 \
1931  \ |
1932   A3
1933 
1934 */
1935 
1936 namespace t34
1937 {
1938 
1939 struct A1
1940 {
1941     char _[43981];
1942     virtual ~A1() {}
1943 
1944     A1* getA1() {return this;}
1945 };
1946 
1947 struct 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 
1957 struct 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 
1969 void 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 
1998 namespace t35
1999 {
2000 
2001 struct A1
2002 {
2003     char _[43981];
2004     virtual ~A1() {}
2005 
2006     A1* getA1() {return this;}
2007 };
2008 
2009 struct 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 
2019 struct 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 
2031 void 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 
2058 namespace t36
2059 {
2060 
2061 struct A1
2062 {
2063     char _[43981];
2064     virtual ~A1() {}
2065 
2066     A1* getA1() {return this;}
2067 };
2068 
2069 struct 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 
2079 struct 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 
2091 void 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 
2120 namespace t37
2121 {
2122 
2123 struct A1
2124 {
2125     char _[43981];
2126     virtual ~A1() {}
2127 
2128     A1* getA1() {return this;}
2129 };
2130 
2131 struct 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 
2141 struct 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 
2153 void 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 
2181 namespace t38
2182 {
2183 
2184 struct A1
2185 {
2186     char _[43981];
2187     virtual ~A1() {}
2188 
2189     A1* getA1() {return this;}
2190 };
2191 
2192 struct 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 
2202 struct 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 
2214 void 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 
2241 namespace t39
2242 {
2243 
2244 struct A1
2245 {
2246     char _[43981];
2247     virtual ~A1() {}
2248 
2249     A1* getA1() {return this;}
2250 };
2251 
2252 struct 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 
2262 struct 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 
2274 void 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 
2300 namespace t40
2301 {
2302 
2303 struct A1
2304 {
2305     char _[43981];
2306     virtual ~A1() {}
2307 
2308     A1* getA1() {return this;}
2309 };
2310 
2311 struct 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 
2321 struct 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 
2333 void 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 
2359 namespace t41
2360 {
2361 
2362 struct A1
2363 {
2364     char _[43981];
2365     virtual ~A1() {}
2366 
2367     A1* getA1() {return this;}
2368 };
2369 
2370 struct 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 
2380 struct 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 
2392 void 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 
2417 int 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