1 //===------------------------- dynamic_cast3.cpp --------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include <cassert>
11 #include "support/timer.hpp"
12
13 // This test explicitly tests dynamic cast with types that have inaccessible
14 // bases.
15 #if defined(__clang__)
16 #pragma clang diagnostic ignored "-Winaccessible-base"
17 #endif
18
19 /*
20
21 A1 A2 A3
22
23 */
24
25 namespace t1
26 {
27
28 struct A1
29 {
30 char _[43981];
~A1t1::A131 virtual ~A1() {}
32
getA1t1::A133 A1* getA1() {return this;}
34 };
35
36 struct A2
37 {
38 char _[34981];
~A2t1::A239 virtual ~A2() {}
40
getA2t1::A241 A2* getA2() {return this;}
42 };
43
44 struct A3
45 {
46 char _[93481];
~A3t1::A347 virtual ~A3() {}
48
getA3t1::A349 A3* getA3() {return this;}
50 };
51
test()52 void test()
53 {
54 A1 a1;
55 A2 a2;
56 A3 a3;
57 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
58 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
59 assert(dynamic_cast<A1*>(a3.getA3()) == 0);
60 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
61 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
62 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
63 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
64 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
65 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
66 }
67
68 } // t1
69
70 /*
71
72 A1 A2
73 |
74 A3
75
76 */
77
78 namespace t2
79 {
80
81 struct A1
82 {
83 char _[43981];
~A1t2::A184 virtual ~A1() {}
85
getA1t2::A186 A1* getA1() {return this;}
87 };
88
89 struct A2
90 {
91 char _[34981];
~A2t2::A292 virtual ~A2() {}
93
getA2t2::A294 A2* getA2() {return this;}
95 };
96
97 struct A3
98 : public A1
99 {
100 char _[93481];
~A3t2::A3101 virtual ~A3() {}
102
getA3t2::A3103 A3* getA3() {return this;}
104 };
105
test()106 void test()
107 {
108 A1 a1;
109 A2 a2;
110 A3 a3;
111 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
112 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
113 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
114 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
115
116 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
117 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
118 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
119 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
120
121 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
122 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
123 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
124 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
125 }
126
127 } // t2
128
129 namespace t3
130 {
131
132 struct A1
133 {
134 char _[43981];
~A1t3::A1135 virtual ~A1() {}
136
getA1t3::A1137 A1* getA1() {return this;}
138 };
139
140 struct A2
141 {
142 char _[34981];
~A2t3::A2143 virtual ~A2() {}
144
getA2t3::A2145 A2* getA2() {return this;}
146 };
147
148 struct A3
149 : public virtual A1
150 {
151 char _[93481];
~A3t3::A3152 virtual ~A3() {}
153
getA3t3::A3154 A3* getA3() {return this;}
155 };
156
test()157 void test()
158 {
159 A1 a1;
160 A2 a2;
161 A3 a3;
162 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
163 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
164 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
165 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
166
167 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
168 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
169 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
170 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
171
172 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
173 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
174 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
175 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
176 }
177
178 } // t3
179
180 namespace t4
181 {
182
183 struct A1
184 {
185 char _[43981];
~A1t4::A1186 virtual ~A1() {}
187
getA1t4::A1188 A1* getA1() {return this;}
189 };
190
191 struct A2
192 {
193 char _[34981];
~A2t4::A2194 virtual ~A2() {}
195
getA2t4::A2196 A2* getA2() {return this;}
197 };
198
199 struct A3
200 : private A1
201 {
202 char _[93481];
~A3t4::A3203 virtual ~A3() {}
204
getA1t4::A3205 A1* getA1() {return this;}
getA3t4::A3206 A3* getA3() {return this;}
207 };
208
test()209 void test()
210 {
211 A1 a1;
212 A2 a2;
213 A3 a3;
214 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
215 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
216 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
217
218 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
219 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
220 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
221 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
222
223 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
224 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
225 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
226 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
227 }
228
229 } // t4
230
231 namespace t5
232 {
233
234 struct A1
235 {
236 char _[43981];
~A1t5::A1237 virtual ~A1() {}
238
getA1t5::A1239 A1* getA1() {return this;}
240 };
241
242 struct A2
243 {
244 char _[34981];
~A2t5::A2245 virtual ~A2() {}
246
getA2t5::A2247 A2* getA2() {return this;}
248 };
249
250 struct A3
251 : private virtual A1
252 {
253 char _[93481];
~A3t5::A3254 virtual ~A3() {}
255
getA1t5::A3256 A1* getA1() {return this;}
getA3t5::A3257 A3* getA3() {return this;}
258 };
259
test()260 void test()
261 {
262 A1 a1;
263 A2 a2;
264 A3 a3;
265 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
266 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
267 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
268
269 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
270 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
271 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
272 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
273
274 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
275 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
276 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
277 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
278 }
279
280 } // t5
281
282 /*
283
284 A1 A2
285 \ /
286 A3
287
288 */
289
290 namespace t6
291 {
292
293 struct A1
294 {
295 char _[43981];
~A1t6::A1296 virtual ~A1() {}
297
getA1t6::A1298 A1* getA1() {return this;}
299 };
300
301 struct A2
302 {
303 char _[34981];
~A2t6::A2304 virtual ~A2() {}
305
getA2t6::A2306 A2* getA2() {return this;}
307 };
308
309 struct A3
310 : public A1,
311 public A2
312 {
313 char _[93481];
~A3t6::A3314 virtual ~A3() {}
315
getA1t6::A3316 A1* getA1() {return this;}
getA2t6::A3317 A2* getA2() {return this;}
getA3t6::A3318 A3* getA3() {return this;}
319 };
320
test()321 void test()
322 {
323 A1 a1;
324 A2 a2;
325 A3 a3;
326 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
327 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
328 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
329 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
330 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
331
332 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
333 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
334 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
335 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
336 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
337
338 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
339 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
340 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
341 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
342 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
343 }
344
345 } // t6
346
347 namespace t7
348 {
349
350 struct A1
351 {
352 char _[43981];
~A1t7::A1353 virtual ~A1() {}
354
getA1t7::A1355 A1* getA1() {return this;}
356 };
357
358 struct A2
359 {
360 char _[34981];
~A2t7::A2361 virtual ~A2() {}
362
getA2t7::A2363 A2* getA2() {return this;}
364 };
365
366 struct A3
367 : public virtual A1,
368 public A2
369 {
370 char _[93481];
~A3t7::A3371 virtual ~A3() {}
372
getA1t7::A3373 A1* getA1() {return this;}
getA2t7::A3374 A2* getA2() {return this;}
getA3t7::A3375 A3* getA3() {return this;}
376 };
377
test()378 void test()
379 {
380 A1 a1;
381 A2 a2;
382 A3 a3;
383 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
384 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
385 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
386 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
387 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
388
389 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
390 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
391 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
392 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
393 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
394
395 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
396 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
397 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
398 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
399 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
400 }
401
402 } // t7
403
404 namespace t8
405 {
406
407 struct A1
408 {
409 char _[43981];
~A1t8::A1410 virtual ~A1() {}
411
getA1t8::A1412 A1* getA1() {return this;}
413 };
414
415 struct A2
416 {
417 char _[34981];
~A2t8::A2418 virtual ~A2() {}
419
getA2t8::A2420 A2* getA2() {return this;}
421 };
422
423 struct A3
424 : private A1,
425 public A2
426 {
427 char _[93481];
~A3t8::A3428 virtual ~A3() {}
429
getA1t8::A3430 A1* getA1() {return this;}
getA2t8::A3431 A2* getA2() {return this;}
getA3t8::A3432 A3* getA3() {return this;}
433 };
434
test()435 void test()
436 {
437 A1 a1;
438 A2 a2;
439 A3 a3;
440 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
441 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
442 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
443 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
444
445 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
446 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
447 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
448 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
449 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
450
451 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
452 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
453 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
454 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
455 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
456 }
457
458 } // t8
459
460 namespace t9
461 {
462
463 struct A1
464 {
465 char _[43981];
~A1t9::A1466 virtual ~A1() {}
467
getA1t9::A1468 A1* getA1() {return this;}
469 };
470
471 struct A2
472 {
473 char _[34981];
~A2t9::A2474 virtual ~A2() {}
475
getA2t9::A2476 A2* getA2() {return this;}
477 };
478
479 struct A3
480 : private virtual A1,
481 public A2
482 {
483 char _[93481];
~A3t9::A3484 virtual ~A3() {}
485
getA1t9::A3486 A1* getA1() {return this;}
getA2t9::A3487 A2* getA2() {return this;}
getA3t9::A3488 A3* getA3() {return this;}
489 };
490
test()491 void test()
492 {
493 A1 a1;
494 A2 a2;
495 A3 a3;
496 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
497 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
498 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
499 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
500
501 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
502 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
503 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
504 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
505 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
506
507 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
508 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
509 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
510 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
511 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
512 }
513
514 } // t9
515
516 namespace t10
517 {
518
519 struct A1
520 {
521 char _[43981];
~A1t10::A1522 virtual ~A1() {}
523
getA1t10::A1524 A1* getA1() {return this;}
525 };
526
527 struct A2
528 {
529 char _[34981];
~A2t10::A2530 virtual ~A2() {}
531
getA2t10::A2532 A2* getA2() {return this;}
533 };
534
535 struct A3
536 : public virtual A1,
537 public virtual A2
538 {
539 char _[93481];
~A3t10::A3540 virtual ~A3() {}
541
getA1t10::A3542 A1* getA1() {return this;}
getA2t10::A3543 A2* getA2() {return this;}
getA3t10::A3544 A3* getA3() {return this;}
545 };
546
test()547 void test()
548 {
549 A1 a1;
550 A2 a2;
551 A3 a3;
552 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
553 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
554 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
555 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
556 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
557
558 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
559 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
560 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
561 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
562 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
563
564 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
565 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
566 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
567 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
568 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
569 }
570
571 } // t10
572
573 namespace t11
574 {
575
576 struct A1
577 {
578 char _[43981];
~A1t11::A1579 virtual ~A1() {}
580
getA1t11::A1581 A1* getA1() {return this;}
582 };
583
584 struct A2
585 {
586 char _[34981];
~A2t11::A2587 virtual ~A2() {}
588
getA2t11::A2589 A2* getA2() {return this;}
590 };
591
592 struct A3
593 : private A1,
594 public virtual A2
595 {
596 char _[93481];
~A3t11::A3597 virtual ~A3() {}
598
getA1t11::A3599 A1* getA1() {return this;}
getA2t11::A3600 A2* getA2() {return this;}
getA3t11::A3601 A3* getA3() {return this;}
602 };
603
test()604 void test()
605 {
606 A1 a1;
607 A2 a2;
608 A3 a3;
609 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
610 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
611 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
612 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
613
614 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
615 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
616 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
617 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
618 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
619
620 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
621 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
622 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
623 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
624 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
625 }
626
627 } // t11
628
629 namespace t12
630 {
631
632 struct A1
633 {
634 char _[43981];
~A1t12::A1635 virtual ~A1() {}
636
getA1t12::A1637 A1* getA1() {return this;}
638 };
639
640 struct A2
641 {
642 char _[34981];
~A2t12::A2643 virtual ~A2() {}
644
getA2t12::A2645 A2* getA2() {return this;}
646 };
647
648 struct A3
649 : private virtual A1,
650 public virtual A2
651 {
652 char _[93481];
~A3t12::A3653 virtual ~A3() {}
654
getA1t12::A3655 A1* getA1() {return this;}
getA2t12::A3656 A2* getA2() {return this;}
getA3t12::A3657 A3* getA3() {return this;}
658 };
659
test()660 void test()
661 {
662 A1 a1;
663 A2 a2;
664 A3 a3;
665 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
666 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
667 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
668 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
669
670 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
671 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
672 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
673 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
674 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
675
676 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
677 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
678 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
679 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
680 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
681 }
682
683 } // t12
684
685 namespace t13
686 {
687
688 struct A1
689 {
690 char _[43981];
~A1t13::A1691 virtual ~A1() {}
692
getA1t13::A1693 A1* getA1() {return this;}
694 };
695
696 struct A2
697 {
698 char _[34981];
~A2t13::A2699 virtual ~A2() {}
700
getA2t13::A2701 A2* getA2() {return this;}
702 };
703
704 struct A3
705 : private A1,
706 private A2
707 {
708 char _[93481];
~A3t13::A3709 virtual ~A3() {}
710
getA1t13::A3711 A1* getA1() {return this;}
getA2t13::A3712 A2* getA2() {return this;}
getA3t13::A3713 A3* getA3() {return this;}
714 };
715
test()716 void test()
717 {
718 A1 a1;
719 A2 a2;
720 A3 a3;
721 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
722 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
723 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
724 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
725
726 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
727 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
728 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
729 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
730
731 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
732 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
733 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
734 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
735 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
736 }
737
738 } // t13
739
740 namespace t14
741 {
742
743 struct A1
744 {
745 char _[43981];
~A1t14::A1746 virtual ~A1() {}
747
getA1t14::A1748 A1* getA1() {return this;}
749 };
750
751 struct A2
752 {
753 char _[34981];
~A2t14::A2754 virtual ~A2() {}
755
getA2t14::A2756 A2* getA2() {return this;}
757 };
758
759 struct A3
760 : private virtual A1,
761 private A2
762 {
763 char _[93481];
~A3t14::A3764 virtual ~A3() {}
765
getA1t14::A3766 A1* getA1() {return this;}
getA2t14::A3767 A2* getA2() {return this;}
getA3t14::A3768 A3* getA3() {return this;}
769 };
770
test()771 void test()
772 {
773 A1 a1;
774 A2 a2;
775 A3 a3;
776 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
777 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
778 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
779 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
780
781 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
782 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
783 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
784 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
785
786 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
787 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
788 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
789 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
790 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
791 }
792
793 } // t14
794
795 namespace t15
796 {
797
798 struct A1
799 {
800 char _[43981];
~A1t15::A1801 virtual ~A1() {}
802
getA1t15::A1803 A1* getA1() {return this;}
804 };
805
806 struct A2
807 {
808 char _[34981];
~A2t15::A2809 virtual ~A2() {}
810
getA2t15::A2811 A2* getA2() {return this;}
812 };
813
814 struct A3
815 : private virtual A1,
816 private virtual A2
817 {
818 char _[93481];
~A3t15::A3819 virtual ~A3() {}
820
getA1t15::A3821 A1* getA1() {return this;}
getA2t15::A3822 A2* getA2() {return this;}
getA3t15::A3823 A3* getA3() {return this;}
824 };
825
test()826 void test()
827 {
828 A1 a1;
829 A2 a2;
830 A3 a3;
831 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
832 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
833 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
834 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
835
836 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
837 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
838 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
839 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
840
841 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
842 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
843 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
844 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
845 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
846 }
847
848 } // t15
849
850 /*
851
852 A1
853 |
854 A2
855 |
856 A3
857
858 */
859
860 namespace t16
861 {
862
863 struct A1
864 {
865 char _[43981];
~A1t16::A1866 virtual ~A1() {}
867
getA1t16::A1868 A1* getA1() {return this;}
869 };
870
871 struct A2
872 : public A1
873 {
874 char _[34981];
~A2t16::A2875 virtual ~A2() {}
876
getA1t16::A2877 A1* getA1() {return this;}
getA2t16::A2878 A2* getA2() {return this;}
879 };
880
881 struct A3
882 : public A2
883 {
884 char _[93481];
~A3t16::A3885 virtual ~A3() {}
886
getA1t16::A3887 A1* getA1() {return this;}
getA2t16::A3888 A2* getA2() {return this;}
getA3t16::A3889 A3* getA3() {return this;}
890 };
891
test()892 void test()
893 {
894 A1 a1;
895 A2 a2;
896 A3 a3;
897 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
898 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
899 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
900 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
901 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
902 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
903
904 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
905 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
906 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
907 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
908 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
909 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
910
911 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
912 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
913 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
914 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
915 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
916 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
917 }
918
919 } // t16
920
921 namespace t17
922 {
923
924 struct A1
925 {
926 char _[43981];
~A1t17::A1927 virtual ~A1() {}
928
getA1t17::A1929 A1* getA1() {return this;}
930 };
931
932 struct A2
933 : public virtual A1
934 {
935 char _[34981];
~A2t17::A2936 virtual ~A2() {}
937
getA1t17::A2938 A1* getA1() {return this;}
getA2t17::A2939 A2* getA2() {return this;}
940 };
941
942 struct A3
943 : public A2
944 {
945 char _[93481];
~A3t17::A3946 virtual ~A3() {}
947
getA1t17::A3948 A1* getA1() {return this;}
getA2t17::A3949 A2* getA2() {return this;}
getA3t17::A3950 A3* getA3() {return this;}
951 };
952
test()953 void test()
954 {
955 A1 a1;
956 A2 a2;
957 A3 a3;
958 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
959 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
960 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
961 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
962 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
963 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
964
965 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
966 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
967 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
968 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
969 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
970 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
971
972 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
973 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
974 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
975 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
976 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
977 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
978 }
979
980 } // t17
981
982 namespace t18
983 {
984
985 struct A1
986 {
987 char _[43981];
~A1t18::A1988 virtual ~A1() {}
989
getA1t18::A1990 A1* getA1() {return this;}
991 };
992
993 struct A2
994 : private A1
995 {
996 char _[34981];
~A2t18::A2997 virtual ~A2() {}
998
getA1t18::A2999 A1* getA1() {return this;}
getA2t18::A21000 A2* getA2() {return this;}
1001 };
1002
1003 struct A3
1004 : public A2
1005 {
1006 char _[93481];
~A3t18::A31007 virtual ~A3() {}
1008
getA2t18::A31009 A2* getA2() {return this;}
getA3t18::A31010 A3* getA3() {return this;}
1011 };
1012
test()1013 void test()
1014 {
1015 A1 a1;
1016 A2 a2;
1017 A3 a3;
1018 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1019 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1020 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1021
1022 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1023 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1024 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1025 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1026 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1027 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1028
1029 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1030 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1031 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1032 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1033 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1034 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1035 }
1036
1037 } // t18
1038
1039 namespace t19
1040 {
1041
1042 struct A1
1043 {
1044 char _[43981];
~A1t19::A11045 virtual ~A1() {}
1046
getA1t19::A11047 A1* getA1() {return this;}
1048 };
1049
1050 struct A2
1051 : protected virtual A1
1052 {
1053 char _[34981];
~A2t19::A21054 virtual ~A2() {}
1055
getA1t19::A21056 A1* getA1() {return this;}
getA2t19::A21057 A2* getA2() {return this;}
1058 };
1059
1060 struct A3
1061 : public A2
1062 {
1063 char _[93481];
~A3t19::A31064 virtual ~A3() {}
1065
getA2t19::A31066 A2* getA2() {return this;}
getA3t19::A31067 A3* getA3() {return this;}
1068 };
1069
test()1070 void test()
1071 {
1072 A1 a1;
1073 A2 a2;
1074 A3 a3;
1075 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1076 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1077 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1078
1079 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1080 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1081 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1082 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1083 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1084 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1085
1086 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1087 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1088 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1089 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1090 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1091 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1092 }
1093
1094 } // t19
1095
1096 namespace t20
1097 {
1098
1099 struct A1
1100 {
1101 char _[43981];
~A1t20::A11102 virtual ~A1() {}
1103
getA1t20::A11104 A1* getA1() {return this;}
1105 };
1106
1107 struct A2
1108 : public virtual A1
1109 {
1110 char _[34981];
~A2t20::A21111 virtual ~A2() {}
1112
getA1t20::A21113 A1* getA1() {return this;}
getA2t20::A21114 A2* getA2() {return this;}
1115 };
1116
1117 struct A3
1118 : public virtual A2
1119 {
1120 char _[93481];
~A3t20::A31121 virtual ~A3() {}
1122
getA1t20::A31123 A1* getA1() {return this;}
getA2t20::A31124 A2* getA2() {return this;}
getA3t20::A31125 A3* getA3() {return this;}
1126 };
1127
test()1128 void test()
1129 {
1130 A1 a1;
1131 A2 a2;
1132 A3 a3;
1133 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1134 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1135 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1136 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1137 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
1138 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
1139
1140 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1141 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1142 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1143 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
1144 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1145 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1146
1147 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1148 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1149 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1150 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
1151 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1152 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1153 }
1154
1155 } // t20
1156
1157 namespace t21
1158 {
1159
1160 struct A1
1161 {
1162 char _[43981];
~A1t21::A11163 virtual ~A1() {}
1164
getA1t21::A11165 A1* getA1() {return this;}
1166 };
1167
1168 struct A2
1169 : private A1
1170 {
1171 char _[34981];
~A2t21::A21172 virtual ~A2() {}
1173
getA1t21::A21174 A1* getA1() {return this;}
getA2t21::A21175 A2* getA2() {return this;}
1176 };
1177
1178 struct A3
1179 : public virtual A2
1180 {
1181 char _[93481];
~A3t21::A31182 virtual ~A3() {}
1183
getA2t21::A31184 A2* getA2() {return this;}
getA3t21::A31185 A3* getA3() {return this;}
1186 };
1187
test()1188 void test()
1189 {
1190 A1 a1;
1191 A2 a2;
1192 A3 a3;
1193 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1194 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1195 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1196
1197 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1198 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1199 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1200 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1201 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1202 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1203
1204 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1205 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1206 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1207 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1208 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1209 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1210 }
1211
1212 } // t21
1213
1214 namespace t22
1215 {
1216
1217 struct A1
1218 {
1219 char _[43981];
~A1t22::A11220 virtual ~A1() {}
1221
getA1t22::A11222 A1* getA1() {return this;}
1223 };
1224
1225 struct A2
1226 : protected virtual A1
1227 {
1228 char _[34981];
~A2t22::A21229 virtual ~A2() {}
1230
getA1t22::A21231 A1* getA1() {return this;}
getA2t22::A21232 A2* getA2() {return this;}
1233 };
1234
1235 struct A3
1236 : public virtual A2
1237 {
1238 char _[93481];
~A3t22::A31239 virtual ~A3() {}
1240
getA2t22::A31241 A2* getA2() {return this;}
getA3t22::A31242 A3* getA3() {return this;}
1243 };
1244
test()1245 void test()
1246 {
1247 A1 a1;
1248 A2 a2;
1249 A3 a3;
1250 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1251 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1252 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1253
1254 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1255 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1256 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1257 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1258 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1259 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1260
1261 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1262 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1263 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1264 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1265 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1266 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1267 }
1268
1269 } // t22
1270
1271 namespace t23
1272 {
1273
1274 struct A1
1275 {
1276 char _[43981];
~A1t23::A11277 virtual ~A1() {}
1278
getA1t23::A11279 A1* getA1() {return this;}
1280 };
1281
1282 struct A2
1283 : private A1
1284 {
1285 char _[34981];
~A2t23::A21286 virtual ~A2() {}
1287
getA1t23::A21288 A1* getA1() {return this;}
getA2t23::A21289 A2* getA2() {return this;}
1290 };
1291
1292 struct A3
1293 : private A2
1294 {
1295 char _[93481];
~A3t23::A31296 virtual ~A3() {}
1297
getA1t23::A31298 t23::A1* getA1() {return A2::getA1();}
getA2t23::A31299 A2* getA2() {return this;}
getA3t23::A31300 A3* getA3() {return this;}
1301 };
1302
test()1303 void test()
1304 {
1305 A1 a1;
1306 A2 a2;
1307 A3 a3;
1308 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1309 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1310 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1311
1312 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1313 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1314 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1315 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1316 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1317
1318 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1319 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1320 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1321 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1322 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1323 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1324 }
1325
1326 } // t23
1327
1328 namespace t24
1329 {
1330
1331 struct A1
1332 {
1333 char _[43981];
~A1t24::A11334 virtual ~A1() {}
1335
getA1t24::A11336 A1* getA1() {return this;}
1337 };
1338
1339 struct A2
1340 : protected virtual A1
1341 {
1342 char _[34981];
~A2t24::A21343 virtual ~A2() {}
1344
getA1t24::A21345 A1* getA1() {return this;}
getA2t24::A21346 A2* getA2() {return this;}
1347 };
1348
1349 struct A3
1350 : private A2
1351 {
1352 char _[93481];
~A3t24::A31353 virtual ~A3() {}
1354
getA1t24::A31355 t24::A1* getA1() {return A2::getA1();}
getA2t24::A31356 A2* getA2() {return this;}
getA3t24::A31357 A3* getA3() {return this;}
1358 };
1359
test()1360 void test()
1361 {
1362 A1 a1;
1363 A2 a2;
1364 A3 a3;
1365 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1366 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1367 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1368
1369 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1370 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1371 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1372 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1373 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1374
1375 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1376 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1377 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1378 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1379 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1380 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1381 }
1382
1383 } // t24
1384
1385 namespace t25
1386 {
1387
1388 struct A1
1389 {
1390 char _[43981];
~A1t25::A11391 virtual ~A1() {}
1392
getA1t25::A11393 A1* getA1() {return this;}
1394 };
1395
1396 struct A2
1397 : protected virtual A1
1398 {
1399 char _[34981];
~A2t25::A21400 virtual ~A2() {}
1401
getA1t25::A21402 A1* getA1() {return this;}
getA2t25::A21403 A2* getA2() {return this;}
1404 };
1405
1406 struct A3
1407 : private virtual A2
1408 {
1409 char _[93481];
~A3t25::A31410 virtual ~A3() {}
1411
getA1t25::A31412 t25::A1* getA1() {return A2::getA1();}
getA2t25::A31413 A2* getA2() {return this;}
getA3t25::A31414 A3* getA3() {return this;}
1415 };
1416
test()1417 void test()
1418 {
1419 A1 a1;
1420 A2 a2;
1421 A3 a3;
1422 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1423 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1424 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1425
1426 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1427 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1428 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1429 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1430 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1431
1432 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1433 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1434 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1435 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1436 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1437 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1438 }
1439
1440 } // t25
1441
1442 /*
1443
1444 A1 A1
1445 | |
1446 A2 |
1447 \ |
1448 A3
1449
1450 */
1451
1452 namespace t26
1453 {
1454
1455 struct A1
1456 {
1457 char _[43981];
~A1t26::A11458 virtual ~A1() {}
1459
getA1t26::A11460 A1* getA1() {return this;}
1461 };
1462
1463 struct A2
1464 : public A1
1465 {
1466 char _[34981];
~A2t26::A21467 virtual ~A2() {}
1468
getA1t26::A21469 A1* getA1() {return this;}
getA2t26::A21470 A2* getA2() {return this;}
1471 };
1472
1473 struct A3
1474 : public A1,
1475 public A2
1476 {
1477 char _[93481];
~A3t26::A31478 virtual ~A3() {}
1479
getA12t26::A31480 A1* getA12() {return A2::getA1();}
getA2t26::A31481 A2* getA2() {return this;}
getA3t26::A31482 A3* getA3() {return this;}
1483 };
1484
test()1485 void test()
1486 {
1487 A1 a1;
1488 A2 a2;
1489 A3 a3;
1490 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1491 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1492 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1493 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1494 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1495
1496 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1497 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1498 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1499 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1500 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1501 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1502
1503 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1504 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1505 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1506 assert(dynamic_cast<A3*>(a3.getA12()) == a3.getA3());
1507 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1508 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1509 }
1510
1511 } // t26
1512
1513 namespace t27
1514 {
1515
1516 struct A1
1517 {
1518 char _[43981];
~A1t27::A11519 virtual ~A1() {}
1520
getA1t27::A11521 A1* getA1() {return this;}
1522 };
1523
1524 struct A2
1525 : private A1
1526 {
1527 char _[34981];
~A2t27::A21528 virtual ~A2() {}
1529
getA1t27::A21530 A1* getA1() {return this;}
getA2t27::A21531 A2* getA2() {return this;}
1532 };
1533
1534 struct A3
1535 : public A1,
1536 public A2
1537 {
1538 char _[93481];
~A3t27::A31539 virtual ~A3() {}
1540
getA12t27::A31541 A1* getA12() {return A2::getA1();}
getA2t27::A31542 A2* getA2() {return this;}
getA3t27::A31543 A3* getA3() {return this;}
1544 };
1545
test()1546 void test()
1547 {
1548 A1 a1;
1549 A2 a2;
1550 A3 a3;
1551 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1552 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1553 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1554
1555 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1556 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1557 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1558 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1559 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1560 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1561
1562 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1563 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1564 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1565 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1566 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1567 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1568 }
1569
1570 } // t27
1571
1572 namespace t28
1573 {
1574
1575 struct A1
1576 {
1577 char _[43981];
~A1t28::A11578 virtual ~A1() {}
1579
getA1t28::A11580 A1* getA1() {return this;}
1581 };
1582
1583 struct A2
1584 : public A1
1585 {
1586 char _[34981];
~A2t28::A21587 virtual ~A2() {}
1588
getA1t28::A21589 A1* getA1() {return this;}
getA2t28::A21590 A2* getA2() {return this;}
1591 };
1592
1593 struct A3
1594 : private A1,
1595 public A2
1596 {
1597 char _[93481];
~A3t28::A31598 virtual ~A3() {}
1599
getA12t28::A31600 A1* getA12() {return A2::getA1();}
getA2t28::A31601 A2* getA2() {return this;}
getA3t28::A31602 A3* getA3() {return this;}
1603 };
1604
test()1605 void test()
1606 {
1607 A1 a1;
1608 A2 a2;
1609 A3 a3;
1610 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1611 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1612 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1613 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1614
1615 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1616 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1617 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1618 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1619 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1620 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1621
1622 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1623 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1624 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1625 assert(dynamic_cast<A3*>(a3.getA12()) == a3.getA3());
1626 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1627 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1628 }
1629
1630 } // t28
1631
1632 namespace t29
1633 {
1634
1635 struct A1
1636 {
1637 char _[43981];
~A1t29::A11638 virtual ~A1() {}
1639
getA1t29::A11640 A1* getA1() {return this;}
1641 };
1642
1643 struct A2
1644 : public A1
1645 {
1646 char _[34981];
~A2t29::A21647 virtual ~A2() {}
1648
getA1t29::A21649 A1* getA1() {return this;}
getA2t29::A21650 A2* getA2() {return this;}
1651 };
1652
1653 struct A3
1654 : public A1,
1655 private A2
1656 {
1657 char _[93481];
~A3t29::A31658 virtual ~A3() {}
1659
getA12t29::A31660 A1* getA12() {return A2::getA1();}
getA2t29::A31661 A2* getA2() {return this;}
getA3t29::A31662 A3* getA3() {return this;}
1663 };
1664
test()1665 void test()
1666 {
1667 A1 a1;
1668 A2 a2;
1669 A3 a3;
1670 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1671 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1672 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1673 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1674
1675 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1676 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1677 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1678 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1679 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1680
1681 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1682 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1683 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1684 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1685 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1686 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1687 }
1688
1689 } // t29
1690
1691 namespace t30
1692 {
1693
1694 struct A1
1695 {
1696 char _[43981];
~A1t30::A11697 virtual ~A1() {}
1698
getA1t30::A11699 A1* getA1() {return this;}
1700 };
1701
1702 struct A2
1703 : public A1
1704 {
1705 char _[34981];
~A2t30::A21706 virtual ~A2() {}
1707
getA1t30::A21708 A1* getA1() {return this;}
getA2t30::A21709 A2* getA2() {return this;}
1710 };
1711
1712 struct A3
1713 : private A1,
1714 private A2
1715 {
1716 char _[93481];
~A3t30::A31717 virtual ~A3() {}
1718
getA12t30::A31719 A1* getA12() {return A2::getA1();}
getA2t30::A31720 A2* getA2() {return this;}
getA3t30::A31721 A3* getA3() {return this;}
1722 };
1723
test()1724 void test()
1725 {
1726 A1 a1;
1727 A2 a2;
1728 A3 a3;
1729 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1730 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1731 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1732 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1733 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1734
1735 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1736 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1737 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1738 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1739 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1740
1741 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1742 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1743 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1744 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1745 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1746 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1747 }
1748
1749 } // t30
1750
1751 namespace t31
1752 {
1753
1754 struct A1
1755 {
1756 char _[43981];
~A1t31::A11757 virtual ~A1() {}
1758
getA1t31::A11759 A1* getA1() {return this;}
1760 };
1761
1762 struct A2
1763 : private A1
1764 {
1765 char _[34981];
~A2t31::A21766 virtual ~A2() {}
1767
getA1t31::A21768 A1* getA1() {return this;}
getA2t31::A21769 A2* getA2() {return this;}
1770 };
1771
1772 struct A3
1773 : public A1,
1774 private A2
1775 {
1776 char _[93481];
~A3t31::A31777 virtual ~A3() {}
1778
getA12t31::A31779 A1* getA12() {return A2::getA1();}
getA2t31::A31780 A2* getA2() {return this;}
getA3t31::A31781 A3* getA3() {return this;}
1782 };
1783
test()1784 void test()
1785 {
1786 A1 a1;
1787 A2 a2;
1788 A3 a3;
1789 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1790 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1791 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1792
1793 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1794 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1795 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1796 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1797 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1798
1799 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1800 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1801 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1802 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1803 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1804 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1805 }
1806
1807 } // t31
1808
1809 namespace t32
1810 {
1811
1812 struct A1
1813 {
1814 char _[43981];
~A1t32::A11815 virtual ~A1() {}
1816
getA1t32::A11817 A1* getA1() {return this;}
1818 };
1819
1820 struct A2
1821 : private A1
1822 {
1823 char _[34981];
~A2t32::A21824 virtual ~A2() {}
1825
getA1t32::A21826 A1* getA1() {return this;}
getA2t32::A21827 A2* getA2() {return this;}
1828 };
1829
1830 struct A3
1831 : private A1,
1832 public A2
1833 {
1834 char _[93481];
~A3t32::A31835 virtual ~A3() {}
1836
getA12t32::A31837 A1* getA12() {return A2::getA1();}
getA2t32::A31838 A2* getA2() {return this;}
getA3t32::A31839 A3* getA3() {return this;}
1840 };
1841
test()1842 void test()
1843 {
1844 A1 a1;
1845 A2 a2;
1846 A3 a3;
1847 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1848 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1849 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1850
1851 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1852 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1853 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1854 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1855 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1856
1857 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1858 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1859 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1860 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1861 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1862 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1863 }
1864
1865 } // t32
1866
1867 namespace t33
1868 {
1869
1870 struct A1
1871 {
1872 char _[43981];
~A1t33::A11873 virtual ~A1() {}
1874
getA1t33::A11875 A1* getA1() {return this;}
1876 };
1877
1878 struct A2
1879 : private A1
1880 {
1881 char _[34981];
~A2t33::A21882 virtual ~A2() {}
1883
getA1t33::A21884 A1* getA1() {return this;}
getA2t33::A21885 A2* getA2() {return this;}
1886 };
1887
1888 struct A3
1889 : private A1,
1890 private A2
1891 {
1892 char _[93481];
~A3t33::A31893 virtual ~A3() {}
1894
getA12t33::A31895 A1* getA12() {return A2::getA1();}
getA2t33::A31896 A2* getA2() {return this;}
getA3t33::A31897 A3* getA3() {return this;}
1898 };
1899
test()1900 void test()
1901 {
1902 A1 a1;
1903 A2 a2;
1904 A3 a3;
1905 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1906 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1907 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1908
1909 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1910 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1911 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1912 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1913 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1914
1915 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1916 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1917 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1918 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1919 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1920 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1921 }
1922
1923 } // t33
1924
1925 /*
1926
1927 A1
1928 | \
1929 A2 \
1930 \ |
1931 A3
1932
1933 */
1934
1935 namespace t34
1936 {
1937
1938 struct A1
1939 {
1940 char _[43981];
~A1t34::A11941 virtual ~A1() {}
1942
getA1t34::A11943 A1* getA1() {return this;}
1944 };
1945
1946 struct A2
1947 : public virtual A1
1948 {
1949 char _[34981];
~A2t34::A21950 virtual ~A2() {}
1951
getA1t34::A21952 A1* getA1() {return this;}
getA2t34::A21953 A2* getA2() {return this;}
1954 };
1955
1956 struct A3
1957 : public virtual A1,
1958 public A2
1959 {
1960 char _[93481];
~A3t34::A31961 virtual ~A3() {}
1962
getA1t34::A31963 A1* getA1() {return A1::getA1();}
getA2t34::A31964 A2* getA2() {return this;}
getA3t34::A31965 A3* getA3() {return this;}
1966 };
1967
test()1968 void test()
1969 {
1970 A1 a1;
1971 A2 a2;
1972 A3 a3;
1973 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1974 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1975 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1976 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1977 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
1978 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
1979
1980 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1981 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1982 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1983 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
1984 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1985 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1986
1987 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1988 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1989 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1990 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
1991 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1992 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1993 }
1994
1995 } // t34
1996
1997 namespace t35
1998 {
1999
2000 struct A1
2001 {
2002 char _[43981];
~A1t35::A12003 virtual ~A1() {}
2004
getA1t35::A12005 A1* getA1() {return this;}
2006 };
2007
2008 struct A2
2009 : private virtual A1
2010 {
2011 char _[34981];
~A2t35::A22012 virtual ~A2() {}
2013
getA1t35::A22014 A1* getA1() {return this;}
getA2t35::A22015 A2* getA2() {return this;}
2016 };
2017
2018 struct A3
2019 : public virtual A1,
2020 public A2
2021 {
2022 char _[93481];
~A3t35::A32023 virtual ~A3() {}
2024
getA1t35::A32025 A1* getA1() {return A1::getA1();}
getA2t35::A32026 A2* getA2() {return this;}
getA3t35::A32027 A3* getA3() {return this;}
2028 };
2029
test()2030 void test()
2031 {
2032 A1 a1;
2033 A2 a2;
2034 A3 a3;
2035 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2036 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2037 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2038 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2039
2040 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2041 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2042 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2043 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2044 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2045 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2046
2047 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2048 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2049 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2050 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2051 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2052 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2053 }
2054
2055 } // t35
2056
2057 namespace t36
2058 {
2059
2060 struct A1
2061 {
2062 char _[43981];
~A1t36::A12063 virtual ~A1() {}
2064
getA1t36::A12065 A1* getA1() {return this;}
2066 };
2067
2068 struct A2
2069 : public virtual A1
2070 {
2071 char _[34981];
~A2t36::A22072 virtual ~A2() {}
2073
getA1t36::A22074 A1* getA1() {return this;}
getA2t36::A22075 A2* getA2() {return this;}
2076 };
2077
2078 struct A3
2079 : private virtual A1,
2080 public A2
2081 {
2082 char _[93481];
~A3t36::A32083 virtual ~A3() {}
2084
getA1t36::A32085 A1* getA1() {return A1::getA1();}
getA2t36::A32086 A2* getA2() {return this;}
getA3t36::A32087 A3* getA3() {return this;}
2088 };
2089
test()2090 void test()
2091 {
2092 A1 a1;
2093 A2 a2;
2094 A3 a3;
2095 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2096 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2097 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2098 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2099 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2100 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2101
2102 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2103 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2104 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2105 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2106 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2107 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2108
2109 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2110 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2111 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2112 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2113 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2114 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2115 }
2116
2117 } // t36
2118
2119 namespace t37
2120 {
2121
2122 struct A1
2123 {
2124 char _[43981];
~A1t37::A12125 virtual ~A1() {}
2126
getA1t37::A12127 A1* getA1() {return this;}
2128 };
2129
2130 struct A2
2131 : public virtual A1
2132 {
2133 char _[34981];
~A2t37::A22134 virtual ~A2() {}
2135
getA1t37::A22136 A1* getA1() {return this;}
getA2t37::A22137 A2* getA2() {return this;}
2138 };
2139
2140 struct A3
2141 : public virtual A1,
2142 private A2
2143 {
2144 char _[93481];
~A3t37::A32145 virtual ~A3() {}
2146
getA1t37::A32147 A1* getA1() {return A1::getA1();}
getA2t37::A32148 A2* getA2() {return this;}
getA3t37::A32149 A3* getA3() {return this;}
2150 };
2151
test()2152 void test()
2153 {
2154 A1 a1;
2155 A2 a2;
2156 A3 a3;
2157 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2158 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2159 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2160 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2161 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2162 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2163
2164 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2165 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2166 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2167 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2168 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2169
2170 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2171 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2172 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2173 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2174 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2175 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2176 }
2177
2178 } // t37
2179
2180 namespace t38
2181 {
2182
2183 struct A1
2184 {
2185 char _[43981];
~A1t38::A12186 virtual ~A1() {}
2187
getA1t38::A12188 A1* getA1() {return this;}
2189 };
2190
2191 struct A2
2192 : public virtual A1
2193 {
2194 char _[34981];
~A2t38::A22195 virtual ~A2() {}
2196
getA1t38::A22197 A1* getA1() {return this;}
getA2t38::A22198 A2* getA2() {return this;}
2199 };
2200
2201 struct A3
2202 : private virtual A1,
2203 private A2
2204 {
2205 char _[93481];
~A3t38::A32206 virtual ~A3() {}
2207
getA1t38::A32208 A1* getA1() {return A1::getA1();}
getA2t38::A32209 A2* getA2() {return this;}
getA3t38::A32210 A3* getA3() {return this;}
2211 };
2212
test()2213 void test()
2214 {
2215 A1 a1;
2216 A2 a2;
2217 A3 a3;
2218 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2219 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2220 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2221 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2222 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2223
2224 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2225 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2226 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2227 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2228 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2229
2230 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2231 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2232 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2233 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2234 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2235 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2236 }
2237
2238 } // t38
2239
2240 namespace t39
2241 {
2242
2243 struct A1
2244 {
2245 char _[43981];
~A1t39::A12246 virtual ~A1() {}
2247
getA1t39::A12248 A1* getA1() {return this;}
2249 };
2250
2251 struct A2
2252 : private virtual A1
2253 {
2254 char _[34981];
~A2t39::A22255 virtual ~A2() {}
2256
getA1t39::A22257 A1* getA1() {return this;}
getA2t39::A22258 A2* getA2() {return this;}
2259 };
2260
2261 struct A3
2262 : public virtual A1,
2263 private A2
2264 {
2265 char _[93481];
~A3t39::A32266 virtual ~A3() {}
2267
getA1t39::A32268 A1* getA1() {return A1::getA1();}
getA2t39::A32269 A2* getA2() {return this;}
getA3t39::A32270 A3* getA3() {return this;}
2271 };
2272
test()2273 void test()
2274 {
2275 A1 a1;
2276 A2 a2;
2277 A3 a3;
2278 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2279 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2280 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2281 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2282
2283 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2284 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2285 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2286 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2287 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2288
2289 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2290 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2291 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2292 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2293 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2294 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2295 }
2296
2297 } // t39
2298
2299 namespace t40
2300 {
2301
2302 struct A1
2303 {
2304 char _[43981];
~A1t40::A12305 virtual ~A1() {}
2306
getA1t40::A12307 A1* getA1() {return this;}
2308 };
2309
2310 struct A2
2311 : private virtual A1
2312 {
2313 char _[34981];
~A2t40::A22314 virtual ~A2() {}
2315
getA1t40::A22316 A1* getA1() {return this;}
getA2t40::A22317 A2* getA2() {return this;}
2318 };
2319
2320 struct A3
2321 : private virtual A1,
2322 public A2
2323 {
2324 char _[93481];
~A3t40::A32325 virtual ~A3() {}
2326
getA1t40::A32327 A1* getA1() {return A1::getA1();}
getA2t40::A32328 A2* getA2() {return this;}
getA3t40::A32329 A3* getA3() {return this;}
2330 };
2331
test()2332 void test()
2333 {
2334 A1 a1;
2335 A2 a2;
2336 A3 a3;
2337 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2338 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2339 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2340
2341 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2342 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2343 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2344 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2345 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2346 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2347
2348 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2349 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2350 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2351 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2352 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2353 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2354 }
2355
2356 } // t40
2357
2358 namespace t41
2359 {
2360
2361 struct A1
2362 {
2363 char _[43981];
~A1t41::A12364 virtual ~A1() {}
2365
getA1t41::A12366 A1* getA1() {return this;}
2367 };
2368
2369 struct A2
2370 : private virtual A1
2371 {
2372 char _[34981];
~A2t41::A22373 virtual ~A2() {}
2374
getA1t41::A22375 A1* getA1() {return this;}
getA2t41::A22376 A2* getA2() {return this;}
2377 };
2378
2379 struct A3
2380 : private virtual A1,
2381 private A2
2382 {
2383 char _[93481];
~A3t41::A32384 virtual ~A3() {}
2385
getA1t41::A32386 A1* getA1() {return A1::getA1();}
getA2t41::A32387 A2* getA2() {return this;}
getA3t41::A32388 A3* getA3() {return this;}
2389 };
2390
test()2391 void test()
2392 {
2393 A1 a1;
2394 A2 a2;
2395 A3 a3;
2396 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2397 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2398 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2399
2400 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2401 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2402 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2403 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2404 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2405
2406 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2407 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2408 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2409 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2410 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2411 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2412 }
2413
2414 } // t41
2415
main()2416 int main()
2417 {
2418 timer t;
2419 t1::test();
2420 t2::test();
2421 t3::test();
2422 t4::test();
2423 t5::test();
2424 t6::test();
2425 t7::test();
2426 t8::test();
2427 t9::test();
2428 t10::test();
2429 t11::test();
2430 t12::test();
2431 t13::test();
2432 t14::test();
2433 t15::test();
2434 t16::test();
2435 t17::test();
2436 t18::test();
2437 t19::test();
2438 t20::test();
2439 t21::test();
2440 t22::test();
2441 t23::test();
2442 t24::test();
2443 t25::test();
2444 t26::test();
2445 t27::test();
2446 t28::test();
2447 t29::test();
2448 t30::test();
2449 t31::test();
2450 t32::test();
2451 t33::test();
2452 t34::test();
2453 t35::test();
2454 t36::test();
2455 t37::test();
2456 t38::test();
2457 t39::test();
2458 t40::test();
2459 t41::test();
2460 }
2461