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