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