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