1 //===------------------------- dynamic_cast3.cpp --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include <cassert>
10 #include "support/timer.h"
11
12 // This test explicitly tests dynamic cast with types that have inaccessible
13 // bases.
14 #if defined(__clang__)
15 # pragma clang diagnostic ignored "-Winaccessible-base"
16 #elif defined(__GNUC__)
17 # pragma GCC diagnostic ignored "-Winaccessible-base"
18 #endif
19
20 /*
21
22 A1 A2 A3
23
24 */
25
26 namespace t1
27 {
28
29 struct A1
30 {
31 char _[43981];
~A1t1::A132 virtual ~A1() {}
33
getA1t1::A134 A1* getA1() {return this;}
35 };
36
37 struct A2
38 {
39 char _[34981];
~A2t1::A240 virtual ~A2() {}
41
getA2t1::A242 A2* getA2() {return this;}
43 };
44
45 struct A3
46 {
47 char _[93481];
~A3t1::A348 virtual ~A3() {}
49
getA3t1::A350 A3* getA3() {return this;}
51 };
52
test()53 void test()
54 {
55 A1 a1;
56 A2 a2;
57 A3 a3;
58 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
59 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
60 assert(dynamic_cast<A1*>(a3.getA3()) == 0);
61 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
62 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
63 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
64 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
65 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
66 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
67 }
68
69 } // t1
70
71 /*
72
73 A1 A2
74 |
75 A3
76
77 */
78
79 namespace t2
80 {
81
82 struct A1
83 {
84 char _[43981];
~A1t2::A185 virtual ~A1() {}
86
getA1t2::A187 A1* getA1() {return this;}
88 };
89
90 struct A2
91 {
92 char _[34981];
~A2t2::A293 virtual ~A2() {}
94
getA2t2::A295 A2* getA2() {return this;}
96 };
97
98 struct A3
99 : public A1
100 {
101 char _[93481];
~A3t2::A3102 virtual ~A3() {}
103
getA3t2::A3104 A3* getA3() {return this;}
105 };
106
test()107 void test()
108 {
109 A1 a1;
110 A2 a2;
111 A3 a3;
112 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
113 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
114 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
115 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
116
117 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
118 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
119 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
120 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
121
122 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
123 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
124 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
125 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
126 }
127
128 } // t2
129
130 namespace t3
131 {
132
133 struct A1
134 {
135 char _[43981];
~A1t3::A1136 virtual ~A1() {}
137
getA1t3::A1138 A1* getA1() {return this;}
139 };
140
141 struct A2
142 {
143 char _[34981];
~A2t3::A2144 virtual ~A2() {}
145
getA2t3::A2146 A2* getA2() {return this;}
147 };
148
149 struct A3
150 : public virtual A1
151 {
152 char _[93481];
~A3t3::A3153 virtual ~A3() {}
154
getA3t3::A3155 A3* getA3() {return this;}
156 };
157
test()158 void test()
159 {
160 A1 a1;
161 A2 a2;
162 A3 a3;
163 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
164 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
165 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
166 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
167
168 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
169 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
170 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
171 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
172
173 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
174 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
175 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
176 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
177 }
178
179 } // t3
180
181 namespace t4
182 {
183
184 struct A1
185 {
186 char _[43981];
~A1t4::A1187 virtual ~A1() {}
188
getA1t4::A1189 A1* getA1() {return this;}
190 };
191
192 struct A2
193 {
194 char _[34981];
~A2t4::A2195 virtual ~A2() {}
196
getA2t4::A2197 A2* getA2() {return this;}
198 };
199
200 struct A3
201 : private A1
202 {
203 char _[93481];
~A3t4::A3204 virtual ~A3() {}
205
getA1t4::A3206 A1* getA1() {return this;}
getA3t4::A3207 A3* getA3() {return this;}
208 };
209
test()210 void test()
211 {
212 A1 a1;
213 A2 a2;
214 A3 a3;
215 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
216 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
217 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
218
219 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
220 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
221 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
222 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
223
224 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
225 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
226 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
227 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
228 }
229
230 } // t4
231
232 namespace t5
233 {
234
235 struct A1
236 {
237 char _[43981];
~A1t5::A1238 virtual ~A1() {}
239
getA1t5::A1240 A1* getA1() {return this;}
241 };
242
243 struct A2
244 {
245 char _[34981];
~A2t5::A2246 virtual ~A2() {}
247
getA2t5::A2248 A2* getA2() {return this;}
249 };
250
251 struct A3
252 : private virtual A1
253 {
254 char _[93481];
~A3t5::A3255 virtual ~A3() {}
256
getA1t5::A3257 A1* getA1() {return this;}
getA3t5::A3258 A3* getA3() {return this;}
259 };
260
test()261 void test()
262 {
263 A1 a1;
264 A2 a2;
265 A3 a3;
266 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
267 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
268 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
269
270 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
271 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
272 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
273 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
274
275 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
276 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
277 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
278 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
279 }
280
281 } // t5
282
283 /*
284
285 A1 A2
286 \ /
287 A3
288
289 */
290
291 namespace t6
292 {
293
294 struct A1
295 {
296 char _[43981];
~A1t6::A1297 virtual ~A1() {}
298
getA1t6::A1299 A1* getA1() {return this;}
300 };
301
302 struct A2
303 {
304 char _[34981];
~A2t6::A2305 virtual ~A2() {}
306
getA2t6::A2307 A2* getA2() {return this;}
308 };
309
310 struct A3
311 : public A1,
312 public A2
313 {
314 char _[93481];
~A3t6::A3315 virtual ~A3() {}
316
getA1t6::A3317 A1* getA1() {return this;}
getA2t6::A3318 A2* getA2() {return this;}
getA3t6::A3319 A3* getA3() {return this;}
320 };
321
test()322 void test()
323 {
324 A1 a1;
325 A2 a2;
326 A3 a3;
327 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
328 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
329 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
330 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
331 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
332
333 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
334 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
335 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
336 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
337 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
338
339 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
340 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
341 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
342 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
343 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
344 }
345
346 } // t6
347
348 namespace t7
349 {
350
351 struct A1
352 {
353 char _[43981];
~A1t7::A1354 virtual ~A1() {}
355
getA1t7::A1356 A1* getA1() {return this;}
357 };
358
359 struct A2
360 {
361 char _[34981];
~A2t7::A2362 virtual ~A2() {}
363
getA2t7::A2364 A2* getA2() {return this;}
365 };
366
367 struct A3
368 : public virtual A1,
369 public A2
370 {
371 char _[93481];
~A3t7::A3372 virtual ~A3() {}
373
getA1t7::A3374 A1* getA1() {return this;}
getA2t7::A3375 A2* getA2() {return this;}
getA3t7::A3376 A3* getA3() {return this;}
377 };
378
test()379 void test()
380 {
381 A1 a1;
382 A2 a2;
383 A3 a3;
384 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
385 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
386 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
387 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
388 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
389
390 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
391 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
392 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
393 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
394 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
395
396 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
397 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
398 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
399 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
400 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
401 }
402
403 } // t7
404
405 namespace t8
406 {
407
408 struct A1
409 {
410 char _[43981];
~A1t8::A1411 virtual ~A1() {}
412
getA1t8::A1413 A1* getA1() {return this;}
414 };
415
416 struct A2
417 {
418 char _[34981];
~A2t8::A2419 virtual ~A2() {}
420
getA2t8::A2421 A2* getA2() {return this;}
422 };
423
424 struct A3
425 : private A1,
426 public A2
427 {
428 char _[93481];
~A3t8::A3429 virtual ~A3() {}
430
getA1t8::A3431 A1* getA1() {return this;}
getA2t8::A3432 A2* getA2() {return this;}
getA3t8::A3433 A3* getA3() {return this;}
434 };
435
test()436 void test()
437 {
438 A1 a1;
439 A2 a2;
440 A3 a3;
441 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
442 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
443 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
444 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
445
446 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
447 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
448 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
449 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
450 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
451
452 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
453 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
454 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
455 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
456 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
457 }
458
459 } // t8
460
461 namespace t9
462 {
463
464 struct A1
465 {
466 char _[43981];
~A1t9::A1467 virtual ~A1() {}
468
getA1t9::A1469 A1* getA1() {return this;}
470 };
471
472 struct A2
473 {
474 char _[34981];
~A2t9::A2475 virtual ~A2() {}
476
getA2t9::A2477 A2* getA2() {return this;}
478 };
479
480 struct A3
481 : private virtual A1,
482 public A2
483 {
484 char _[93481];
~A3t9::A3485 virtual ~A3() {}
486
getA1t9::A3487 A1* getA1() {return this;}
getA2t9::A3488 A2* getA2() {return this;}
getA3t9::A3489 A3* getA3() {return this;}
490 };
491
test()492 void test()
493 {
494 A1 a1;
495 A2 a2;
496 A3 a3;
497 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
498 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
499 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
500 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
501
502 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
503 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
504 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
505 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
506 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
507
508 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
509 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
510 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
511 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
512 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
513 }
514
515 } // t9
516
517 namespace t10
518 {
519
520 struct A1
521 {
522 char _[43981];
~A1t10::A1523 virtual ~A1() {}
524
getA1t10::A1525 A1* getA1() {return this;}
526 };
527
528 struct A2
529 {
530 char _[34981];
~A2t10::A2531 virtual ~A2() {}
532
getA2t10::A2533 A2* getA2() {return this;}
534 };
535
536 struct A3
537 : public virtual A1,
538 public virtual A2
539 {
540 char _[93481];
~A3t10::A3541 virtual ~A3() {}
542
getA1t10::A3543 A1* getA1() {return this;}
getA2t10::A3544 A2* getA2() {return this;}
getA3t10::A3545 A3* getA3() {return this;}
546 };
547
test()548 void test()
549 {
550 A1 a1;
551 A2 a2;
552 A3 a3;
553 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
554 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
555 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
556 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
557 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
558
559 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
560 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
561 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
562 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
563 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
564
565 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
566 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
567 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
568 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
569 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
570 }
571
572 } // t10
573
574 namespace t11
575 {
576
577 struct A1
578 {
579 char _[43981];
~A1t11::A1580 virtual ~A1() {}
581
getA1t11::A1582 A1* getA1() {return this;}
583 };
584
585 struct A2
586 {
587 char _[34981];
~A2t11::A2588 virtual ~A2() {}
589
getA2t11::A2590 A2* getA2() {return this;}
591 };
592
593 struct A3
594 : private A1,
595 public virtual A2
596 {
597 char _[93481];
~A3t11::A3598 virtual ~A3() {}
599
getA1t11::A3600 A1* getA1() {return this;}
getA2t11::A3601 A2* getA2() {return this;}
getA3t11::A3602 A3* getA3() {return this;}
603 };
604
test()605 void test()
606 {
607 A1 a1;
608 A2 a2;
609 A3 a3;
610 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
611 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
612 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
613 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
614
615 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
616 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
617 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
618 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
619 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
620
621 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
622 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
623 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
624 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
625 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
626 }
627
628 } // t11
629
630 namespace t12
631 {
632
633 struct A1
634 {
635 char _[43981];
~A1t12::A1636 virtual ~A1() {}
637
getA1t12::A1638 A1* getA1() {return this;}
639 };
640
641 struct A2
642 {
643 char _[34981];
~A2t12::A2644 virtual ~A2() {}
645
getA2t12::A2646 A2* getA2() {return this;}
647 };
648
649 struct A3
650 : private virtual A1,
651 public virtual A2
652 {
653 char _[93481];
~A3t12::A3654 virtual ~A3() {}
655
getA1t12::A3656 A1* getA1() {return this;}
getA2t12::A3657 A2* getA2() {return this;}
getA3t12::A3658 A3* getA3() {return this;}
659 };
660
test()661 void test()
662 {
663 A1 a1;
664 A2 a2;
665 A3 a3;
666 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
667 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
668 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
669 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
670
671 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
672 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
673 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
674 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
675 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
676
677 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
678 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
679 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
680 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
681 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
682 }
683
684 } // t12
685
686 namespace t13
687 {
688
689 struct A1
690 {
691 char _[43981];
~A1t13::A1692 virtual ~A1() {}
693
getA1t13::A1694 A1* getA1() {return this;}
695 };
696
697 struct A2
698 {
699 char _[34981];
~A2t13::A2700 virtual ~A2() {}
701
getA2t13::A2702 A2* getA2() {return this;}
703 };
704
705 struct A3
706 : private A1,
707 private A2
708 {
709 char _[93481];
~A3t13::A3710 virtual ~A3() {}
711
getA1t13::A3712 A1* getA1() {return this;}
getA2t13::A3713 A2* getA2() {return this;}
getA3t13::A3714 A3* getA3() {return this;}
715 };
716
test()717 void test()
718 {
719 A1 a1;
720 A2 a2;
721 A3 a3;
722 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
723 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
724 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
725 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
726
727 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
728 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
729 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
730 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
731
732 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
733 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
734 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
735 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
736 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
737 }
738
739 } // t13
740
741 namespace t14
742 {
743
744 struct A1
745 {
746 char _[43981];
~A1t14::A1747 virtual ~A1() {}
748
getA1t14::A1749 A1* getA1() {return this;}
750 };
751
752 struct A2
753 {
754 char _[34981];
~A2t14::A2755 virtual ~A2() {}
756
getA2t14::A2757 A2* getA2() {return this;}
758 };
759
760 struct A3
761 : private virtual A1,
762 private A2
763 {
764 char _[93481];
~A3t14::A3765 virtual ~A3() {}
766
getA1t14::A3767 A1* getA1() {return this;}
getA2t14::A3768 A2* getA2() {return this;}
getA3t14::A3769 A3* getA3() {return this;}
770 };
771
test()772 void test()
773 {
774 A1 a1;
775 A2 a2;
776 A3 a3;
777 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
778 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
779 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
780 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
781
782 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
783 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
784 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
785 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
786
787 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
788 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
789 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
790 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
791 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
792 }
793
794 } // t14
795
796 namespace t15
797 {
798
799 struct A1
800 {
801 char _[43981];
~A1t15::A1802 virtual ~A1() {}
803
getA1t15::A1804 A1* getA1() {return this;}
805 };
806
807 struct A2
808 {
809 char _[34981];
~A2t15::A2810 virtual ~A2() {}
811
getA2t15::A2812 A2* getA2() {return this;}
813 };
814
815 struct A3
816 : private virtual A1,
817 private virtual A2
818 {
819 char _[93481];
~A3t15::A3820 virtual ~A3() {}
821
getA1t15::A3822 A1* getA1() {return this;}
getA2t15::A3823 A2* getA2() {return this;}
getA3t15::A3824 A3* getA3() {return this;}
825 };
826
test()827 void test()
828 {
829 A1 a1;
830 A2 a2;
831 A3 a3;
832 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
833 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
834 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
835 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
836
837 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
838 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
839 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
840 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
841
842 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
843 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
844 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
845 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
846 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
847 }
848
849 } // t15
850
851 /*
852
853 A1
854 |
855 A2
856 |
857 A3
858
859 */
860
861 namespace t16
862 {
863
864 struct A1
865 {
866 char _[43981];
~A1t16::A1867 virtual ~A1() {}
868
getA1t16::A1869 A1* getA1() {return this;}
870 };
871
872 struct A2
873 : public A1
874 {
875 char _[34981];
~A2t16::A2876 virtual ~A2() {}
877
getA1t16::A2878 A1* getA1() {return this;}
getA2t16::A2879 A2* getA2() {return this;}
880 };
881
882 struct A3
883 : public A2
884 {
885 char _[93481];
~A3t16::A3886 virtual ~A3() {}
887
getA1t16::A3888 A1* getA1() {return this;}
getA2t16::A3889 A2* getA2() {return this;}
getA3t16::A3890 A3* getA3() {return this;}
891 };
892
test()893 void test()
894 {
895 A1 a1;
896 A2 a2;
897 A3 a3;
898 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
899 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
900 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
901 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
902 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
903 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
904
905 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
906 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
907 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
908 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
909 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
910 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
911
912 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
913 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
914 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
915 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
916 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
917 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
918 }
919
920 } // t16
921
922 namespace t17
923 {
924
925 struct A1
926 {
927 char _[43981];
~A1t17::A1928 virtual ~A1() {}
929
getA1t17::A1930 A1* getA1() {return this;}
931 };
932
933 struct A2
934 : public virtual A1
935 {
936 char _[34981];
~A2t17::A2937 virtual ~A2() {}
938
getA1t17::A2939 A1* getA1() {return this;}
getA2t17::A2940 A2* getA2() {return this;}
941 };
942
943 struct A3
944 : public A2
945 {
946 char _[93481];
~A3t17::A3947 virtual ~A3() {}
948
getA1t17::A3949 A1* getA1() {return this;}
getA2t17::A3950 A2* getA2() {return this;}
getA3t17::A3951 A3* getA3() {return this;}
952 };
953
test()954 void test()
955 {
956 A1 a1;
957 A2 a2;
958 A3 a3;
959 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
960 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
961 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
962 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
963 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
964 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
965
966 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
967 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
968 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
969 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
970 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
971 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
972
973 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
974 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
975 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
976 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
977 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
978 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
979 }
980
981 } // t17
982
983 namespace t18
984 {
985
986 struct A1
987 {
988 char _[43981];
~A1t18::A1989 virtual ~A1() {}
990
getA1t18::A1991 A1* getA1() {return this;}
992 };
993
994 struct A2
995 : private A1
996 {
997 char _[34981];
~A2t18::A2998 virtual ~A2() {}
999
getA1t18::A21000 A1* getA1() {return this;}
getA2t18::A21001 A2* getA2() {return this;}
1002 };
1003
1004 struct A3
1005 : public A2
1006 {
1007 char _[93481];
~A3t18::A31008 virtual ~A3() {}
1009
getA2t18::A31010 A2* getA2() {return this;}
getA3t18::A31011 A3* getA3() {return this;}
1012 };
1013
test()1014 void test()
1015 {
1016 A1 a1;
1017 A2 a2;
1018 A3 a3;
1019 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1020 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1021 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1022
1023 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1024 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1025 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1026 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1027 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1028 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1029
1030 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1031 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1032 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1033 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1034 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1035 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1036 }
1037
1038 } // t18
1039
1040 namespace t19
1041 {
1042
1043 struct A1
1044 {
1045 char _[43981];
~A1t19::A11046 virtual ~A1() {}
1047
getA1t19::A11048 A1* getA1() {return this;}
1049 };
1050
1051 struct A2
1052 : protected virtual A1
1053 {
1054 char _[34981];
~A2t19::A21055 virtual ~A2() {}
1056
getA1t19::A21057 A1* getA1() {return this;}
getA2t19::A21058 A2* getA2() {return this;}
1059 };
1060
1061 struct A3
1062 : public A2
1063 {
1064 char _[93481];
~A3t19::A31065 virtual ~A3() {}
1066
getA2t19::A31067 A2* getA2() {return this;}
getA3t19::A31068 A3* getA3() {return this;}
1069 };
1070
test()1071 void test()
1072 {
1073 A1 a1;
1074 A2 a2;
1075 A3 a3;
1076 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1077 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1078 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1079
1080 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1081 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1082 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1083 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1084 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1085 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1086
1087 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1088 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1089 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1090 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1091 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1092 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1093 }
1094
1095 } // t19
1096
1097 namespace t20
1098 {
1099
1100 struct A1
1101 {
1102 char _[43981];
~A1t20::A11103 virtual ~A1() {}
1104
getA1t20::A11105 A1* getA1() {return this;}
1106 };
1107
1108 struct A2
1109 : public virtual A1
1110 {
1111 char _[34981];
~A2t20::A21112 virtual ~A2() {}
1113
getA1t20::A21114 A1* getA1() {return this;}
getA2t20::A21115 A2* getA2() {return this;}
1116 };
1117
1118 struct A3
1119 : public virtual A2
1120 {
1121 char _[93481];
~A3t20::A31122 virtual ~A3() {}
1123
getA1t20::A31124 A1* getA1() {return this;}
getA2t20::A31125 A2* getA2() {return this;}
getA3t20::A31126 A3* getA3() {return this;}
1127 };
1128
test()1129 void test()
1130 {
1131 A1 a1;
1132 A2 a2;
1133 A3 a3;
1134 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1135 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1136 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1137 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1138 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
1139 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
1140
1141 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1142 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1143 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1144 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
1145 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1146 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1147
1148 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1149 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1150 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1151 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
1152 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1153 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1154 }
1155
1156 } // t20
1157
1158 namespace t21
1159 {
1160
1161 struct A1
1162 {
1163 char _[43981];
~A1t21::A11164 virtual ~A1() {}
1165
getA1t21::A11166 A1* getA1() {return this;}
1167 };
1168
1169 struct A2
1170 : private A1
1171 {
1172 char _[34981];
~A2t21::A21173 virtual ~A2() {}
1174
getA1t21::A21175 A1* getA1() {return this;}
getA2t21::A21176 A2* getA2() {return this;}
1177 };
1178
1179 struct A3
1180 : public virtual A2
1181 {
1182 char _[93481];
~A3t21::A31183 virtual ~A3() {}
1184
getA2t21::A31185 A2* getA2() {return this;}
getA3t21::A31186 A3* getA3() {return this;}
1187 };
1188
test()1189 void test()
1190 {
1191 A1 a1;
1192 A2 a2;
1193 A3 a3;
1194 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1195 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1196 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1197
1198 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1199 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1200 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1201 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1202 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1203 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1204
1205 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1206 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1207 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1208 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1209 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1210 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1211 }
1212
1213 } // t21
1214
1215 namespace t22
1216 {
1217
1218 struct A1
1219 {
1220 char _[43981];
~A1t22::A11221 virtual ~A1() {}
1222
getA1t22::A11223 A1* getA1() {return this;}
1224 };
1225
1226 struct A2
1227 : protected virtual A1
1228 {
1229 char _[34981];
~A2t22::A21230 virtual ~A2() {}
1231
getA1t22::A21232 A1* getA1() {return this;}
getA2t22::A21233 A2* getA2() {return this;}
1234 };
1235
1236 struct A3
1237 : public virtual A2
1238 {
1239 char _[93481];
~A3t22::A31240 virtual ~A3() {}
1241
getA2t22::A31242 A2* getA2() {return this;}
getA3t22::A31243 A3* getA3() {return this;}
1244 };
1245
test()1246 void test()
1247 {
1248 A1 a1;
1249 A2 a2;
1250 A3 a3;
1251 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1252 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1253 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1254
1255 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1256 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1257 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1258 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1259 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1260 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1261
1262 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1263 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1264 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1265 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1266 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1267 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1268 }
1269
1270 } // t22
1271
1272 namespace t23
1273 {
1274
1275 struct A1
1276 {
1277 char _[43981];
~A1t23::A11278 virtual ~A1() {}
1279
getA1t23::A11280 A1* getA1() {return this;}
1281 };
1282
1283 struct A2
1284 : private A1
1285 {
1286 char _[34981];
~A2t23::A21287 virtual ~A2() {}
1288
getA1t23::A21289 A1* getA1() {return this;}
getA2t23::A21290 A2* getA2() {return this;}
1291 };
1292
1293 struct A3
1294 : private A2
1295 {
1296 char _[93481];
~A3t23::A31297 virtual ~A3() {}
1298
getA1t23::A31299 t23::A1* getA1() {return A2::getA1();}
getA2t23::A31300 A2* getA2() {return this;}
getA3t23::A31301 A3* getA3() {return this;}
1302 };
1303
test()1304 void test()
1305 {
1306 A1 a1;
1307 A2 a2;
1308 A3 a3;
1309 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1310 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1311 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1312
1313 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1314 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1315 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1316 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1317 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1318
1319 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1320 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1321 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1322 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1323 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1324 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1325 }
1326
1327 } // t23
1328
1329 namespace t24
1330 {
1331
1332 struct A1
1333 {
1334 char _[43981];
~A1t24::A11335 virtual ~A1() {}
1336
getA1t24::A11337 A1* getA1() {return this;}
1338 };
1339
1340 struct A2
1341 : protected virtual A1
1342 {
1343 char _[34981];
~A2t24::A21344 virtual ~A2() {}
1345
getA1t24::A21346 A1* getA1() {return this;}
getA2t24::A21347 A2* getA2() {return this;}
1348 };
1349
1350 struct A3
1351 : private A2
1352 {
1353 char _[93481];
~A3t24::A31354 virtual ~A3() {}
1355
getA1t24::A31356 t24::A1* getA1() {return A2::getA1();}
getA2t24::A31357 A2* getA2() {return this;}
getA3t24::A31358 A3* getA3() {return this;}
1359 };
1360
test()1361 void test()
1362 {
1363 A1 a1;
1364 A2 a2;
1365 A3 a3;
1366 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1367 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1368 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1369
1370 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1371 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1372 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1373 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1374 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1375
1376 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1377 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1378 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1379 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1380 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1381 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1382 }
1383
1384 } // t24
1385
1386 namespace t25
1387 {
1388
1389 struct A1
1390 {
1391 char _[43981];
~A1t25::A11392 virtual ~A1() {}
1393
getA1t25::A11394 A1* getA1() {return this;}
1395 };
1396
1397 struct A2
1398 : protected virtual A1
1399 {
1400 char _[34981];
~A2t25::A21401 virtual ~A2() {}
1402
getA1t25::A21403 A1* getA1() {return this;}
getA2t25::A21404 A2* getA2() {return this;}
1405 };
1406
1407 struct A3
1408 : private virtual A2
1409 {
1410 char _[93481];
~A3t25::A31411 virtual ~A3() {}
1412
getA1t25::A31413 t25::A1* getA1() {return A2::getA1();}
getA2t25::A31414 A2* getA2() {return this;}
getA3t25::A31415 A3* getA3() {return this;}
1416 };
1417
test()1418 void test()
1419 {
1420 A1 a1;
1421 A2 a2;
1422 A3 a3;
1423 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1424 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1425 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1426
1427 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1428 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1429 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1430 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1431 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1432
1433 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1434 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1435 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1436 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1437 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1438 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1439 }
1440
1441 } // t25
1442
1443 /*
1444
1445 A1 A1
1446 | |
1447 A2 |
1448 \ |
1449 A3
1450
1451 */
1452
1453 namespace t26
1454 {
1455
1456 struct A1
1457 {
1458 char _[43981];
~A1t26::A11459 virtual ~A1() {}
1460
getA1t26::A11461 A1* getA1() {return this;}
1462 };
1463
1464 struct A2
1465 : public A1
1466 {
1467 char _[34981];
~A2t26::A21468 virtual ~A2() {}
1469
getA1t26::A21470 A1* getA1() {return this;}
getA2t26::A21471 A2* getA2() {return this;}
1472 };
1473
1474 struct A3
1475 : public A1,
1476 public A2
1477 {
1478 char _[93481];
~A3t26::A31479 virtual ~A3() {}
1480
getA12t26::A31481 A1* getA12() {return A2::getA1();}
getA2t26::A31482 A2* getA2() {return this;}
getA3t26::A31483 A3* getA3() {return this;}
1484 };
1485
test()1486 void test()
1487 {
1488 A1 a1;
1489 A2 a2;
1490 A3 a3;
1491 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1492 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1493 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1494 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1495 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1496
1497 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1498 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1499 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1500 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1501 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1502 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1503
1504 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1505 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1506 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1507 assert(dynamic_cast<A3*>(a3.getA12()) == a3.getA3());
1508 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1509 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1510 }
1511
1512 } // t26
1513
1514 namespace t27
1515 {
1516
1517 struct A1
1518 {
1519 char _[43981];
~A1t27::A11520 virtual ~A1() {}
1521
getA1t27::A11522 A1* getA1() {return this;}
1523 };
1524
1525 struct A2
1526 : private A1
1527 {
1528 char _[34981];
~A2t27::A21529 virtual ~A2() {}
1530
getA1t27::A21531 A1* getA1() {return this;}
getA2t27::A21532 A2* getA2() {return this;}
1533 };
1534
1535 struct A3
1536 : public A1,
1537 public A2
1538 {
1539 char _[93481];
~A3t27::A31540 virtual ~A3() {}
1541
getA12t27::A31542 A1* getA12() {return A2::getA1();}
getA2t27::A31543 A2* getA2() {return this;}
getA3t27::A31544 A3* getA3() {return this;}
1545 };
1546
test()1547 void test()
1548 {
1549 A1 a1;
1550 A2 a2;
1551 A3 a3;
1552 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1553 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1554 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1555
1556 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1557 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1558 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1559 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1560 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1561 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1562
1563 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1564 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1565 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1566 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1567 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1568 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1569 }
1570
1571 } // t27
1572
1573 namespace t28
1574 {
1575
1576 struct A1
1577 {
1578 char _[43981];
~A1t28::A11579 virtual ~A1() {}
1580
getA1t28::A11581 A1* getA1() {return this;}
1582 };
1583
1584 struct A2
1585 : public A1
1586 {
1587 char _[34981];
~A2t28::A21588 virtual ~A2() {}
1589
getA1t28::A21590 A1* getA1() {return this;}
getA2t28::A21591 A2* getA2() {return this;}
1592 };
1593
1594 struct A3
1595 : private A1,
1596 public A2
1597 {
1598 char _[93481];
~A3t28::A31599 virtual ~A3() {}
1600
getA12t28::A31601 A1* getA12() {return A2::getA1();}
getA2t28::A31602 A2* getA2() {return this;}
getA3t28::A31603 A3* getA3() {return this;}
1604 };
1605
test()1606 void test()
1607 {
1608 A1 a1;
1609 A2 a2;
1610 A3 a3;
1611 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1612 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1613 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1614 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1615
1616 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1617 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1618 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1619 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1620 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1621 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1622
1623 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1624 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1625 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1626 assert(dynamic_cast<A3*>(a3.getA12()) == a3.getA3());
1627 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1628 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1629 }
1630
1631 } // t28
1632
1633 namespace t29
1634 {
1635
1636 struct A1
1637 {
1638 char _[43981];
~A1t29::A11639 virtual ~A1() {}
1640
getA1t29::A11641 A1* getA1() {return this;}
1642 };
1643
1644 struct A2
1645 : public A1
1646 {
1647 char _[34981];
~A2t29::A21648 virtual ~A2() {}
1649
getA1t29::A21650 A1* getA1() {return this;}
getA2t29::A21651 A2* getA2() {return this;}
1652 };
1653
1654 struct A3
1655 : public A1,
1656 private A2
1657 {
1658 char _[93481];
~A3t29::A31659 virtual ~A3() {}
1660
getA12t29::A31661 A1* getA12() {return A2::getA1();}
getA2t29::A31662 A2* getA2() {return this;}
getA3t29::A31663 A3* getA3() {return this;}
1664 };
1665
test()1666 void test()
1667 {
1668 A1 a1;
1669 A2 a2;
1670 A3 a3;
1671 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1672 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1673 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1674 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1675
1676 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1677 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1678 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1679 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1680 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1681
1682 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1683 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1684 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1685 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1686 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1687 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1688 }
1689
1690 } // t29
1691
1692 namespace t30
1693 {
1694
1695 struct A1
1696 {
1697 char _[43981];
~A1t30::A11698 virtual ~A1() {}
1699
getA1t30::A11700 A1* getA1() {return this;}
1701 };
1702
1703 struct A2
1704 : public A1
1705 {
1706 char _[34981];
~A2t30::A21707 virtual ~A2() {}
1708
getA1t30::A21709 A1* getA1() {return this;}
getA2t30::A21710 A2* getA2() {return this;}
1711 };
1712
1713 struct A3
1714 : private A1,
1715 private A2
1716 {
1717 char _[93481];
~A3t30::A31718 virtual ~A3() {}
1719
getA12t30::A31720 A1* getA12() {return A2::getA1();}
getA2t30::A31721 A2* getA2() {return this;}
getA3t30::A31722 A3* getA3() {return this;}
1723 };
1724
test()1725 void test()
1726 {
1727 A1 a1;
1728 A2 a2;
1729 A3 a3;
1730 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1731 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1732 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1733 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1734 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1735
1736 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1737 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1738 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1739 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1740 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1741
1742 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1743 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1744 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1745 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1746 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1747 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1748 }
1749
1750 } // t30
1751
1752 namespace t31
1753 {
1754
1755 struct A1
1756 {
1757 char _[43981];
~A1t31::A11758 virtual ~A1() {}
1759
getA1t31::A11760 A1* getA1() {return this;}
1761 };
1762
1763 struct A2
1764 : private A1
1765 {
1766 char _[34981];
~A2t31::A21767 virtual ~A2() {}
1768
getA1t31::A21769 A1* getA1() {return this;}
getA2t31::A21770 A2* getA2() {return this;}
1771 };
1772
1773 struct A3
1774 : public A1,
1775 private A2
1776 {
1777 char _[93481];
~A3t31::A31778 virtual ~A3() {}
1779
getA12t31::A31780 A1* getA12() {return A2::getA1();}
getA2t31::A31781 A2* getA2() {return this;}
getA3t31::A31782 A3* getA3() {return this;}
1783 };
1784
test()1785 void test()
1786 {
1787 A1 a1;
1788 A2 a2;
1789 A3 a3;
1790 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1791 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1792 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1793
1794 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1795 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1796 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1797 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1798 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1799
1800 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1801 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1802 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1803 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1804 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1805 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1806 }
1807
1808 } // t31
1809
1810 namespace t32
1811 {
1812
1813 struct A1
1814 {
1815 char _[43981];
~A1t32::A11816 virtual ~A1() {}
1817
getA1t32::A11818 A1* getA1() {return this;}
1819 };
1820
1821 struct A2
1822 : private A1
1823 {
1824 char _[34981];
~A2t32::A21825 virtual ~A2() {}
1826
getA1t32::A21827 A1* getA1() {return this;}
getA2t32::A21828 A2* getA2() {return this;}
1829 };
1830
1831 struct A3
1832 : private A1,
1833 public A2
1834 {
1835 char _[93481];
~A3t32::A31836 virtual ~A3() {}
1837
getA12t32::A31838 A1* getA12() {return A2::getA1();}
getA2t32::A31839 A2* getA2() {return this;}
getA3t32::A31840 A3* getA3() {return this;}
1841 };
1842
test()1843 void test()
1844 {
1845 A1 a1;
1846 A2 a2;
1847 A3 a3;
1848 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1849 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1850 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1851
1852 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1853 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1854 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1855 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1856 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1857
1858 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1859 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1860 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1861 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1862 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1863 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1864 }
1865
1866 } // t32
1867
1868 namespace t33
1869 {
1870
1871 struct A1
1872 {
1873 char _[43981];
~A1t33::A11874 virtual ~A1() {}
1875
getA1t33::A11876 A1* getA1() {return this;}
1877 };
1878
1879 struct A2
1880 : private A1
1881 {
1882 char _[34981];
~A2t33::A21883 virtual ~A2() {}
1884
getA1t33::A21885 A1* getA1() {return this;}
getA2t33::A21886 A2* getA2() {return this;}
1887 };
1888
1889 struct A3
1890 : private A1,
1891 private A2
1892 {
1893 char _[93481];
~A3t33::A31894 virtual ~A3() {}
1895
getA12t33::A31896 A1* getA12() {return A2::getA1();}
getA2t33::A31897 A2* getA2() {return this;}
getA3t33::A31898 A3* getA3() {return this;}
1899 };
1900
test()1901 void test()
1902 {
1903 A1 a1;
1904 A2 a2;
1905 A3 a3;
1906 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1907 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1908 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1909
1910 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1911 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1912 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1913 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1914 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1915
1916 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1917 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1918 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1919 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1920 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1921 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1922 }
1923
1924 } // t33
1925
1926 /*
1927
1928 A1
1929 | \
1930 A2 \
1931 \ |
1932 A3
1933
1934 */
1935
1936 namespace t34
1937 {
1938
1939 struct A1
1940 {
1941 char _[43981];
~A1t34::A11942 virtual ~A1() {}
1943
getA1t34::A11944 A1* getA1() {return this;}
1945 };
1946
1947 struct A2
1948 : public virtual A1
1949 {
1950 char _[34981];
~A2t34::A21951 virtual ~A2() {}
1952
getA1t34::A21953 A1* getA1() {return this;}
getA2t34::A21954 A2* getA2() {return this;}
1955 };
1956
1957 struct A3
1958 : public virtual A1,
1959 public A2
1960 {
1961 char _[93481];
~A3t34::A31962 virtual ~A3() {}
1963
getA1t34::A31964 A1* getA1() {return A1::getA1();}
getA2t34::A31965 A2* getA2() {return this;}
getA3t34::A31966 A3* getA3() {return this;}
1967 };
1968
test()1969 void test()
1970 {
1971 A1 a1;
1972 A2 a2;
1973 A3 a3;
1974 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1975 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1976 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1977 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1978 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
1979 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
1980
1981 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1982 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1983 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1984 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
1985 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1986 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1987
1988 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1989 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1990 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1991 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
1992 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1993 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1994 }
1995
1996 } // t34
1997
1998 namespace t35
1999 {
2000
2001 struct A1
2002 {
2003 char _[43981];
~A1t35::A12004 virtual ~A1() {}
2005
getA1t35::A12006 A1* getA1() {return this;}
2007 };
2008
2009 struct A2
2010 : private virtual A1
2011 {
2012 char _[34981];
~A2t35::A22013 virtual ~A2() {}
2014
getA1t35::A22015 A1* getA1() {return this;}
getA2t35::A22016 A2* getA2() {return this;}
2017 };
2018
2019 struct A3
2020 : public virtual A1,
2021 public A2
2022 {
2023 char _[93481];
~A3t35::A32024 virtual ~A3() {}
2025
getA1t35::A32026 A1* getA1() {return A1::getA1();}
getA2t35::A32027 A2* getA2() {return this;}
getA3t35::A32028 A3* getA3() {return this;}
2029 };
2030
test()2031 void test()
2032 {
2033 A1 a1;
2034 A2 a2;
2035 A3 a3;
2036 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2037 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2038 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2039 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2040
2041 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2042 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2043 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2044 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2045 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2046 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2047
2048 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2049 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2050 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2051 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2052 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2053 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2054 }
2055
2056 } // t35
2057
2058 namespace t36
2059 {
2060
2061 struct A1
2062 {
2063 char _[43981];
~A1t36::A12064 virtual ~A1() {}
2065
getA1t36::A12066 A1* getA1() {return this;}
2067 };
2068
2069 struct A2
2070 : public virtual A1
2071 {
2072 char _[34981];
~A2t36::A22073 virtual ~A2() {}
2074
getA1t36::A22075 A1* getA1() {return this;}
getA2t36::A22076 A2* getA2() {return this;}
2077 };
2078
2079 struct A3
2080 : private virtual A1,
2081 public A2
2082 {
2083 char _[93481];
~A3t36::A32084 virtual ~A3() {}
2085
getA1t36::A32086 A1* getA1() {return A1::getA1();}
getA2t36::A32087 A2* getA2() {return this;}
getA3t36::A32088 A3* getA3() {return this;}
2089 };
2090
test()2091 void test()
2092 {
2093 A1 a1;
2094 A2 a2;
2095 A3 a3;
2096 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2097 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2098 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2099 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2100 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2101 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2102
2103 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2104 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2105 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2106 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2107 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2108 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2109
2110 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2111 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2112 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2113 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2114 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2115 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2116 }
2117
2118 } // t36
2119
2120 namespace t37
2121 {
2122
2123 struct A1
2124 {
2125 char _[43981];
~A1t37::A12126 virtual ~A1() {}
2127
getA1t37::A12128 A1* getA1() {return this;}
2129 };
2130
2131 struct A2
2132 : public virtual A1
2133 {
2134 char _[34981];
~A2t37::A22135 virtual ~A2() {}
2136
getA1t37::A22137 A1* getA1() {return this;}
getA2t37::A22138 A2* getA2() {return this;}
2139 };
2140
2141 struct A3
2142 : public virtual A1,
2143 private A2
2144 {
2145 char _[93481];
~A3t37::A32146 virtual ~A3() {}
2147
getA1t37::A32148 A1* getA1() {return A1::getA1();}
getA2t37::A32149 A2* getA2() {return this;}
getA3t37::A32150 A3* getA3() {return this;}
2151 };
2152
test()2153 void test()
2154 {
2155 A1 a1;
2156 A2 a2;
2157 A3 a3;
2158 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2159 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2160 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2161 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2162 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2163 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2164
2165 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2166 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2167 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2168 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2169 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2170
2171 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2172 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2173 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2174 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2175 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2176 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2177 }
2178
2179 } // t37
2180
2181 namespace t38
2182 {
2183
2184 struct A1
2185 {
2186 char _[43981];
~A1t38::A12187 virtual ~A1() {}
2188
getA1t38::A12189 A1* getA1() {return this;}
2190 };
2191
2192 struct A2
2193 : public virtual A1
2194 {
2195 char _[34981];
~A2t38::A22196 virtual ~A2() {}
2197
getA1t38::A22198 A1* getA1() {return this;}
getA2t38::A22199 A2* getA2() {return this;}
2200 };
2201
2202 struct A3
2203 : private virtual A1,
2204 private A2
2205 {
2206 char _[93481];
~A3t38::A32207 virtual ~A3() {}
2208
getA1t38::A32209 A1* getA1() {return A1::getA1();}
getA2t38::A32210 A2* getA2() {return this;}
getA3t38::A32211 A3* getA3() {return this;}
2212 };
2213
test()2214 void test()
2215 {
2216 A1 a1;
2217 A2 a2;
2218 A3 a3;
2219 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2220 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2221 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2222 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2223 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2224
2225 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2226 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2227 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2228 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2229 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2230
2231 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2232 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2233 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2234 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2235 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2236 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2237 }
2238
2239 } // t38
2240
2241 namespace t39
2242 {
2243
2244 struct A1
2245 {
2246 char _[43981];
~A1t39::A12247 virtual ~A1() {}
2248
getA1t39::A12249 A1* getA1() {return this;}
2250 };
2251
2252 struct A2
2253 : private virtual A1
2254 {
2255 char _[34981];
~A2t39::A22256 virtual ~A2() {}
2257
getA1t39::A22258 A1* getA1() {return this;}
getA2t39::A22259 A2* getA2() {return this;}
2260 };
2261
2262 struct A3
2263 : public virtual A1,
2264 private A2
2265 {
2266 char _[93481];
~A3t39::A32267 virtual ~A3() {}
2268
getA1t39::A32269 A1* getA1() {return A1::getA1();}
getA2t39::A32270 A2* getA2() {return this;}
getA3t39::A32271 A3* getA3() {return this;}
2272 };
2273
test()2274 void test()
2275 {
2276 A1 a1;
2277 A2 a2;
2278 A3 a3;
2279 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2280 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2281 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2282 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2283
2284 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2285 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2286 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2287 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2288 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2289
2290 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2291 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2292 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2293 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2294 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2295 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2296 }
2297
2298 } // t39
2299
2300 namespace t40
2301 {
2302
2303 struct A1
2304 {
2305 char _[43981];
~A1t40::A12306 virtual ~A1() {}
2307
getA1t40::A12308 A1* getA1() {return this;}
2309 };
2310
2311 struct A2
2312 : private virtual A1
2313 {
2314 char _[34981];
~A2t40::A22315 virtual ~A2() {}
2316
getA1t40::A22317 A1* getA1() {return this;}
getA2t40::A22318 A2* getA2() {return this;}
2319 };
2320
2321 struct A3
2322 : private virtual A1,
2323 public A2
2324 {
2325 char _[93481];
~A3t40::A32326 virtual ~A3() {}
2327
getA1t40::A32328 A1* getA1() {return A1::getA1();}
getA2t40::A32329 A2* getA2() {return this;}
getA3t40::A32330 A3* getA3() {return this;}
2331 };
2332
test()2333 void test()
2334 {
2335 A1 a1;
2336 A2 a2;
2337 A3 a3;
2338 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2339 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2340 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2341
2342 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2343 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2344 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2345 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2346 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2347 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2348
2349 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2350 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2351 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2352 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2353 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2354 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2355 }
2356
2357 } // t40
2358
2359 namespace t41
2360 {
2361
2362 struct A1
2363 {
2364 char _[43981];
~A1t41::A12365 virtual ~A1() {}
2366
getA1t41::A12367 A1* getA1() {return this;}
2368 };
2369
2370 struct A2
2371 : private virtual A1
2372 {
2373 char _[34981];
~A2t41::A22374 virtual ~A2() {}
2375
getA1t41::A22376 A1* getA1() {return this;}
getA2t41::A22377 A2* getA2() {return this;}
2378 };
2379
2380 struct A3
2381 : private virtual A1,
2382 private A2
2383 {
2384 char _[93481];
~A3t41::A32385 virtual ~A3() {}
2386
getA1t41::A32387 A1* getA1() {return A1::getA1();}
getA2t41::A32388 A2* getA2() {return this;}
getA3t41::A32389 A3* getA3() {return this;}
2390 };
2391
test()2392 void test()
2393 {
2394 A1 a1;
2395 A2 a2;
2396 A3 a3;
2397 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2398 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2399 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2400
2401 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2402 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2403 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2404 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2405 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2406
2407 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2408 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2409 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2410 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2411 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2412 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2413 }
2414
2415 } // t41
2416
main(int,char **)2417 int main(int, char**)
2418 {
2419 timer t;
2420 t1::test();
2421 t2::test();
2422 t3::test();
2423 t4::test();
2424 t5::test();
2425 t6::test();
2426 t7::test();
2427 t8::test();
2428 t9::test();
2429 t10::test();
2430 t11::test();
2431 t12::test();
2432 t13::test();
2433 t14::test();
2434 t15::test();
2435 t16::test();
2436 t17::test();
2437 t18::test();
2438 t19::test();
2439 t20::test();
2440 t21::test();
2441 t22::test();
2442 t23::test();
2443 t24::test();
2444 t25::test();
2445 t26::test();
2446 t27::test();
2447 t28::test();
2448 t29::test();
2449 t30::test();
2450 t31::test();
2451 t32::test();
2452 t33::test();
2453 t34::test();
2454 t35::test();
2455 t36::test();
2456 t37::test();
2457 t38::test();
2458 t39::test();
2459 t40::test();
2460 t41::test();
2461
2462 return 0;
2463 }
2464